EdgeVertexOperator

class EdgeVertexOperator(coeffs, left_indices, right_indices, boundaries)

Basen: object

Ein Kanten-Eckpunkt-Operator.

Begriffsbestimmung

Dieser Operator wird anhand der Kanten-Eckpunkt-Operatoren ( $E_{jk}$ , $V_j$ ) definiert:

\begin{align} V_j &= -i \gamma_{2j-1} \gamma_{2j} = -(a_j a_j - a_j a^\dagger_j + a^\dagger_j a_j - a^\dagger_j a^\dagger_j) = 1 - 2 a^\dagger_j a_j \, , \nonumber \\ E_{jk} &= -i \gamma_{2j-1} \gamma_{2k-1} = -i (a_j a_k + a_j a^\dagger_k + a^\dagger_j a_k + a^\dagger_j a^\dagger_k) = -E_{kj} \nonumber \end{align}

die die folgenden gemischten fermionisch-bosonischen Kommutationsrelationen für $j \neq k \neq l \neq m$ erfüllen: [1]

\begin{align} \left\{ E_{jk}, V_k \right\} &= 0 \nonumber \\ \left\{ E_{jk}, E_{kl} \right\} &= 0 \nonumber \\ \left[ V_k, V_l \right] &= 0 \nonumber \\ \left[ E_{jk}, V_l \right] &= 0 \nonumber \\ \left[ E_{jk}, E_{lm} \right] &= 0 \nonumber \, . \end{align}

Zusammenfassend lässt sich sagen, dass Kanten- und Eckpunktoperatoren kommutieren, es sei denn, sie haben genau einen gemeinsamen Index; in diesem Fall antikommutieren sie.

Anmerkung

Die oben genannten Beziehungen gelten für $j \neq k \neq l \neq m$ ; sie erfassen daher keine zwei Kantenoperatoren, die dasselbe Modenpaar überspannen. Diese kommutieren: Da $E_{kj} = -E_{jk}$ gilt, liegt ein solches Paar auf einer Geraden, und jeder Operator kommutiert mit sich selbst. Aus diesem Grund lautet die Bedingung „genau ein“ gemeinsamer Index und nicht „mindestens ein“.

Ein einfaches Beispiel lässt sich visuell wie folgt darstellen:

Eine visuelle Darstellung eines Kanten-Knoten-Operators.

Wir können die Notation ein wenig beugen und $V_j = E_{jj}$ definieren, was die Funktionsweise der internen Datenstruktur dieses Operators widerspiegelt. Damit lautet die Definition des gesamten Operators wie folgt:

\text{\texttt{EdgeVertexOperator}} = \sum_i c_i \bigotimes_{lr} E_{lr} \, ,

wobei $lr$ die Indizes der beteiligten Operatorterme sind und $c_i$ der (komplexe) Koeffizient ist, der die Linearkombination der Produkte bildet. Die Indizes $l$ und $r$ können jeden Wert zwischen 0 und der Anzahl der vom Operator beeinflussten Fermionenmoden minus 1 annehmen.

$E_{lr}$ werden wir als verallgemeinerte Kantenoperatoren bezeichnen.

Bereitstellung

Diese Klasse speichert die Terme und Koeffizienten in mehreren spärlichen Vektoren, ähnlich dem „Compressed Sparse Row“-Format, das üblicherweise für spärliche Matrizen verwendet wird. Genauer gesagt enthält ein einzelner Operator vier Arrays:

Kolumne „ 1 “	Kolumne „ 2 “
`coeffs`	Ein Vektor mit komplexen Koeffizienten, bestehend aus zwei 64-Bit-Gleitkommazahlen.
`left_indices`	Ein Vektor aus 32-Bit-Ganzzahlen, der die Indizes der linken fermionischen Moden speichert (siehe $l$ ).
`right_indices`	Ein Vektor aus 32-Bit-Ganzzahlen, der die Indizes der rechten Fermionenmoden speichert (siehe $r$ ).
`boundaries`	Ein Vektor aus ganzen Zahlen, der die Grenzen in und `actions` angibt `modes`.

Fermionische Moden, die durch und left_indices indexiert sind, right_indices gelten als spinlos.

Anmerkung

Auf schreibgeschützte Kopien dieser internen Arrays können Sie über die entsprechenden Methoden, get_coeffs()get_left_indices(), get_right_indices(), und zugreifen get_boundaries().

Diese Datenstruktur ermöglicht eine sehr effiziente Erstellung und Bearbeitung von Operatoren. Dies bedeutet jedoch, dass ein Operator jederzeit doppelte Terme enthalten könnte. Diese müssen manuell mithilfe von simplify(). behoben werden.

Bauwesen

Ein Operator kann direkt durch die Angabe der oben beschriebenen Arrays erstellt werden:

>>> from qiskit_fermions.operators import EdgeVertexOperator
>>> coeffs = [1.0, 2.0, -3.0, 4.0j, -0.5j]
>>> left_indices = [0, 3, 0, 2, 3, 0]
>>> right_indices = [1, 4, 1, 2, 3, 1]
>>> boundaries = [0, 0, 1, 2, 4, 6]
>>> op = EdgeVertexOperator(coeffs, left_indices, right_indices, boundaries)
>>> print(format(op))
  1.000000e0 +0.000000e0j * ()
  2.000000e0 +0.000000e0j * (E(0,1))
  0.000000e0 +4.000000e0j * (E(0,1) V(2))
 -0.000000e0-5.000000e-1j * (V(3) E(0,1))
 -3.000000e0 +0.000000e0j * (E(3,4))

Der Einfachheit halber lässt sich ein Operator aus einem „ Python “-Wörterbuch wie folgt erstellen:

>>> op = EdgeVertexOperator.from_dict(
...     {
...         (): 1.0,
...         ((0, 1),): 2.0,
...         ((3, 4),): -3.0,
...         ((0, 1), (2, 2)): 4.0j,
...         ((3, 3), (0, 1)): -0.5j,
...     }
... )
>>> print(format(op))
  1.000000e0 +0.000000e0j * ()
  2.000000e0 +0.000000e0j * (E(0,1))
  0.000000e0 +4.000000e0j * (E(0,1) V(2))
 -0.000000e0-5.000000e-1j * (V(3) E(0,1))
 -3.000000e0 +0.000000e0j * (E(3,4))

Darüber hinaus stehen die folgenden Konstruktions- und Schnellhilfemethoden zur Verfügung:

Kolumne „ 1 “	Kolumne „ 2 “
`zero`()	Erzeugt den additiven Identitätsoperator.
`one`()	Erzeugt den multiplikativen Identitätsoperator.
`from_terms`(Begriffe)	Erstellt einen neuen Operator aus einem Iterator von Termen (siehe auch `iter_terms()`).
`from_terms_with_groups`(Begriffe)	Erstellt einen neuen Operator aus einem Iterator von Termen mit Gruppen (siehe auch `iter_terms_with_groups()`).

Formatierung

In den obigen Beispielen wurden die konstruierten Operatoren mithilfe der Ausgabe von ausgegeben format(), wodurch eine für Menschen lesbare Darstellung des Operators entsteht.

>>> print(format(op))
  1.000000e0 +0.000000e0j * ()
  2.000000e0 +0.000000e0j * (E(0,1))
  0.000000e0 +4.000000e0j * (E(0,1) V(2))
 -0.000000e0-5.000000e-1j * (V(3) E(0,1))
 -3.000000e0 +0.000000e0j * (E(3,4))

Anmerkung

Die Ausgabereihenfolge von format(op) wird vor der Ausgabe explizit sortiert. Daher spiegelt sie nicht die Reihenfolge der Terme innerhalb des Operators wider.

Eine alternative Form lässt sich über die Funktion repr() ableiten, was zu einer Darstellung führt, die im Sinne von „ Python “ interpretierbar ist. Mit anderen Worten: Diese Ausgabe lässt sich problemlos kopieren und in eine „ Python “-Shell einfügen:

>>> print(repr(op))
EdgeVertexOperator.from_dict({...})

Schließlich könnten diese beiden Ausgaben bei großen Operatoren sehr lang und unerwünscht sein. Dann lässt sich über die Funktion str() eine sehr einfache Form mit minimalen Informationen erhalten:

>>> print(str(op))
<EdgeVertexOperator with 5 terms>

Iteration

Da die zugrunde liegende Datenstruktur in Rust implementiert ist und eine nicht triviale Struktur aufweist, kann sie nicht direkt durchlaufen werden:

>>> list(iter(op))
Traceback (most recent call last):
  ...
TypeError: 'qiskit_fermions.operators.edge_vertex_operator.EdgeVertexOperator' object is not iterable

Stattdessen stellt diese Klasse benutzerdefinierte Iteratoren bereit, die diesen Zweck erfüllen:

>>> list(sorted(op.iter_terms()))
[([], (1+0j)), ([(0, 1)], (2+0j)), ([(0, 1), (2, 2)], 4j), ([(3, 3), (0, 1)], (-0-0.5j)), ([(3, 4)], (-3+0j))]

Siehe auch

iter_terms()

Weitere relevante Details zur Umsetzung.

In der folgenden Tabelle sind alle verfügbaren Iteratoren aufgeführt:

Kolumne „ 1 “	Kolumne „ 2 “
`iter_terms`()	Ein Iterator über die Terme des Operators.
`iter_terms_with_groups`()	Ein Iterator über die Terme des Operators mit den zugehörigen Gruppenindizes.

Rechenaufgaben

Die folgenden arithmetischen Operationen werden unterstützt:

Addition/Subtraktion

>>> op = EdgeVertexOperator.one()
>>> (op + op).simplify()
EdgeVertexOperator.from_dict({(): 2+0j})
>>> (op - op).simplify()
EdgeVertexOperator.from_dict({})
>>> op += op
>>> op.simplify()
EdgeVertexOperator.from_dict({(): 2+0j})
>>> op -= op
>>> op.simplify()
EdgeVertexOperator.from_dict({})

Skalar-Multiplikation/Division

>>> op = EdgeVertexOperator.one()
>>> (2 * op).simplify()
EdgeVertexOperator.from_dict({(): 2+0j})
>>> (op / 2).simplify()
EdgeVertexOperator.from_dict({(): 0.5+0j})
>>> op *= 2
>>> op.simplify()
EdgeVertexOperator.from_dict({(): 2+0j})
>>> op /= 2
>>> op.simplify()
EdgeVertexOperator.from_dict({(): 1+0j})

Zusammensetzung des Bedienpersonals

Anmerkung

Die Komposition von Operatoren entspricht der linken Multiplikation: c = a & b entspricht „ $C = B A$ “. Mit anderen Worten: Die Komposition zweier Operatoren ergibt einen resultierenden Operator, der „zuerst a und dann “ ausführt. b

>>> op1 = EdgeVertexOperator.from_dict({(): 2.0, ((0, 1),): 3.0})
>>> op2 = EdgeVertexOperator.from_dict({(): 1.5, ((2, 2),): 4.0})
>>> comp = (op1 & op2).simplify()
>>> print(format(comp))
  3.000000e0 +0.000000e0j * ()
  4.500000e0 +0.000000e0j * (E(0,1))
  8.000000e0 +0.000000e0j * (V(2))
  1.200000e1 +0.000000e0j * (V(2) E(0,1))
>>> op2 &= op1
>>> print(format(op2.simplify()))
  3.000000e0 +0.000000e0j * ()
  4.500000e0 +0.000000e0j * (E(0,1))
  1.200000e1 +0.000000e0j * (E(0,1) V(2))
  8.000000e0 +0.000000e0j * (V(2))
>>> squared = (op1 ** 2).simplify()
>>> print(format(squared))
  4.000000e0 +0.000000e0j * ()
  1.200000e1 +0.000000e0j * (E(0,1))
  9.000000e0 +0.000000e0j * (E(0,1) E(0,1))

Anmerkung

Der Einfachheit halber wird die Rechtsmultiplikation wie folgt implementiert ( c = a @ b was zu „ $C = A B$ “ führt).

>>> (op1 @ op2).equiv(op2 & op1)
True

Andere Operationen

Neben den magischen Methoden, die den oben beschriebenen arithmetischen Operationen entsprechen, stehen folgende Methoden zur Verfügung:

Kolumne „ 1 “	Kolumne „ 2 “
`adjoint`()	Gibt das hermitische Konjugat (oder Adjungierte) dieses Operators zurück.
`ichop`( [Atoll] )	Entfernt Terme, deren Koeffizientenwert unter dem angegebenen Schwellenwert liegt.
`simplify`( [Atoll] )	Gibt einen gleichwertigen, aber vereinfachten Operator zurück.
`normal_ordered`( [aufsteigend, reduzieren] )	Gibt einen Äquivalenzoperator mit normal geordneten Termen zurück.
`relabel_modes`(Permutation)	Gibt einen neuen Operator mit neu benannten Modi zurück.

Eigenschaften

Schließlich gibt es verschiedene Methoden, um bestimmte Eigenschaften eines Operators zu überprüfen:

Kolumne „ 1 “	Kolumne „ 2 “
`is_hermitian`( [Atoll] )	Gibt zurück, ob dieser Operator hermitesch ist.

[ 1 ]

Gandon et al., arXiv:2512.11418.

Attribute

groups

Ein optionaler Vektor mit Gruppenindizes für jeden Term.

Weitere Informationen finden Sie im Modul grouping .

Methoden

adjoint

adjoint()

Gibt das hermitische Konjugat (oder Adjungierte) dieses Operators zurück.

Mit jedem Begriff passieren zwei Dinge:

Die Koeffizienten sind komplex konjugiert
Die Generatoren innerhalb jedes Terms sind in umgekehrter Reihenfolge angeordnet

Die Umkehrung ist erforderlich, da $(AB)^\dagger = B^\dagger A^\dagger$ gilt. Die einzelnen Eckpunkt- und Kantengeneratoren sind zwar hermitesch, antikommutieren jedoch, wenn sie denselben Index haben (siehe obige Definition ), sodass das umgekehrte Produkt nicht mit dem ursprünglichen Produkt übereinstimmt und die Reihenfolge nicht einfach weggelassen werden kann.

Beachten Sie, dass der Operator dadurch im Allgemeinen nicht selbstadjungiert wird: Ein Operator mit komplexen Koeffizienten unterscheidet sich von seinem Adjungierten (wie der folgende Doctest veranschaulicht).

>>> from qiskit_fermions.operators import EdgeVertexOperator
>>> op = EdgeVertexOperator.from_dict({(): -1.0j, ((0, 0), (0, 1)): 1.0})
>>> adj = op.adjoint()
>>> print(format(adj))
 -0.000000e0 +1.000000e0j * ()
  1.000000e0 -0.000000e0j * (E(0,1) V(0))

equiv

equiv(other, atol=1e-08)

Prüft, ob dieser Operator mit einem anderen Operator gleichwertig ist.

Äquivalenz bedeutet in diesem Zusammenhang eine annähernde Gleichheit bis auf die angegebene absolute Toleranz. Genauer gesagt gibt diese Methode den Wert zurück True, wenn alle Absolutwerte der Koeffizienten in der Differenz unter dem festgelegten Schwellenwert liegen other - self``atol .

Anmerkung

Das ist der mathematische Vergleich, den man fast immer haben möchte. Er unterscheidet sich vom Operator == , der die exakte Gleichheit der gespeicherten Terme (ihrer Koeffizienten, Indizes und internen Termgrenzen) ohne Toleranz und ohne Vereinfachung prüft. Zwei mathematisch gleichwertige Operatoren können daher unter unterschiedliche Ergebnisse liefern, == wenn sie unterschiedlich gespeichert sind – beispielsweise ein nicht vereinfachtes a + a im Vergleich zu oder Terme 2 * a, die in einer anderen Reihenfolge vorliegen. Verwenden Sie, equiv um Operatoren bis zur numerischen Toleranz zu vergleichen.

>>> from qiskit_fermions.operators import EdgeVertexOperator
>>> op = EdgeVertexOperator.from_dict({(): 1e-7})
>>> zero = EdgeVertexOperator.zero()
>>> op.equiv(zero)
False
>>> op.equiv(zero, 1e-6)
True
>>> op.equiv(zero, 1e-9)
False

Parameter

anderer – der andere Operator, mit dem verglichen werden soll.
Atol – die absolute Toleranz für den Vergleich. Dieser Wert ist standardmäßig auf 1e-8. gesetzt.

from_dict

classmethod from_dict(data)

Erstellt einen neuen Operator aus einem Wörterbuch.

>>> from qiskit_fermions.operators import EdgeVertexOperator
>>> op = EdgeVertexOperator.from_dict(
...     {
...         (): 1.0-1.0j,
...         ((0, 0),): 2.0,
...         ((0, 1),): 2.0j,
...     }
... )
>>> print(format(op))
  1.000000e0 -1.000000e0j * ()
  2.000000e0 +0.000000e0j * (V(0))
  0.000000e0 +2.000000e0j * (E(0,1))

Parameter

data – ein Wörterbuch, das Tupel aus Termen komplexen Koeffizienten zuordnet. Jeder Schlüssel ist ein Tupel aus Paaren (int, int) , die die Indizes des verallgemeinerten Kantenoperators $E_{lr}$ angeben (wenn $l = r$ , dann entspricht dies dem Knotenoperator $V_l$ ).

Rückgabe

Ein neuer Betreiber.

from_terms

classmethod from_terms(terms)

Erstellt einen neuen Operator aus einem Iterator von Termen (siehe auch iter_terms()).

>>> from qiskit_fermions.operators import EdgeVertexOperator
>>> op = EdgeVertexOperator.from_dict({(): 2.0, ((0, 0),): 1.0, ((0, 1),): -1.0j})
>>> op.equiv(EdgeVertexOperator.from_terms(op.iter_terms()))
True

Parameter

Terme – ein Iterator über die von … erzeugten Terme iter_terms().

Rückgabe

Ein neuer Betreiber.

from_terms_with_groups

classmethod from_terms_with_groups(terms)

Erstellt einen neuen Operator aus einem Iterator von Termen mit Gruppen (siehe auch iter_terms_with_groups()).

>>> from qiskit_fermions.operators import EdgeVertexOperator
>>> op = EdgeVertexOperator([2.0, 1.0, -1.0j], [0, 0], [0, 1], [0, 0, 1, 2])
>>> op.groups = [0, 1, 1]
>>> reconstructed = EdgeVertexOperator.from_terms_with_groups(op.iter_terms_with_groups())
>>> op.equiv(reconstructed) and op.groups == reconstructed.groups
True

Parameter

Terme – ein Iterator über die von … erzeugten Terme iter_terms_with_groups().

Rückgabe

Ein neuer Betreiber.

get_boundaries

get_boundaries()

Gibt eine schreibgeschützte Liste der Indizes zurück, die die Grenzen zwischen den Operandenteilen angeben.

Anmerkung

Diese Methode gibt eine Kopie der internen Daten zurück.

Siehe auch

Die Erläuterung der internen Datenstruktur finden Sie hier.

>>> from qiskit_fermions.operators import EdgeVertexOperator
>>> op = EdgeVertexOperator.one()
>>> op += EdgeVertexOperator.from_dict({((0, 1),): 1.0})
>>> op.get_boundaries()
[0, 0, 1]

Rückgabe

Eine Auflistung der Begriffsgrenzen des Betreibers.

get_coeffs

get_coeffs()

Gibt eine schreibgeschützte Liste der Koeffizienten des Operators zurück.

Anmerkung

Diese Methode gibt eine Kopie der internen Daten zurück.

Siehe auch

Die Erläuterung der internen Datenstruktur finden Sie hier.

>>> from qiskit_fermions.operators import EdgeVertexOperator
>>> op = EdgeVertexOperator.one()
>>> op += -1j * EdgeVertexOperator.one()
>>> op.get_coeffs()
[(1+0j), -1j]

Rückgabe

Eine Liste der Koeffizienten des Betreibers.

get_left_indices

get_left_indices()

Gibt eine schreibgeschützte Liste der linken Indizes aller generalisierten Kantenoperatorterme zurück.

Anmerkung

Diese Methode gibt eine Kopie der internen Daten zurück.

Siehe auch

Die Erläuterung der internen Datenstruktur finden Sie hier.

>>> from qiskit_fermions.operators import EdgeVertexOperator
>>> op = EdgeVertexOperator.from_dict({((0, 0),): 1.0})
>>> op += EdgeVertexOperator.from_dict({((0, 1),): 1.0})
>>> op.get_left_indices()
[0, 0]

Rückgabe

Eine Liste der linken Indizes aller generalisierten Kantenoperatorterme.

get_right_indices

get_right_indices()

Gibt eine schreibgeschützte Liste der rechten Indizes aller generalisierten Kantenoperatorterme zurück.

Anmerkung

Diese Methode gibt eine Kopie der internen Daten zurück.

Siehe auch

Die Erläuterung der internen Datenstruktur finden Sie hier.

>>> from qiskit_fermions.operators import EdgeVertexOperator
>>> op = EdgeVertexOperator.from_dict({((0, 0),): 1.0})
>>> op += EdgeVertexOperator.from_dict({((0, 1),): 1.0})
>>> op.get_right_indices()
[0, 1]

Rückgabe

Eine Liste der rechten Indizes aller verallgemeinerten Kantenoperatorterme.

get_support

get_support()

Gibt die Menge der Modusindizes zurück, auf die dieser Operator wirkt.

>>> from qiskit_fermions.operators import EdgeVertexOperator
>>> op = EdgeVertexOperator.from_dict(
...     {
...         ((0, 1), (3, 4)): 1,
...         ((7, 7),): 1,
...     }
... )
>>> assert op.get_support() == {0, 1, 3, 4, 7}

Rückgabe

Die Menge der Modenindizes, auf die dieser Operator wirkt.

has_groups

has_groups()

Gibt zurück, ob dieser Operator Gruppenindizes verfolgt.

Dies entspricht der Überprüfung von (ist jedoch kostengünstiger als diese) op.groups is not None, da die Gruppenindizes nicht aus dem Operator kopiert werden, um sie zu überprüfen.

Anmerkung

Dies liefert ein Ergebnis, selbst True wenn eine leere Liste groups ist, was dem Zustand eines gruppierten Operators entspricht, der keine Terme enthält.

>>> from qiskit_fermions.operators import EdgeVertexOperator
>>> op = EdgeVertexOperator(
...     [1.0, 2.0, -1.0],
...     [0, 1, 2, 3],
...     [1, 0, 3, 2],
...     [0, 1, 3, 4],
... )
>>> op.has_groups()
False
>>> op.groups = [0, 1, 0]
>>> op.has_groups()
True

Rückgabe

Ob für diesen Operator festgelegt groups ist.

ichop

ichop(atol=1e-08)

Entfernt Terme, deren Koeffizientenwert unter dem angegebenen Schwellenwert liegt.

Diese Methode ändert den Operator an Ort und Stelle und gibt None. zurück.

Vorsicht

Diese Methode kürzt Koeffizienten nach dem Greedy-Prinzip! Falls der Operand, auf den die Funktion angewendet wird, separate Koeffizienten für doppelte Terme enthalten kann, sollten Sie stattdessen simplify() den Aufruf in Betracht ziehen!

>>> from qiskit_fermions.operators import EdgeVertexOperator
>>> op = EdgeVertexOperator.from_dict({(): 1e-4, ((1, 0),): 1e-6, ((0, 1),): 1e-10})
>>> print(format(op))
  1.000000e-4 +0.000000e0j * ()
 1.000000e-10 +0.000000e0j * (E(0,1))
  1.000000e-6 +0.000000e0j * (E(1,0))
>>> op.ichop()
>>> print(format(op))
  1.000000e-4 +0.000000e0j * ()
  1.000000e-6 +0.000000e0j * (E(1,0))
>>> op.ichop(1e-5)
>>> print(format(op))
  1.000000e-4 +0.000000e0j * ()

Parameter

atol – die absolute Toleranz für den Schwellenwert. Dieser Wert ist standardmäßig auf 1e-8. gesetzt.

is_hermitian

is_hermitian(atol=1e-08)

Gibt zurück, ob dieser Operator hermitesch ist.

Anmerkung

Diese Überprüfung erfolgt equiv() anhand der vollständig reduzierten normal_ordered() Differenz von und self deren sowie adjoint() zero(). Da diese Normalform jedes reduzierbare Paar benachbarter Generatoren zusammenzieht – einschließlich der Fusion zweier Kantenoperatoren, die sich einen Modus teilen, über $E_{ab} E_{bc} = -i E_{ac}$ –, wird ein Term, der sich erst nach einer solchen Kontraktion mit seinem Adjunkten aufhebt, weiterhin als Null erkannt.

Parameter

atol – Die numerische Genauigkeit, bis zu der Koeffizienten als gleich angesehen werden. Dieser Wert ist standardmäßig auf 1e-8. gesetzt.

Rückgabe

Ob dieser Operator hermitisch ist.

iter_terms

iter_terms()

Ein Iterator über die Terme des Operators.

Warnung

Das Ändern der Iterationselemente hat keine Auswirkungen auf die zugrunde liegenden Operator-Daten.

>>> from qiskit_fermions.operators import EdgeVertexOperator
>>> op = EdgeVertexOperator.from_dict({(): 2.0, ((0, 0),): 1.0, ((0, 1),): -1.0j})
>>> list(sorted(op.iter_terms()))
[([], (2+0j)), ([(0, 0)], (1+0j)), ([(0, 1)], (-0-1j))]

iter_terms_with_groups

iter_terms_with_groups()

Ein Iterator über die Terme des Operators mit dem jeweils zugehörigen Gruppenindex.

Warnung

Das Ändern der Iterationselemente hat keine Auswirkungen auf die zugrunde liegenden Operator-Daten.

>>> from qiskit_fermions.operators import EdgeVertexOperator
>>> op = EdgeVertexOperator([2.0, 1.0, -1.0j], [0, 0], [0, 1], [0, 0, 1, 2])
>>> op.groups = [0, 1, 1]
>>> list(op.iter_terms_with_groups())
[([], (2+0j), 0), ([(0, 0)], (1+0j), 1), ([(0, 1)], (-0-1j), 1)]

normal_ordered

normal_ordered(ascending=True, reduce=True)

Gibt einen Äquivalenzoperator mit normal geordneten Termen zurück.

Die normale Reihenfolge eines Operatorausdrucks ist so definiert, dass alle Knotenoperatoren vor allen Kantenoperatoren stehen. Innerhalb jeder Gruppe sind die betroffenen Modi lexikografisch geordnet.

Anmerkung

Bei der Umordnung eines Terms müssen die gemischten Kommutations- und Antikommutationsrelationen berücksichtigt werden. Die detaillierten Definitionen finden Sie hier.

>>> from qiskit_fermions.operators import EdgeVertexOperator
>>> op = EdgeVertexOperator.from_dict({((0, 1), (1, 0), (1, 2), (0, 0), (2, 2)): 1})
>>> print(format(op.normal_ordered(reduce=False).simplify()))
 -1.000000e0 -0.000000e0j * (V(0) V(2) E(0,1) E(1,0) E(1,2))
>>> print(format(op.normal_ordered().simplify()))
  1.000000e0 +0.000000e0j * (V(0) V(2) E(1,2))

Parameter

aufsteigend – die Orientierungskonvention für Kantenoperatoren. Seit „ $E_{kj} = -E_{jk}$ “ hat jeder Kantenoperator zwei Darstellungen; True wählt $j < k$ und False wählt $j > k$ , wobei das Vorzeichen im Koeffizienten enthalten ist. Vertex-Operatoren sind davon nicht betroffen. Dieser Wert ist standardmäßig auf True. gesetzt.
reduzieren – Festlegen, ob benachbarte Generatoren, die sich zu einem Skalar oder zu einem einzelnen Generator zusammenfassen, reduziert werden sollen. Siehe das obige Beispiel. Dieser Wert ist standardmäßig auf True. gesetzt.

Rückgabe

Ein äquivalenter, aber normalgeordneter Operator.

num_groups

num_groups()

Gibt die Anzahl der Gruppen zurück.

Wenn ist groupsNone , gibt diese Funktion ebenfalls zurück None. Andernfalls gibt sie die Anzahl der Gruppen zurück, die als der Index der größten vorkommenden Gruppe plus 1 definiert ist (und somit als Index für die nächste Gruppe verwendet werden kann).

>>> from qiskit_fermions.operators import EdgeVertexOperator
>>> op = EdgeVertexOperator(
...     [1.0, 2.0, -1.0],
...     [0, 1, 2, 3],
...     [1, 0, 3, 2],
...     [0, 1, 3, 4],
... )
>>> op.groups = [0, 1, 0]
>>> op.num_groups()
2

Rückgabe

Der größte Gruppenindex liegt bei plus groups 1.

one

classmethod one()

Erzeugt den multiplikativen Identitätsoperator.

Die Kombination des auf diese Weise konstruierten Operators mit einem anderen hat keine Auswirkungen.

>>> from qiskit_fermions.operators import EdgeVertexOperator
>>> op = EdgeVertexOperator.from_dict({(): 2.0})
>>> one = EdgeVertexOperator.one()
>>> op & one == op
True

relabel_modes

relabel_modes(permutation)

Gibt einen neuen Operator mit neu benannten Modi zurück.

>>> from qiskit_fermions.operators import EdgeVertexOperator
>>> op = EdgeVertexOperator.from_dict({
...     ((0, 1), (2, 3)): 1,
...     ((1, 2), (3, 0)): 1,
... })
>>> permutation = [4, 2, 5, 3]
>>> relabeled = op.relabel_modes(permutation)
>>> print(format(relabeled))
  1.000000e0 +0.000000e0j * (E(2,5) E(3,4))
  1.000000e0 +0.000000e0j * (E(4,2) E(5,3))

Parameter

Permutation – die Liste der Indexpermutationen. „Mode“ wird i in umbenannt permutation[i], daher darf die Liste keine doppelten Einträge enthalten und muss lang genug sein, um jeden Modus zu indizieren, auf den der Operator wirkt (ihre Länge muss den größten Modusindex des Operators übersteigen).

Rückgabe

Ein neuer Operator, dessen Modi neu benannt wurden.

Erhöhungen

ValueError – wenn doppelte Einträge enthält permutation oder zu kurz ist, um einen Modus, auf den der Operator wirkt, neu zu benennen.

simplify

simplify(atol=1e-08)

Gibt einen gleichwertigen, aber vereinfachten Operator zurück.

Bei der Vereinfachung werden zunächst alle Koeffizienten addiert, die zu gleichen Termen gehören, und anschließend nur diejenigen beibehalten, deren Gesamtkoeffizient die festgelegte Toleranz überschreitet (genau wie ichop()).

Wenn ein Operator arithmetisch so manipuliert oder konstruiert wurde, dass keine eindeutigen Terme garantiert sind, sollte diese Methode aufgerufen werden, bevor eine Methode angewendet wird, die numerisch kleine Koeffizienten herausfiltert, um Informationsverlust zu vermeiden. Das folgende Beispiel veranschaulicht, wie Terme abgeschnitten werden ichop() können, deren Koeffizienten in der Summe eine Größe ergeben, die eigentlich nicht abgeschnitten werden sollte:

>>> from qiskit_fermions.operators import EdgeVertexOperator
>>> coeffs = [1e-5] * int(1e5)
>>> boundaries = [0] + [0] * int(1e5)
>>> op = EdgeVertexOperator(coeffs, [], [], boundaries)
>>> canon = op.simplify(1e-4)
>>> assert canon.equiv(op.one(), 1e-6)
>>> op.ichop(1e-4)
>>> assert op.equiv(op.zero(), 1e-6)

Parameter

atol – die absolute Toleranz für den Schwellenwert. Dieser Wert ist standardmäßig auf 1e-8. gesetzt.

Rückgabe

Ein gleichwertiger, aber vereinfachter Operator.

split_out_groups

split_out_groups(group_indices=None)

Teilt diesen Operator basierend auf in eine optionale Liste neuer Operatoren auf groups.

Wenn ist groupsNone , gibt diese Funktion ebenfalls zurück None. Andernfalls, wenn group_indices ist None (Standardeinstellung), gibt die Funktion eine Liste zurück, die für jeden Gruppenindex in einen neuen Operator enthält groups, und zwar in der Reihenfolge der Indizes. Wenn angegeben group_indices ist, werden nur die angeforderten Indizes in der angegebenen Reihenfolge erstellt: Dadurch lassen sich die Kosten für die Erstellung von Operatoren für Gruppen vermeiden, die nie verwendet werden. Dies ist besonders vorteilhaft, wenn nur eine kleine Anzahl von Gruppen aus einer viel größeren Gesamtmenge benötigt wird, z. B. bei der Stichprobenauswahl von Gruppen für eine randomisierte Produktformel. Ein doppelter Eintrag in group_indices wird einmal pro Vorkommen zurückgegeben.

>>> from qiskit_fermions.operators import EdgeVertexOperator
>>> op = EdgeVertexOperator(
...     [1.0, 2.0, -1.0],
...     [0, 1, 2, 3],
...     [1, 0, 3, 2],
...     [0, 1, 3, 4],
... )
>>> print(op.split_out_groups())
None
>>> op.groups = [0, 1, 0]
>>> groups = op.split_out_groups()
>>> for g in groups:
...     print(list(sorted(g.iter_terms())))
[([(0, 1)], (1+0j)), ([(3, 2)], (-1+0j))]
[([(1, 0), (2, 3)], (2+0j))]
>>> groups = op.split_out_groups(group_indices=[1])
>>> for g in groups:
...     print(list(sorted(g.iter_terms())))
[([(1, 0), (2, 3)], (2+0j))]

Parameter

group_indices – die Gruppenindizes, für die Operatoren erstellt werden sollen, in der gewünschten Ausgabereihenfolge. Wird dies weggelassen, werden alle Gruppen in der Reihenfolge ihres Indexes erstellt.

Rückgabe

Ein optionaler Vektor mit jeweils einem neuen Operator für jeden angeforderten Gruppenindex.

zero

classmethod zero()

Erzeugt den additiven Identitätsoperator.

Das Hinzufügen des auf diese Weise erstellten Operators zu einem anderen hat keine Auswirkung.

>>> from qiskit_fermions.operators import EdgeVertexOperator
>>> op = EdgeVertexOperator.from_dict({(): 2.0})
>>> zero = EdgeVertexOperator.zero()
>>> op + zero == op
True

Protokollmethoden

_anti_commutator_

static _anti_commutator_(op_a, op_b)

_commutator_

static _commutator_(op_a, op_b)

_double_commutator_

static _double_commutator_(op_a, op_b, op_c, sign)

_fermion_operator_

_fermion_operator_()

Wandelt diesen Operator in ein FermionOperator. um.

Dies implementiert das Protokoll SupportsFermionOperator durch Delegierung an edge_vertex_to_fermion().

_majorana_operator_

_majorana_operator_()

Wandelt diesen Operator in ein MajoranaOperator. um.

Dies implementiert das Protokoll SupportsMajoranaOperator durch Delegierung an edge_vertex_to_majorana().

War diese Seite hilfreich?

Melden Sie auf GitHub einen Fehler, einen Tippfehler oder fordern Sie Inhalte an.