TransferVertexOperator

class TransferVertexOperator(coeffs, left_indices, right_indices, boundaries)

Basen: object

Ein Transfer-Vertex-Operator.

Begriffsbestimmung

Dieser Operator wird anhand der Transfer-Vertex-Operatoren ( $T_{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 \\ T_{jk} &= \frac{i}{2} V_j E_{jk} = \frac{i}{2} \gamma_{2j} \gamma_{2k-1} \, , \nonumber \\ T_{kj} &= \frac{i}{2} E_{jk} V_k = -\frac{i}{2} \gamma_{2j-1} \gamma_{2k} \nonumber \end{align}

wobei $E_{jk}$ ein Kantenoperator von ist und EdgeVertexOperator diese einzelnen Terme die folgenden gemischten fermionisch-bosonischen Kommutationsrelationen für $j \lt k \lt l \lt m$ erfüllen: [1]

\begin{align} \left\{ T_{jk}, V_k \right\} &= 0 \nonumber \\ \left\{ T_{jk}, T_{lk} \right\} &= 0 \nonumber \\ \left[ V_k, V_l \right] &= 0 \nonumber \\ \left[ T_{jk}, V_l \right] &= 0 \nonumber \\ \left[ T_{jk}, T_{lm} \right] &= 0 \nonumber \\ \left[ T_{jk}, T_{kj} \right] &= 0 \nonumber \\ \left[ T_{jk}, T_{km} \right] &= 0 \nonumber \, . \end{align}

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

Eine visuelle Darstellung eines Transfer-Vertex-Operators.

Wir können die Notation ein wenig freizügig handhaben und $V_j = T_{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} T_{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 fermionischen Moden minus 1 annehmen.

$T_{lr}$ werden wir als verallgemeinerte Übertragungsoperatoren 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 Fermionenmodi speichert (siehe $r$ oben).
`boundaries`	Ein Vektor aus ganzen Zahlen, der die Grenzen in `actions` und angibt `modes`.

Fermionische Moden, die durch und left_indices indiziert 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 Angabe der oben beschriebenen Arrays erstellt werden:

>>> from qiskit_fermions.operators import TransferVertexOperator
>>> 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 = TransferVertexOperator(coeffs, left_indices, right_indices, boundaries)
>>> print(format(op))
  1.000000e0 +0.000000e0j * ()
  2.000000e0 +0.000000e0j * (T(0,1))
  0.000000e0 +4.000000e0j * (T(0,1) V(2))
 -0.000000e0-5.000000e-1j * (V(3) T(0,1))
 -3.000000e0 +0.000000e0j * (T(3,4))

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

>>> op = TransferVertexOperator.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 * (T(0,1))
  0.000000e0 +4.000000e0j * (T(0,1) V(2))
 -0.000000e0-5.000000e-1j * (V(3) T(0,1))
 -3.000000e0 +0.000000e0j * (T(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 * (T(0,1))
  0.000000e0 +4.000000e0j * (T(0,1) V(2))
 -0.000000e0-5.000000e-1j * (V(3) T(0,1))
 -3.000000e0 +0.000000e0j * (T(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))
TransferVertexOperator.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))
<TransferVertexOperator with 5 terms>

Iteration

Da die zugrunde liegende Datenstruktur in Rust implementiert ist und einen nicht trivialen Aufbau aufweist, kann sie nicht direkt durchlaufen werden:

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

Stattdessen stellt diese Klasse benutzerdefinierte Iteratoren bereit, um diesen Zweck zu 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 = TransferVertexOperator.one()
>>> (op + op).simplify()
TransferVertexOperator.from_dict({(): 2+0j})
>>> (op - op).simplify()
TransferVertexOperator.from_dict({})
>>> op += op
>>> op.simplify()
TransferVertexOperator.from_dict({(): 2+0j})
>>> op -= op
>>> op.simplify()
TransferVertexOperator.from_dict({})

Skalare Multiplikation/Division

>>> op = TransferVertexOperator.one()
>>> (2 * op).simplify()
TransferVertexOperator.from_dict({(): 2+0j})
>>> (op / 2).simplify()
TransferVertexOperator.from_dict({(): 0.5+0j})
>>> op *= 2
>>> op.simplify()
TransferVertexOperator.from_dict({(): 2+0j})
>>> op /= 2
>>> op.simplify()
TransferVertexOperator.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 = TransferVertexOperator.from_dict({(): 2.0, ((0, 1),): 3.0})
>>> op2 = TransferVertexOperator.from_dict({(): 1.5, ((2, 2),): 4.0})
>>> comp = (op1 & op2).simplify()
>>> print(format(comp))
  3.000000e0 +0.000000e0j * ()
  4.500000e0 +0.000000e0j * (T(0,1))
  8.000000e0 +0.000000e0j * (V(2))
  1.200000e1 +0.000000e0j * (V(2) T(0,1))
>>> op2 &= op1
>>> print(format(op2.simplify()))
  3.000000e0 +0.000000e0j * ()
  4.500000e0 +0.000000e0j * (T(0,1))
  1.200000e1 +0.000000e0j * (T(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 * (T(0,1))
  9.000000e0 +0.000000e0j * (T(0,1) T(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 Konjugierte (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`( [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 hermitisch 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 Konjugierte (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 Transfergeneratoren sind zwar hermitesch, antikommutieren jedoch, wenn sie denselben Index haben (siehe die 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 TransferVertexOperator
>>> op = TransferVertexOperator.from_dict({(): -1.0j, ((0, 0), (0, 1)): 1.0})
>>> adj = op.adjoint()
>>> print(format(adj))
 -0.000000e0 +1.000000e0j * ()
  1.000000e0 -0.000000e0j * (T(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 uneinheitlich verglichen werden, wenn == sie unterschiedlich gespeichert sind – beispielsweise ein nicht vereinfachtes im a + a Vergleich zu oder Terme 2 * a, die in einer anderen Reihenfolge vorliegen. Verwenden Sie equiv zum Vergleich von Operatoren bis zur numerischen Toleranz.

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

Parameter

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

from_dict

classmethod from_dict(data)

Erstellt einen neuen Operator aus einem Wörterbuch.

>>> from qiskit_fermions.operators import TransferVertexOperator
>>> op = TransferVertexOperator.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 * (T(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 Transferoperators $T_{lr}$ angeben (wenn $l = r$ gilt, 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 TransferVertexOperator
>>> op = TransferVertexOperator.from_dict({(): 2.0, ((0, 0),): 1.0, ((0, 1),): -1.0j})
>>> op.equiv(TransferVertexOperator.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 TransferVertexOperator
>>> op = TransferVertexOperator([2.0, 1.0, -1.0j], [0, 0], [0, 1], [0, 0, 1, 2])
>>> op.groups = [0, 1, 1]
>>> reconstructed = TransferVertexOperator.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 Operanden 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 TransferVertexOperator
>>> op = TransferVertexOperator.one()
>>> op += TransferVertexOperator.from_dict({((0, 1),): 1.0})
>>> op.get_boundaries()
[0, 0, 1]

Rückgabe

Eine Auflistung der Grenzen der Geschäftsbedingungen 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 TransferVertexOperator
>>> op = TransferVertexOperator.one()
>>> op += -1j * TransferVertexOperator.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 Terme des verallgemeinerten Transferoperators 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 TransferVertexOperator
>>> op = TransferVertexOperator.from_dict({((0, 0),): 1.0})
>>> op += TransferVertexOperator.from_dict({((0, 1),): 1.0})
>>> op.get_left_indices()
[0, 0]

Rückgabe

Eine Liste der linken Indizes aller Terme des verallgemeinerten Übertragungsoperators.

get_right_indices

get_right_indices()

Gibt eine schreibgeschützte Liste der rechten Indizes aller generalisierten Transferoperatorterme 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 TransferVertexOperator
>>> op = TransferVertexOperator.from_dict({((0, 0),): 1.0})
>>> op += TransferVertexOperator.from_dict({((0, 1),): 1.0})
>>> op.get_right_indices()
[0, 1]

Rückgabe

Eine Liste der richtigen Indizes aller Terme des verallgemeinerten Transferoperators.

get_support

get_support()

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

>>> from qiskit_fermions.operators import TransferVertexOperator
>>> op = TransferVertexOperator.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 TransferVertexOperator
>>> op = TransferVertexOperator(
...     [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 Operator, auf den die Aktion angewendet wird, separate Koeffizienten für doppelte Terme enthalten könnte, sollten Sie stattdessen simplify() den Aufruf in Betracht ziehen!

>>> from qiskit_fermions.operators import TransferVertexOperator
>>> op = TransferVertexOperator.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 * (T(0,1))
  1.000000e-6 +0.000000e0j * (T(1,0))
>>> op.ichop()
>>> print(format(op))
  1.000000e-4 +0.000000e0j * ()
  1.000000e-6 +0.000000e0j * (T(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. eingestellt.

is_hermitian

is_hermitian(atol=1e-08)

Gibt zurück, ob dieser Operator hermitisch ist.

Anmerkung

Diese Überprüfung erfolgt equiv() anhand der vollständig reduzierten normal_ordered() Differenz von und self dessen sowie adjoint() zero().

Anmerkung

Diese Überprüfung ist konservativ : Sie kann auch für False einen Operator, der tatsächlich hermitisch ist, ein positives Ergebnis liefern. Ein Ergebnis True ist immer zuverlässig.

normal_ordered() Jedes Paar benachbarter Generatoren, das sich zu einem kürzeren Term zusammenfassen lässt, wird zusammengezogen, nicht jedoch zwei Transferoperatoren, die denselben Modus teilen: Wie dort erläutert, lässt sich „ $T_{jk} T_{jl}$ “ nur in ein anderes Produkt der Länge zwei umschreiben. Da keine der beiden Formen kanonischer ist als die andere, werden solche Produkte unverändert belassen, und ein Term, der sich erst nach einer Umformung mit seinem Adjunkten aufheben würde, wird nicht als Null erkannt. EdgeVertexOperator weist keine solche Lücke auf, da dort das analoge Produkt zu einem einzigen Kantenoperator verschmilzt.

Parameter

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

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 TransferVertexOperator
>>> op = TransferVertexOperator.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 den zugehörigen Gruppenindizes.

Warnung

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

>>> from qiskit_fermions.operators import TransferVertexOperator
>>> op = TransferVertexOperator([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(reduce=True)

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

Die normale Reihenfolge eines Operatorterms ist so definiert, dass alle Knotenoperatoren vor allen Übertragungsoperatoren 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.

Anmerkung

Hier stehen weniger Kontraktionen zur Verfügung als bei EdgeVertexOperator. Zwei Randoperatoren, die sich einen Modus teilen, verschmelzen zu einem einzigen, das entsprechende Transferprodukt jedoch nicht: Wenn man „ $T_{jk} = \frac{i}{2} \gamma_{2j} \gamma_{2k-1}$ “ schreibt und den gemeinsamen Majorana-Term aufhebt, bleibt immer ein (gerades, ungerades) Paar übrig, das aus zwei verschiedenen Moden stammt, was kein einzelner Generator ist. Nur V(j) V(j), T(j,k) T(j,k) und Vertrag T(j,k) T(k,j) .

>>> from qiskit_fermions.operators import TransferVertexOperator
>>> op = TransferVertexOperator.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) T(0,1) T(1,0) T(1,2))
>>> print(format(op.normal_ordered().simplify()))
 2.500000e-1 +0.000000e0j * (V(1) V(2) T(1,2))

Parameter

reduzieren – ob benachbarte Generatoren, die sich zu einem Skalar oder zu einem Paar von Eckpunktoperatoren verbinden, zusammengefasst werden sollen. Siehe das obige Beispiel. Dieser Wert ist standardmäßig auf True. eingestellt.

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 wird die Anzahl der Gruppen zurückgegeben, 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 TransferVertexOperator
>>> op = TransferVertexOperator(
...     [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 Konzernindex 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 TransferVertexOperator
>>> op = TransferVertexOperator.from_dict({(): 2.0})
>>> one = TransferVertexOperator.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 TransferVertexOperator
>>> op = TransferVertexOperator.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 * (T(2,5) T(3,4))
  1.000000e0 +0.000000e0j * (T(4,2) T(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 Eindeutigkeit der Terme gewährleistet ist, sollte diese Methode aufgerufen werden, bevor eine Methode angewendet wird, die numerisch kleine Koeffizienten herausfiltert, um einen Informationsverlust zu vermeiden. Das folgende Beispiel veranschaulicht, wie Terme abgeschnitten werden ichop() können, deren Koeffizienten in der Summe eine Größe erreichen, die eigentlich nicht abgeschnitten werden sollte:

>>> from qiskit_fermions.operators import TransferVertexOperator
>>> coeffs = [1e-5] * int(1e5)
>>> boundaries = [0] + [0] * int(1e5)
>>> op = TransferVertexOperator(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. eingestellt.

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 (Standard), 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 niemals 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 TransferVertexOperator
>>> op = TransferVertexOperator(
...     [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 TransferVertexOperator
>>> op = TransferVertexOperator.from_dict({(): 2.0})
>>> zero = TransferVertexOperator.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 transfer_vertex_to_fermion().

_majorana_operator_

_majorana_operator_()

Wandelt diesen Operator in ein MajoranaOperator. um.

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

War diese Seite hilfreich?

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