Sintesi dei circuiti

qiskit.synthesis.synth_cnot_count_full_pmh(state, section_size=None)

Sintetizzare circuiti reversibili lineari per architetture all-to-all utilizzando i metodi di Patel, Markov e Hayes.

Questa funzione è un'implementazione dell'algoritmo di Patel, Markov e Hayes di [1] per la sintesi ottimale di circuiti lineari reversibili per architettura all-to-all, come specificato da una matrice $n \times n$.

Parametri

• state (list[list[bool]] | ndarray[bool]) – $n \times n$ matrice booleana invertibile, che descrive lo stato del circuito di ingresso.
• section_size (int | None) – La dimensione di ciascuna sezione nell'algoritmo di Patel-Markov-Hayes [1]. Se None è scelto come $\max(2, \alpha\log_2(n))$ con $\alpha = 0.56$, che minimizza approssimativamente il limite superiore del numero di operazioni di riga dato in [1] Eq. (3).

Risultati

Un circuito solo CX che implementa la trasformazione lineare.

Aumenti

ValueError - Quando section_size è maggiore del numero di colonne.

Tipo di restituzione

QuantumCircuit

Riferimenti

1. Patel, Ketan N., Igor L. Markov, and John P. Hayes, Optimal synthesis of linear reversible circuits, Quantum Information & Computation 8.3 (2008): 282-294. arXiv:quant-ph/0302002 [quant-ph]

qiskit.synthesis.synth_cnot_depth_line_kms(mat)

Sintetizzare un circuito reversibile lineare per architetture lineari nearest-neighbor utilizzando il metodo di Kutin, Moulton e Smithline.

Algoritmo di sintesi per circuiti lineari reversibili da [1], sezione 7. Questo algoritmo sintetizza qualsiasi circuito reversibile lineare di $n$ qubit su un'architettura lineare nearest-neighbor utilizzando porte CX con profondità massima di $5n$.

Parametri

mat (ndarray[bool]) – Una matrice booleana invertibile.

Risultati

Il circuito quantistico sintetizzato.

Aumenti

QiskitError - se mat non è invertibile.

Tipo di restituzione

QuantumCircuit

Riferimenti

1. Kutin, S., Moulton, D. P., Smithline, L., Calcolo a distanza, Chicago J. Theor. Computerizzato. Sci, vol. 2007, (2007), arXiv:quant-ph/0701194

qiskit.synthesis.synth_cz_depth_line_mr(mat)

Sintesi di un circuito CZ per la connettività linear nearest neighbor (LNN), basato su Maslov e Roetteler.

CXGateSi noti che questo metodo inverte l'ordine dei qubit nel circuito e restituisce un circuito contenente porte s e di fase (SGate, SdgGate o ZGate).

Parametri

mat (ndarray) – una matrice quadrata a diagonale superiore di valori booleani che rappresenta il circuito CZ. mat[i][j]=1 for i<j rappresenta un cz(i,j) cancello. Viene letto solo il triangolo superiore; la diagonale e il triangolo inferiore non hanno alcun effetto.

Risultati

Implementazione del circuito CZ di profondità $2n+2$ per la connettività LNN.

Tipo di restituzione

QuantumCircuit

Riferimenti

1. Dmitri Maslov, Martin Roetteler, Circuiti stabilizzatori più brevi tramite la decomposizione di Bruhat e le trasformazioni quantistiche dei circuiti, arXiv:1705.09176.

qiskit.synthesis.synth_cx_cz_depth_line_my(mat_x, mat_z)

Sintesi congiunta di un circuito -CZ-CX- per la connettività linear nearest neighbor (LNN), con profondità di 2 qubit al massimo 5n, basata su Maslov e Yang. Questo metodo calcola il circuito CZ all'interno del circuito CX mediante l'inserimento di gate di fase.

Parametri

• mat_z (ndarray) – una matrice simmetrica booleana che rappresenta un circuito CZ. mat_z[i][j]=1 rappresenta una porta cz(i,j)
• mat_x (ndarray) – una matrice booleana invertibile che rappresenta un circuito CX.

Risultati

Un'implementazione di un circuito CX che segue un circuito CZ, indicato come circuito -CZ-CX-, con profondità di due qubit al massimo 5n, per connettività LNN.

Tipo di restituzione

QuantumCircuit

Riferimenti

1. Kutin, S., Moulton, D. P., Smithline, L., Calcolo a distanza, Chicago J. Theor. Computerizzato. Sci, vol. 2007, (2007), arXiv:quant-ph/0701194
2. Dmitri Maslov, Willers Yang, I circuiti CNOT hanno bisogno di poco aiuto per implementare le trasformazioni di Clifford libere da Hadamard che generano, arXiv:2210.16195.

qiskit.synthesis.synth_cnot_phase_aam(cnots, angles, section_size=2)

Questa funzione è un'implementazione dell'algoritmo GraySynth di Amy, Azimadeh e Mosca.

GraySynth è un algoritmo euristico derivato dal [punto 1] per la sintesi di piccole reti di parità. Si ispira ai codici Gray. Dato un insieme di stringhe binarie $S$ (di seguito cnots denominate ), l'algoritmo sintetizza una rete di parità per $S$ scegliendo ripetutamente un indice $i$ da espandere e poi ricorrendo effettivamente sui cofattori $S_0$ e $S_1$, costituiti dalle stringhe $y \in S$, rispettivamente con $y_i = 0$ o $1$. Man mano che un sottoinsieme $S$ viene espanso in modo ricorsivo, vengono cx applicati dei gate in modo tale che un bit di destinazione designato contenga la parità (parziale) $\chi_y(x)$ dove $y_i = 1$ se e solo se $y'_i = 1$ per tutti i $y' \in S$. Se $S$ contiene un singolo elemento $\{y'\}$, allora $y = y'$, e il bit di destinazione contiene il valore $\chi_{y'}(x)$ come desiderato.

In particolare, invece di decomprimere questa sequenza di porte cx (CNOT) quando un sottoinsieme $S$ finisce di essere sintetizzato, l'algoritmo mantiene l'invariante che le restanti parità da calcolare sono espresse sullo stato attuale dei bit. In questo modo l'algoritmo evita il "backtracking" tipico dei metodi non basati sul calcolo.

L'algoritmo è descritto in dettaglio nella sezione 4. [1].

Parametri

• cnots (list[list[int]]) –

  Una matrice le cui colonne sono le parità da sintetizzare e. g.:

  [[0, 1, 1, 1, 1, 1],
   [1, 0, 0, 1, 1, 1],
   [1, 0, 0, 1, 0, 0],
   [0, 0, 1, 0, 1, 0]]

  Corrisponde a:

  x1^x2 + x0 + x0^x3 + x0^x1^x2 + x0^x1^x3 + x0^x1

• angles (list[str]) – Un elenco contenente tutte le porte di sfasamento da applicare, nello stesso ordine di cnots. Un numero viene interpretato come l'angolo di $p(angle)$, altrimenti gli elementi devono essere 't', 'tdg', 's', 'sdg' o 'z'.

• section_size (int) – La dimensione di ogni sezione nell'algoritmo di Patel-Markov-Hayes. section_size deve essere un fattore del numero di qubit.

Risultati

Il circuito quantistico scomposto.

Aumenti

QiskitError - quando le dimensioni di cnots e angles non sono allineate.

Tipo di restituzione

QuantumCircuit

Riferimenti

1. Matthew Amy, Parsiad Azimzadeh e Michele Mosca. Sulla complessità controllata-NOT dei circuiti controllati-NOT-fase.., Scienza e tecnologia quantistica 4.1 (2018): 015002. arXiv:1712.01859

qiskit.synthesis.synth_permutation_depth_lnn_kms(pattern)

Sintetizzare un circuito di permutazione per un'architettura lineare nearest-neighbor utilizzando il metodo Kutin, Moulton, Smithline.

Si tratta dell'algoritmo di sintesi permutativa di cui al punto [1], sezione 6. Sintetizza qualsiasi permutazione di n qubit su un'architettura lineare nearest-neighbor utilizzando porte SWAP con profondità massima di $n$ e dimensione massima di $n(n-1)/2$ (dove sia la profondità che la dimensione sono misurate rispetto alle SWAP).

Parametri

pattern (list[int] | ndarray[int]) – Modello di permutazione, che descrive quali qubit occupano le posizioni 0, 1, 2, ecc. dopo l'applicazione della permutazione. Cioè, pattern[k] = m quando la permutazione mappa il qubit m alla posizione k. Ad esempio, il modello [2, 4, 3, 0, 1] significa che il qubit 2 va nella posizione 0, il qubit 4 va nella posizione 1, ecc.

Risultati

Il circuito quantistico sintetizzato.

Tipo di restituzione

QuantumCircuit

Riferimenti

1. Samuel A. Kutin, David Petrie Moulton e Lawren M. Smithline. Calcolo a distanza.., arXiv:quant-ph/0701194v1

qiskit.synthesis.synth_permutation_basic(pattern)

Sintetizzare un circuito di permutazione per un'architettura completamente connessa utilizzando l'ordinamento.

Più precisamente, se la permutazione in ingresso è un ciclo di lunghezza m, allora si crea un circuito quantistico con m-1 SWAP (e di profondità m-1); se la permutazione in ingresso consiste in più cicli disgiunti, allora ogni ciclo viene trattato essenzialmente in modo indipendente.

Parametri

pattern (list[int] | ndarray[int]) – Modello di permutazione, che descrive quali qubit occupano le posizioni 0, 1, 2, ecc. dopo l'applicazione della permutazione. Cioè, pattern[k] = m quando la permutazione mappa il qubit m alla posizione k. Ad esempio, il modello [2, 4, 3, 0, 1] significa che il qubit 2 va nella posizione 0, il qubit 4 va nella posizione 1, ecc.

Risultati

Il circuito quantistico sintetizzato.

Tipo di restituzione

QuantumCircuit

qiskit.synthesis.synth_permutation_acg(pattern)

Sintetizzare un circuito di permutazione per un'architettura completamente connessa utilizzando il metodo di Alon, Chung e Graham.

Questo produce un circuito quantistico di profondità 2 (misurato in numero di SWAP).

Questa implementazione si basa sulla proposizione 4.1 della referenza [1], la cui dimostrazione dettagliata è contenuta nel teorema 2 della referenza [2]

Parametri

pattern (list[int] | ndarray[int]) – Modello di permutazione, che descrive quali qubit occupano le posizioni 0, 1, 2, ecc. dopo l'applicazione della permutazione. Cioè, pattern[k] = m quando la permutazione mappa il qubit m alla posizione k. Ad esempio, il modello [2, 4, 3, 0, 1] significa che il qubit 2 va nella posizione 0, il qubit 4 va nella posizione 1, ecc.

Risultati

Il circuito quantistico sintetizzato.

Tipo di restituzione

QuantumCircuit

Riferimenti

1. del contatto Alon, F. R. K. Chung e R. L. Graham. Permutazioni di instradamento su grafici tramite abbinamenti.., Atti del venticinquesimo simposio annuale ACM sulla teoria dell'informatica (1993). Pagine 583-591. (Estratto) 10.1145/167088.167239
2. del contatto Alon, F. R. K. Chung e R. L. Graham. Permutazioni di instradamento su grafici tramite abbinamenti.., (Articolo completo)

qiskit.synthesis.synth_permutation_reverse_lnn_kms(num_qubits)

Sintetizzare la permutazione inversa per architetture lineari nearest-neighbor utilizzando il metodo di Kutin, Moulton, Smithline.

Algoritmo di sintesi per la permutazione inversa da [1], sezione 5. Questo algoritmo sintetizza la permutazione inversa su $n$ qubit su un'architettura lineare nearest-neighbor utilizzando porte CX con profondità $2 * n + 2$.

Parametri

num_qubits (int) – Il numero di qubit.

Risultati

Il circuito quantistico sintetizzato.

Tipo di restituzione

QuantumCircuit

Riferimenti

1. Kutin, S., Moulton, D. P., Smithline, L., Calcolo a distanza, Chicago J. Theor. Computerizzato. Sci, vol. 2007, (2007), arXiv:quant-ph/0701194

qiskit.synthesis.synth_clifford_full(clifford, method=None)

Scomporre un Clifford operatore in un QuantumCircuit.

Per $N \leq 3$ qubit questo si basa sulla decomposizione ottimale dei costi CX di cui al riferimento [1]. Per $N > 3$ qubit si utilizza la routine di compilazione generale non ottimale greedy della referenza [3], che in genere produce un costo CX migliore rispetto al metodo AG della [2].

Parametri

• clifford (Clifford) – Un operatore di Clifford.
• method (str | None) – un metodo di sintesi ('AG' o 'greedy'). Se impostato, questo parametro prevale sulla decomposizione ottimale per i qubit di tipo $N \leq 3$.

Risultati

Un'implementazione circuitale della Clifford.

Tipo di restituzione

QuantumCircuit

Riferimenti

1. S. Bravyi, D. Maslov, Circuiti privi di Hadamard espongono la struttura del gruppo di Clifford, arXiv:2003.09412 [quant-ph]
2. S. Aaronson, D. Gottesman, Improved Simulation of Stabilizer Circuits, Phys. Rev. A 70, 052328 (2004). arXiv:quant-ph/0406196
3. Sergey Bravyi, Shaohan Hu, Dmitri Maslov, Ruslan Shaydulin, Clifford Circuit Optimization with Templates and Symbolic Pauli Gates, arXiv:2105.02291 [quant-ph]

qiskit.synthesis.synth_clifford_ag(clifford)

Scomporre un Clifford operatore in un QuantumCircuit secondo il metodo di Aaronson-Gottesman [1].

Parametri

clifford (Clifford) – Un operatore di Clifford.

Risultati

Un'implementazione circuitale della Clifford.

Tipo di restituzione

QuantumCircuit

Riferimenti

1. S. Aaronson, D. Gottesman, Improved Simulation of Stabilizer Circuits, Phys. Rev. A 70, 052328 (2004). arXiv:quant-ph/0406196

qiskit.synthesis.synth_clifford_bm(clifford)

Scomposizione ottimale del costo CX di un Clifford operatore su 2 o 3 qubit in un operatore QuantumCircuit basato sul metodo di Bravyi-Maslov [1].

Parametri

clifford (Clifford) – Un operatore di Clifford.

Risultati

Un'implementazione circuitale della Clifford.

Aumenti

QiskitError - se Clifford è su più di 3 qubit.

Tipo di restituzione

QuantumCircuit

Riferimenti

1. S. Bravyi, D. Maslov, Circuiti privi di Hadamard espongono la struttura del gruppo di Clifford, arXiv:2003.09412 [quant-ph]

qiskit.synthesis.synth_clifford_greedy(clifford)

Scomporre un Clifford operatore in un QuantumCircuit basandosi sul compilatore di Clifford "greedy" descritto nell'Appendice A di Bravyi, Hu, Maslov e Shaydulin [1].

Questo metodo produce in genere un costo CX migliore rispetto al metodo Aaronson-Gottesman.

Si noti che questa funzione implementa solo il compilatore Clifford greedy dell'Appendice A di [1] e non le ottimizzazioni dei template e delle porte di Pauli simboliche, menzionate nello stesso documento.

Parametri

clifford (Clifford) – Un operatore di Clifford.

Risultati

Un'implementazione circuitale della Clifford.

Aumenti

QiskitError - se l'eliminazione gaussiana simplettica fallisce.

Tipo di restituzione

QuantumCircuit

Riferimenti

1. Sergey Bravyi, Shaohan Hu, Dmitri Maslov, Ruslan Shaydulin, Clifford Circuit Optimization with Templates and Symbolic Pauli Gates, arXiv:2105.02291 [quant-ph]

qiskit.synthesis.synth_clifford_layers(cliff, cx_synth_func=<function _default_cx_synth_func>, cz_synth_func=<function _default_cz_synth_func>, cx_cz_synth_func=None, cz_func_reverse_qubits=False, validate=False)

La sintesi di a Clifford in strati fornisce una scomposizione simile alla sintesi descritta nel Lemma 8 di Bravyi e Maslov [1].

Ad esempio, un circuito Clifford a 5 qubit viene scomposto nei seguenti strati:

     ┌─────┐┌─────┐┌────────┐┌─────┐┌─────┐┌─────┐┌─────┐┌────────┐
q_0: ┤0    ├┤0    ├┤0       ├┤0    ├┤0    ├┤0    ├┤0    ├┤0       ├
     │     ││     ││        ││     ││     ││     ││     ││        │
q_1: ┤1    ├┤1    ├┤1       ├┤1    ├┤1    ├┤1    ├┤1    ├┤1       ├
     │     ││     ││        ││     ││     ││     ││     ││        │
q_2: ┤2 S2 ├┤2 CZ ├┤2 CX_dg ├┤2 H2 ├┤2 S1 ├┤2 CZ ├┤2 H1 ├┤2 Pauli ├
     │     ││     ││        ││     ││     ││     ││     ││        │
q_3: ┤3    ├┤3    ├┤3       ├┤3    ├┤3    ├┤3    ├┤3    ├┤3       ├
     │     ││     ││        ││     ││     ││     ││     ││        │
q_4: ┤4    ├┤4    ├┤4       ├┤4    ├┤4    ├┤4    ├┤4    ├┤4       ├
     └─────┘└─────┘└────────┘└─────┘└─────┘└─────┘└─────┘└────────┘

Questa decomposizione si riferisce alle funzioni predefinite cz_synth_func e cx_synth_func , mentre con altre funzioni si può osservare una decomposizione leggermente diversa.

Parametri

• cliff (Clifford) – Un operatore di Clifford.
• cx_synth_func (Callable[[ndarray], QuantumCircuit]) – Una funzione per scomporre il sottocircuito CX. Riceve in ingresso una matrice invertibile booleana e restituisce in uscita una QuantumCircuit.
• cz_synth_func (Callable[[ndarray], QuantumCircuit]) – Una funzione per decomporre il sottocircuito CZ. Riceve in ingresso una matrice simmetrica booleana ed emette una matrice QuantumCircuit.
• cx_cz_synth_func (Callable) – opzionale, una funzione per decomporre entrambi i sottocircuiti CZ e CX.
• validate (Boolean) – se Vero, convalida il processo di sintesi.
• cz_func_reverse_qubits (Boolean) – Vero solo se cz_synth_func è synth_cz_depth_line_mr()poiché questa funzione restituisce un circuito che inverte l'ordine dei qubit.

Risultati

Un'implementazione circuitale della Clifford.

Tipo di restituzione

QuantumCircuit

Riferimenti

1. S. Bravyi, D. Maslov, Circuiti privi di Hadamard espongono la struttura del gruppo di Clifford, arXiv:2003.09412 [quant-ph]

qiskit.synthesis.synth_clifford_depth_lnn(cliff)

Sintesi di un Clifford in strati per ottenere una connettività lineare “nearest neighbor”.

La profondità del circuito a n-qubit sintetizzato è limitata da $7n+2$, che non è ottimale. Dovrebbe essere sostituito da un algoritmo migliore che fornisca una profondità delimitata da $7n-4$ [3].

Parametri

cliff (Clifford) – un operatore di Clifford.

Risultati

un'implementazione circuitale della Clifford.

Tipo di restituzione

QuantumCircuit

Riferimenti

1. S. Bravyi, D. Maslov, Circuiti privi di Hadamard espongono la struttura del gruppo di Clifford, arXiv:2003.09412 [quant-ph]
2. Dmitri Maslov, Martin Roetteler, Circuiti stabilizzatori più brevi tramite la decomposizione di Bruhat e le trasformazioni quantistiche dei circuiti, arXiv:1705.09176.
3. Dmitri Maslov, Willers Yang, I circuiti CNOT hanno bisogno di poco aiuto per implementare le trasformazioni di Clifford libere da Hadamard che generano, arXiv:2210.16195.

qiskit.synthesis.synth_cnotdihedral_full(elem)

Scomporre un CNOTDihedral elemento in un QuantumCircuit.

Per $N \leq 2$ qubit questo si basa sulla decomposizione ottimale dei costi CX di cui alla referenza [1]. Per $N > 2$ qubit questo viene fatto usando la routine di compilazione generale non ottimale della referenza [2].

Parametri

elem (CNOTDihedral) – Un CNOTDihedral elemento.

Risultati

CNOTDihedral Implementazione circuitale dell'elemento.

Tipo di restituzione

QuantumCircuit

Riferimenti

1. Shelly Garion e Andrew W. Cross, Synthesis of CNOT-Dihedral circuits with optimal number of two qubit gates, Quantum 4(369), 2020
2. Andrew W. Cross, Easwar Magesan, Lev S. Bishop, John A. Smolin e Jay M. Gambetta, Scalable randomized benchmarking of non-Clifford gates, npj Quantum Inf 2, 16012 (2016).

qiskit.synthesis.synth_cnotdihedral_two_qubits(elem)

Scomporre un CNOTDihedral elemento su un singolo qubit e su due qubit in un QuantumCircuit. Questa scomposizione presenta un numero ottimale di CXGates.

Parametri

elem (CNOTDihedral) – Un CNOTDihedral elemento.

Risultati

CNOTDihedral Implementazione circuitale dell'elemento.

Aumenti

CNOTDihedralQiskitError – se l'elemento non è a 1 o 2 qubit.

Tipo di restituzione

QuantumCircuit

Riferimenti

1. Shelly Garion e Andrew W. Cross, Sulla struttura del gruppo CNOT-Diedrale, arXiv:2006.12042 [quant-ph]

qiskit.synthesis.synth_cnotdihedral_general(elem)

Scomporre un CNOTDihedral elemento in un QuantumCircuit.

Scomporre un elemento generico CNOTDihedral in elementi. Il numero di gate CX non è necessariamente ottimale. Per una scomposizione di un elemento a 1 o 2 qubit, chiamare synth_cnotdihedral_two_qubits().

Parametri

elem (CNOTDihedral) – Un CNOTDihedral elemento.

Risultati

CNOTDihedral Implementazione circuitale dell'elemento.

Aumenti

QiskitError - se l'elemento non può essere scomposto in un circuito.

Tipo di restituzione

QuantumCircuit

Riferimenti

1. Andrew W. Cross, Easwar Magesan, Lev S. Bishop, John A. Smolin e Jay M. Gambetta, Scalable randomized benchmarking of non-Clifford gates, npj Quantum Inf 2, 16012 (2016).

qiskit.synthesis.synth_stabilizer_layers(stab, cz_synth_func=<function _default_cz_synth_func>, cz_func_reverse_qubits=False, validate=False)

Sintesi di uno stato stabilizzatore in strati.

Fornisce una scomposizione simile alla sintesi descritta nel Lemma 8 del riferimento [1], senza il sottocircuito iniziale privo di Hadamard che non influisce sullo stato dello stabilizzatore.

Ad esempio, uno stato stabilizzatore a 5-qubit viene scomposto nei seguenti strati:

     ┌─────┐┌─────┐┌─────┐┌─────┐┌────────┐
q_0: ┤0    ├┤0    ├┤0    ├┤0    ├┤0       ├
     │     ││     ││     ││     ││        │
q_1: ┤1    ├┤1    ├┤1    ├┤1    ├┤1       ├
     │     ││     ││     ││     ││        │
q_2: ┤2 H2 ├┤2 S1 ├┤2 CZ ├┤2 H1 ├┤2 Pauli ├
     │     ││     ││     ││     ││        │
q_3: ┤3    ├┤3    ├┤3    ├┤3    ├┤3       ├
     │     ││     ││     ││     ││        │
q_4: ┤4    ├┤4    ├┤4    ├┤4    ├┤4       ├
     └─────┘└─────┘└─────┘└─────┘└────────┘

Parametri

• stab (StabilizerState) – Uno stato stabilizzatore.
• cz_synth_func (Callable[[ndarray], QuantumCircuit]) – Una funzione per decomporre il sottocircuito CZ. Riceve in ingresso una matrice simmetrica booleana ed emette una matrice QuantumCircuit.
• cz_func_reverse_qubits (bool) – True solo se cz_synth_func è synth_cz_depth_line_mr()poiché questa funzione restituisce un circuito che inverte l'ordine dei qubit.
• validate (bool) – Se True, convalida il processo di sintesi.

Risultati

Un'implementazione del circuito dello stato stabilizzatore.

Aumenti

QiskitError – se l'input non è un StabilizerState.

Tipo di restituzione

QuantumCircuit

Riferimenti

1. S. Bravyi, D. Maslov, Circuiti privi di Hadamard espongono la struttura del gruppo di Clifford, arXiv:2003.09412 [quant-ph]

qiskit.synthesis.synth_stabilizer_depth_lnn(stab)

CXGateSintesi di uno stato stabilizzatore a n qubit per una connettività lineare tra vicini più prossimi, con profondità di 2 qubit $2n+2$ e due strati CX distinti, utilizzando gate s e di fase (SGate, SdgGate o ZGate).

Parametri

stab (StabilizerState) – Uno stato stabilizzatore.

Risultati

Un'implementazione del circuito dello stato stabilizzatore.

Tipo di restituzione

QuantumCircuit

Riferimenti

1. S. Bravyi, D. Maslov, Circuiti privi di Hadamard espongono la struttura del gruppo di Clifford, arXiv:2003.09412 [quant-ph]
2. Dmitri Maslov, Martin Roetteler, Circuiti stabilizzatori più brevi tramite la decomposizione di Bruhat e le trasformazioni quantistiche dei circuiti, arXiv:1705.09176.

qiskit.synthesis.synth_circuit_from_stabilizers(stabilizers, allow_redundant=False, allow_underconstrained=False, invert=False)

Sintesi di un circuito che genera uno stato stabilizzato dagli stabilizzatori utilizzando l'eliminazione gaussiana con porte Clifford. Se gli stabilizzatori sono poco vincolati e allow_underconstrained è True, il circuito emetterà uno degli stati stabilizzati dagli stabilizzatori. Basato sull'implementazione di stimoli.

Parametri

• stabilizers (Collection[str]) – Elenco delle corde di stabilizzazione
• allow_redundant (bool) – Consentire stabilizzatori ridondanti (ovvero, alcuni stabilizzatori possono essere il prodotto di altri)
• allow_underconstrained (bool) – Consentire un insieme di stabilizzatori sottodeterminato (ovvero, gli stabilizzatori non specificano uno stato univoco)
• invert (bool) – Circuito inverso di ritorno

Risultati

Un circuito che genera uno stato stabilizzato da stabilizers.

Aumenti

QiskitError - se gli stabilizzatori non sono validi, non commutano o si contraddicono, se la lista è sottocostretta e allow_underconstrained è False, o se la lista è ridondante e allow_redundant è False.

Tipo di restituzione

QuantumCircuit

Riferimenti

1. https://github.com/quantumlib/Stim/blob/c0dd0b1c8125b2096cd54b6f72884a459e47fe3e/src/stim/stabilizers/conversions.inl#L469
2. https://quantumcomputing.stackexchange.com/questions/12721/how-to-calculate-destabilizer-group-of-toric-and-other-codes

qiskit.synthesis.gridsynth_rz(angle, epsilon=1e-10)

Rotazione RZ approssimativa utilizzando l'algoritmo di Ross-Selinger.

L'algoritmo è descritto al punto [1]. Il codice sorgente (in Rust) è disponibile all'indirizzo https://github.com/qiskit-community/rsgridsynth.

Parametri

• angle (float) – Specifica l'angolo di rotazione RZ.
• epsilon (float) – L'errore di approssimazione consentito.

Risultati

Un circuito a un qubit che approssima RZ(angle).

Tipo di restituzione

QuantumCircuit

Riferimenti:

[1] Neil J. Ross, Peter Selinger, Approssimazione ottimale senza ancilla Clifford+T delle rotazioni z,

arXiv:1403.2975

qiskit.synthesis.gridsynth_unitary(matrix, epsilon=1e-10)

Approssimare una matrice unitaria a 1 qubit utilizzando l'algoritmo di Ross-Selinger.

L'algoritmo è descritto al punto [1]. Il codice sorgente (in Rust) è disponibile all'indirizzo https://github.com/qiskit-community/rsgridsynth.

Parametri

• matrix (ndarray) – Una matrice unitaria $2 imes 2$.
• epsilon (float) – L'errore di approssimazione consentito.

Risultati

Un circuito a un qubit che approssima matrix.

Tipo di restituzione

QuantumCircuit

Riferimenti:

[1] Neil J. Ross, Peter Selinger, Approssimazione ottimale senza ancilla Clifford+T delle rotazioni z,

arXiv:1403.2975

qiskit.synthesis.generate_basic_approximations(basis_gates, depth, filename=None)

Genera un elenco di GateSequences con le porte in basis_gates.

Parametri

• basis_gates (list[str |Gate]) – Le porte da cui partire per creare le sequenze di porte.
• depth (int) – La profondità massima delle approssimazioni.
• filename (str | None) – Se fornito, le approssimazioni di base vengono memorizzate in questo file.

Risultati

Elenco dei siti GateSequenceche utilizzano le porte in basis_gates.

Aumenti

ValueError - Se basis_gates contiene un identificatore di gate non valido.

Tipo di restituzione

elenco [GateSequence]

qiskit.synthesis.synth_qft_line(num_qubits, do_swaps=True, approximation_degree=0)

Costruire un circuito per la trasformata di Fourier quantistica utilizzando la connettività lineare dei vicini.

La costruzione si basa sulla figura 2.b di Fowler et al. [1].

Parametri

• num_qubits (int) – Il numero di qubit su cui agisce la trasformata quantistica di Fourier.
• approximation_degree (int) – Il grado di approssimazione (0 per nessuna approssimazione). È possibile implementare la QFT ignorando approssimativamente le rotazioni a fase controllata con angolo inferiore a una soglia. Questo aspetto è discusso in modo più dettagliato in https://arxiv.org/abs/quant-ph/9601018 o https://arxiv.org/abs/quant-ph/0403071.
• do_swaps (bool) – Se sintetizzare l'operazione "QFT" o "QFT con inversione".

Risultati

Un circuito che implementa l'operazione QFT.

Tipo di restituzione

QuantumCircuit

Riferimenti

1. A. G. Fowler, S. J. Devitt e L. C. L. Hollenberg, Implementazione dell'algoritmo di Shor su un array lineare di qubit nearest neighbour, Quantum Info. Computerizzato. 4, 4 (luglio 2004), 237-251. arXiv:quant-ph/0402196 [quant-ph]

qiskit.synthesis.synth_qft_full(num_qubits, do_swaps=True, approximation_degree=0, insert_barriers=False, inverse=False, name=None)

Costruire un circuito per la trasformata quantistica di Fourier utilizzando la connettività all-to-all.

Parametri

• num_qubits (int) – Il numero di qubit su cui agisce la trasformata quantistica di Fourier.
• do_swaps (bool) – Se sintetizzare l'operazione "QFT" o "QFT con inversione".
• approximation_degree (int) – Il grado di approssimazione (0 per nessuna approssimazione). È possibile implementare la QFT ignorando approssimativamente le rotazioni a fase controllata con angolo inferiore a una soglia. Questo aspetto è discusso in modo più dettagliato in https://arxiv.org/abs/quant-ph/9601018 o https://arxiv.org/abs/quant-ph/0403071.
• insert_barriers (bool) – Se True, vengono inserite delle barriere per migliorare la visualizzazione.
• inverse (bool) – Se True, si costruisce la trasformata quantistica di Fourier inversa.
• name (str | None) – Il nome del circuito.

Risultati

Un circuito che implementa l'operazione QFT.

Tipo di restituzione

QuantumCircuit

qiskit.synthesis.qs_decomposition(mat, opt_a1=None, opt_a2=None, decomposer_1q=None, decomposer_2q=None, *, _depth=0)

Decompone una matrice unitaria in porte a uno e due qubit utilizzando la Decomposizione Quantistica di Shannon, basata sulla Decomposizione ZXZ a blocchi.

Questa decomposizione è descritta in Krol e Al-Ars [2] e migliora il metodo di Shende et al. [1].

  ┌───┐              ┌───┐     ┌───┐
 ─┤   ├─      ────□──┤ H ├──□──┤ H ├──□──
  │   │    ≃    ┌─┴─┐└───┘┌─┴─┐└───┘┌─┴─┐
/─┤   ├─      ──┤ C ├─────┤ B ├─────┤ A ├
  └───┘         └───┘     └───┘     └───┘

Senza le ottimizzazioni, il numero di CXGates generato dalla scomposizione è lo stesso del metodo non ottimizzato riportato in [1] :

L'ottimizzazione " A.1 ", che migliora [la versione 1] e viene applicata automaticamente, consente di risparmiare due CXGatesecondi anziché uno in ogni fase della ricorsione, riducendo il numero di CX di:

L' A.2 di ottimizzazione, come nel punto [1], scompone le operazioni unitarie a due qubit in un gate diagonale e in un'operazione unitaria a due CX, riducendo ulteriormente il numero di CX di:

Poiché questa ottimizzazione non deve essere eseguita se l'unitario originale è controllato, viene applicata automaticamente a meno che la matrice di input non sia equivalente a un unitario controllato (diagonale a blocchi).

Pertanto, il numero di CXGates generato dalla scomposizione con entrambe le ottimizzazioni applicate è:

Parametri

• mat (ndarray) – matrice unitaria da scomporre
• opt_a1 (bool | None) – questo argomento è deprecato; l'ottimizzazione viene applicata automaticamente quando None (impostazione predefinita).
• opt_a2 (bool | None) – questo argomento è deprecato; l'ottimizzazione viene applicata automaticamente quando None (impostazione predefinita).
• decomposer_1q (Callable[[ndarray], QuantumCircuit] | None) – decompositore opzionale 1Q, un'istanza di OneQubitEulerDecomposer. In tal caso None, viene utilizzata la decomposizione predefinita a un qubit.
• decomposer_2q (Callable[[ndarray], QuantumCircuit] | None) – decompositore opzionale 2Q, un'istanza di TwoQubitBasisDecomposer. In tal caso None, viene utilizzata la decomposizione predefinita a due qubit.

Risultati

Circuito quantistico decomposto.

Tipo di restituzione

QuantumCircuit

Riferimenti

1. Shende, Bullock, Markov, Sintesi di circuiti logici quantistici, arXiv:0406176 [quant-ph]
2. Krol, Al-Ars, Oltre Shannon quantistico: costruzione di circuiti per porte generali a n-Qubit basate sulla decomposizione ZXZ a blocchi, arXiv:2403.13692

qiskit.synthesis.two_qubit_cnot_decompose(*args, **kwargs)

Si tratta di un'istanza di TwoQubitBasisDecomposer che utilizza cx sempre come gate KAK per la decomposizione in basi. cxÈ possibile utilizzare questa funzione come accesso rapido alle decomposizioni a 2 qubit basate su.

Parametri

• unitary (Operator or np.ndarray) – L' 4x4 e unitario da sintetizzare.
• basis_fidelity (float or None) – Se si considera la fedeltà ipotizzata per le applicazioni di CXGate.
• approximate (bool) – Se True approssima se basis_fidelity è inferiore a 1.0.

Risultati

Il circuito sintetizzato dell'ingresso unitario.

Tipo di restituzione

QuantumCircuit

qiskit.synthesis.synth_mcmt_vchain(gate, num_ctrl_qubits, num_target_qubits, ctrl_state=None)

Sintetizzare MCMT utilizzando una catena a V.

Questo utilizza una catena di porte CCX, utilizzando num_ctrl_qubits - 1 qubit ausiliari.

Ad esempio, una porta H a 3 controlli e 2 obiettivi sarà sintetizzata come:

q_0: ──■────────────────────────■──
       │                        │
q_1: ──■────────────────────────■──
       │                        │
q_2: ──┼────■──────────────■────┼──
       │    │  ┌───┐       │    │
q_3: ──┼────┼──┤ H ├───────┼────┼──
       │    │  └─┬─┘┌───┐  │    │
q_4: ──┼────┼────┼──┤ H ├──┼────┼──
     ┌─┴─┐  │    │  └─┬─┘  │  ┌─┴─┐
q_5: ┤ X ├──■────┼────┼────■──┤ X ├
     └───┘┌─┴─┐  │    │  ┌─┴─┐└───┘
q_6: ─────┤ X ├──■────■──┤ X ├─────
          └───┘          └───┘

Parametri

• gate (Gate) – Porta di base da applicare ai bersagli.
• num_ctrl_qubits (int) – Numero di qubit di controllo.
• num_target_qubits (int) – Numero di qubit di destinazione.
• ctrl_state (int | None) – Stato di controllo opzionale come numero intero.

Risultati

Il circuito sintetizzato per il gate MCMT.

Tipo di restituzione

QuantumCircuit

qiskit.synthesis.synth_mcmt_xgate(num_ctrl_qubits, num_target_qubits, ctrl_state=None)

Sintetizzare la porta MCMT X.

Utilizza una struttura circuitale speciale che è efficiente per le porte MCMT X. Non richiede qubit ausiliari e beneficia di efficienti decomposizioni MCX.

E.g. una porta X a 3 controlli e 3 target sarà sintetizzata come:

q_0: ─────────────■────────────
                  |
q_1: ─────────────■────────────
                  |
q_2: ─────────────■────────────
                ┌─┴─┐
q_3: ────────■──┤ X ├──■───────
           ┌─┴─┐└───┘┌─┴─┐
q_4: ───■──┤ X ├─────┤ X ├──■──
      ┌─┴─┐└───┘     └───┘┌─┴─┐
q_5: ─┤ X ├───────────────┤ X ├
      └───┘               └───┘

Parametri

• num_ctrl_qubits (int) – Numero di qubit di controllo.
• num_target_qubits (int) – Numero di qubit di destinazione.
• ctrl_state (int | None) – Stato di controllo opzionale come numero intero.

Risultati

Il circuito sintetizzato per la porta MCMT X.

Tipo di restituzione

QuantumCircuit

qiskit.synthesis.synth_mcx_1_clean_kg24(num_ctrl_qubits)

Sintetizzare una porta X a controlli multipli con controlli di tipo $k\ge 3$ utilizzando un qubit ausiliario pulito di tipo $1$, ottenendo un circuito con porte Toffoli di tipo $2k-3$ o porte CX di tipo $6k-6$ e una profondità $O(k)$, come descritto nella Sez. 5.1 di [1]. Per l’ $k\le 2$ a, il circuito restituito è costituito da un singolo gate X, CX o CCX (corrispondente rispettivamente a un $k = 0, 1, 2$ ) e non utilizza qubit ausiliari.

Parametri

num_ctrl_qubits (int) – Il numero di qubit di controllo.

Risultati

Il circuito quantistico sintetizzato.

Aumenti

QiskitError – se num_ctrl_qubits è illegale.

Tipo di restituzione

QuantumCircuit

Riferimenti

1. Khattar e Gidney, L'ascesa di ancille condizionalmente pulite per l'ottimizzazione dei circuiti quantistici arXiv:2407.17966

qiskit.synthesis.synth_mcx_1_dirty_kg24(num_ctrl_qubits)

Sintetizzare una porta X a controlli multipli con controlli di tipo $k\ge 3$ utilizzando un qubit ausiliario "dirty" di tipo $1$, ottenendo un circuito con porte Toffoli di tipo $4k-8$ o porte CX di tipo $12k-18$ e una profondità $O(k)$, come descritto nella Sez. 5.3 di [1]. Per l’ $k\le 2$ a, il circuito restituito è costituito da un singolo gate X, CX o CCX (corrispondente rispettivamente a un $k = 0, 1, 2$ ) e non utilizza qubit ausiliari.

Parametri

num_ctrl_qubits (int) – Il numero di qubit di controllo.

Risultati

Il circuito quantistico sintetizzato.

Aumenti

QiskitError – se num_ctrl_qubits è illegale.

Tipo di restituzione

QuantumCircuit

Riferimenti

1. Khattar e Gidney, L'ascesa di ancille condizionalmente pulite per l'ottimizzazione dei circuiti quantistici arXiv:2407.17966

qiskit.synthesis.synth_mcx_2_clean_kg24(num_ctrl_qubits)

Sintetizzare una porta X a controlli multipli con controlli di tipo $k\ge 3$ utilizzando qubit ausiliari $2$ puliti, ottenendo un circuito con porte Toffoli di tipo $2k-3$ o porte CX di tipo $6k-6$ e una profondità $O(\log(k))$, come descritto nella Sez. 5.2 di [1]. Per l’ $k\le 2$ a, il circuito restituito è costituito da un singolo gate X, CX o CCX (corrispondente rispettivamente a un $k = 0, 1, 2$ ) e non utilizza qubit ausiliari.

Parametri

num_ctrl_qubits (int) – Il numero di qubit di controllo.

Risultati

Il circuito quantistico sintetizzato.

Aumenti

QiskitError – se num_ctrl_qubits è illegale.

Tipo di restituzione

QuantumCircuit

Riferimenti

1. Khattar e Gidney, L'ascesa di ancille condizionalmente pulite per l'ottimizzazione dei circuiti quantistici arXiv:2407.17966

qiskit.synthesis.synth_mcx_2_dirty_kg24(num_ctrl_qubits)

Sintetizzare una porta X a controlli multipli con controlli di tipo $k\ge 3$ utilizzando qubit ausiliari $2$ che producono un circuito con porte Toffoli di tipo $4k-8$ o porte CX di tipo $12k-18$ e profondità $O(\log(k))$, come descritto nella Sez. 5.4 di [1]. Per l’ $k\le 2$ a, il circuito restituito è costituito da un singolo gate X, CX o CCX (corrispondente rispettivamente a un $k = 0, 1, 2$ ) e non utilizza qubit ausiliari.

Parametri

num_ctrl_qubits (int) – Il numero di qubit di controllo.

Risultati

Il circuito quantistico sintetizzato.

Aumenti

QiskitError – se num_ctrl_qubits è illegale.

Tipo di restituzione

QuantumCircuit

Riferimenti

1. Khattar e Gidney, L'ascesa di ancille condizionalmente pulite per l'ottimizzazione dei circuiti quantistici arXiv:2407.17966

qiskit.synthesis.synth_mcx_n_dirty_i15(num_ctrl_qubits, relative_phase=False, action_only=False)

Sintetizzare un gate X multicontrollato con controlli $k$ basato sull'articolo di Iten et al. [1].

Per l' $k\ge 4$ o, il metodo utilizza $k - 2$ qubit ausiliari "dirty", generando un circuito con $2 * k - 1$ qubit e al massimo $8 * k - 6$ porte CX. Per l' $k\le 3$ si utilizzano invece circuiti efficienti progettati appositamente che non richiedono qubit ausiliari.

Parametri

• num_ctrl_qubits (int) – Il numero di qubit di controllo.
• relative_phase (bool) – quando è impostato su True, il metodo applica la porta X multicontrollata ottimizzata fino a una fase relativa, in modo che, per il lemma 8 di [1], le fasi relative di action part si annullino con le fasi di reset part.
• action_only (bool) – quando è impostato su True, il metodo applica solo il action part del lemma 8 dell' [1].

Risultati

Il circuito quantistico sintetizzato.

Aumenti

QiskitError – se num_ctrl_qubits è illegale.

Tipo di restituzione

QuantumCircuit

Riferimenti

1. Iten e altri. et al., Circuiti quantistici per isometrie, Phys. Rev. A 93, 23/03/2018 (2016), arXiv:1501.06911

qiskit.synthesis.synth_mcx_n_clean_m15(num_ctrl_qubits)

Sintetizzare una porta X a controlli multipli con comandi di tipo $k\ge 3$ utilizzando qubit ausiliari puliti di tipo $k - 2$, realizzando un circuito con qubit di tipo $2 * k - 1$ e al massimo $6 * k - 6$ porte CX, secondo Maslov [1]. Per l’ $k\le 2$ a, il circuito restituito è costituito da un singolo gate X, CX o CCX (corrispondente rispettivamente a un $k = 0, 1, 2$ ) e non utilizza qubit ausiliari.

Parametri

num_ctrl_qubits (int) – Il numero di qubit di controllo.

Risultati

Il circuito quantistico sintetizzato.

Aumenti

QiskitError – se num_ctrl_qubits è illegale.

Tipo di restituzione

QuantumCircuit

Riferimenti

1. Maslov, Fisico. Rev. A 93, 022311 (2016), arXiv:1508.03273

qiskit.synthesis.synth_mcx_1_clean_b95(num_ctrl_qubits)

Sintetizzare una porta X a controlli multipli con controlli di tipo $k\ge 3$ utilizzando un unico qubit ausiliario pulito, in modo da ottenere un circuito con $k + 2$ qubit e al massimo $16 * k - 24$ porte CX, per [1], [2]. Per l’ $k\le 2$ a, il circuito restituito è costituito da un singolo gate X, CX o CCX (corrispondente rispettivamente a un $k = 0, 1, 2$ ) e non utilizza qubit ausiliari.

Parametri

num_ctrl_qubits (int) – Il numero di qubit di controllo.

Risultati

Il circuito quantistico sintetizzato.

Aumenti

QiskitError – se num_ctrl_qubits è illegale.

Tipo di restituzione

QuantumCircuit

Riferimenti

1. Barenco et. al, Porte elementari per la computazione quantistica, Phys.Rev. A52 3457 (1995), arXiv:quant-ph/9503016
2. Iten e altri. et al., Circuiti quantistici per isometrie, Phys. Rev. A 93, 23/03/2018 (2016), arXiv:1501.06911

qiskit.synthesis.synth_mcx_noaux_v24(num_ctrl_qubits)

Sintetizzare una porta X multicontrollata con controlli $k$ sulla base dell'implementazione per MCPhaseGate.

A sua volta, il gate MCPhase utilizza la decomposizione per gli unitari speciali multicontrollati descritta in [1].

Produce un circuito quantistico con $k + 1$ qubit. Il numero di porte CX è quadratico in $k$.

Parametri

num_ctrl_qubits (int) – Il numero di qubit di controllo.

Risultati

Il circuito quantistico sintetizzato.

Aumenti

QiskitError – se num_ctrl_qubits è illegale.

Tipo di restituzione

QuantumCircuit

Riferimenti

1. Vale et. al, Decomposizione circuitale di porte unitarie speciali multicontrollate a singolo Qubit, IEEE TCAD 43(3) (2024), arXiv:2302.06377

qiskit.synthesis.synth_mcx_noaux_hp24(num_ctrl_qubits)

Sintetizzare un gate X multicontrollato con controlli $k$ basato sul lavoro di Huang e Palsberg.

Produce un circuito quantistico con $k + 1$ qubit. Il numero di porte CX è lineare in $k$.

Parametri

num_ctrl_qubits (int) – Il numero di qubit di controllo.

Risultati

Il circuito quantistico sintetizzato.

Aumenti

QiskitError – se num_ctrl_qubits è illegale.

Tipo di restituzione

QuantumCircuit

Riferimenti

1. Huang e Palsberg, Compilazione di porte quantistiche condizionali senza l'uso di Qubit di aiuto, PLDI (2024), <https://dl.acm.org/doi/10.1145/3656436> `\code(0144)_

qiskit.synthesis.synth_mcx_gray_code(num_ctrl_qubits)

Sintetizza un circuito X-gate a controlli multipli con controlli di tip $k\ge 3$ i utilizzando il codice Gray.

Genera un circuito quantistico con $k + 1$ qubit. Questo metodo genera un numero esponenziale di porte CX e dovrebbe essere utilizzato solo per valori ridotti di $k$. Per $k\le 2$, il circuito restituito è costituito da una singola porta X, CX o CCX (corrispondente rispettivamente a $k = 0, 1, 2$) e non utilizza qubit ausiliari.

Parametri

num_ctrl_qubits (int) – Il numero di qubit di controllo.

Aumenti

QiskitError – se num_ctrl_qubits è illegale.

Risultati

Il circuito quantistico sintetizzato.

Tipo di restituzione

QuantumCircuit

qiskit.synthesis.synth_c3x()

Sintesi efficiente di X-gate a 3 controlli.

Tipo di restituzione

QuantumCircuit

qiskit.synthesis.synth_c4x()

Sintesi efficiente di X-gate a 4 controlli.

Tipo di restituzione

QuantumCircuit

qiskit.synthesis.adder_qft_d00(num_state_qubits, kind='half', annotated=False)

Un circuito che utilizza la QFT per eseguire l'addizione in-place su due registri di qubit.

Per i registri con qubit di tipo “ $n$ ”, l’addizionatore QFT può eseguire l’addizione modulo “ $2^n$ ” (con kind="fixed") oppure l’addizione ordinaria aggiungendo un qubit di riporto (con kind="half"). L'addizionatore fisso utilizza operatori di tipo " $(3n^2 - n)/2$CPhaseGate ", con un ulteriore operatore " $n$ " per il semi-addizionatore.

A titolo di esempio, un circuito addizionatore QFT a punto non fisso che esegue l'addizione su due registri di dimensioni pari a 2 qubit è il seguente:

 a_0: ─────────■──────■────────■──────────────────────────────────
               │      │        │
 a_1: ─────────┼──────┼────────┼────────■──────■──────────────────
      ┌──────┐ │      │        │P(π/4)  │      │P(π/2) ┌─────────┐
 b_0: ┤0     ├─┼──────┼────────■────────┼──────■───────┤0        ├
      │      │ │      │P(π/2)           │P(π)          │         │
 b_1: ┤1 Qft ├─┼──────■─────────────────■──────────────┤1 qft_dg ├
      │      │ │P(π)                                   │         │
cout: ┤2     ├─■───────────────────────────────────────┤2        ├
      └──────┘                                         └─────────┘

Parametri

• num_state_qubits (int) – Il numero di qubit in uno dei due registri di ingresso per lo stato $|a\rangle$ o $|b\rangle$. I due registri di ingresso devono avere lo stesso numero di qubit.
• kind (str) – Il tipo di sommatore può essere "half" per un mezzo sommatore o "fixed" per un sommatore a dimensione fissa. Un mezzo sommatore contiene un riporto per rappresentare il bit più significativo, ma l'addizionatore a grandezza fissa non lo contiene e quindi esegue l'addizione modulo 2 ** num_state_qubits.
• annotated (bool) – Se True, crea le operazioni di controllo e di inversione appropriate come oggetti AnnotatedOperation .

Tipo di restituzione

QuantumCircuit

Riferimenti:

[1] T. G. Draper, Addition on a Quantum Computer, 2000. arXiv:quant-ph/0008033

[2] Ruiz-Perez et al., Aritmetica quantistica con la trasformata di Fourier quantistica, 2017. arXiv:1411.5949

[3] Vedral et al, Reti quantistiche per operazioni aritmetiche elementari, 1995. arXiv:quant-ph/9511018

qiskit.synthesis.adder_ripple_c04(num_state_qubits, kind='half')

Un circuito di ripple-carry per eseguire l'addizione in-place su due registri di qubit.

Questo circuito utilizza le porte $2n + O(1)$ CCX e le porte $5n + O(1)$ CX, a una profondità di $2n + O(1)$ [1]. La costante dipende dal tipo di sommatore implementato.

A titolo di esempio, un circuito sommatore a ripple-carry che esegue l'addizione su due registri di dimensioni pari a 3 qubit con un bit di riporto (kind="full") è il seguente:

        ┌──────┐                                     ┌──────┐
 cin_0: ┤2     ├─────────────────────────────────────┤2     ├
        │      │┌──────┐                     ┌──────┐│      │
   a_0: ┤0     ├┤2     ├─────────────────────┤2     ├┤0     ├
        │      ││      │┌──────┐     ┌──────┐│      ││      │
   a_1: ┤  MAJ ├┤0     ├┤2     ├─────┤2     ├┤0     ├┤  UMA ├
        │      ││      ││      │     │      ││      ││      │
   a_2: ┤      ├┤  MAJ ├┤0     ├──■──┤0     ├┤  UMA ├┤      ├
        │      ││      ││      │  │  │      ││      ││      │
   b_0: ┤1     ├┤      ├┤  MAJ ├──┼──┤  UMA ├┤      ├┤1     ├
        └──────┘│      ││      │  │  │      ││      │└──────┘
   b_1: ────────┤1     ├┤      ├──┼──┤      ├┤1     ├────────
                └──────┘│      │  │  │      │└──────┘
   b_2: ────────────────┤1     ├──┼──┤1     ├────────────────
                        └──────┘┌─┴─┐└──────┘
cout_0: ────────────────────────┤ X ├────────────────────────
                                └───┘

Qui le porte MAJ e UMA corrispondono alle porte introdotte in [1]. Si noti che in questa implementazione i qubit del registro di ingresso sono ordinati come tutti i qubit del primo registro di ingresso, seguiti da tutti i qubit del secondo registro di ingresso.

Sono supportati due diversi tipi di sommatori. Impostando l'argomento kind , è possibile scegliere anche un half-adder, che non ha un carry-in, e un fixed-sized-adder, che non ha né carry-in né carry-out e quindi agisce su registri di dimensioni fisse. A differenza del full-adder, questi circuiti necessitano di un qubit di aiuto aggiuntivo.

Lo schema del circuito per l'addizionatore a virgola fissa (kind="fixed") su ingressi di dimensioni pari a 3 qubit è

        ┌──────┐┌──────┐                ┌──────┐┌──────┐
   a_0: ┤0     ├┤2     ├────────────────┤2     ├┤0     ├
        │      ││      │┌──────┐┌──────┐│      ││      │
   a_1: ┤      ├┤0     ├┤2     ├┤2     ├┤0     ├┤      ├
        │      ││      ││      ││      ││      ││      │
   a_2: ┤      ├┤  MAJ ├┤0     ├┤0     ├┤  UMA ├┤      ├
        │      ││      ││      ││      ││      ││      │
   b_0: ┤1 MAJ ├┤      ├┤  MAJ ├┤  UMA ├┤      ├┤1 UMA ├
        │      ││      ││      ││      ││      ││      │
   b_1: ┤      ├┤1     ├┤      ├┤      ├┤1     ├┤      ├
        │      │└──────┘│      ││      │└──────┘│      │
   b_2: ┤      ├────────┤1     ├┤1     ├────────┤      ├
        │      │        └──────┘└──────┘        │      │
help_0: ┤2     ├────────────────────────────────┤2     ├
        └──────┘                                └──────┘

Ha un qubit in meno rispetto al full-adder perché non ha il carry-out, ma usa un qubit di aiuto al posto del carry-in, quindi ha solo un qubit in meno, non due.

Parametri

• num_state_qubits (int) – Il numero di qubit in uno dei due registri di ingresso per lo stato $|a\rangle$ o $|b\rangle$. I due registri di ingresso devono avere lo stesso numero di qubit.
• kind (str) – Il tipo di sommatore può essere "full" per un sommatore completo, "half" per un mezzo sommatore o "fixed" per un sommatore a dimensione fissa. Un sommatore completo include sia il carry-in che il carry-out, un sommatore dimezzato solo il carry-out e un sommatore di dimensioni fisse né il carry-in né il carry-out.

Aumenti

ValueError - Se num_state_qubits è inferiore a 1.

Tipo di restituzione

QuantumCircuit

Riferimenti:

[1] Cuccaro et al, Un nuovo circuito di addizione quantistica ripple-carry, 2004. arXiv:quant-ph/0410184

[2] Vedral et al, Reti quantistiche per operazioni aritmetiche elementari, 1995. arXiv:quant-ph/9511018

qiskit.synthesis.adder_ripple_v95(num_state_qubits, kind='half')

L'addizionatore di riporto VBE [1].

Questo metodo utilizza le porte $4n + O(1)$ CCX e le porte $4n + 1$ CX a una profondità di $6n - 2$ [2].

Questo circuito esegue l'addizione inplace di due registri quantistici di pari dimensioni. A titolo di esempio, un circuito sommatore classico che esegue un'addizione completa (cioè con un bit di riporto) su due registri di dimensioni pari a 2 qubit è il seguente:

          ┌────────┐                       ┌───────────┐┌──────┐
   cin_0: ┤0       ├───────────────────────┤0          ├┤0     ├
          │        │                       │           ││      │
     a_0: ┤1       ├───────────────────────┤1          ├┤1     ├
          │        │┌────────┐     ┌──────┐│           ││  Sum │
     a_1: ┤        ├┤1       ├──■──┤1     ├┤           ├┤      ├
          │        ││        │  │  │      ││           ││      │
     b_0: ┤2 Carry ├┤        ├──┼──┤      ├┤2 Carry_dg ├┤2     ├
          │        ││        │┌─┴─┐│      ││           │└──────┘
     b_1: ┤        ├┤2 Carry ├┤ X ├┤2 Sum ├┤           ├────────
          │        ││        │└───┘│      ││           │
  cout_0: ┤        ├┤3       ├─────┤      ├┤           ├────────
          │        ││        │     │      ││           │
helper_0: ┤3       ├┤0       ├─────┤0     ├┤3          ├────────
          └────────┘└────────┘     └──────┘└───────────┘

Qui le porte Carry e Sum corrispondono alle porte introdotte nel paragrafo [1]. Carry_dg corrispondono all'inverso del gate Carry. Si noti che in questa implementazione i qubit del registro di ingresso sono ordinati come tutti i qubit del primo registro di ingresso, seguiti da tutti i qubit del secondo registro di ingresso. Si tratta di un ordinamento diverso rispetto alla Figura 2 in [1], che porta a un disegno diverso del circuito.

Parametri

• num_state_qubits (int) – La dimensione del registro.
• kind (str) – Il tipo di sommatore può essere "full" per un sommatore completo, "half" per un mezzo sommatore o "fixed" per un sommatore a dimensione fissa. Un sommatore completo include sia il carry-in che il carry-out, un sommatore dimezzato solo il carry-out e un sommatore di dimensioni fisse né il carry-in né il carry-out.

Aumenti

ValueError - Se num_state_qubits è inferiore a 1.

Tipo di restituzione

QuantumCircuit

Riferimenti:

[1] Vedral et al, Reti quantistiche per operazioni aritmetiche elementari, 1995. arXiv:quant-ph/9511018

[2] Cuccaro et al, Un nuovo circuito di addizione quantistica ripple-carry, 2004. arXiv:quant-ph/0410184

qiskit.synthesis.adder_ripple_r25(num_qubits)

L'addizionatore di riporto a ripple RV [1]. Costruire un circuito sommatore quantistico privo di ancilla con profondità sublineare basato sul sommatore RV ripple-carry mostrato in [1]. L'implementazione ha una profondità di $O(\log^2 n)$ e utilizza porte matematiche O(n log n).

A titolo di esempio, un circuito sommatore ripple-carry che esegue l'addizione su due registri di dimensioni pari a 4-qubit è il seguente:

                               ┌───────────┐                    ┌────────┐
 a_0: ─────────────────────────┤0          ├────────────────────┤0       ├───────────────■─────────────────
                     ┌────────┐│           │                    │        │┌───────────┐  │
 a_1: ──■────────────┤0       ├┤2          ├──■─────────────────┤2       ├┤0          ├──┼────■────────────
        │            │        ││           │  │                 │        ││           │  │    │
 a_2: ──┼────■───────┤1       ├┤4          ├──┼────■────────────┤4       ├┤1 LAD_1_dg ├──┼────┼────■───────
        │    │       │        ││           │  │    │            │        ││           │  │    │    │
 a_3: ──┼────┼────■──┤2       ├┤6          ├──┼────┼────■───────┤6 LAD_2 ├┤2          ├──┼────┼────┼────■──
        │    │    │  │        ││           │  │    │    │       │        │└───────────┘┌─┴─┐  │    │    │
 b_0: ──┼────┼────┼──┤        ├┤1 LAD_2_dg ├──┼────┼────┼───────┤1       ├─────────────┤ X ├──┼────┼────┼──
      ┌─┴─┐  │    │  │  LAD_1 ││           │┌─┴─┐  │    │  ┌───┐│        │    ┌───┐    └───┘┌─┴─┐  │    │
 b_1: ┤ X ├──┼────┼──┤        ├┤3          ├┤ X ├──┼────┼──┤ X ├┤3       ├────┤ X ├─────────┤ X ├──┼────┼──
      └───┘┌─┴─┐  │  │        ││           │└───┘┌─┴─┐  │  ├───┤│        │    ├───┤         └───┘┌─┴─┐  │
 b_2: ─────┤ X ├──┼──┤        ├┤5          ├─────┤ X ├──┼──┤ X ├┤5       ├────┤ X ├──────────────┤ X ├──┼──
           └───┘┌─┴─┐│        ││           │     └───┘┌─┴─┐└───┘└────────┘    └───┘              └───┘┌─┴─┐
 b_3: ──────────┤ X ├┤        ├┤7          ├──────────┤ X ├───────────────────────────────────────────┤ X ├
                └───┘│        ││           │          └───┘                                           └───┘
cout: ───────────────┤3       ├┤8          ├───────────────────────────────────────────────────────────────
                     └────────┘└───────────┘

Qui LAD_1 e LAD_2 sono le scale CX e CCX introdotte rispettivamente in [1]. Si noti che in questa implementazione i qubit del registro di ingresso sono ordinati come tutti i qubit del primo registro di ingresso, seguiti da tutti i qubit del secondo registro di ingresso.

Parametri

num_qubits (int) – La dimensione del registro.

Risultati

Il circuito quantistico che implementa l'addizionatore di carry ripple RV.

Aumenti

ValueError - Se num_qubits è inferiore a 1.

Tipo di restituzione

QuantumCircuit

Riferimenti:

1. Remaud e Vandaele, Ancilla-free Quantum Adder with Sublinear Depth, 2025. arXiv:2501.16802

qiskit.synthesis.adder_modular_v17(num_qubits)

Costruire un circuito sommatore modulare senza qubit ausiliari basato sull'addizionatore di Van Rentergem di Fig. 15 di [1]. L'implementazione utilizza al massimo $16k - 13$ porte CX per un sommatore con k qubit in ogni registro, dove k = num_qubit.

Parametri

num_qubits (int) – La dimensione del registro.

Risultati

Il circuito quantistico che implementa l'addizionatore modulare.

Aumenti

ValueError - Se num_qubits è inferiore a 1.

Tipo di restituzione

QuantumCircuit

Riferimenti:

[1] Gidney, Factoring with n+2 clean qubits and n-1 dirty qubits, 2017. arxiv:1706.07884

qiskit.synthesis.multiplier_cumulative_h18(num_state_qubits, num_result_qubits=None)

Un circuito di moltiplicazione per memorizzare il prodotto di due registri di ingresso fuori posto.

Il circuito utilizza l'approccio di Rif. [1]. A titolo di esempio, un circuito moltiplicatore che esegue una moltiplicazione non modulare su due registri di dimensioni pari a 3 qubit è:

from qiskit.synthesis.arithmetic import multiplier_cumulative_h18

num_state_qubits = 3
circuit = multiplier_cumulative_h18(num_state_qubits)
circuit.draw("mpl")

La moltiplicazione in questo circuito è implementata con un approccio classico, eseguendo una serie di addizioni spostate utilizzando uno dei registri di ingresso, mentre i qubit dell'altro registro di ingresso fungono da qubit di controllo per gli addizionatori.

Parametri

• num_state_qubits (int) – Il numero di qubit in uno dei due registri di ingresso per lo stato $|a\rangle$ o $|b\rangle$. I due registri di ingresso devono avere lo stesso numero di qubit.
• num_result_qubits (int | None) – Il numero di qubit di risultato a cui limitare l'uscita. Se il numero di qubit del risultato è $n$, viene eseguita la moltiplicazione modulo $2^n$ per limitare l'uscita al numero di qubit specificato. Il valore predefinito è 2 * num_state_qubits per rappresentare ogni possibile risultato della moltiplicazione dei due ingressi.

Aumenti

ValueError - Se num_result_qubits è dato e non è valido, significa che non si trova in [num_state_qubits, 2 * num_state_qubits].

Tipo di restituzione

QuantumCircuit

Riferimenti:

[1] Häner et al, Ottimizzazione dei circuiti quantistici per l'aritmetica, 2018. arXiv:1805.12445

qiskit.synthesis.multiplier_qft_r17(num_state_qubits, num_result_qubits=None)

Un circuito di moltiplicazione QFT per memorizzare il prodotto di due registri di ingresso fuori posto.

La moltiplicazione in questo circuito è implementata utilizzando la procedura della Fig. 3 in [1], dove le rotazioni a somma ponderata sono implementate come indicato nella Fig. 5 in [1]. Il QFT viene utilizzato sul registro di uscita ed è seguito da rotazioni controllate dai registri di ingresso. Le rotazioni trasformano lo stato nel prodotto di due registri di ingresso in base QFT, che viene ripristinato dalla base QFT utilizzando la QFT inversa. Ad esempio, su 3 qubit di stato, un moltiplicatore completo è dato da:

from qiskit.synthesis.arithmetic import multiplier_qft_r17

num_state_qubits = 3
circuit = multiplier_qft_r17(num_state_qubits)
circuit.draw("mpl")

Parametri

• num_state_qubits (int) – Il numero di qubit in uno dei due registri di ingresso per lo stato $|a\rangle$ o $|b\rangle$. I due registri di ingresso devono avere lo stesso numero di qubit.
• num_result_qubits (int | None) – Il numero di qubit di risultato a cui limitare l'uscita. Se il numero di qubit del risultato è $n$, viene eseguita la moltiplicazione modulo $2^n$ per limitare l'uscita al numero di qubit specificato. Il valore predefinito è 2 * num_state_qubits per rappresentare ogni possibile risultato della moltiplicazione dei due ingressi.

Aumenti

ValueError - Se num_result_qubits è dato e non è valido, significa che non si trova in [num_state_qubits, 2 * num_state_qubits].

Tipo di restituzione

QuantumCircuit

Riferimenti:

[1] Ruiz-Perez et al., Aritmetica quantistica con la trasformata di Fourier quantistica, 2017. arXiv:1411.5949

qiskit.synthesis.synth_weighted_sum_carry(weighted_sum)

Sintetizzare una porta a somma pesata, in base al numero di qubit di stato e ai pesi dei qubit.

Questo metodo è descritto nell'Appendice A del n. [1].

Riferimenti:

[1] Stamatopoulos et al. Prezzi delle opzioni con i computer quantistici (2020)

Quantum 4, 291

Parametri

weighted_sum (WeightedSumGate)

Tipo di restituzione

QuantumCircuit

qiskit.synthesis.synth_integer_comparator_2s(num_state_qubits, value, geq=True)

Implementare un confronto tra interi basato sul complemento 2s.

Questo si basa sull'Appendice B del capitolo [1].

Parametri

• num_state_qubits (int) – Il numero di qubit che codificano il valore da confrontare.
• value (int) – Il valore da confrontare.
• geq (bool) – Se True capovolge il bit di destinazione se lo stato del qubit è $\geq$ superiore al valore, altrimenti implementa $<$.

Risultati

Un circuito che implementa il comparatore di numeri interi.

Tipo di restituzione

QuantumCircuit

Riferimenti

[1] J. Gacon et al. "Ottimizzazione quantistica basata sulla simulazione"

arXiv:2005.10780.

qiskit.synthesis.synth_integer_comparator_greedy(num_state_qubits, value, geq=True)

Implementare un confronto tra interi basato sul confronto valore per valore.

Per value più piccolo di 2 ** (num_state_qubits - 1) questo circuito implementa value porte multicontrollate con stati di controllo 0, 1,..., value - 1, in modo che il qubit di destinazione venga capovolto se lo stato del qubit rappresenta uno dei valori consentiti. Per value più grandi, geq viene capovolto. Questa implementazione può richiedere un numero esponenziale di porte. Se sono disponibili qubit ausiliari, l'implementazione fornita da synth_integer_comparator_2s() è più efficiente.

Parametri

• num_state_qubits (int) – Il numero di qubit che codificano il valore da confrontare.
• value (int) – Il valore da confrontare.
• geq (bool) – Se True capovolge il bit di destinazione se lo stato del qubit è $\geq$ superiore al valore, altrimenti implementa $<$.

Risultati

Un circuito che implementa il comparatore di numeri interi.

Tipo di restituzione

QuantumCircuit