Qiskit SDK 2.3 note di rilascio

2.3.1

Preludio

Qiskit v2.3.1 risolve diversi bug individuati dopo il rilascio di Qiskit v2.3.0.

Correzioni di bug

Il plugin di sintesi permutation.kms integrato in ora qiskit.synthesis gestisce correttamente le permutazioni di lunghezza zero. Risolto il problema n. 15550.
Fisso synth_clifford_depth_lnn() per Clifford a un singolo qubit. Vedi n. 15780.
È stato risolto un bug nel passaggio HighLevelSynthesis del transpiler in cui gli stati dei qubit non venivano aggiornati correttamente dopo la sintesi ricorsiva di un'operazione. In alcuni casi, ciò potrebbe comportare la generazione di circuiti errati da parte del pass.
È stato risolto un problema nella qs_decomposition() funzione in cui eventuali problemi di tolleranza nelle routine interne di algebra lineare causavano un errore di panico, provocando l'arresto anomalo del programma. Il problema è stato risolto, quindi in queste situazioni viene generata invece un'eccezione appropriata QiskitError o una sua sottoclasse.

Risolto il problema n. 15610.
La sintesi predefinita di un UnitaryGate quando si accede UnitaryGate.definition e si chiama UnitaryGate.control() per i gate che coinvolgono più di due qubit si baserà internamente sulla qs_decomposition() funzione. In alcune situazioni, a causa della tolleranza intrinseca dei numeri in virgola mobile utilizzata nelle routine di algebra lineare coinvolte nella decomposizione iterativa di Shannon-Quantum, il calcolo potrebbe non andare sempre a buon fine. Per evitare che questi attributi o metodi generino un errore, in tali situazioni si ricorre invece alla Isometry scomposizione da. Sebbene ciò comporti una decomposizione meno efficiente, qs_decomposition() fungerà da soluzione alternativa nel caso in cui qs_decomposition() fallisca.
È stato risolto un bug per ParameterExpression.sympify() cui, in determinate combinazioni di Parameter, ParameterExpression e valori numerici, le operazioni aritmetiche asimmetriche (come ** o -) potevano invertire gli operandi. Vedi n. 15642.
Corretto qk_obs_term() durante l'accesso a un termine osservabile di identità. Vedi n. 15536.
È stato risolto un artefatto di visualizzazione in plot_state_qsphere() cui gli stati simmetrici intrecciati (come gli stati di Bell) venivano ruotati in modo arbitrario a causa del rumore dei numeri in virgola mobile.
Risolto QuantumCircuit.repeat() per circuiti con porte parametrizzate.

Vedi n. 15645.
Risolve un bug che causava qpy.load() il crash di sui circuiti creati utilizzando QuantumCircuit.ensure_physical() quando era presente un registro creato dall'utente denominato «ancilla».
È stato risolto BreakLoopOp il problema per cui ContinueLoopOp alcune operazioni venivano erroneamente interpretate come operazioni di controllo del flusso in determinati passaggi del transpiler, il che poteva causare la generazione di AttributeError un'eccezione. Vedi n. 15579.
Risolve un bug che causava qpy.load() il crash di sui circuiti creati utilizzando SabreLayout quando era presente un registro creato dall'utente denominato «ancilla».
La versione minima richiesta di NumPy è ora correttamente indicata come 1.21 (anziché 1.17 ). Questo limite è in vigore già da diverse versioni a causa dell'uso di numpy.typing.NDArray, introdotto in NumPy 1.21, pertanto Qiskit non riuscirebbe a importarsi con le versioni precedenti di NumPy.
L'esportatore OpenQASM 3 (qasm3.dumps() e dump()) ora esegue correttamente l'escape dei caratteri Unicode "numerici" diversi dalle cifre ASCII, quando questi vengono utilizzati negli identificatori. In precedenza, caratteri come gli apici superiori rimanevano nell'output, il che non è consentito n OpenQASM e 3.
L'esportatore OpenQASM 3 (qasm3.dumps() e dump()) ora esegue correttamente l'escape degli identificatori il cui nome inizia con una cifra ASCII.

I metodi SparsePauliOp.from_list() e SparsePauliOp.from_sparse_list() ora deducono automaticamente il tipo di dati del coefficiente, se dtype l'argomento non è specificato.

Ad esempio:

from qiskit.quantum_info import SparsePauliOp
from qiskit.circuit import Parameter

theta = Parameter("theta")

# Previously required manually setting dtype=object
op_list = SparsePauliOp.from_list([("X", theta)])
op_sparse = SparsePauliOp.from_sparse_list([("X", [0], theta)], num_qubits=1)

2.3.0

Preludio

Qiskit v2.3.0 è una nuova funzionalità rilasciata dall' Qiskit SDK.

Questa nuova versione amplia notevolmente l'API C per la transpilazione, rendendo disponibili dal C ulteriori funzionalità di Target (QkTarget) e consentendo la creazione e la manipolazione di DAGCircuit (QkDag). Ciò consente di scrivere passaggi personalizzati del transpiler durante la compilazione dell'oggetto libqiskit autonomo. L'API C mette a disposizione singole funzioni relative alla fase di transpilazione (ad esempio, qk_transpile_stage_layout()), per facilitare l'inserimento di logica personalizzata nella transpilazione senza dover ricreare manualmente l'intera pipeline.

Sono state migliorate anche le prestazioni e le funzionalità della transpilazione verso destinazioni precoci tolleranti ai guasti. Con la nuova PauliProductMeasurement istruzione, che rappresenta una trasformazione proiettiva in una base di prodotto di Pauli, Qiskit ora supporta pienamente la transpilazione dei circuiti in una base di calcolo basata su Pauli utilizzando il pass LitinskiTransformation esistente. Il nuovo metodo di sintesi unitaria, RossSelingerSynthesis, che può essere configurato nel transpiler tramite unitary_synthesis_method="gridsynth", consente di utilizzare l'algoritmo di Ross-Selinger, asintoticamente ottimale, per la sintesi Clifford+T a singolo qubit. Altri miglioramenti includono, ad esempio, un passaggio OptimizeCliffordT migliore o il CommutativeOptimization passaggio, che tiene conto delle ottimizzazioni commutative dei circuiti basati su Pauli.

A livello interno, la rappresentazione degli ControlFlowOp oggetti è stata modificata per essere nativa di Rust. Questa trasformazione non è ancora stata completata; potresti riscontrare un calo delle prestazioni in Qiskit 2.3 per quanto riguarda le operazioni relative al flusso di controllo. Le versioni successive di Qiskit dovrebbero approfondire ulteriormente questo aspetto, risolvendo le questioni relative alle prestazioni e alle API, da tempo oggetto di discussione, in merito alle operazioni di controllo del flusso.

Si noti che a partire da questa versione, Python 3.9 non è più supportato poiché ha superato la fine del ciclo di vita nell'ottobre 2025, mentre macOS sui processori Intel è stato declassato al supporto di piattaforma di livello 2 poiché Apple ha iniziato a ritirare la piattaforma. Sono supportate tutte le versioni di CPython a partire da 3.10. Vedere Supporto del sistema operativo per i livelli di supporto attuali delle diverse piattaforme.

Ci saranno ulteriori rilasci di funzionalità di Qiskit nella serie " 2.x "; non prevediamo di rilasciare Qiskit 3.0 fino a molto più avanti nel 2026, poiché al momento non vi è alcuna necessità di apportare modifiche sostanziali.

Funzionalità API C

È stata aggiunta la funzione qk_target_instruction_supported() per verificare la compatibilità di qualsiasi gate o istruzione con l'istanza di QkTarget. Questo controllo viene eseguito in base al nome dell'istruzione fornita, ai qargs e ai parametri.
È stata aggiunta la funzione qk_target_entry_set_name() per impostare il nome di una voce di destinazione esistente.
È stata aggiunta una nuova funzione qk_circuit_library_quantum_volume() per generare un circuito con modello di volume quantistico.

Aggiunti metodi per iterare e controllare la mappa dei gate di un QkTarget. Sono stati aggiunti i seguenti metodi:

È stata aggiunta la seguente rappresentazione:

QkInstructionProperties: per rappresentare il InstructionProperties.

Esempio:

// Create Target with a mix of global and non-global gates.
QkTarget *target = qk_target_new(2);

// Create a CX entry
QkTargetEntry *cx_entry = qk_target_entry_new(QkGate_CX);
uint32_t qarg_samples[2][2] = {
    {0, 1}, {1, 0},
};
double props[2][2] = {
    {2.7022e-11, 0.00713}, {3.0577e-11, 0.00713}
};
for (int i = 0; i < 2; i++) {
    qk_target_entry_add_property(cx_entry, qarg_samples[i], 2, props[i][0], props[i][1]);
}
qk_target_add_instruction(target, cx_entry);

// Create an SX entry
QkTargetEntry *sx_entry = qk_target_entry_new(QkGate_SX);
for (int i = 0; i < 2; i++) {
    uint32_t qargs[1] = {i};
    qk_target_entry_add_property(sx_entry, qargs, 1, 35.5e-9, 0.);
}
qk_target_add_instruction(target, sx_entry);

// Create an H entry
qk_target_add_instruction(target, qk_target_entry_new(QkGate_H));

// Get the size of the 
size_t target_length = qk_target_num_instructions(target);

for (size_t op_idx = 0; op_idx < target_length; op_idx++) {
  // Allocate space for qargs and props
  uint32_t *qargs;
  uint32_t qargs_len;
  QkInstructionProperties props;

  // Retrieve the operation's name
  char *name = qk_target_op_name(target, op_idx);
  size_t num_props = qk_target_op_num_properties(target, op_idx);
  for (size_t props_idx = 0; props_idx < num_props; props_idx++) {
    // Populate qargs
    qk_target_op_qargs(target, op_idx, props_idx, &qargs, &qargs_len);
    // Populate properties
    qk_target_op_props(target, op_idx, props_idx, &props);
  }
  // Free the name string
  qk_str_free(name);
}

QkTarget ora offre ai propri utenti la possibilità di recuperare le operazioni direttamente da esso. Sono stati aggiunti i seguenti metodi:
È stata aggiunta la seguente rappresentazione:
- QkTargetOp: Per rappresentare un'operazione nel QkTarget.

L'API C ora espone QkParam per rappresentare i parametri di gate, inclusi simboli ed espressioni parametrizzate. L'interfaccia QkParam stessa supporta calcoli simbolici, comprese operazioni aritmetiche standard e funzioni trigonometriche. Ad esempio:

QkParam *x = qk_symbol_new("x"); // a symbol called "x"
QkParam *y = qk_symbol_new("y"); // a symbol called "y"
QkParam *val = qk_symbol_from_double(2.0); // the value 2.0
QkParam *out = qk_symbol_zero(); // to store the final expression

// build 2 sin(x + y)
qk_param_add(out, x, y); // out = x + y
qk_param_sin(out, out); // out = sin(out)
qk_param_mul(out, out, val); // out = out * 2

qk_param_free(x);
qk_param_free(y);
qk_param_free(val);
qk_param_free(out);

L'API C è ora in grado di rappresentare e manipolare DAGCircuit come oggetto opaco QkDag. Sono state aggiunte le seguenti funzioni relative al DAG:
È stata aggiunta QkDagNodeType l'enumerazione per distinguere il tipo di un nodo DAG. Questo è il tipo di ritorno di qk_dag_node_type().
È stata aggiunta QkOperationKind l'enumerazione per distinguere i diversi tipi di operazioni native. Questo è il tipo di ritorno di qk_dag_op_node_kind().
Aggiunto qk_circuit_copy_empty_like() per creare una copia del circuito specificato, come immagine speculare di QuantumCircuit.copy_empty_like().
Aggiunte nuove enumerazioni da utilizzare con alcune funzioni API di circuito e DAG per specificare le modalità di copia:
- QkVarsMode
- QkBlocksMode
È stata aggiunta la QkDagNeighbors struttura, che è il tipo di ritorno di qk_dag_successors() e qk_dag_predecessors(), e la relativa funzione di qk_dag_neighbors_clear()liberazione.
Viene aggiunta una nuova struttura, QkNeighbors, che rappresenta il grafico di accoppiamento a due qubit implicito in un Target. Viene inizializzato dalla funzione new qk_neighbors_from_target(), azzerato con qk_neighbors_clear() clear e dispone di una funzione di supporto qk_neighbors_is_all_to_all().
Sono state aggiunte le funzioni qk_dag_to_circuit() qk_circuit_to_dag() e per supportare, rispettivamente, la conversione da DAG a circuito e da circuito a DAG.
Le funzioni qk_transpiler_pass_standalone_unitary_synthesis()qk_transpile() e ora supportano la sintesi di oggetti a UnitaryGate 3 o più qubit in un circuito. In Qiskit 2.2 questa funzionalità non era supportata poiché l'algoritmo di sintesi qs_decomposition() sottostante utilizzato per la sintesi unitaria di 3 o più qubit era stato originariamente scritto in Python; tuttavia, ora che è stato portato su Rust, questa funzionalità è disponibile anche in C.

Aggiunte nuove funzioni per l'esecuzione delle fasi di transpilazione all'API C. Queste funzioni sono:

Funzione C	Fase di transpilazione
`qk_transpile_stage_init()`	Fase di inizializzazione
`qk_transpile_stage_layout()`	Fase di impaginazione
`qk_transpile_stage_routing()`	Fase di instradamento
`qk_transpile_stage_translation()`	Fase di traduzione
`qk_transpile_stage_optimization()`	Fase di ottimizzazione

Queste funzioni vengono utilizzate per eseguire queste fasi dal gestore di passaggi preimpostato su un QkDag oggetto. L'obiettivo di queste funzioni è consentire flussi di lavoro di transpilazione componibili da C quando combinati con passaggi di transpilazione personalizzati.

È stata aggiunta una nuova funzione qk_transpile_layout_generate_from_mapping() che serve a generare un layout personalizzato QkTranspileLayout con un layout iniziale definito da un array di mappatura. Lo scopo di questa funzione è consentire la creazione di un oggetto layout per i passaggi del transpiler di layout personalizzati.
Le due forme di selezione del layout "perfetto" tramite l'algoritmo di isomorfismo dei sottografi VF2 sono ora disponibili come passaggi transpiler autonomi nell'API C. Queste funzioni sono
- qk_transpiler_pass_standalone_vf2_layout_average()
- qk_transpiler_pass_standalone_vf2_layout_exact()
Questi differiscono nel modo in cui vengono gestiti la direzionalità e i gate set delle interazioni; exact richiede che le corrispondenze supportino direttamente tutti i gate in modo nativo, mentre average si aspetta che ulteriori passaggi del transpiler scompongano i gate nell'insieme supportato di un dato qubit o link.

Queste funzioni utilizzano una versione incapsulata della configurazione VF2 (QkVF2LayoutConfiguration), che dispone di metodi setter per ciascuna delle opzioni. Ciò include consentire l'accesso alla nuova forma a due limiti call_limit dell'argomento.

Caratteristiche dei circuiti

È stata aggiunta una nuova classe di istruzioni, PauliProductMeasurement, che rappresenta una misura proiettiva congiunta su più qubit, in cui l'osservabile misurato è un prodotto tensoriale di operatori di Pauli. Il risultato di questa misurazione è un singolo autovalore, che può essere $+1$ o $-1$ , indicante lo stato proprio del prodotto di Pauli.

Per ulteriori informazioni, consultare A Game of Surface Codes: Large-Scale Quantum Computing with Lattice Surgery (Un gioco di codici superficiali: calcolo quantistico su larga scala con chirurgia reticolare) di Daniel Litinski.

Un PauliProductMeasurement può essere istanziato da un Pauli, dove il Pauli può includere una fase di $-1$ , ma non di $i$ o $-i$ . L'istruzione ha lo stesso numero di qubit del Pauli e un singolo bit classico.

Ad esempio:
```
from qiskit.circuit import QuantumCircuit
from qiskit.quantum_info import Pauli
from qiskit.circuit.library import PauliProductMeasurement

ppm = PauliProductMeasurement(Pauli("XZ"))

qc = QuantumCircuit(6, 2)
qc.append(ppm, [4, 1], [1])
```
Un nuovo QuantumCircuit.to_dag() metodo offre ora una comoda interfaccia attorno a circuit_to_dag().
ParameterExpression ora dispone di un num_parameters attributo, il cui valore è pari alla lunghezza del suo parameters insieme, ma calcolato con un minor dispendio di risorse.

OpenQASM Caratteristiche

L'esportatore OpenQASM 2(qasm2.dumps()) ora supporta la generazione di semplici IfElseOp blocchi a istruzione singola, se la condizione è un semplice test di uguaglianza tra un registro e un numero intero. Ciò corrisponde a ciò che il linguaggio di seconda generazione dell' OpenQASM e è in grado di rappresentare.

Caratteristiche QPY

La versione 17 di QPY ora include formati di serializzazione per SparseObservable gli oggetti utilizzati come parametri di altri oggetti. In particolare, ciò consente di serializzare PauliEvolutionGate gli oggetti che utilizzano internamente questo operatore e il payload del gate di evoluzione viene aggiornato.

Caratteristiche dell'informazione quantistica

Aggiunto Statevector.from_circuit() come mirror di Operator.from_circuit(). Ciò consente di istanziare direttamente un Statevector nello spazio dei qubit virtuali, anche per i circuiti che sono stati transpilati in uno spazio di qubit fisici.
Sono state migliorate le prestazioni di Clifford.dot() e di Clifford.compose() quando vengono chiamati con front=True e un QuantumCircuit contenente solo porte di Clifford. In precedenza, il circuito veniva prima elaborato interamente in un Clifford oggetto, e poi i due oggetti venivano uniti. Ora, la base Clifford viene aggiornata in modo iterativo, il che risulta notevolmente più veloce per i circuiti di piccole dimensioni.
È stato aggiunto il PauliLindbladMap.parity_sample() metodo. Questo metodo è molto simile a quello PauliLindbladMap.signed_sample() preesistente, tuttavia utilizza una convenzione di segno più coerente con il resto di Qiskit e, pertanto, è il metodo da preferire in futuro. Dispone di ulteriori argomenti opzionali per applicare ridimensionamenti alle frequenze durante il campionamento senza modificare l'istanza.
Diverse funzioni " quantum_info predicate", come ad esempio is_identity_matrix(), sono state ottimizzate per evitare allocazioni di matrici non necessarie.

Caratteristiche della sintesi

Aggiunto gridsynth_rz(), che costruisce un circuito quantistico a singolo qubit che approssima una rotazione RZ con un angolo specificato. L'algoritmo è descritto nell'articolo «Optimal ancilla-free Clifford+T approximation of z-rotations» di Neil J. Ross e Peter Selinger ed è implementato all'indirizzo https://github.com/qiskit-community/rsgridsynth.
Aggiunto gridsynth_unitary(), che costruisce un circuito quantistico a singolo qubit che approssima una data matrice unitaria a singolo qubit. L'algoritmo funziona scomponendo la matrice unitaria in una rotazione RZ, una rotazione RX e un'altra rotazione RZ, e applicando l'algoritmo di Ross-Selinger a ciascuna delle tre rotazioni.
L'algoritmo generale di sintesi qs_decomposition() unitaria è stato riscritto in Rust, migliorando notevolmente le prestazioni di esecuzione della funzione.

Funzionalità del transpiler

È stato aggiunto un nuovo passaggio del transpiler, CommutativeOptimization, che esegue la cancellazione e l'unione dei gate sfruttando le relazioni di commutatività. Il pass unifica ed estende le funzionalità sia di CommutativeCancellation che di CommutativeInverseCancellation.

Nello specifico, il pass:
- Cancella coppie di porte inverse, comprese le coppie che sono inverse fino a una fase globale (regolando la fase globale se necessario).
- Tenta di unire porte consecutive quando possibile, ad esempio sequenze di porte RZ, porte RX, rotazioni di Pauli e così via.
È stata aggiunta una nuova opzione, fallback_on_default, al passaggio del UnitarySynthesis transpiler. Questa opzione si applica quando il pass viene richiamato con un plugin di sintesi non predefinito, specificato tramite l'argomento method.

Per impostazione predefinita, il plugin specificato viene utilizzato per sintetizzare ogni operatore unitario nel circuito (a condizione che il plugin sia applicabile; ad esempio, non verrà eseguito se non supporta il numero di qubit su cui è definito l'operatore unitario). Se il plugin non è in grado di sintetizzare l'operatore unitario e restituisce None, l'operatore unitario originale rimane invariato nel circuito. Quando fallback_on_default è impostato su True, il pass richiamerà invece DefaultUnitarySynthesis il plugin nel caso in cui il metodo specificato fallisca.

Questa funzione è particolarmente utile quando i plugin personalizzati sono destinati a gestire solo un sottoinsieme di tutte le unità: gli utenti possono fare affidamento sulla loro logica personalizzata quando è applicabile e utilizzare la sintesi predefinita quando non lo è.
È stato aggiunto un nuovo plugin per la sintesi unitaria, RossSelingerSynthesis, che sintetizza porte unitarie a singolo qubit utilizzando l'algoritmo di Ross-Selinger e produce un circuito quantistico a singolo qubit composto da porte Clifford, $T$ e $T^\dagger$ .

Il plugin viene attivato dal passaggio del UnitarySynthesis transpiler quando il parametro method è impostato su "gridsynth".
Durante la transpilazione nella base Clifford+T, il passaggio UnitarySynthesis di transpilazione utilizza ora per impostazione predefinita un algoritmo di sintesi Clifford+T per approssimare le operazioni unitarie su un singolo qubit.

Allo stesso modo, il DefaultUnitarySynthesis plugin utilizza ora lo stesso algoritmo di sintesi Clifford+T per approssimare le operazioni unitarie su un singolo qubit.
Un nuovo DAGCircuit.to_circuit() metodo offre ora una comoda interfaccia attorno a dag_to_circuit().
È stato aggiunto un nuovo passaggio del SubstitutePi4Rotationstranspiler che converte i gate di rotazione a singolo RYGate qubit RZGate, RXGate e i cui angoli sono multipli interi di $\pi/4$ , in insiemi discreti di gate di TdgGate Clifford, TGate e. Si noti che i multipli dispari di $\pi/4$ richiedono un singolo TGate e TdgGate, oltre ad alcune porte di Clifford, mentre i multipli pari di $\pi/4$ , o, equivalentemente, i multipli interi di $\pi/2$ , possono essere scritti utilizzando solo porte di Clifford.
Il passaggio del LitinskiTransformation transpiler è stato esteso per gestire le misurazioni. Pertanto, la trasformazione si applica ora a un circuito contenente porte Clifford, porte di rotazione RZ a singolo qubit (comprese $T$ e $T^\dagger$ ) e misurazioni Z standard, e sposta le porte Clifford alla fine del circuito. Nel corso del processo, trasforma le rotazioni RZ in rotazioni di Pauli moltiplicate (implementate come PauliEvolutionGate gate) e le misurazioni Z in misurazioni di Pauli moltiplicate (implementate tramite PauliProductMeasurement istruzioni).
Il ciclo di ottimizzazione del OptimizeCliffordT transpiler è stato notevolmente migliorato e reimplementato in Rust.

Questo passaggio esegue un'ottimizzazione peephole sui circuiti espressi utilizzando il set di porte Clifford+T. Più precisamente, collassa tutte le catene di porte a singolo qubit contenenti Clifford+T in un utilizzo minimo di $T$ (o $T^\dagger$ ). Il passaggio viene eseguito su una catena in un tempo proporzionale al numero di porte presenti nella catena.
Aggiunto WrapAngles.DEFAULT_REGISTRY contenente il registro predefinito per WrapAngles. Questo nuovo attributo sostituisce quello precedente WRAP_ANGLE_REGISTRYe invitiamo gli utenti a passare alla nuova forma il prima possibile.
I metodi DAGCircuit.topological_op_nodes() DAGCircuit.topological_nodes() e ora supportano un reverse argomento di tipo booleano. Se impostati su True, i metodi restituiscono i nodi in ordine topologico inverso, dalle uscite del circuito verso gli ingressi. Questo offre un modo diretto ed efficiente per percorrere un DAG all'indietro senza l'onere di invertire esplicitamente l'elenco dei nodi restituito dalle funzioni, creando un nuovo DAG strutturalmente invertito con DAGCircuit.reverse_ops().
Ora CommutationChecker supporta controlli di commutazione efficienti tra i gate basati su PauliGate Pauli, PauliEvolutionGate e PauliProductMeasurement verificando se gli operatori di Pauli generatori commutano. Ciò consente di effettuare ottimizzazioni, in particolare per i circuiti nel formato di calcolo basato su Pauli, espressi in termini di evoluzioni di Pauli e misurazioni del prodotto di Pauli. Si noti che le commutazioni tra questi gate basati sui stati di Pauli e altri gate standard non vengono ancora gestite con la stessa efficienza.
È stato aggiunto un nuovo argomento, matrix_max_num_qubits, a CommutationChecker.commute(). Ciò consente di limitare la dimensione delle istruzioni per le quali il verificatore di commutazione è autorizzato a calcolare la rappresentazione matriciale, che comporta un costo esponenziale. Questo nuovo parametro consente di distinguere tra il limite di dimensione delle istruzioni da elaborare (impostato tramite, max_num_qubits che ora è None impostato di default su, ovvero nessun limite) e il limite di dimensione della matrice.
Le funzioni generate_preset_pass_manager() e transpile() ora tengono conto unitary_synthesis_method dell'argomento durante la compilazione nel set di basi Clifford+T, consentendo così l'utilizzo di plugin personalizzati per la sintesi unitaria.
VF2Layout e VF2PostLayout ora tiene traccia dei punteggi parziali dei layout candidati durante l'abbinamento degli isomorfismi dei sottografi. Ciò non ha alcun effetto significativo quando non esiste una disposizione perfetta da individuare, ma può ridurre drasticamente il costo del calcolo delle disposizioni per scegliere la migliore in casi di elevata simmetria.
L'argomento call_limit di VF2Layout e VF2PostLayout può ora essere una tupla a due elementi, in cui il primo elemento viene utilizzato prima che venga trovata la prima corrispondenza, dopodiché il limite passa al secondo. Si tratta di un limitatore di tempo di esecuzione più affidabile rispetto max_trials all'argomento, ora che i layout vengono valutati al volo con un pruning più aggressivo.

Caratteristiche varie

È stata aggiunta la possibilità di calcolare il valore atteso di a SparseObservable a partire da stringhe di bit campionate nella base Z utilizzando la sampled_expectation_value() funzione.

Note sull'aggiornamento

ConsolidateBlocks ora legge una PropertySet chiave ConsolidateBlocks_qubit_map all'accesso. Questa chiave e il suo valore non sono pubblici e non devono essere letti o modificati da altre pass.

Note sull'aggiornamento dell'API C

qk_target_entry_new_fixed() ha un parametro name aggiuntivo per impostare il nome della voce di destinazione. Le voci ad angolo fisso richiedono quasi sempre di sovrascrivere il nome del gate standard per funzionare correttamente.

Note sull'aggiornamento dei circuiti

I nomi dei circuiti prodotti come definizioni dei gate della libreria dei circuiti standard sono ora impostati su None. In precedenza, questi circuiti avevano lo stesso nome del gate, rendendo molto facile costruire gate opachi con nomi corrispondenti a un gate standard. Ciò viola un presupposto comune in Qiskit, secondo cui i nomi dei gate standard dovrebbero essere univoci.
La rappresentazione interna di ControlFlowOps è cambiata quando sono stati aggiunti a a QuantumCircuit o DAGCircuit. L'oggetto memorizzato nel circuito e restituito in occasione di un accesso successivo non sarà necessariamente la stessa istanza aggiunta al circuito. Gli utenti non devono tentare di modificare in loco alcun oggetto una volta che questi sono stati aggiunti a un circuito. Ciò rischia di danneggiare il circuito, che si tratti del flusso di controllo o di un altro oggetto.

Come per tutte le mutazioni in loco apportate agli oggetti Python memorizzati all'interno di un QuantumCircuit o di un DAGCircuit, è necessario riassegnare l'istruzione al circuito affinché Rust Space rilevi le modifiche. Ad esempio, quando si aggiungono annotazioni a un BoxOp che si trova già in un circuito, un passaggio del transpiler dovrebbe assicurarsi di utilizzare DAGCircuit.substitute_node() per aggiornare l'oggetto nello spazio Rust:
```
from qiskit.circuit import QuantumCircuit, Annotation

class MyAnnotation(Annotation):
    namespace = "my"

qc = QuantumCircuit(2)
with qc.box():
    qc.cx(0, 1)
dag = qc.to_dag()

# Modifications to the box's annotations in-place require
# writing back the information to Rust space.
box_node = next(dag.topological_op_nodes())
box_node.op.annotations.append(MyAnnotation())

# Write back the operation.
dag.substitute_node(box_node, box_node.op)
```
Si prevede che le prestazioni del transpiler in presenza di ControlFlowOp istruzioni, tra cui BoxOp, risulteranno temporaneamente inferiori in Qiskit 2.3, poiché stiamo passando dalla versione precedente, incentrata su Python, a una rappresentazione del flusso di controllo nativa di Rust. Prevediamo che le prestazioni migliorino ulteriormente in una versione successiva di Qiskit e che ciò ci consenta di risolvere le carenze di lunga data dell'API nei passaggi del transpiler relativi alle operazioni di flusso di controllo.
I blocchi di ControlFlowOp istanze non terranno più traccia name dei metadata campi. Questi elementi non erano già configurabili tramite l'interfaccia del generatore di flussi di controllo, e la loro esistenza era un dettaglio di implementazione non previsto piuttosto che un'API intenzionale.
Il metodo Gate.control() non restituisce più un AnnotatedOperation quando l'argomento annotated è impostato su True ed è disponibile una classe nativa di gate controllato. Questa modifica è in linea con il modo in cui l'argomento annotated viene utilizzato nella libreria dei circuiti standard e consente una scomposizione più efficiente delle porte con annotazioni di controllo. I cancelli interessati sono:
- Porte a comando singolo H``CZ , S, Sdg, U3 Y, Z, SX, RX, RY,, RZ, Swap e;
- Porta a doppio Z controllo;
- controllati arbitrariamente Phase, CPhase, MCPhase, U1 CU1,, MCU1 e MCMT gate.
Il valore predefinito dell'argomento annotated in QuantumCircuit.control() è ora None invece di False. Ciò non influisce sui circuiti stessi, ma è coerente con il valore predefinito utilizzato in tutta la annotated libreria dei circuiti.

Note sull'aggiornamento QPY

La versione predefinita di QPY (QPY_VERSION) utilizzata in qpy.dump() è ora la 17.

Note sull'aggiornamento delle informazioni quantistiche

Sono state migliorate le prestazioni degli operatori di Pauli identici ricorrendo Statevector.expectation_value() all'implementazione ottimizzata per il caso generale, anziché a una scorciatoia dedicata che scalava male con il numero di qubit.

Note sull'aggiornamento del transpiler

I limiti massimi di chiamate e tentativi per la sequenza a corrispondenza esatta di VF2PostLayout in optimization_level=3 sono stati ridotti per evitare tempi di esecuzione eccessivi nel caso di circuiti di prova altamente simmetrici mappati su mappe di accoppiamento di grandi dimensioni.
Il percorso predefinito per il registro del passaggio del WrapAngles transpiler è ora WrapAngles.DEFAULT_REGISTRY. Il percorso precedente, caratterizzato WRAP_ANGLE_REGISTRY da un'impostazione profondamente annidata, continuerà a funzionare per motivi di compatibilità con le versioni precedenti, ma invitiamo i pacchetti a valle a utilizzare il nuovo percorso. Il percorso precedente era un errore di Qiskit 2.2 e attraversa moduli che non erano mai stati pensati per far parte dell'API pubblica.
Sebbene l'interfaccia per VF2Layout e VF2PostLayout rimanga logicamente invariata, max_trials l'argomento ora ha un effetto molto minore come limitatore di runtime, tranne quando è impostato sul valore 1. Questo perché, grazie al nuovo algoritmo di calcolo e ottimizzazione in tempo reale utilizzato internamente dalla classe, i layout «completi» si verificano molto più raramente, e il conteggio dei «tentativi» aumenta solo quando si incontra un nuovo layout che presenta un tasso di errore inferiore rispetto a quello precedente. Si dovrebbe invece utilizzare call_limit come limitatore deterministico del tempo di esecuzione; dove max_trials misura i layout completi rilevati, call_limit misura le estensioni dei layout parziali.

Note varie sull'aggiornamento

La versione minima supportata di Python è ora 3.10, a seguito della fine del ciclo di vita di Python 3.9 nell'ottobre 2025 e degli avvisi di obsolescenza in Qiskit dalla versione 2.1.
Il supporto per macOS x86-64 (Intel) è stato declassato dal livello 1 al livello 2. Qiskit continuerà a fornire componenti testati e precompilati per questa piattaforma, ma i test saranno eseguiti solo al momento del rilascio, anziché ad ogni modifica. Ciò potrebbe causare ritardi nel rilascio delle ruote per questa piattaforma.

Questa modifica è stata apportata perché Apple ha iniziato a ritirare la piattaforma e il team Qiskit non dispone più delle risorse di sviluppo o CI necessarie per continuare a fornire il supporto di primo livello. Possiamo supportare solo macOS x86-64 mentre GitHub continua a fornire runner per esso, e prevediamo che questo supporto verrà rimosso nella seconda metà del 2027.

Deprecazioni API C

La funzione qk_transpiler_pass_standalone_vf2_layout() è obsoleta; gli utenti dovrebbero ora utilizzare qk_transpiler_pass_standalone_vf2_layout_average(). Il nuovo nome della funzione descrive meglio l'euristica di punteggio, e l'API consente un accesso incapsulato all'intero nuovo oggetto di configurazione, compresa la forma a due limiti di call_limit.

Questa deprecazione non è del tutto necessaria per gli utenti, ma dato che l'API C è ancora esplicitamente instabile, la stiamo utilizzando come prova per gestire le deprecazioni e gli avvisi specifici del compilatore nell'API C, prima di raggiungere garanzie di stabilità.

Circuiti deprecati

A partire dalla versione 1.0 di Qiskit, i metodi Gate.control() e QuantumCircuit.control() accettano l'argomento, annotated che può Falseessere, True o None. Attualmente, un gate controllato viene rappresentato utilizzando una classe dedicata ai gate controllati, qualora esista, indipendentemente dal valore di annotated; ad esempio, una versione a due controlli di un XGate è un CCXGate. Se non esiste una classe specifica per i gate controllati, il gate controllato viene rappresentato come un ControlledGate quando annotated=False e come un AnnotatedOperation quando annotated=True. Il valore annotated=None predefinito viene trattato esattamente come False.

In Qiskit 3.0, non sarà più possibile impostare annotated=None e invece cambieremo l'impostazione predefinita in annotated=True. Questo è consigliabile, poiché differisce la costruzione del circuito controllato dalla costruzione del circuito al transpiler e consente ulteriori ottimizzazioni del gate controllato, che in genere portano a circuiti di qualità superiore (in particolare per i circuiti gerarchici).

Tuttavia, sarà ancora possibile impostare esplicitamente annotated=False per mantenere il comportamento precedente.

Deprecazioni del transpiler

È stato deprecato il formato di serializzazione legacy utilizzato in SolovayKitaevDecomposition, che si basava sulla conversione in formato pickle delle approssimazioni di base sotto forma di un oggetto Pythondict. Il processo di caricamento rappresenta una potenziale vulnerabilità di sicurezza e dovrebbe essere utilizzato solo con file affidabili. Il nuovo formato di serializzazione elimina questa vulnerabilità. Le funzioni per generare il formato legacy, generate_basic_approximations(), e caricarlo, SolovayKitaevDecomposition.load_basic_approximations() e nell'inizializzatore di SolovayKitaevDecomposition, sono state deprecate. Utilizza invece SolovayKitaevDecomposition.save_basic_approximations() per generare un formato che possa essere caricato in tutta sicurezza nell'inizializzatore della classe.

Modifiche al sistema di compilazione

Quando si compila o si impacchetta Qiskit dal codice sorgente, la versione richiesta di setuptools è ora almeno la versione 77.0 (rilasciata nel marzo 2025). Questo serve a supportare le nuove specifiche dei metadati delle licenze di PEP 639. Questa dipendenza è specificata nei requisiti di compilazione, quindi non dovrebbe essere necessaria alcuna azione manuale.

Correzioni di bug

Correzione dell'implementazione di __deepcopy__() in QuantumCircuit che non eseguiva la copia profonda dei parametri del circuito. Di conseguenza, la mutazione di un elemento BoxOp in un circuito copiato non influisce più sul circuito originale.
DAGCircuit.apply_operation_back(), apply_operation_back() e ora circuit_to_dag() aggiungerà i nuovi spigoli in un ordine deterministico. Il comportamento precedente potrebbe far sì che alcuni passaggi del transpiler (come SabreSwap) percorrano il DAG in ordini non deterministici.
DAGCircuit.apply_operation_front() Non è più possibile inserire cicli su se stessi non validi durante la gestione dei nodi che includono condizioni classiche.
È stato risolto un problema che si verificava Optimize1qGatesDecomposition quando il percorso veniva inizializzato con un Target file contenente porte " 1q " con parametri di angolo fissi. In precedenza, il passaggio avrebbe potuto generare porte al di fuori dell'area di destinazione, poiché non verificava che la porta nell'area di destinazione supportasse valori arbitrari dei parametri. Risolto il problema n. 14743.
È stato risolto un comportamento errato nel BasisTranslator passaggio in cui un gate multi-qubit all'interno di un ControlFlowOp blocco utilizzava gli indici dei qubit locali invece degli indici assoluti del circuito di origine.
È stato risolto il problema del riutilizzo della stessa ConsolidateBlocks istanza su più circuiti, comprese le chiamate con più di un transpile() circuito e senza parallelizzazione basata sui processi. Un bug introdotto in Qiskit 2.2.2 causava un errore di panico o un output non valido se la stessa istanza veniva riutilizzata su circuiti diversi.
Il passaggio del ConsolidateBlocks transpiler ora valuterà correttamente se una determinata porta è supportata dall'hardware durante la ricorsione nelle operazioni di flusso di controllo.
qpy.dump() ora è in grado di scrivere su .gz file aperti tramite il modulo della gzip libreria standard con le versioni 16 o successive di QPY. Per ulteriori dettagli, consultare il n. 15157.
Sono stati corretti i metodi MCPhaseGate.inverse() e MCU1Gate.inverse() per preservare gli stati di controllo dei gate a controllo aperto durante il calcolo dei loro inversi.
ConsolidateBlocks ora genererà un'eccezione di tipo " Python -space" invece di andare in panico quando rileva un'analisi non valida o non aggiornata nelle chiavi legacy run_list``block_listPropertySet o.
Optimize1qGatesDecomposition ora genererà un TranspilerError anziché un panic di spazio Rust quando si tenta di eseguire il codice su un circuito troppo grande per il Target.
È stato risolto un problema relativo pickle al supporto per il metodo SabreSwap in cui SabreSwap un'istanza generava un errore durante la serializzazione dopo l'esecuzione SabreSwap.run() del metodo. Risolto il problema n. 15071.
I passaggi di pianificazione ALAPScheduleAnalysis e ora ASAPScheduleAnalysis gestiranno correttamente i circuiti privi di operazioni. In precedenza, veniva visualizzato un messaggio TranspilerError errato che recitava: «Nessuna durata specificata». Risolto il problema n. 15145.
È stato risolto un problema per cui is_unitary() non venivano rispettati correttamente i valori di tolleranza di ingresso durante la verifica dell'unitarità di un operatore. Il metodo ora utilizza correttamente i parametri rtol e atol forniti durante la semplificazione dell'operatore e la verifica della sua identità. Questo risolve il problema n. 14107.
È stato risolto un errore nel passaggio UnitarySynthesis del transpiler, quando viene chiamato con un plugin di sintesi non predefinito (specificato tramite method) che supporta basis_gates ma non target. Il pass ora trasmette correttamente i segnali di base dal target al plugin.
È stato risolto un errore nel pannello di testo del circuito, che poteva verificarsi quando i blocchi del circuito all'interno delle operazioni di flusso di controllo erano definiti su registri diversi rispetto al circuito esterno. Questa situazione potrebbe verificarsi, ad esempio, quando si aggiungono ControlFlowOp operazioni direttamente o nei circuiti dopo la transpilazione.
È stato risolto il problema relativo alla serializzazione PauliEvolutionGate con operatori di tipo SparseObservable, quando si utilizza la versione 17 di QPY.
È stata risolta una discrepanza in QkTargetOp cui la lunghezza dell'array memorizzato in non QkTargetOp.params corrispondeva al numero restituito da QkTargetOp.num_params. I parametri jolly sono ora rappresentati da NAN, e la lunghezza dell'array sarà sempre QkTargetOp.num_params. Questo bug era presente solo nella versione 2.3.0rc1.
È stata risolta una regressione nella rappresentazione dell'espressione classica di tipo UintValue con larghezza superiore a 64 bit. In precedenza, il valore delle espressioni contenenti questi tipi veniva involontariamente convertito internamente in un valore in virgola mobile di tipo double, con conseguente perdita di precisione.
Il HighLevelSynthesis passaggio ora selezionerà correttamente la metrica di ottimizzazione in base al set di basi: il numero di porte a due qubit per le basi continue e il numero di T per le basi Clifford+T. In precedenza, queste informazioni non venivano trasmesse correttamente, con il risultato che i conteggi dei T erano inferiori alle aspettative.
Corretto il disegno del testo del circuito in modo che le istruzioni del circuito con cavi classici siano disegnate in livelli separati.
La moltiplicazione matriciale (@) tra Operator e Statevector applicherà ora l'operatore allo stato e restituirà il risultato Statevector.
È stato risolto un bug nel passaggio ElidePermutations del transpiler che causava un arresto anomalo durante la gestione delle permutazioni di un singolo qubit.
È stato risolto un potenziale problema di deadlock che si verificava durante l'esecuzione di passaggi di layout, ad esempio SabreLayout con una connettività disgiunta nel Target e in un contesto di elaborazione multiprocesso, derivante dall'esecuzione PassManager.run() di o transpile() con più di un circuito. Su Linux questo è il comportamento predefinito quando si esegue PassManager.run() o transpile() con più di un circuito; su tutte le altre piattaforme, è necessario abilitare espressamente l'uso di un contesto di multiprocessing.

Ciò era dovuto a un problema sottostante in CPython tracciato in python/cpython#84559 quando si combinavano multiprocessing e multithreading. In genere Qiskit impedisce la combinazione dei due metodi di parallelismo, ma nel caso della gestione di grafici di connettività disgiunti questa protezione era assente nel codice Rust multithread.
Il metodo ora Statevector.to_dict() terrà conto dell'argomento decimals chiave, che in precedenza ignorava.
È stato risolto un problema con la funzione timeline_drawer() di visualizzazione che causava un errore durante la visualizzazione di un circuito pianificato proveniente da un target contenente porte parametrizzate con una durata impostata.
Generazione fissa delle etichette per gli SparseObservable operatori PauliEvolutionGate «with». Le etichette ora mostrano gli operatori di Pauli con indici di qubit (ad es. "X0 X2") anziché nel formato a stringa concatenata (ad es. "XX"), migliorando la chiarezza nella distinzione tra i diversi operatori.
Pauli.evolve() ora gestisce correttamente i circuiti quantistici contenenti determinati gate di rotazione parametrizzati, quando l'angolo è un multiplo di $\pi/2$ , ad esempio RZGate(math.pi/2) oppure RZZGate(math.pi/2). In precedenza non venivano riconosciuti come cancelli Clifford e veniva segnalato un errore.
BasePassManager non sostituisce più i risultati falsi ma validi ottenuti dai passaggi con il programma di input originale. Un valore "pass returning 0" False o un altro valore falso verrà ora mantenuto, e solo "failure None " indicherà un errore.
QuantumCircuit.compose() ora rimapperà correttamente tutte le variabili e gli intervalli utilizzati nelle Delay istruzioni quando viene specificato var_remap l'argomento.

Questa pagina è stata utile?

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