Mapper-Bibliothek

Die C-API bietet effiziente Implementierungen häufig verwendeter Routinen zur Darstellung von Operatoren.

Kolumne „ 1 “	Kolumne „ 2 “
`qf_ferm_op_jordan_wigner()`	Ordne a unter der Jordan-Wigner-Transformation einem QkObs `QfFermionOperator` zu.
`qf_maj_op_jordan_wigner()`	Ordne a unter der Jordan-Wigner-Transformation einem QkObs `QfMajoranaOperator` zu.
`qf_edge_op_jordan_wigner()`	Ordne a unter der Jordan-Wigner-Transformation einem QkObs `QfEdgeVertexOperator` zu.
`qf_transfer_op_jordan_wigner()`	Ordne a unter der Jordan-Wigner-Transformation einem QkObs `QfTransferVertexOperator` zu.
`qf_fermion_to_majorana()`	Ordne a zu `QfFermionOperator` `QfMajoranaOperator`.
`qf_majorana_to_fermion()`	Ordne a zu `QfMajoranaOperator` `QfFermionOperator`.
`qf_edge_vertex_to_fermion()`	Ordne a zu `QfEdgeVertexOperator` `QfFermionOperator`.
`qf_edge_vertex_to_majorana()`	Ordne a zu `QfEdgeVertexOperator` `QfMajoranaOperator`.
`qf_transfer_vertex_to_fermion()`	Ordne a zu `QfTransferVertexOperator` `QfFermionOperator`.
`qf_transfer_vertex_to_majorana()`	Ordne a zu `QfTransferVertexOperator` `QfMajoranaOperator`.
`qf_transfer_vertex_to_edge_vertex()`	Ordne a zu `QfTransferVertexOperator` `QfEdgeVertexOperator`.

qf_edge_vertex_to_fermion

QfFermionOperator *qf_edge_vertex_to_fermion(const QfEdgeVertexOperator *edge_op)

Ordne a zu QfEdgeVertexOperator QfFermionOperator.

Begriffsbestimmung

Diese Funktion zerlegt die Kanten- und Knotenoperatoren in die hier definierten fermionischen Erzeugungs- und Vernichtungsoperatoren.

Beispiel

1// define some kind of edge-vertex operator
2QfEdgeVertexOperator *edge_op = qf_edge_op_one();
3
4// and map it to a fermionic operator
5QfFermionOperator *fer_op = qf_edge_vertex_to_fermion(edge_op);

Anmerkung

Der abgebildete Operator wird nicht vereinfacht. Da sich jeder Generator in eine Summe aus fermionischen Termen auflösen lässt, enthält das Ergebnis in der Regel doppelte Terme; wende qf_ferm_op_normal_ordered() gefolgt von an, qf_ferm_op_simplify() um diese zu reduzieren.

Parameter

edge_op – Ein Zeiger auf den zuzuordnenden Kanten-Eckpunkt-Operator.

Rückgabe

Ein Zeiger auf den abgebildeten fermionischen Operator.

qf_edge_vertex_to_majorana

QfMajoranaOperator *qf_edge_vertex_to_majorana(const QfEdgeVertexOperator *edge_op)

Ordne a zu QfEdgeVertexOperator QfMajoranaOperator.

Begriffsbestimmung

Diese Funktion zerlegt die Kanten- und Knotenoperatoren in Majorana-Operatoren, wie sie hier definiert sind.

Beispiel

1// define some kind of edge-vertex operator
2QfEdgeVertexOperator *edge_op = qf_edge_op_one();
3
4// and map it to a Majorana operator
5QfMajoranaOperator *maj_op = qf_edge_vertex_to_majorana(edge_op);

Anmerkung

Der abgebildete Operator wird nicht vereinfacht; siehe und qf_maj_op_normal_ordered() qf_maj_op_simplify().

Parameter

edge_op – Ein Zeiger auf den zuzuordnenden Kanten-Eckpunkt-Operator.

Rückgabe

Ein Zeiger auf den abgebildeten Majorana-Operator.

qf_ferm_op_jordan_wigner

QfExitCode qf_ferm_op_jordan_wigner(const QfFermionOperator *op, uint32_t num_qubits, QkObs **out)

Wendet die Jordan-Wigner-Transformation auf einen Operator an.

Ordne a unter der Jordan-Wigner-Transformation einem QkObs QfFermionOperator zu. [JW-ferm]

Begriffsbestimmung

Die Jordan-Wigner-Transformation bildet fermionische Erzeugungs- und Vernichtungsoperatoren auf Spin- (oder in diesem Fall Qubit-)Operatoren ab:

a^\dagger_j \rightarrow \bigotimes_{k\lt j} \sigma^Z_k \otimes \sigma^-_j ~~\text{and}~~ a_j \rightarrow \bigotimes_{k\lt j} \sigma^Z_k \otimes \sigma^+_j \, ,

wobei $a^\dagger_j$ ( $a_j$ ) der fermionische Erzeugungs- (Vernichtungs-)Operator ist, der auf den $j$ -ten spinlosen fermionischen Modus wirkt, $\sigma^P$ mit $P \in \{X,Y,Z\}$ die spin- $\frac{1}{2}$ -Pauli-Operatoren sind und $\sigma^\pm = (\sigma^X \pm \mathrm{i} \sigma^Y) / 2$ gilt.

Diese Abbildung bewahrt die fermionischen Antikommutationsrelationen, indem sie eine Kette von „ $\sigma^Z$ “-Operatoren auf alle Qubits einführt, die dem betroffenen Index $j$ vorangehen.

[ JW-ferm ]

P. Jordan und E. Wigner, „Über das Paulsche Äquivalenzverbot“, Zeitschrift für Physik 47, Nr. 9. (1928), S. 631–651, doi:10.1007/BF01331938.

Hauptspeichernutzung

Es kann nicht garantiert werden, dass das Ergebnis vollständig vereinfacht ist: Doppelte Terme werden bei der Erstellung zusammengefasst, um den Speicherbedarf zu begrenzen, doch einige davon können möglicherweise bestehen bleiben. Rufen Sie an, wenn qk_obs_canonicalize Sie alle zusammen benötigen. Die genaue Anzahl der zurückgegebenen Begriffe kann daher je nach Anzahl der verwendeten Threads variieren, was jedoch keinen Einfluss auf den Operator hat, den das Ergebnis darstellt.

Diese Zuordnung wird aus Geschwindigkeitsgründen parallelisiert, was jedoch zu einem höheren Speicherbedarf führt. Jeder Worker-Thread sammelt die Daten in einem eigenen Observable, und die Terme werden an den jeweils freien Thread übergeben, anstatt danach aufgeteilt zu werden, welche Pauli-Strings sie erzeugen. Daher verfügt jeder Thread am Ende über eine annähernd vollständige Kopie des abgebildeten Operators. Der maximale Speicherbedarf steigt daher mit der Anzahl der Threads: Man kann von einem Wert in der Größenordnung der Größe des abgebildeten Operators multipliziert mit der Anzahl der Threads zuzüglich des Eingabeoperators ausgehen.

Wenn der Speicherbedarf wichtiger ist als die tatsächliche Laufzeit, reduzieren Sie die Anzahl der Threads über die RAYON_NUM_THREADS Umgebungsvariable von Rayon – der Spitzenwert des Speicherbedarfs sinkt in etwa proportional, und die Zuordnung dauert entsprechend länger – oder ordnen Sie den Operator in Stapeln zu und addieren Sie die Teilergebnisse selbst zusammen, wodurch der Spitzenwert durch die Stapelgröße begrenzt wird, allerdings auf Kosten der wiederholten Zusammenführung.

Beispiel

1// define some kind of fermionic operator
2QfFermionOperator *hamil = qf_ferm_op_one();
3
4// and map it to a qubit operator
5QkObs *result;
6QfExitCode exit = qf_ferm_op_jordan_wigner(hamil, 4, &result);
7
8assert(exit == QfExitCode_Success);

Parameter

op – Ein Zeiger auf den abzubildenden fermionischen Operator.
num_qubits – Die Anzahl der Qubits des resultierenden Operators. Dieser Wert muss streng größer sein als der größte Modusindex, auf den einwirkt op.
out – Ein Zeiger auf die Stelle, an die der erstellte Qubit-Operator im Erfolgsfall geschrieben wird. Es bleibt unverändert, wenn die Umwandlung fehlschlägt.

Rückgabe

Ein Exit-Code. Dies ist der Fall, >0 wenn ein Fehler aufgetreten ist. Insbesondere QfExitCode_ValueError wird a zurückgegeben, wenn a zu klein ist num_qubits , um den Definitionsbereich des Operators aufzunehmen.

qf_maj_op_jordan_wigner

QfExitCode qf_maj_op_jordan_wigner(const QfMajoranaOperator *op, uint32_t num_qubits, QkObs **out)

Wendet die Jordan-Wigner-Transformation auf einen Majorana-Operator an.

Ordne a unter der Jordan-Wigner-Transformation einem QkObs QfMajoranaOperator zu. [JW-maj]

Begriffsbestimmung

Gemäß der Konvention QfMajoranaOperator , dass gerade Indizes $\gamma_j = a^\dagger_j + a_j$ und ungerade Indizes $\gamma'_j = i(a^\dagger_j - a_j)$ tragen, wirkt der Majorana-Index $m$ auf den fermionischen Modus $\lfloor m/2 \rfloor$ und bildet diesen auf eine einzelne Pauli-Kette ab,

\gamma_j \rightarrow \bigotimes_{k\lt j} \sigma^Z_k \otimes \sigma^X_j ~~\text{and}~~ \gamma'_j \rightarrow \bigotimes_{k\lt j} \sigma^Z_k \otimes \sigma^Y_j \, .

Dadurch wird auch eine Zwischenvervielfachung im Vergleich zur Umwandlung in eine QfFermionOperator „first“-Form vermieden: Jede fermionische Wirkung lässt sich auf eine Summe aus zwei Termen abbilden, sodass dieser Weg eine einzelne Pauli-Kette auf bis zu $4^L$ -Terme aufbläht – für einen Term, der aus $L$ -Majorana-Operatoren aufgebaut ist. Die Ersparnis steigt mit der Laufzeit; bei Verträgen mit einem einzigen Anbieter kosten die beiden Routen etwa gleich viel.

[ JW-maj ]

P. Jordan und E. Wigner, „Über das Paulsche Äquivalenzverbot“, Zeitschrift für Physik 47, Nr. 9. (1928), S. 631–651, doi:10.1007/BF01331938.

Hauptspeichernutzung

Siehe qf_ferm_op_jordan_wigner(); es gilt dasselbe Verhalten bei der Parallelisierung und Zusammenführung.

Beispiel

1// define some kind of Majorana operator
2QfMajoranaOperator *hamil = qf_maj_op_one();
3
4// and map it to a qubit operator
5QkObs *result;
6QfExitCode exit = qf_maj_op_jordan_wigner(hamil, 4, &result);
7
8assert(exit == QfExitCode_Success);

Parameter

op – Ein Zeiger auf den abzubildenden Majorana-Operator.
num_qubits – Die Anzahl der Qubits des resultierenden Operators. Beachten Sie, dass dies in fermionischen Moden gezählt wird; daher muss der Wert streng größer sein als der größte Majorana-Index, auf den einwirkt, geteilt op durch zwei.
out – Ein Zeiger auf die Stelle, an die der erstellte Qubit-Operator im Erfolgsfall geschrieben wird. Es bleibt unverändert, wenn die Umwandlung fehlschlägt.

Rückgabe

qf_edge_op_jordan_wigner

QfExitCode qf_edge_op_jordan_wigner(const QfEdgeVertexOperator *op, uint32_t num_qubits, QkObs **out)

Wendet die Jordan-Wigner-Transformation auf einen Kanten-Eckpunkt-Operator an.

Ordne a unter der Jordan-Wigner-Transformation einem QkObs QfEdgeVertexOperator zu. [JW-edge]

Begriffsbestimmung

Setzt man für den kleineren und den größeren der beiden Indizes $l_\text{min}$ bzw. $l_\text{max}$ ein, so bilden die verallgemeinerten Kantenoperatoren auf einzelne Pauli-Strings ab,

\begin{align} V_l = E_{ll} &\rightarrow \sigma^Z_l \, , \nonumber \\ E_{lr} &\rightarrow \mp \, \sigma^Y_{l_\text{min}} \left( \bigotimes_{l_\text{min} \lt k \lt l_\text{max}} \sigma^Z_k \right) \sigma^X_{l_\text{max}} \nonumber \end{align}

wobei das Vorzeichen für $l \lt r$ negativ und ansonsten positiv ist. Die Ketten „ $\sigma^Z$ “ der beiden zugrunde liegenden Majorana-Operatoren heben sich unterhalb des unteren Index auf, weshalb sich die Zeichenfolge „ $\sigma^Z$ “ nur auf die Moden erstreckt, die streng zwischen den beiden Endpunkten liegen.

[ JW-edge ]

P. Jordan und E. Wigner, „Über das Paulsche Äquivalenzverbot“, Zeitschrift für Physik 47, Nr. 9. (1928), S. 631–651, doi:10.1007/BF01331938.

[ Gandon-Kante ]

L. Gandon et al., Fermionische Quantensimulation mit Flussmengen, arXiv:2512.11418.

Hauptspeichernutzung

Siehe qf_ferm_op_jordan_wigner(); es gilt dasselbe Verhalten bei der Parallelisierung und Zusammenführung.

Beispiel

1// define some kind of edge-vertex operator
2QfEdgeVertexOperator *hamil = qf_edge_op_one();
3
4// and map it to a qubit operator
5QkObs *result;
6QfExitCode exit = qf_edge_op_jordan_wigner(hamil, 4, &result);
7
8assert(exit == QfExitCode_Success);

Anmerkung

Wendet man die beiden Indizes um, bleibt die Pauli-Zeichenfolge unverändert und es wird lediglich das Vorzeichen umgekehrt – dies ist die Antisymmetrie $E_{lr} = -E_{rl}$ . Im Gegensatz dazu ist bei qf_transfer_op_jordan_wigner(), bei dem der Koeffizient für beide Orientierungen gleich ist, stattdessen die Pauli-Zeichenfolge, die sich ändert.

Anmerkung

Diese Pauli-Strings unterscheiden sich von denen in Gl. (10) von [Gandon-edge] durch Austausch von $\sigma^X$ und $\sigma^Y$ an den beiden Endpunkten. Es handelt sich hierbei um eine Basiswahl für ein einzelnes Qubit – beide Konventionen erfüllen alle definierenden Relationen der Algebra –, und die hier verwendete Konvention ist diejenige, die mit konsistent ist qf_edge_vertex_to_fermion(), sodass die Abbildung eines Operators direkt mit dessen Umwandlung in einen QfFermionOperator übereinstimmt.

Parameter

op – Ein Zeiger auf den zu abgebildenden Kanten-Eckpunkt-Operator.
num_qubits – Die Anzahl der Qubits des resultierenden Operators. Dieser Wert muss streng größer sein als der größte Modusindex, auf den einwirkt op.
out – Ein Zeiger auf die Stelle, an die der erstellte Qubit-Operator im Erfolgsfall geschrieben wird. Es bleibt unverändert, wenn die Umwandlung fehlschlägt.

Rückgabe

qf_transfer_op_jordan_wigner

QfExitCode qf_transfer_op_jordan_wigner(const QfTransferVertexOperator *op, uint32_t num_qubits, QkObs **out)

Wendet die Jordan-Wigner-Transformation auf einen Transferknotenoperator an.

Ordne a unter der Jordan-Wigner-Transformation einem QkObs QfTransferVertexOperator zu. [JW-Übertragung]

Begriffsbestimmung

Setzt man $l_\text{min}$ und $l_\text{max}$ für den kleineren bzw. größeren der beiden Indizes ein, so bilden die verallgemeinerten Transferoperatoren Abbildungen auf einzelne Pauli-Strings,

\begin{align} V_l = T_{ll} &\rightarrow \sigma^Z_l \, , \nonumber \\ T_{lr} &\rightarrow -\frac{1}{2} \, \sigma^P_{l_\text{min}} \left( \bigotimes_{l_\text{min} \lt k \lt l_\text{max}} \sigma^Z_k \right) \sigma^P_{l_\text{max}} \nonumber \end{align}

wobei $P = X$ für $l \lt r$ gilt und andernfalls $P = Y$ .

[ JW-Übertragung ]

P. Jordan und E. Wigner, „Über das Paulsche Äquivalenzverbot“, Zeitschrift für Physik 47, Nr. 9. (1928), S. 631–651, doi:10.1007/BF01331938.

[ Gandon-Transfer ]

L. Gandon et al., Fermionische Quantensimulation mit Flussmengen, arXiv:2512.11418.

Hauptspeichernutzung

Siehe qf_ferm_op_jordan_wigner(); es gilt dasselbe Verhalten bei der Parallelisierung und Zusammenführung.

Beispiel

1// define some kind of transfer-vertex operator
2QfTransferVertexOperator *hamil = qf_transfer_op_one();
3
4// and map it to a qubit operator
5QkObs *result;
6QfExitCode exit = qf_transfer_op_jordan_wigner(hamil, 4, &result);
7
8assert(exit == QfExitCode_Success);

Anmerkung

Die Indexreihenfolge funktioniert genau umgekehrt qf_edge_op_jordan_wigner(): Der Koeffizient lautet für beide Ausrichtungen „ $-1/2$ “, und es sind die Pauli-Buchstaben, die vertauscht werden. „ $T_{lr}$ “ und „ $T_{rl}$ “ sind tatsächlich unterschiedliche Operatoren, zwischen denen keine Antisymmetrie besteht.

Anmerkung

Was betrifft qf_edge_op_jordan_wigner(), so unterscheiden sich diese Pauli-Strings von der Gleichung. (10) von [Gandon-Transfer] durch eine Einzel-Qubit-Basiswahl; die hier verwendete Konvention entspricht der in qf_transfer_vertex_to_fermion().

Parameter

op – Ein Zeiger auf den zu abgebildenden Transfer-Vertex-Operator.
num_qubits – Die Anzahl der Qubits des resultierenden Operators. Dieser Wert muss streng größer sein als der größte Modusindex, auf den einwirkt op.
out – Ein Zeiger auf die Stelle, an die der erstellte Qubit-Operator im Erfolgsfall geschrieben wird. Es bleibt unverändert, wenn die Umwandlung fehlschlägt.

Rückgabe

qf_fermion_to_majorana

QfMajoranaOperator *qf_fermion_to_majorana(const QfFermionOperator *fer_op)

Ordne a zu QfFermionOperator QfMajoranaOperator.

Begriffsbestimmung

Diese Funktion implementiert die folgende einfache Transformation:

a^\dagger_j \rightarrow \frac{1}{2} (\gamma_j - i \gamma'_j) ~~\text{and}~~ a_j \rightarrow \frac{1}{2} (\gamma_j + i \gamma'_j)

wobei $a^\dagger_j$ ( $a_j$ ) der fermionische Erzeugungs- (Vernichtungs-)Operator ist, der auf den $j$ -ten spinlosen fermionischen Modus wirkt, und $\gamma_j$ / $\gamma'_j$ die beiden Majorana-Fermionen-Operatoren sind. Im Falle der werden QfMajoranaOperator diese jeweils auf den geraden und ungeraden Majorana-Moden gespeichert.

Beispiel

1// define some kind of fermionic operator
2QfFermionOperator *fer_op = qf_ferm_op_one();
3
4// and map it to a majorana operator
5QfMajoranaOperator *maj_op = qf_fermion_to_majorana(fer_op);

Parameter

fer_op – Ein Zeiger auf den abzubildenden Fermionenoperator.

Rückgabe

Ein Zeiger auf den abgebildeten Majorana-Operator.

qf_majorana_to_fermion

QfFermionOperator *qf_majorana_to_fermion(const QfMajoranaOperator *maj_op)

Ordne a zu QfMajoranaOperator QfFermionOperator.

Begriffsbestimmung

Diese Funktion implementiert die folgende einfache Transformation:

\gamma_j \rightarrow a^\dagger_j + a_j ~~\text{and}~~ \gamma'_j \rightarrow i (a^\dagger_j - a_j)

wobei $\gamma_j$ / $\gamma'_j$ die beiden Majorana-Fermionenoperatoren sind (die jeweils auf den geraden und ungeraden Moden gespeichert sind) und $a^\dagger_j$ ( $a_j$ ) der fermionische Erzeugungs- (Vernichtungs-)Operator ist, der auf den $j$ -ten spinlosen fermionischen Modus wirkt.

Beispiel

1// define some kind of majorana operator
2QfMajoranaOperator *maj_op = qf_maj_op_one();
3
4// and map it to a fermion operator
5QfFermionOperator *fer_op = qf_majorana_to_fermion(maj_op);

Parameter

maj_op – Ein Zeiger auf den abzubildenden Majorana-Operator.

Rückgabe

Ein Zeiger auf den abgebildeten Fermionenoperator.

qf_transfer_vertex_to_fermion

QfFermionOperator *qf_transfer_vertex_to_fermion(const QfTransferVertexOperator *transfer_op)

Ordne a zu QfTransferVertexOperator QfFermionOperator.

Begriffsbestimmung

Diese Funktion zerlegt die Transfer- und Knotenoperatoren in die hier definierten fermionischen Erzeugungs- und Vernichtungsoperatoren.

Beispiel

1// define some kind of transfer-vertex operator
2QfTransferVertexOperator *transfer_op = qf_transfer_op_one();
3
4// and map it to a fermionic operator
5QfFermionOperator *fer_op = qf_transfer_vertex_to_fermion(transfer_op);

Anmerkung

Parameter

transfer_op – Ein Zeiger auf den zuzuordnenden Transfer-Vertex-Operator.

Rückgabe

Ein Zeiger auf den abgebildeten fermionischen Operator.

qf_transfer_vertex_to_majorana

QfMajoranaOperator *qf_transfer_vertex_to_majorana(const QfTransferVertexOperator *transfer_op)

Ordne a zu QfTransferVertexOperator QfMajoranaOperator.

Begriffsbestimmung

Diese Funktion zerlegt die Transfer- und Knotenoperatoren in Majorana-Operatoren, wie sie hier definiert sind.

Beispiel

1// define some kind of transfer-vertex operator
2QfTransferVertexOperator *transfer_op = qf_transfer_op_one();
3
4// and map it to a Majorana operator
5QfMajoranaOperator *maj_op = qf_transfer_vertex_to_majorana(transfer_op);

Anmerkung

Der abgebildete Operator wird nicht vereinfacht; siehe und qf_maj_op_normal_ordered() qf_maj_op_simplify().

Parameter

transfer_op – Ein Zeiger auf den zuzuordnenden Transfer-Vertex-Operator.

Rückgabe

Ein Zeiger auf den abgebildeten Majorana-Operator.

qf_transfer_vertex_to_edge_vertex

QfEdgeVertexOperator *qf_transfer_vertex_to_edge_vertex(const QfTransferVertexOperator *transfer_op)

Ordne a zu QfTransferVertexOperator QfEdgeVertexOperator.

Begriffsbestimmung

Diese Funktion schreibt jeden Transferoperator in Form der Kanten- und Knotenoperatoren um. Ein Knotenoperator bildet sich auf sich selbst ab, während ein Transferoperator $T_{jk}$ zu einem Produkt der Länge zwei aus einem Kanten- und einem Knotenoperator wird.

Beispiel

1// define some kind of transfer-vertex operator
2QfTransferVertexOperator *transfer_op = qf_transfer_op_one();
3
4// and map it to an edge-vertex operator
5QfEdgeVertexOperator *edge_op = qf_transfer_vertex_to_edge_vertex(transfer_op);

Anmerkung

Dies ist der einzige Mapper, der im Rahmen der Darstellungen von Interaktionsoperatoren bleibt; daher ist dies der naheliegende Weg, um die beiden zu vergleichen: Die Abbildung eines Transferoperators auf einen Kanten-Knoten-Operator und anschließend auf einen fermionischen Operator stimmt mit der direkten Abbildung auf einen fermionischen Operator überein.

Parameter

transfer_op – Ein Zeiger auf den zuzuordnenden Transfer-Vertex-Operator.

Rückgabe

Ein Zeiger auf den abgebildeten Kanten-Knoten-Operator.

War diese Seite hilfreich?

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