Libreria Mapper

L'API C fornisce implementazioni efficienti delle routine di mappatura degli operatori più comunemente utilizzate.

Rubrica 1	Rubrica 2
`qf_ferm_op_jordan_wigner()`	Associa `QfFermionOperator` a un QkObs e mediante la trasformazione di Jordan-Wigner.
`qf_maj_op_jordan_wigner()`	Associa a `QfMajoranaOperator` un QkObs o mediante la trasformazione di Jordan-Wigner.
`qf_edge_op_jordan_wigner()`	Associa a `QfEdgeVertexOperator` un QkObs o mediante la trasformazione di Jordan-Wigner.
`qf_transfer_op_jordan_wigner()`	Associa a `QfTransferVertexOperator` un QkObs o mediante la trasformazione di Jordan-Wigner.
`qf_fermion_to_majorana()`	Assegna a `QfFermionOperator` `QfMajoranaOperator`.
`qf_majorana_to_fermion()`	Assegna a `QfMajoranaOperator` `QfFermionOperator`.
`qf_edge_vertex_to_fermion()`	Assegna a `QfEdgeVertexOperator` `QfFermionOperator`.
`qf_edge_vertex_to_majorana()`	Assegna a `QfEdgeVertexOperator` `QfMajoranaOperator`.
`qf_transfer_vertex_to_fermion()`	Assegna a `QfTransferVertexOperator` `QfFermionOperator`.
`qf_transfer_vertex_to_majorana()`	Assegna a `QfTransferVertexOperator` `QfMajoranaOperator`.
`qf_transfer_vertex_to_edge_vertex()`	Assegna a `QfTransferVertexOperator` `QfEdgeVertexOperator`.

qf_edge_vertex_to_fermion

QfFermionOperator *qf_edge_vertex_to_fermion(const QfEdgeVertexOperator *edge_op)

Assegna a QfEdgeVertexOperator QfFermionOperator.

Definizione

Questa funzione scompone gli operatori di spigolo e di vertice in termini di operatori di creazione e annichilimento fermionici, come definiti qui.

Esempio

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);

Nota

L'operatore mappato non viene semplificato. Poiché ogni generatore si espande in una somma di termini fermionici, il risultato contiene generalmente termini duplicati; si utilizzi seguito qf_ferm_op_normal_ordered() da qf_ferm_op_simplify() per ridurlo.

Parametri

edge_op – Un puntatore all'operatore bordo-vertice da mappare.

Risultati

Un puntatore all'operatore fermionico mappato.

qf_edge_vertex_to_majorana

QfMajoranaOperator *qf_edge_vertex_to_majorana(const QfEdgeVertexOperator *edge_op)

Assegna a QfEdgeVertexOperator QfMajoranaOperator.

Definizione

Questa funzione scompone gli operatori di spigolo e di vertice in termini di operatori di Majorana, come definiti qui.

Esempio

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);

Nota

L'operatore mappato non viene semplificato; si vedano e qf_maj_op_normal_ordered() qf_maj_op_simplify().

Parametri

edge_op – Un puntatore all'operatore bordo-vertice da mappare.

Risultati

Un puntatore all'operatore di Majorana mappato.

qf_ferm_op_jordan_wigner

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

Applica la trasformazione di Jordan-Wigner a un operatore.

Associa a QfFermionOperator un QkObs o mediante la trasformazione di Jordan-Wigner. [JW-ferm]

Definizione

La trasformazione di Jordan-Wigner mappa gli operatori di creazione e annichilimento fermionici su operatori di spin (o, in questo caso, su operatori di qubit):

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 \, ,

dove $a^\dagger_j$ ( $a_j$ ) è l’operatore di creazione (annichilimento) fermionico che agisce sull’ $j$ -esima modalità fermionica senza spin, $\sigma^P$ con $P \in \{X,Y,Z\}$ sono gli operatori di Pauli con spin $\frac{1}{2}$ e $\sigma^\pm = (\sigma^X \pm \mathrm{i} \sigma^Y) / 2$ .

Questa mappatura preserva le relazioni di anticommutazione fermioniche introducendo una catena di operatori di " $\sigma^Z$ " su tutti i qubit che precedono l'indice su cui agisce l'operatore $j$ .

[ JW-ferm ]

P. Jordan ed E. Wigner, “Über das Paulische Äquivalenzverbot”, Zeitschrift für Physik 47, n. 9. (1928), pp. 631–651, doi:10.1007/BF01331938.

Utilizzo della memoria

Non è garantito che il risultato sia completamente semplificato: i termini duplicati vengono uniti durante l'elaborazione, per limitare la memoria richiesta, ma alcuni potrebbero comunque rimanere. Chiama qk_obs_canonicalize se ti servono tutti insieme. Il numero esatto di termini restituiti può quindi variare in base al numero di thread utilizzati, il che non influisce sull'operatore rappresentato dal risultato.

Questa mappatura è parallelizzata per garantire maggiore velocità, ma questa scelta comporta un maggiore consumo di memoria. Ogni thread di lavoro accumula dati in un proprio osservabile, e i termini vengono assegnati al primo thread disponibile anziché essere suddivisi in base alle stringhe di Pauli che generano; di conseguenza, ogni thread finisce per contenere all’incirca una copia completa dell’operatore mappato. La memoria massima cresce quindi con il numero di thread: ci si può aspettare un valore dell’ordine della dimensione dell’operatore mappato moltiplicata per il numero di thread, più l’operatore di input.

Se la memoria è più importante del tempo di esecuzione, riduci il numero di thread tramite la variabile d'ambiente RAYON_NUM_THREADS di rayon: il picco di memoria diminuisce all'incirca in proporzione e la mappatura richiede di conseguenza più tempo; in alternativa, mappa l'operatore in batch e somma tu stesso i risultati parziali, il che limita il picco alla dimensione del batch al costo di ripetere l'operazione di unione.

Esempio

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);

Parametri

op – Un puntatore all’operatore fermionico da mappare.
num_qubits – Il numero di qubit dell'operatore risultante. Questo valore deve essere rigorosamente maggiore dell'indice della moda più grande su cui agisce op.
out – Un puntatore alla posizione in cui verrà scritto l’operatore del qubit creato in caso di esito positivo. Se la trasformazione fallisce, rimane invariato.

Risultati

Un codice di uscita. Questo vale nel caso >0 in cui si verifichi un errore. In particolare, QfExitCode_ValueError viene restituito un se è num_qubits troppo piccolo per contenere il supporto dell'operatore.

qf_maj_op_jordan_wigner

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

Applica la trasformazione di Jordan-Wigner a un operatore di Majorana.

Associa a QfMajoranaOperator un QkObs o mediante la trasformazione di Jordan-Wigner. [JW-maj]

Definizione

In base alla convenzione QfMajoranaOperator secondo cui anche gli indici portano $\gamma_j = a^\dagger_j + a_j$ e quelli dispari $\gamma'_j = i(a^\dagger_j - a_j)$ , l’indice di Majorana $m$ agisce sulla modalità fermionica $\lfloor m/2 \rfloor$ e si proietta su una singola stringa di Pauli,

\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 \, .

Ciò evita inoltre un’espansione intermedia rispetto alla conversione in un primo QfFermionOperator : ogni azione fermionica si mappa su una somma a due termini, per cui tale percorso espande una singola stringa di Pauli in un numero massimo di $4^L$ i termini per ogni termine costruito da operatori di Majorana $L$ . Il risparmio aumenta con la durata dei contratti; per i contratti con un unico operatore, le due opzioni hanno un costo pressoché identico.

[ JW-maj ]

P. Jordan ed E. Wigner, “Über das Paulische Äquivalenzverbot”, Zeitschrift für Physik 47, n. 9. (1928), pp. 631–651, doi:10.1007/BF01331938.

Utilizzo della memoria

Vedi qf_ferm_op_jordan_wigner(); si applica lo stesso comportamento di parallelizzazione e fusione.

Esempio

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);

Parametri

op – Un puntatore all’operatore di Majorana da mappare.
num_qubits – Il numero di qubit dell'operatore risultante. Si noti che questo valore è calcolato in modi fermionici, quindi deve essere rigorosamente maggiore del più grande indice di Majorana su cui agisce diviso op per due.
out – Un puntatore alla posizione in cui verrà scritto l’operatore del qubit creato in caso di esito positivo. Se la trasformazione fallisce, rimane invariato.

Risultati

qf_edge_op_jordan_wigner

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

Applica la trasformazione di Jordan-Wigner a un operatore bordo-vertice.

Associa a QfEdgeVertexOperator un QkObs o mediante la trasformazione di Jordan-Wigner. [JW-edge]

Definizione

Indichando con $l_\text{min}$ e $l_\text{max}$ rispettivamente l’indice minore e quello maggiore, gli operatori di bordo generalizzati si mappano su singole stringhe di Pauli,

\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}

dove il segno è negativo per $l \lt r$ e positivo in tutti gli altri casi. Le catene di $\sigma^Z$ i dei due operatori di Majorana sottostanti si annullano sotto l’indice inferiore; ecco perché la stringa $\sigma^Z$ copre solo le modalità strettamente comprese tra i due estremi.

[ JW-edge ]

P. Jordan ed E. Wigner, “Über das Paulische Äquivalenzverbot”, Zeitschrift für Physik 47, n. 9. (1928), pp. 631–651, doi:10.1007/BF01331938.

[ Gandon-edge ]

L. Gandon et al., Simulazione quantistica fermionica con insiemi di flusso, arXiv:2512.11418.

Utilizzo della memoria

Vedi qf_ferm_op_jordan_wigner(); si applica lo stesso comportamento di parallelizzazione e fusione.

Esempio

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);

Nota

Invertendo i due indici, la stringa di Pauli rimane invariata e cambia solo il segno: questa è l'antisimmetria $E_{lr} = -E_{rl}$ . Si confronti qf_transfer_op_jordan_wigner()con il caso in cui il coefficiente è lo stesso per entrambi gli orientamenti e cambiano invece le lettere di Pauli.

Nota

Queste stringhe di Pauli differiscono da quelle riportate nell'equazione (10) di [Gandon-edge] mediante uno scambio tra $\sigma^X$ e $\sigma^Y$ sui due endpoint. Si tratta di una scelta di base a un singolo qubit – entrambe le convenzioni soddisfano tutte le relazioni che definiscono l'algebra – e quella qui utilizzata è quella coerente con qf_edge_vertex_to_fermion(), per cui la mappatura di un operatore corrisponde direttamente alla sua conversione in un prima QfFermionOperator .

Parametri

op – Un puntatore all’operatore bordo-vertice da mappare.
num_qubits – Il numero di qubit dell'operatore risultante. Questo valore deve essere rigorosamente maggiore dell'indice della moda più grande su cui agisce op.
out – Un puntatore alla posizione in cui verrà scritto l’operatore del qubit creato in caso di esito positivo. Se la trasformazione fallisce, rimane invariato.

Risultati

qf_transfer_op_jordan_wigner

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

Applica la trasformazione di Jordan-Wigner a un operatore di vertice di trasferimento.

Associa a QfTransferVertexOperator un QkObs o mediante la trasformazione di Jordan-Wigner. [JW-transfer]

Definizione

Indichando con $l_\text{min}$ e $l_\text{max}$ i valori più piccolo e più grande dei due indici, gli operatori di trasferimento generalizzati si mappano su singole stringhe di Pauli,

\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}

dove $P = X$ per $l \lt r$ e $P = Y$ in tutti gli altri casi.

[ JW-transfer ]

P. Jordan ed E. Wigner, “Über das Paulische Äquivalenzverbot”, Zeitschrift für Physik 47, n. 9. (1928), pp. 631–651, doi:10.1007/BF01331938.

[ Gandon-transfer ]

L. Gandon et al., Simulazione quantistica fermionica con insiemi di flusso, arXiv:2512.11418.

Utilizzo della memoria

Vedi qf_ferm_op_jordan_wigner(); si applica lo stesso comportamento di parallelizzazione e fusione.

Esempio

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);

Nota

L'ordine degli indici funziona in modo opposto rispetto a qf_edge_op_jordan_wigner(): il coefficiente è $-1/2$ per entrambi gli orientamenti ed è l'ordine delle lettere di Pauli a invertirsi. $T_{lr}$ e $T_{rl}$ sono operatori realmente diversi, senza alcuna antisimmetria che li colleghi.

Nota

Per quanto riguarda qf_edge_op_jordan_wigner(), queste stringhe di Pauli differiscono dall'equazione (10) di [Gandon-transfer] mediante una scelta di base a singolo qubit; la convenzione qui utilizzata è quella coerente con qf_transfer_vertex_to_fermion().

Parametri

op – Un puntatore all’operatore di trasferimento dei vertici da mappare.
num_qubits – Il numero di qubit dell'operatore risultante. Questo valore deve essere rigorosamente maggiore dell'indice della moda più grande su cui agisce op.
out – Un puntatore alla posizione in cui verrà scritto l’operatore del qubit creato in caso di esito positivo. Se la trasformazione fallisce, rimane invariato.

Risultati

qf_fermion_to_majorana

QfMajoranaOperator *qf_fermion_to_majorana(const QfFermionOperator *fer_op)

Assegnare a QfFermionOperator a QfMajoranaOperator.

Definizione

Questa funzione implementa la seguente trasformazione semplice:

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)

dove $a^\dagger_j$ ( $a_j$ ) è l'operatore di creazione (annichilimento) fermionico che agisce sull' $j$ -esima modalità fermionica senza spin, e $\gamma_j$ / $\gamma'_j$ sono i due operatori dei fermioni di Majorana. Nel caso di questi QfMajoranaOperator , saranno immagazzinati rispettivamente sulle modalità Majorana pari e dispari.

Esempio

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);

Parametri

fer_op – Un puntatore all'operatore fermionico da mappare.

Risultati

Un puntatore all'operatore di Majorana mappato.

qf_majorana_to_fermion

QfFermionOperator *qf_majorana_to_fermion(const QfMajoranaOperator *maj_op)

Assegnare a QfMajoranaOperator a QfFermionOperator.

Definizione

Questa funzione implementa la seguente trasformazione semplice:

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

dove $\gamma_j$ / $\gamma'_j$ sono i due operatori dei fermioni di Majorana (associati rispettivamente alle modalità pari e dispari), e $a^\dagger_j$ ( $a_j$ ) è l’operatore di creazione (annichilimento) fermionico che agisce sulla ( $j$ -esima modalità fermionica senza spin.

Esempio

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);

Parametri

maj_op – Un puntatore all’operatore di Majorana da mappare.

Risultati

Un puntatore all'operatore fermionico mappato.

qf_transfer_vertex_to_fermion

QfFermionOperator *qf_transfer_vertex_to_fermion(const QfTransferVertexOperator *transfer_op)

Assegna a QfTransferVertexOperator QfFermionOperator.

Definizione

Questa funzione scompone gli operatori di trasferimento e di vertice in termini di operatori di creazione e annichilimento fermionici, come definiti qui.

Esempio

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);

Nota

Parametri

transfer_op – Un puntatore all'operatore di trasferimento dei vertici da mappare.

Risultati

Un puntatore all'operatore fermionico mappato.

qf_transfer_vertex_to_majorana

QfMajoranaOperator *qf_transfer_vertex_to_majorana(const QfTransferVertexOperator *transfer_op)

Assegna a QfTransferVertexOperator QfMajoranaOperator.

Definizione

Questa funzione scompone gli operatori di trasferimento e di vertice in termini di operatori di Majorana, come definiti qui.

Esempio

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);

Nota

L'operatore mappato non viene semplificato; si vedano e qf_maj_op_normal_ordered() qf_maj_op_simplify().

Parametri

transfer_op – Un puntatore all'operatore di trasferimento dei vertici da mappare.

Risultati

Un puntatore all'operatore di Majorana mappato.

qf_transfer_vertex_to_edge_vertex

QfEdgeVertexOperator *qf_transfer_vertex_to_edge_vertex(const QfTransferVertexOperator *transfer_op)

Assegna a QfTransferVertexOperator QfEdgeVertexOperator.

Definizione

Questa funzione riscrive ciascun operatore di trasferimento in termini di operatori di spigolo e di vertice. Un operatore di vertice si mappa su se stesso, mentre un operatore di trasferimento $T_{jk}$ diventa un prodotto di lunghezza due costituito da un operatore di spigolo e da un operatore di vertice.

Esempio

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);

Nota

Questo è l’unico mappatore che rimane nell’ambito delle rappresentazioni degli operatori di interazione, quindi rappresenta il percorso naturale per confrontare i due approcci: mappare un operatore di trasferimento su un operatore bordo-vertice e poi su uno fermionico coincide con il mapparlo direttamente su un operatore fermionico.

Parametri

transfer_op – Un puntatore all'operatore di trasferimento dei vertici da mappare.

Risultati

Un puntatore all'operatore bordo-vertice mappato.

Questa pagina è stata utile?

Segnala un bug, un errore di battitura o richiedi contenuti su GitHub.