FermionOperator

class FermionOperator(coeffs, actions, modes, boundaries)

Basen: object

Ein spinloser fermionischer Operator.

Begriffsbestimmung

Dieser Operator wird durch eine Linearkombination von Produkten aus fermionischen Erzeugungs- und Vernichtungsoperatoren definiert, die auf spinlose fermionische Moden wirken. Das heißt, die einzelnen Terme erfüllen die folgenden Antikommutationsrelationen: [1]

\left\{a^\dagger_i, a^\dagger_j\right\} = \left\{a_i, a_j\right\} = 0,~~\text{and}~~ \left\{a_i, a^\dagger_j\right\} = \delta_{ij} \, ,

wobei „ $i$ “ und „ $j$ “ keinen Unterschied zwischen den Spinarten der fermionischen Moden machen, die sie indizieren.

Damit lautet die Definition des gesamten Operators wie folgt:

\text{\texttt{FermionOperator}} = \sum_i c_i \bigotimes_j \hat{A_j} \, ,

wobei $\hat{A_j} \in \{ a_j, a^\dagger_j \}$ und $c_i$ der (komplexe) Koeffizient ist, der die Linearkombination der Produkte bildet. Der Index $j$ kann jeden Wert zwischen 0 und der Anzahl der vom Operator beeinflußten Fermionenmoden minus 1 annehmen.

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.
`actions`	Ein Vektor aus Booleschen Werten, der die Art der Zweitskvantisierungsvorgänge speichert.
`modes`	Ein Vektor aus 32-Bit-Ganzzahlen, in dem die Indizes der betroffenen Fermionenmoden gespeichert sind.
`boundaries`	Ein Vektor aus ganzen Zahlen, der die Grenzen in und `actions` angibt `modes`.

Einträge in bezeichnen actions Erzeugungs- (bzw. Vernichtungs-)Operatoren von True (False). Die durch indizierten Fermionenmoden modes gelten als spinlos.

Anmerkung

Auf schreibgeschützte Kopien dieser internen Arrays können Sie über die entsprechenden Methoden, get_coeffs()get_actions(), get_modes(), 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 FermionOperator
>>> coeffs = [1.0, 2.0, -3.0, 4.0j, -0.5j]
>>> actions = [True, False, False, True, True, True, False, False]
>>> modes = [0, 0, 0, 1, 0, 1, 2, 3]
>>> boundaries = [0, 0, 1, 2, 4, 8]
>>> op = FermionOperator(coeffs, actions, modes, boundaries)
>>> print(format(op))
  1.000000e0 +0.000000e0j * ()
 -3.000000e0 +0.000000e0j * (-0)
  0.000000e0 +4.000000e0j * (-0 +1)
  2.000000e0 +0.000000e0j * (+0)
 -0.000000e0-5.000000e-1j * (+0 +1 -2 -3)

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

>>> from qiskit_fermions.operators import cre, ann
>>> op = FermionOperator.from_dict(
...     {
...         (): 1.0,
...         (cre(0),): 2.0,
...         (ann(0),): -3.0,
...         (ann(0), cre(1)): 4.0j,
...         (cre(0), cre(1), ann(2), ann(3)): -0.5j,
...     }
... )
>>> print(format(op))
  1.000000e0 +0.000000e0j * ()
 -3.000000e0 +0.000000e0j * (-0)
  0.000000e0 +4.000000e0j * (-0 +1)
  2.000000e0 +0.000000e0j * (+0)
 -0.000000e0-5.000000e-1j * (+0 +1 -2 -3)

In diesem Beispiel haben wir und cre() ann() zur Bildung der Erzeugungs- und Vernichtungsoperatoren für die angegebenen Moden verwendet.

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 * ()
 -3.000000e0 +0.000000e0j * (-0)
  0.000000e0 +4.000000e0j * (-0 +1)
  2.000000e0 +0.000000e0j * (+0)
 -0.000000e0-5.000000e-1j * (+0 +1 -2 -3)

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 Rahmen von „ Python “ interpretierbar ist. Mit anderen Worten: Diese Ausgabe lässt sich problemlos kopieren und in eine „ Python “-Shell einfügen:

>>> print(repr(op))
FermionOperator.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))
<FermionOperator 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.fermion_operator.FermionOperator' object is not iterable

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

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

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 = FermionOperator.one()
>>> (op + op).simplify()
FermionOperator.from_dict({(): 2+0j})
>>> (op - op).simplify()
FermionOperator.from_dict({})
>>> op += op
>>> op.simplify()
FermionOperator.from_dict({(): 2+0j})
>>> op -= op
>>> op.simplify()
FermionOperator.from_dict({})

Skalare Multiplikation/Division

>>> op = FermionOperator.one()
>>> (2 * op).simplify()
FermionOperator.from_dict({(): 2+0j})
>>> (op / 2).simplify()
FermionOperator.from_dict({(): 0.5+0j})
>>> op *= 2
>>> op.simplify()
FermionOperator.from_dict({(): 2+0j})
>>> op /= 2
>>> op.simplify()
FermionOperator.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 = FermionOperator.from_dict({(): 2.0, (cre(0),): 3.0})
>>> op2 = FermionOperator.from_dict({(): 1.5, (ann(1),): 4.0})
>>> comp = (op1 & op2).simplify()
>>> print(format(comp))
  3.000000e0 +0.000000e0j * ()
  8.000000e0 +0.000000e0j * (-1)
  1.200000e1 +0.000000e0j * (-1 +0)
  4.500000e0 +0.000000e0j * (+0)
>>> op2 &= op1
>>> print(format(op2.simplify()))
  3.000000e0 +0.000000e0j * ()
  8.000000e0 +0.000000e0j * (-1)
  4.500000e0 +0.000000e0j * (+0)
  1.200000e1 +0.000000e0j * (+0 -1)
>>> squared = (op1 ** 2).simplify()
>>> print(format(squared))
  4.000000e0 +0.000000e0j * ()
  1.200000e1 +0.000000e0j * (+0)
  9.000000e0 +0.000000e0j * (+0 +0)

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`( [Sandwich] )	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.
`max_rank`()	Gibt den höchsten Rang der Terme in diesem Operator zurück.
`conserves_particle_number`()	Gibt zurück, ob dieser Operator die Teilchenanzahl bewahrt.

[ 1 ]

https://en.wikipedia.org/wiki/Second _quantization#Fermionen-Erzeugungs- und -Vernichtungsoperatoren

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.

Dies wirkt sich wie folgt auf die Terme und Koeffizienten aus:

Die Vorgänge in jedem Term kehren ihre Reihenfolge um und wechseln zwischen Erzeugung und Vernichtung hin und her
Die Koeffizienten sind komplex konjugiert

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

conserves_particle_number

conserves_particle_number()

Gibt zurück, ob dieser Operator die Teilchenanzahl bewahrt.

>>> from qiskit_fermions.operators import FermionOperator
>>> op = FermionOperator.from_dict({((True, 0), (False, 1)): 1})
>>> op.conserves_particle_number()
True
>>> op = FermionOperator.from_dict({((True, 0),): 1})
>>> op.conserves_particle_number()
False

Rückgabe

Ob dieser Operator die Teilchenanzahl bewahrt.

conserves_sector

conserves_sector(block_sizes)

Gibt zurück, ob jeder Term die Teilchenzahl innerhalb jedes Modusblocks erhält.

block_sizes teilt den Modusbereich in aufeinanderfolgende, sich nicht überschneidende Blöcke auf: Block b umfasst die Modi [start_b, start_b + block_sizes[b]) wobei die Summe der Größen der vorangehenden Blöcke start_b ist. Ein Term bewahrt den Sektor genau dann, wenn in jedem Block die Anzahl seiner Erzeugungsoperatoren der Anzahl seiner Vernichtungsoperatoren entspricht. Ein Term, der auf einen Modus außerhalb des letzten Blocks wirkt, bewahrt den Sektor nicht.

Ein leeres block_sizes behandelt alle Modi als einen einzigen Block, wodurch dies gleichbedeutend mit ist conserves_particle_number(). Ein einzelner Block [norb] überprüft die Erhaltungseigenschaften für einen spinlosen FCI-Sektor, während zwei gleiche Blöcke [norb, norb] überprüfen, ob die Alpha-Moden und [0, norb) die Beta-Moden jeweils erhalten [norb, 2 * norb) bleiben – d. h. die Erhaltung sowohl der Teilchenzahl als auch der z-Komponente des Spins.

>>> from qiskit_fermions.operators import FermionOperator
>>> op = FermionOperator.from_dict({((True, 0), (False, 2)): 1})
>>> op.conserves_sector([4])  # one spinless block of 4 orbitals
True
>>> op.conserves_sector([2, 2])  # moves a particle from the alpha block to the beta block
False

Parameter

block_sizes – die Größen der aufeinanderfolgenden Modusblöcke, die jeweils beibehalten werden müssen.

Rückgabe

Ob jeder Term die Teilchenzahl innerhalb jedes Modusblocks beibehält.

equiv

equiv(other, atol=1e-08)

Prüft, ob dieser Operator mit einem anderen Operator äquivalent 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, Aktionen, Modi 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 zum Vergleich von Operatoren bis zur numerischen Toleranz.

>>> from qiskit_fermions.operators import FermionOperator
>>> op = FermionOperator.from_dict({(): 1e-7})
>>> zero = FermionOperator.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. gesetzt.

from_1body_tril_spin

classmethod from_1body_tril_spin(one_body_a, one_body_b, norb)

Erstellt einen Operator aus einzelnen dreieckförmigen 1-Körper-Integralen für verschiedene Spinarten.

Der resultierende Operator ist definiert durch

\sum_i c^\alpha_{ii} a^\dagger_i a_i + c^\beta_{ii} a^\dagger_{i+n} a_{i+n} + \sum_{i \lt j} c^\alpha_{ij} (a^\dagger_i a_j + a^\dagger_j a_i) + c^\beta_{ij} (a^\dagger_{i+n} a_{j+n} + a^\dagger_{j+n} a_{i+n})

wobei $c^\alpha$ ( $c^\beta$ ) die in one_body_a (one_body_bbzw.) gespeicherten Integral-Koeffizienten sind, $i$ und $j$ die aus dem Dreiecksindex $ij$ erweiterten Indizes sind, der die Arrays indiziert, und $n$ die Anzahl der Orbitale ist, norb.

Der resultierende Operator wirkt auf die $2n$ spinlosen fermionischen Moden in Block-Spin-Ordnung: Die Moden $0, \dots, n-1$ sind die $\alpha$ -Spin-Orbitale, und die Moden $n, \dots, 2n-1$ sind die $\beta$ -Spin-Orbitale (sodass das Orbital $i$ der $\beta$ -Spin-Spezies die Mode $i+n$ ist).

>>> import numpy as np
>>> from qiskit_fermions.operators import FermionOperator
>>> one_body_a = np.array([1.0, 2.0, 3.0])
>>> one_body_b = np.array([-1.0, -2.0, -3.0])
>>> op = FermionOperator.from_1body_tril_spin(one_body_a, one_body_b, norb=2)
>>> print(format(op))
  1.000000e0 +0.000000e0j * (+0 -0)
  2.000000e0 +0.000000e0j * (+0 -1)
  2.000000e0 +0.000000e0j * (+1 -0)
  3.000000e0 +0.000000e0j * (+1 -1)
 -1.000000e0 +0.000000e0j * (+2 -2)
 -2.000000e0 +0.000000e0j * (+2 -3)
 -2.000000e0 +0.000000e0j * (+3 -2)
 -3.000000e0 +0.000000e0j * (+3 -3)

Parameter

one_body_a – ein eindimensionales Array der Länge $n * (n + 1) / 2$ , das die Koeffizienten des Ein-Körper-Elektronenintegrals der Spinarten $\alpha$ als abgeflachte Dreiecksmatrix speichert.
one_body_b – ein eindimensionales Array der Länge $n * (n + 1) / 2$ , das die Koeffizienten des 1-Körper-Elektronenintegrals der $\beta$ -Spin-Spezies als abgeflachte Dreiecksmatrix speichert.
norb – die Anzahl der Orbitale, $n$ .

Rückgabe

Die 1-Körper-Komponente des Hamilton-Operators der elektronischen Struktur, wie oben definiert.

from_1body_tril_spin_sym

classmethod from_1body_tril_spin_sym(one_body_a, norb)

Erstellt einen Operator aus spinsymmetrischen dreieckigen 1-Körper-Integralen.

Der resultierende Operator ist definiert durch

\sum_i c^\alpha_{ii} (a^\dagger_i a_i + a^\dagger_{i+n} a_{i+n}) + \sum_{i \lt j} c^\alpha_{ij} (a^\dagger_i a_j + a^\dagger_j a_i + a^\dagger_{i+n} a_{j+n} + a^\dagger_{j+n} a_{i+n})

wobei $c^\alpha$ die in gespeicherten Integralkoeffizienten sind one_body_a, $i$ und $j$ die aus dem Dreiecksindex $ij$ erweiterten Indizes, die das Array indizieren, und $n$ die Anzahl der Orbitale ist, norb.

>>> import numpy as np
>>> from qiskit_fermions.operators import FermionOperator
>>> one_body_a = np.array([1.0, 2.0, 3.0])
>>> op = FermionOperator.from_1body_tril_spin_sym(one_body_a, norb=2)
>>> print(format(op))
  1.000000e0 +0.000000e0j * (+0 -0)
  2.000000e0 +0.000000e0j * (+0 -1)
  2.000000e0 +0.000000e0j * (+1 -0)
  3.000000e0 +0.000000e0j * (+1 -1)
  1.000000e0 +0.000000e0j * (+2 -2)
  2.000000e0 +0.000000e0j * (+2 -3)
  2.000000e0 +0.000000e0j * (+3 -2)
  3.000000e0 +0.000000e0j * (+3 -3)

Parameter

one_body_a – ein eindimensionales Array der Länge $n * (n + 1) / 2$ , das die Koeffizienten des Ein-Körper-Elektronenintegrals der Spinarten $\alpha$ als abgeflachte Dreiecksmatrix speichert.
norb – die Anzahl der Orbitale, $n$ .

Rückgabe

Die 1-Körper-Komponente des Hamilton-Operators der elektronischen Struktur, wie oben definiert.

from_2body_tril_spin

classmethod from_2body_tril_spin(two_body_aa, two_body_ab, two_body_bb, norb)

Erstellt einen Operator aus einzelnen dreieckigen 2-Körper-Integralen für verschiedene Spinarten.

Der resultierende Operator ist definiert durch

\sum_{ijkl} \frac{1}{2} \sum_{(i,j,k,l) \in \mathcal{P}(ijkl)} c^{\alpha\alpha}_{ijkl} a^\dagger_i a^\dagger_k a_l a_j + c^{\beta\beta}_{ijkl} a^\dagger_{i+n} a^\dagger_{k+n} a_{l+n} a_{j+n} + \sum_{ijkl} \frac{1}{2} \sum_{(i,j,k,l) \in \mathcal{P'}(ijkl)} c^{\alpha\beta}_{ijkl} a^\dagger_{i+n} a^\dagger_k a_l a_{j+n} + c^{\alpha\beta}_{ijkl} a^\dagger_i a^\dagger_{k+n} a_{l+n} a_j +

wobei $c^{\alpha\alpha}$ ( $c^{\alpha\beta}$ , $c^{\beta\beta}$ ) die in two_body_aa (two_body_ab, two_body_bbbzw. ) gespeicherten Integral-Koeffizienten sind, $ijkl$ der laufende Index des Arrays ist, $\mathcal{P}$ ( $\mathcal{P'}$ ) die eindeutigen Permutationen des 4-Index $(i,j,k,l)$ generiert (siehe unten) und $n$ die Anzahl der Orbitalen ist, norb.

Die Zweikörperkoeffizienten werden in der chemischen Reihenfolge erwartet: $(ij|kl)$ , d. h., die beiden Indexpare $(i,j)$ und $(k,l)$ bezeichnen jeweils eine Ladungsdichte. Der Faktor $\frac{1}{2}$ ist der übliche Zwei-Körper-Vorfaktor.

Anmerkung

two_body_aa und two_body_bb sind symmetrische Arrays vom Typ „ S8-fold “. Das bedeutet, es handelt sich um die abgeflachten, unterhalb der Diagonalen liegenden Daten von Matrizen der Form (npair, npair), wobei npair = (norb * (norb + 1) // 2. Dies sind wiederum die unteren dreieckigen Daten der 4-dimensionalen Arrays der Form (norb, norb, norb, norb). Daher erweitert die obige Formel „ $\mathcal{P}$ “ den abgeflachten Index „ $ijkl$ “ auf alle Indexpermutationen „ $(i,j,k,l)$ “, die diese 4-dimensionalen Arrays indizieren.

Allerdings two_body_ab ist nur S4-fold symmetrisch. Somit enthält sie die vollständigen Daten der Matrix (npair, npair) (allerdings weiterhin in abgeflachter Form). Mit dem Befehl „ $\mathcal{P'}$ “ wird die entsprechende Index-Erweiterung durchgeführt. (In der obigen Definition haben wir den Index „ $ijkl$ “ als Notationsmissbrauch wiederverwendet.)

>>> import numpy as np
>>> from qiskit_fermions.operators import FermionOperator
>>> two_body_aa = np.arange(1, 7, dtype=float)
>>> two_body_ab = np.arange(11, 20, dtype=float)
>>> two_body_bb = np.arange(-1, -7, -1, dtype=float)
>>> op = FermionOperator.from_2body_tril_spin(two_body_aa, two_body_ab, two_body_bb, norb=2)
>>> len(op)
64

Parameter

two_body_aa – ein eindimensionales Array der symmetrischen 2-Körper-Elektronenintegralkoeffizienten nach S8-fold für die $\alpha\alpha$ -Spin-Spezies, als abgeflachtes Array.
two_body_ab – ein eindimensionales Array der symmetrischen 2-Körper-Elektronenintegralkoeffizienten nach S4-fold für die $\alpha\beta$ -Spin-Spezies, als abgeflachtes Array.
two_body_bb – ein eindimensionales Array der symmetrischen 2-Körper-Elektronenintegralkoeffizienten nach S8-fold für die $\beta\beta$ -Spin-Spezies, als abgeflachtes Array.
norb – die Anzahl der Orbitale, $n$ .

Rückgabe

Die 2-Körper-Komponente des Hamilton-Operators der elektronischen Struktur, wie oben definiert.

from_2body_tril_spin_sym

classmethod from_2body_tril_spin_sym(two_body_aa, norb)

Erstellt einen Operator aus spinsymmetrischen dreieckigen 2-Körper-Integralen.

Der resultierende Operator ist definiert durch

\sum_{ijkl} \frac{1}{2} c^{\alpha\alpha}_{ijkl} \sum_{(i,j,k,l) \in \mathcal{P}(ijkl)} (a^\dagger_i a^\dagger_k a_l a_j + a^\dagger_{i+n} a^\dagger_k a_l a_{j+n} + a^\dagger_i a^\dagger_{k+n} a_{l+n} a_j + a^\dagger_{i+n} a^\dagger_{k+n} a_{l+n} a_{j+n})

wobei $c^{\alpha\alpha}$ die in gespeicherten Integral-Koeffizienten sind two_body_aa, $ijkl$ der laufende Index des Arrays ist, $\mathcal{P}$ die eindeutigen Permutationen des 4-Index $(i,j,k,l)$ generiert (siehe unten) und $n$ die Anzahl der Orbitalen ist, norb.

Anmerkung

two_body_aa ist ein symmetrisches Array vom Typ „ S8-fold “. Das bedeutet, es handelt sich um die abgeflachten, unterhalb der Diagonalen angeordneten Daten einer Matrix der Form (npair, npair), wobei npair = (norb * (norb + 1) // 2. Dies sind wiederum die unteren dreieckigen Daten des vierdimensionalen Arrays der Form (norb, norb, norb, norb). Daher erweitert die obige Formel „ $\mathcal{P}$ “ den abgeflachten Index „ $ijkl$ “ auf alle Indexpermutationen „ $(i,j,k,l)$ “, die dieses 4-dimensionale Array indizieren.

>>> import numpy as np
>>> from qiskit_fermions.operators import FermionOperator
>>> two_body_aa = np.arange(1, 7, dtype=float)
>>> op = FermionOperator.from_2body_tril_spin_sym(two_body_aa, norb=2)
>>> len(op)
64

Parameter

two_body_aa – ein eindimensionales Array der symmetrischen 2-Körper-Elektronenintegralkoeffizienten nach S8-fold für die $\alpha\alpha$ -Spin-Spezies, als abgeflachtes Array.
norb – die Anzahl der Orbitale, $n$ .

Rückgabe

Die 2-Körper-Komponente des Hamilton-Operators der elektronischen Struktur, wie oben definiert.

from_dict

classmethod from_dict(data)

Erstellt einen neuen Operator aus einem Wörterbuch.

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

Parameter

data – ein Wörterbuch, das Tupel aus Termen komplexen Koeffizienten zuordnet. Jeder Schlüssel ist ein Tupel aus Paaren (bool, int) . Sie können und cre() verwenden, ann() um deren Konstruktion zu vereinfachen.

Rückgabe

Ein neuer Betreiber.

from_fcidump

classmethod from_fcidump(fcidump)

Erstellt ein FermionOperator aus einer FCIDump Datenstruktur.

Angenommen, Sie haben eine FCIDump-Datei namens molecule.fcidump, dann können Sie den zweitquantisierten Operator wie folgt bilden:

from qiskit_fermions.operators import FermionOperator
from qiskit_fermions.operators.library import FCIDump

fcidump = FCIDump.from_file("molecule.fcidump")
operator = FermionOperator.from_fcidump(fcidump)

Parameter

fcidump – die FCIDump-Datenstruktur.

Rückgabe

Der konstruierte Operator. Wenn der FCIDump eine konstante Energie (z. B. die Energie der Kernabstoßung) liefert, wird diese als Identitätsterm einbezogen ().

from_terms

classmethod from_terms(terms)

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

>>> from qiskit_fermions.operators import FermionOperator
>>> op = FermionOperator.from_dict({(): 2.0, ((True, 0),): 1.0, ((False, 1),): -1.0j})
>>> op.equiv(FermionOperator.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 FermionOperator
>>> op = FermionOperator(
...     [2.0, 1.0, -1.0],
...     [True, False, True, False],
...     [0, 1, 1, 0],
...     [0, 0, 2, 4],
... )
>>> op.groups = [0, 1, 1]
>>> reconstructed = FermionOperator.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_actions

get_actions()

Gibt eine schreibgeschützte Liste der Aktionen 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 FermionOperator
>>> op = FermionOperator.one()
>>> op += FermionOperator.from_dict({((True, 0), (False, 1)): 1.0})
>>> op.get_actions()
[True, False]

Rückgabe

Eine Auflistung der Handlungen des Bedieners.

get_boundaries

get_boundaries()

Gibt eine schreibgeschützte Liste der Indizes zurück, die die Grenzen zwischen den Operandentermen 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 FermionOperator
>>> op = FermionOperator.one()
>>> op += FermionOperator.from_dict({((True, 0), (False, 1)): 1.0})
>>> op.get_boundaries()
[0, 0, 2]

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 FermionOperator
>>> op = FermionOperator.one()
>>> op += -1j * FermionOperator.one()
>>> op.get_coeffs()
[(1+0j), -1j]

Rückgabe

Eine Liste der Koeffizienten des Betreibers.

get_modes

get_modes()

Gibt eine schreibgeschützte Liste der Indizes der Modi zurück, auf die der Operator angewendet wurde.

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 FermionOperator
>>> op = FermionOperator.one()
>>> op += FermionOperator.from_dict({((True, 0), (False, 1)): 1.0})
>>> op.get_modes()
[0, 1]

Rückgabe

Eine Liste der Betriebsarten des Geräts.

get_support

get_support()

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

>>> from qiskit_fermions.operators import FermionOperator
>>> op = FermionOperator.from_dict(
...     {
...         ((True, 0), (False, 4)): 1,
...         ((True, 1), (True, 3), (False, 4), (False, 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 FermionOperator
>>> op = FermionOperator(
...     [1.0, 2.0, -1.0, -2.0],
...     [True, False, True, False, True, False, True, False],
...     [0, 1, 2, 3, 1, 0, 3, 2],
...     [0, 2, 4, 6, 8],
... )
>>> op.has_groups()
False
>>> op.groups = [0, 1, 0, 1]
>>> 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 Operation angewendet wird, separate Koeffizienten für doppelte Terme enthalten kann, sollten Sie stattdessen simplify() den Aufruf in Betracht ziehen!

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

Parameter

atol – die absolute Toleranz für den Grenzwert. 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 Differenz normal_ordered() zwischen self und dessen sowie adjoint() zero().

>>> from qiskit_fermions.operators import FermionOperator
>>> op = FermionOperator.from_dict({
...     ((True, 0), (False, 1)): 1.00001j,
...     ((True, 1), (False, 0)): -1j,
... })
>>> op.is_hermitian()
False
>>> op.is_hermitian(1e-4)
True

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 FermionOperator
>>> op = FermionOperator.from_dict({(): 2.0, ((True, 0),): 1.0, ((False, 1),): -1.0j})
>>> list(sorted(op.iter_terms()))
[([], (2+0j)), ([(False, 1)], (-0-1j)), ([(True, 0)], (1+0j))]

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 FermionOperator
>>> op = FermionOperator(
...     [2.0, 1.0, -1.0],
...     [True, False, True, False],
...     [0, 1, 1, 0],
...     [0, 0, 2, 4],
... )
>>> op.groups = [0, 1, 1]
>>> list(sorted(op.iter_terms_with_groups()))
[([], (2+0j), 0), ([(True, 0), (False, 1)], (1+0j), 1), ([(True, 1), (False, 0)], (-1+0j), 1)]

max_rank

max_rank()

Gibt den höchsten Rang der Terme in diesem Operator zurück.

Anmerkung

Die Länge des längsten Terms kann von der Form des Operators abhängen, was bedeutet, dass (beispielsweise) eine Vereinfachung des Operators oder eine Normalordnung zu einem anderen maximalen Rang führen können.

>>> from qiskit_fermions.operators import FermionOperator
>>> op = FermionOperator.from_dict({
...     ((True, 0), (False, 1), (True, 2), (False, 3)): 1,
... })
>>> op.max_rank()
4

Rückgabe

Der maximale Rang dieses Operators.

normal_ordered

normal_ordered(sandwich=None)

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

Die normale Reihenfolge eines Operatorterms ist so definiert, dass alle Erzeugungsaktionen vor allen Vernichtungsaktionen stehen. Innerhalb jeder Gruppe sind die betroffenen Modi lexikografisch geordnet. Ob die Reihenfolge aufsteigend oder absteigend ist, hängt vom Wert des Arguments sandwich ab:

None (Standard): Beide Gruppen werden lexikografisch absteigend sortiert (z. B. +1 +0 -1 -0)
True: Größere Indizes erscheinen in der Mitte, d. h., Erzeugungsaktionen sind lexikografisch aufsteigend, während Vernichtungsaktionen absteigend sind (z. B. +0 +1 -1 -0)
False: Kleinere Indizes erscheinen in der Mitte, d. h., Erzeugungsaktionen sind lexikografisch absteigend, während Vernichtungsaktionen aufsteigend sind (z. B. +1 +0 -0 -1)

Anmerkung

Bei der Umordnung eines Terms müssen die Antikommutationsrelationen berücksichtigt werden: „ $a_i a^\dagger_j = \delta_{ij} - a^\dagger_j a^i$ “, was bedeutet, dass sich die Anzahl der Terme ändern kann.

>>> from qiskit_fermions.operators import FermionOperator
>>> op = FermionOperator.from_dict({((False, 1), (True, 1), (False, 0), (True, 0)): 1})
>>> print(format(op.normal_ordered().simplify()))
  1.000000e0 +0.000000e0j * ()
 -1.000000e0 +0.000000e0j * (+0 -0)
 -1.000000e0 +0.000000e0j * (+1 -1)
 -1.000000e0 +0.000000e0j * (+1 +0 -1 -0)
>>> print(format(op.normal_ordered(sandwich=True).simplify()))
  1.000000e0 +0.000000e0j * ()
 -1.000000e0 +0.000000e0j * (+0 -0)
  1.000000e0 +0.000000e0j * (+0 +1 -1 -0)
 -1.000000e0 +0.000000e0j * (+1 -1)
>>> print(format(op.normal_ordered(sandwich=False).simplify()))
  1.000000e0 +0.000000e0j * ()
 -1.000000e0 +0.000000e0j * (+0 -0)
 -1.000000e0 +0.000000e0j * (+1 -1)
  1.000000e0 +0.000000e0j * (+1 +0 -0 -1)

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 die Funktion 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 FermionOperator
>>> op = FermionOperator(
...     [1.0, 2.0, -1.0, -2.0],
...     [True, False, True, False, True, False, True, False],
...     [0, 1, 2, 3, 1, 0, 3, 2],
...     [0, 2, 4, 6, 8],
... )
>>> op.groups = [0, 1, 0, 1]
>>> 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 FermionOperator
>>> op = FermionOperator.from_dict({(): 2.0})
>>> one = FermionOperator.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 FermionOperator
>>> op = FermionOperator.from_dict({
...     ((True, 0), (False, 1)): 1,
...     ((True, 0), (False, 1), (True, 2), (False, 3)): 1,
... })
>>> permutation = [5, 6, 4, 3]
>>> relabeled = op.relabel_modes(permutation)
>>> print(format(relabeled))
  1.000000e0 +0.000000e0j * (+5 -6)
  1.000000e0 +0.000000e0j * (+5 -6 +4 -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 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 FermionOperator
>>> coeffs = [1e-5] * int(1e5)
>>> boundaries = [0] + [0] * int(1e5)
>>> op = FermionOperator(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 Grenzwert. 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 (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 FermionOperator
>>> op = FermionOperator(
...     [1.0, 2.0, -1.0, -2.0],
...     [True, False, True, False, True, False, True, False],
...     [0, 1, 2, 3, 1, 0, 3, 2],
...     [0, 2, 4, 6, 8],
... )
>>> print(op.split_out_groups())
None
>>> op.groups = [0, 1, 0, 1]
>>> groups = op.split_out_groups()
>>> for g in groups:
...     print(list(sorted(g.iter_terms())))
[([(True, 0), (False, 1)], (1+0j)), ([(True, 1), (False, 0)], (-1+0j))]
[([(True, 2), (False, 3)], (2+0j)), ([(True, 3), (False, 2)], (-2+0j))]
>>> groups = op.split_out_groups(group_indices=[1])
>>> for g in groups:
...     print(list(sorted(g.iter_terms())))
[([(True, 2), (False, 3)], (2+0j)), ([(True, 3), (False, 2)], (-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 gebildeten Operators zu einem anderen hat keine Auswirkung.

>>> from qiskit_fermions.operators import FermionOperator
>>> op = FermionOperator.from_dict({(): 2.0})
>>> zero = FermionOperator.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)

_linear_operator_

_linear_operator_(norb, nelec)

Gibt ein SciPy für LinearOperator diesen Operator im (norb, nelec) FCI-Sektor zurück.

Dies wird umgesetzt, ffsim.SupportsLinearOperator indem in ein konvertiert und ffsim.FermionOperator dieses an übergeben wird ffsim.linear_operator(): Die Simulation ist Aufgabe von ffsim, und dieses Paket enthält die mapperunabhängige Schaltung und kein zweites Simulations-Backend.

ffsim lehnt einen Operator ab, der nicht sowohl die Teilchenzahl als auch die z-Komponente des Spins erhält, da ein solcher Operator auf einen festen Sektor keine Wirkung hat, und ignoriert stillschweigend einen Term, der auf ein Orbital außerhalb dieses Sektors wirkt [0, norb).

Parameter

norb (int) – die Anzahl der Raumorbitale.
nelec (int |tuple[int, int]) – die Elektronenzahl – eine ganze Zahl für einen spinfreien Sektor oder ein p-Paar (n_alpha, n_beta) für einen Sektor mit Spin.
self (FermionOperator)

Rückgabe

A Anwendung scipy.sparse.linalg.LinearOperator dieses Operators auf den angeforderten Sektor.

Rückgabetyp

scipy.sparse.linalg.LinearOperator

_majorana_operator_

_majorana_operator_()

Wandelt diesen Operator in ein MajoranaOperator. um.

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

_trace_

_trace_(norb, nelec)

Gibt die Ablaufverfolgung dieses Operators im (norb, nelec) FCI-Sektor zurück.

Dies wird ffsim.SupportsTrace über implementiert ffsim.trace(), wobei gespiegelt wird _linear_operator_.

Parameter

norb (int) – die Anzahl der Raumorbitale.
nelec (int |tuple[int, int]) – die Elektronenzahl – eine ganze Zahl für einen spinfreien Sektor oder ein p-Paar (n_alpha, n_beta) für einen Sektor mit Spin.
self (FermionOperator)

Rückgabe

Die Spur dieses Operators auf dem angeforderten Sektor.

Rückgabetyp

Komplex

War diese Seite hilfreich?

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