Note di rilascio di Qiskit 0.44

---

Cronologia versioni

Questa è la versione finale in cui qiskit era un "meta-pacchetto", che conteneva diversi "elementi". Ciò che viene chiamato "Qiskit Terra" in questa (e nelle precedenti) note di rilascio è principalmente ciò che ora viene chiamato semplicemente "Qiskit".

Questa tabella tiene traccia delle versioni dei metapacchetti e della versione di ciascun elemento Qiskit installato:

---

0.44.1

Terra 0.25.1

Preludio

Qiskit Terra 0.25.1 è una release di correzione dei bug, che risolve alcuni problemi identificati dopo la release 0.25.1.

Correzioni di bug

• Corretto un bug nella serializzazione QPY (qiskit.qpy) per cui più porte personalizzate controllate in un circuito potevano generare un file QPY non valido che non poteva essere analizzato. Corretto #9746.

• Corretto #9363. etichettando la sintesi senza registro nell'ordine di ritorno di Tweedledum. Ad esempio, confrontate questo esempio prima e dopo la correzione:

  from qiskit.circuit import QuantumCircuit
  from qiskit.circuit.classicalfunction import BooleanExpression
  
  boolean_exp = BooleanExpression.from_dimacs_file("simple_v3_c2.cnf")
  circuit = QuantumCircuit(boolean_exp.num_qubits)
  circuit.append(boolean_exp, range(boolean_exp.num_qubits))
  circuit.draw("text")
  
  from qiskit.circuit.classicalfunction import classical_function
  from qiskit.circuit.classicalfunction.types import Int1
  
  @classical_function
  def grover_oracle(a: Int1, b: Int1, c: Int1) -> Int1:
      return (a and b and not c)
  
  quantum_circuit = grover_oracle.synth(registerless=False)
  print(quantum_circuit.draw())

  Che stamperebbe

       Before             After
  
       c: ──■──           a: ──■──
            │                  │
       b: ──■──           b: ──■──
            │                  │
       a: ──o──           c: ──o──
          ┌─┴─┐              ┌─┴─┐
  return: ┤ X ├      return: ┤ X ├
          └───┘              └───┘

• Corretto plot_state_paulivec(), che in precedenza smorzava i coefficienti di stato di un fattore di $2^n$, dove $n$ è il numero di qubit. Ora il grafico a barre visualizza correttamente i coefficienti come $\mathrm{Tr}(\sigma\rho)$, dove $\rho$ è lo stato da tracciare e $\sigma$ itera su tutti i possibili prodotti tensoriali di Paulis a singolo qubit.

• Gli angoli nell'esportatore OpenQASM 2 (QuantumCircuit.qasm()) ora includono sempre un punto decimale, ad esempio nel caso di 1.e-5. Questo è richiesto da un'interpretazione rigorosa delle specifiche dei letterali a virgola mobile in OpenQASM 2. Il parser OpenQASM 2 di Qiskit (qasm2.load() e loads()) è più permissivo per impostazione predefinita e consente 1e-5 senza il punto decimale, a meno che non sia in modalità strict .

• Il setter per SparsePauliOp.paulis ora rifiuta correttamente i tentativi di impostare l'attributo con dati non corretti, invece di permettere silenziosamente la creazione di un oggetto non valido. Vedere #10384.

• È stato risolto un problema di prestazioni nel file SabreLayout e SabreSwap nei passaggi del transpiler. Corretto #10650

---

0.44.0

Questo rilascio segna ufficialmente la fine del supporto per il pacchetto Qiskit IBMQ Provider e la rimozione di Qiskit Aer dal metapacchetto Qiskit. Dopo questa release il metapacchetto contiene solo Qiskit Terra, quindi questa è l'ultima release in cui ci riferiremo al metapacchetto Qiskit e a Qiskit Terra come cose separate. A partire dalla prossima release Qiskit 0.45.0 il pacchetto Qiskit sarà semplicemente quello che prima era Qiskit Terra e non ci sarà più una separazione tra i due.

Se si utilizza ancora il pacchetto qiskit-ibmq-provider , questo è stato ritirato e non è più supportato. Per passare ai nuovi pacchetti sostitutivi qiskit-ibm-provider, qiskit-ibm-runtime e qiskit-ibm-experiment è necessario seguire i link alle guide alla migrazione presenti nel README del pacchetto:

https://github.com/Qiskit/qiskit-ibmq-provider#migration-guides

Il progetto Qiskit Aer è ancora attivo e mantenuto in futuro, solo che non è più incluso nel pacchetto qiskit . Per continuare a usare qiskit-aer è necessario installare esplicitamente qiskit-aer e importare il pacchetto da qiskit_aer.

Poiché questa è la versione finale del metapacchetto Qiskit, i seguenti setuptools utilizzati per installare le dipendenze opzionali non funzioneranno più nella prossima versione di Qiskit 0.45.0:

• nature
• machine-learning
• finance
• optimization
• experiments

Se si usano gli extra per installare qualche pacchetto, si dovrebbe passare a usare direttamente i pacchetti invece degli extra. Ad esempio, se in precedenza si utilizzava pip install qiskit[experiments] , si deve passare a pip install qiskit qiskit-experiments per installare entrambi i pacchetti. Allo stesso modo l'extra all (che viene installato tramite pip install "qiskit[all]") non includerà più questi pacchetti in Qiskit 0.45.0.

Terra 0.25.0

Preludio

I punti salienti della release Qiskit Terra 0.25.0 sono:

• Le operazioni di flusso di controllo sono ora supportate dal transpiler a tutti i livelli di ottimizzazione, compresi i livelli 2 e 3 (ad esempio, la chiamata a transpile() o generate_preset_pass_manager() con l'argomento optimization_level specificato come 2 o 3 è ora supportato).

• I campi IfElseOp.condition, WhileLoopOp.condition e SwitchCaseOp.target possono ora essere istanze del nuovo tipo di espressione classica di runtime expr.Expr. Si distingue da ParameterExpression perché viene valutato in fase di esecuzione per i backend che supportano tali operazioni.

  Queste nuove espressioni hanno una potenza significativamente maggiore rispetto alla vecchia forma a due tuple per fornire le condizioni classiche. Ad esempio, è possibile rappresentare i vincoli di uguaglianza tra due diversi registri classici o la logica "o" di due bit classici. Questi due esempi si presentano come:

  from qiskit.circuit import QuantumCircuit, ClassicalRegister, QuantumRegister
  from qiskit.circuit.classical import expr
  
  qr = QuantumRegister(4)
  cr1 = ClassicalRegister(2)
  cr2 = ClassicalRegister(2)
  qc = QuantumCircuit(qr, cr1, cr2)
  qc.h(0)
  qc.cx(0, 1)
  qc.h(2)
  qc.cx(2, 3)
  qc.measure([0, 1, 2, 3], [0, 1, 2, 3])
  
  # If the two registers are equal to each other.
  with qc.if_test(expr.equal(cr1, cr2)):
    qc.x(0)
  
  # While either of two bits are set.
  with qc.while_loop(expr.logic_or(cr1[0], cr1[1])):
    qc.reset(0)
    qc.reset(1)
    qc.measure([0, 1], cr1)

  Per ulteriori esempi, vedere la documentazione di qiskit.circuit.classical.

  Questa funzione è nuova sia per Qiskit che per l'hardware quantistico disponibile con cui Qiskit lavora. Poiché le funzioni sono ancora in fase di sviluppo, è probabile che si verifichino casi limite inaspettati che richiederanno un po' di tempo per essere risolti. Se si riscontrano problemi relativi al supporto o all'utilizzo delle espressioni classiche, si prega di aprire un problema con Qiskit o con il proprio fornitore di hardware.

  In questa prima versione, Qiskit ha aggiunto le operazioni:

  • bit_not()
  • logic_not()
  • bit_and()
  • bit_or()
  • bit_xor()
  • logic_and()
  • logic_or()
  • equal()
  • not_equal()
  • less()
  • less_equal()
  • greater()
  • greater_equal()

  Questi possono agire su Python interi e letterali booleani, o su ClassicalRegister e Clbit istanze.

  Tutte queste espressioni classiche sono pienamente supportate dallo stack transpiler di Qiskit, dalla serializzazione di QPY (qiskit.qpy) e per l'esportazione in OpenQASM 3 (qiskit.qasm3). L'importazione da OpenQASM 3 è attualmente gestita da un pacchetto separato (che viene ri-esposto via qiskit.qasm3), che ci auguriamo venga esteso per adattarsi alle nuove funzionalità di Qiskit.

• Il modulo qiskit.algorithms è stato deprecato e sarà rimosso in una prossima versione. È stata sostituita da una nuova libreria standalone qiskit-algorithms che può essere trovata su PyPi o su Github qui:

  https://github.com/qiskit-community/qiskit-algorithms

  Il modulo qiskit.algorithms continuerà a funzionare come prima e verranno apportate correzioni di bug fino alla sua futura rimozione, ma lo sviluppo attivo di nuove funzionalità è passato al nuovo pacchetto. Se ci si affida a qiskit.algorithms si devono aggiornare i requisiti di Python per includere anche qiskit-algorithms e aggiornare le importazioni da qiskit.algorithms a qiskit_algorithms. Si noti che questo nuovo pacchetto non include il codice degli algoritmi già deprecati, compresi gli algoritmi basati su opflow e QuantumInstance. Se non si è ancora migrato dagli algoritmi basati su QuantumInstance a quelli basati sulle primitive, è necessario seguire le linee guida per la migrazione in https://qisk.it/algo \migration. La decisione di migrare il modulo algorithms in un pacchetto separato è stata presa per chiarire lo scopo di Qiskit e fare una distinzione tra gli strumenti e le librerie costruite su di esso.

Qiskit Terra 0.25 ha abbandonato il supporto per Python 3.7 in seguito agli avvisi di deprecazione iniziati in Qiskit Terra 0.23. Questo è coerente con il termine del ciclo di vita di Python 3.7’s il 27 giugno 2023. Per continuare a utilizzare Qiskit, è necessario aggiornare a una versione più recente di Python.

Nuove funzioni

• In questa versione sono state aggiunte le seguenti funzioni.

Funzionalità del transpiler

• Aggiunte due nuove opzioni a BlockCollector.

  La prima nuova opzione split_layers consente di suddividere i blocchi raccolti in sottoblocchi su sottoinsiemi di qubit disgiunti, ovvero in sottoblocchi depth-1.

  La seconda nuova opzione collect_from_back consente di raccogliere avidamente i blocchi a partire dalle uscite del circuito. Questo è importante in combinazione con i passaggi di programmazione ALAP, dove si preferisce mettere i gate nei blocchi successivi piuttosto che in quelli precedenti.

• Aggiunte le nuove opzioni split_layers e collect_from_back a CollectLinearFunctions e CollectCliffords ai passaggi del transpiler.

  Quando split_layers è Vero, i blocchi raccolti vengono suddivisi in sottoblocchi su sottoinsiemi di qubit disgiunti, ossia in sottoblocchi depth-1. Considera il seguente esempio:

  from qiskit.circuit import QuantumCircuit
  from qiskit.transpiler.passes import CollectLinearFunctions
  
  circuit = QuantumCircuit(5)
  circuit.cx(0, 2)
  circuit.cx(1, 4)
  circuit.cx(2, 0)
  circuit.cx(0, 3)
  circuit.swap(3, 2)
  circuit.swap(4, 1)
  
  # Collect all linear gates, without splitting into layers
  qct = CollectLinearFunctions(split_blocks=False, min_block_size=1, split_layers=False)(circuit)
  assert qct.count_ops()["linear_function"] == 1
  
  # Collect all linear gates, with splitting into layers
  qct = CollectLinearFunctions(split_blocks=False, min_block_size=1, split_layers=True)(circuit)
  assert qct.count_ops()["linear_function"] == 4

  Il circuito originale è lineare. Quando si raccolgono le porte lineari senza dividerle in strati, si dovrebbe ottenere un'unica funzione lineare. Tuttavia, quando si raccolgono le porte lineari e si dividono in strati, si dovrebbero ottenere 4 funzioni lineari.

  Quando collect_from_back è vero, i blocchi vengono raccolti avidamente dalle uscite verso gli ingressi del circuito. Considera il seguente esempio:

  from qiskit.circuit import QuantumCircuit
  from qiskit.transpiler.passes import CollectLinearFunctions
  
  circuit = QuantumCircuit(3)
  circuit.cx(1, 2)
  circuit.cx(1, 0)
  circuit.h(2)
  circuit.swap(1, 2)
  
  # This combines the CX(1, 2) and CX(1, 0) gates into a single linear function
  qct = CollectLinearFunctions(collect_from_back=False)(circuit)
  
  # This combines the CX(1, 0) and SWAP(1, 2) gates into a single linear function
  qct = CollectLinearFunctions(collect_from_back=True)(circuit)

  Il circuito originale contiene una porta Hadamard, per cui la porta CX(1, 0) può essere combinata con CX(1, 2) o con SWAP(1, 2), ma non con entrambe. Quando collect_from_back è Falso, i blocchi lineari vengono raccolti avidamente dall'inizio del circuito e quindi CX(1, 0) viene combinato con CX(1, 2). Quando collect_from_back è Vero, i blocchi lineari vengono raccolti avidamente dalla fine del circuito e quindi CX(1, 0) viene combinato con SWAP(1, 2).

• Aggiunto DAGCircuit.classical_predecessors() e DAGCircuit.classical_successors(), un'alternativa alla selezione dei fili classici che non richiede l'accesso diretto al grafo interno di un nodo DAG. L'esempio seguente illustra la nuova funzionalità:

  from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
  from qiskit.converters import circuit_to_dag
  from qiskit.circuit.library import RZGate
  
  q = QuantumRegister(3, 'q')
  c = ClassicalRegister(3, 'c')
  circ = QuantumCircuit(q, c)
  circ.h(q[0])
  circ.cx(q[0], q[1])
  circ.measure(q[0], c[0])
  circ.rz(0.5, q[1]).c_if(c, 2)
  circ.measure(q[1], c[0])
  dag = circuit_to_dag(circ)
  
  rz_node = dag.op_nodes(RZGate)[0]
  # Contains the "measure" on clbit 0, and the "wire start" nodes for clbits 1 and 2.
  classical_predecessors = list(dag.classical_predecessors(rz_node))
  # Contains the "measure" on clbit 0, and the "wire end" nodes for clbits 1 and 2.
  classical_successors = list(dag.classical_successors(rz_node))

• Supporto abilitato per ControlFlowOp nel passaggio CommutativeCancellation passaggio. In precedenza, i blocchi nelle operazioni di flusso di controllo venivano saltati da questo passaggio.

• Supporto abilitato per ControlFlowOp nel passaggio ConsolidateBlocks passaggio.

• Aggiunto DAGCircuit.quantum_causal_cone() per ottenere il cono causale di un qubit in un DAGCircuit. L'esempio seguente ne mostra l'uso corretto:

  from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
  from qiskit.circuit.library import CXGate, CZGate
  from qiskit.dagcircuit import DAGCircuit
  
  # Build a DAGCircuit
  dag = DAGCircuit()
  qreg = QuantumRegister(5)
  creg = ClassicalRegister(5)
  dag.add_qreg(qreg)
  dag.add_creg(creg)
  dag.apply_operation_back(CXGate(), qreg[[1, 2]], [])
  dag.apply_operation_back(CXGate(), qreg[[0, 3]], [])
  dag.apply_operation_back(CZGate(), qreg[[1, 4]], [])
  dag.apply_operation_back(CZGate(), qreg[[2, 4]], [])
  dag.apply_operation_back(CXGate(), qreg[[3, 4]], [])
  
  # Get the causal cone of qubit at index 0
  result = dag.quantum_causal_cone(qreg[0])

• Un nuovo metodo find_bit() è stato aggiunto alla classe DAGCircuit che restituisce le posizioni dei bit del parametro Qubit o Clbit come tupla dell'indice posizionale del bit all'interno del circuito e di un elenco di tuple che localizzano il bit nei registri del circuito.

• Il built-in del transpiler EquivalenceLibrary (qiskit.circuit.equivalence_library.SessionEquivalenceLibrary) ha imparato le relazioni circolari di Pauli $X = iYZ$, $Y = iZX$ e $Z = iXY$. Questo dovrebbe rendere più affidabile la trasposizione su insiemi di basi vincolate e potenzialmente incomplete. Per maggiori dettagli, vedere il numero 10293.

• Le operazioni di flusso di controllo sono ora supportate dal transpiler a tutti i livelli di ottimizzazione, compresi i livelli 2 e 3 (ad esempio, la chiamata a transpile() o generate_preset_pass_manager() con l'argomento parola chiave optimization_level=3).

• DAGCircuit.substitute_node() ha guadagnato un argomento della parola chiave propagate_condition che è analogo allo stesso argomento in substitute_node_with_dag(). Impostando questo valore a False si evita il comportamento tradizionale di copiare una condizione di node nel nuovo op che lo sostituisce.

  Questa opzione viene ignorata per le operazioni generali di flusso di controllo, che non propagheranno mai la loro condizione, né accetteranno una condizione da un altro nodo.

• Introdotto un nuovo metodo, DAGCircuit.separable_circuits()che restituisce una lista di oggetti DAGCircuit uno per ogni insieme di qubit connessi che non hanno porte che li collegano a un altro insieme.

  Ogni istanza DAGCircuit restituita da questo metodo conterrà lo stesso numero di clbit di self. Questo metodo non restituirà DAGCircuit istanze costituite esclusivamente da clbit.

• È stato aggiunto l'attributo Target.concurrent_measurements che rappresenta un vincolo hardware di qubit misurati simultaneamente. Questo vincolo è fornito in forma di elenco annidato, in cui ogni elemento rappresenta un gruppo di qubit da misurare insieme. In un esempio che segue:

  [[0, 1], [2, 3, 4]]

  i qubit 0 e 1 e 2, 3 e 4 sono misurati insieme sul dispositivo. Questo vincolo non blocca la misura di un singolo qubit, ma potrebbe essere necessario considerare l'allineamento delle operazioni di misura per questi qubit quando si lavora con lo scheduler di Qiskit Pulse e quando si scrivono nuovi passaggi del transpiler che sono consapevoli dei tempi (cioè passaggi che eseguono lo scheduling).

• Il passo del transpiler SetLayout può ora essere costruito con una lista di interi che rappresentano i qubit fisici su cui verrà mappato il circuito quantistico. Cioè, il primo qubit del circuito sarà assegnato al qubit fisico in posizione zero dell'elenco, e così via.

• Il transpiler incorporato EquivalenceLibrary ha insegnato più equivalenze di Pauli-rotazione tra le porte a un qubit $R_X$, $R_Y$ e $R_Z$ e tra le porte a due qubit $R_{XX}$, $R_{YY}$ e $R_{ZZ}$. Questo dovrebbe rendere più affidabili le traduzioni di basi semplici, in particolare i circuiti che utilizzano rotazioni $Y$. Vedere il n. 7332.

• Le operazioni di flusso di controllo sono ora supportate dalla famiglia Sabre di passaggi di transpiler, in particolare il passaggio di layout e il passaggio di routing SabreLayout e il passaggio di instradamento SabreSwap. Funzione transpile() gli argomenti delle parole chiave layout_method e routing_method accettano ora l'opzione "sabre" per i circuiti con flusso di controllo, precedentemente non supportata.

Caratteristiche dei circuiti

• I campi IfElseOp.condition, WhileLoopOp.condition e SwitchCaseOp.target possono ora essere istanze del nuovo tipo di espressione classica di runtime expr.Expr. Si distingue da ParameterExpression perché viene valutato in fase di esecuzione per i backend che supportano tali operazioni.

  Queste nuove espressioni hanno una potenza significativamente maggiore rispetto alla vecchia forma a due tuple per fornire le condizioni classiche. Ad esempio, è possibile rappresentare i vincoli di uguaglianza tra due diversi registri classici o la logica "o" di due bit classici. Questi due esempi si presentano come:

  from qiskit.circuit import QuantumCircuit, ClassicalRegister, QuantumRegister
  from qiskit.circuit.classical import expr
  
  qr = QuantumRegister(4)
  cr1 = ClassicalRegister(2)
  cr2 = ClassicalRegister(2)
  qc = QuantumCircuit(qr, cr1, cr2)
  qc.h(0)
  qc.cx(0, 1)
  qc.h(2)
  qc.cx(2, 3)
  qc.measure([0, 1, 2, 3], [0, 1, 2, 3])
  
  # If the two registers are equal to each other.
  with qc.if_test(expr.equal(cr1, cr2)):
    qc.x(0)
  
  # While either of two bits are set.
  with qc.while_loop(expr.logic_or(cr1[0], cr1[1])):
    qc.reset(0)
    qc.reset(1)
    qc.measure([0, 1], cr1)

  Per ulteriori esempi, vedere la documentazione di qiskit.circuit.classical.

  Questa funzione è nuova sia per Qiskit che per l'hardware quantistico disponibile con cui Qiskit lavora. Poiché le funzioni sono ancora in fase di sviluppo, è probabile che si verifichino casi limite inaspettati che richiederanno un po' di tempo per essere risolti. Se si riscontrano problemi relativi al supporto o all'utilizzo delle espressioni classiche, si prega di aprire un problema con Qiskit o con il proprio fornitore di hardware.

  In questa prima versione, Qiskit ha aggiunto le operazioni:

  • bit_not()
  • logic_not()
  • bit_and()
  • bit_or()
  • bit_xor()
  • logic_and()
  • logic_or()
  • equal()
  • not_equal()
  • less()
  • less_equal()
  • greater()
  • greater_equal()

  Questi possono agire su Python interi e letterali booleani, o su ClassicalRegister e Clbit istanze.

  Tutte queste espressioni classiche sono pienamente supportate dallo stack transpiler di Qiskit, dalla serializzazione di QPY (qiskit.qpy) e per l'esportazione in OpenQASM 3 (qiskit.qasm3). L'importazione da OpenQASM 3 è attualmente gestita da un pacchetto separato (che viene ri-esposto via qiskit.qasm3), che ci auguriamo venga esteso per adattarsi alle nuove funzionalità di Qiskit.

• Sono stati aggiunti strumenti per lavorare con le nuove rappresentazioni delle espressioni runtime classiche. Un'espressione generale ExprVisitor per i consumatori di queste espressioni da sottoclasse. Due utility basate su questa struttura, iter_vars() e structurally_equivalent(), che producono rispettivamente un iteratore attraverso i nodi Var e controllano se due Expr sono strutturalmente uguali, fino a una certa mappatura dei nodi contenuti Var nodi contenuti.

• Aggiunta la funzione lift_legacy_condition() che può essere usata per convertire le condizioni di vecchio stile in nodi di nuovo stile Expr nodi. Si noti che questi nodi di espressione non sono consentiti nei campi di tipo vecchio Instruction.condition di vecchio stile, che verranno sostituiti da una gestione classica più avanzata, come quella di IfElseOp.

• Aggiunto il supporto per il calcolo dei valori assoluti di ParameterExpressions. Ad esempio, ora è possibile eseguire quanto segue:

  from qiskit.circuit import QuantumCircuit, Parameter
  
  x = Parameter("x")
  circuit = QuantumCircuit(1)
  circuit.rx(abs(x), 0)
  
  bound = circuit.bind_parameters({x: -1})

• Le prestazioni di QuantumCircuit.assign_parameters() e bind_parameters() sono aumentate in modo significativo per i circuiti di grandi dimensioni con strutture tipiche delle applicazioni. Questo include la maggior parte dei circuiti basati sulla NLocal struttura, come ad esempio EfficientSU2. Per maggiori dettagli, vedere il numero 10282.

• Il metodo QuantumCircuit.assign_parameters() ha ottenuto due nuovi argomenti chiave: flat_input e strict. Queste sono opzioni avanzate che possono essere utilizzate per velocizzare il metodo quando si passano i binding dei parametri come dizionario; flat_input=True è una garanzia che le chiavi del dizionario contengano solo Parameter (non ParameterVectors) e strict=False consente al dizionario di contenere parametri non presenti nel circuito. L'uso di queste due opzioni può ridurre l'overhead della normalizzazione degli ingressi in questa funzione.

• Aggiunta di un nuovo argomento chiave flatten al costruttore delle seguenti classi:

  • EfficientSU2
  • ExcitationPreserving
  • NLocal
  • RealAmplitudes
  • TwoLocal
  • EvolvedOperatorAnsatz
  • QAOAAnsatz

  Se questo parametro è impostato a True , la QuantumCircuit generata non avvolgerà l'implementazione in Gate o Instruction oggetti. Sebbene questo non sia ottimale per la visualizzazione, in genere si ottengono prestazioni migliori in fase di esecuzione, specialmente con i metodi QuantumCircuit.bind_parameters() e QuantumCircuit.assign_parameters() che può vedere un miglioramento substatale dei tempi di esecuzione con un output appiattito rispetto all'output predefinito annidato e avvolto.

• È stato aggiunto il supporto per la costruzione di LinearFunctionda circuiti quantistici più generali, che possono contenere:

  • Barriere (di tipo Barrier) e ritardi (Delay), che vengono semplicemente ignorati
  • Permutazioni (di tipo PermutationGate)
  • Altre funzioni lineari
  • Clifford (di tipo Clifford), quando il Clifford rappresenta una funzione lineare (in caso contrario viene sollevata un'eccezione CircuitError )
  • Circuiti quantistici annidati di questa forma

• Aggiunto il metodo LinearFunction.__eq__() . Due oggetti di tipo LinearFunction sono considerati uguali quando le loro rappresentazioni come matrici binarie invertibili sono uguali.

• Aggiunto LinearFunction.extend_with_identity() che permette di estendere una funzione lineare su k qubit a una funzione lineare su n >= k qubit, specificando le nuove posizioni dei qubit originali e facendo un padding con identità sui qubit rimanenti.

• Aggiunti due metodi per la stampa LinearFunction oggetti: LinearFunction.mat_str(), che restituisce la rappresentazione in stringa della funzione lineare vista come una matrice con voci 0/1, e LinearFunction.function_str()che restituisce la rappresentazione in stringa della funzione lineare vista come una trasformazione lineare.

• Le istruzioni StatePreparation e Initialize, e i relativi metodi di circuito QuantumCircuit.prepare_state() e initialize()hanno ottenuto un argomento di parola chiave normalize, che può essere impostato su True per normalizzare automaticamente un target di matrice. L'impostazione predefinita è False, che mantiene il comportamento attuale di sollevare un'eccezione quando viene dato un input non normalizzato.

Caratteristiche degli algoritmi

• È stata aggiunta la possibilità di passare un callback all'ottimizzatore UMDA che consente di tenere traccia del numero di valutazioni della funzione, dei parametri correnti e del miglior valore della funzione ottenuto.

OpenQASM Caratteristiche

• Il sito OpenQASM 3 esportatori (qasm3.dump(), dumps() e Exporter) hanno un nuovo argomento allow_aliasing , che sostituirà l'argomento alias_classical_registers . Controlla se l'aliasing è consentito sia per i bit classici che per i qubit, anziché essere disponibile solo per i bit classici.

Caratteristiche dell'informazione quantistica

• Aggiunta una nuova funzione negativity() che calcola la misura di entanglement della negatività di uno stato quantistico. Di seguito è riportato un esempio di utilizzo della funzione sopra descritta:

  from qiskit.quantum_info.states.densitymatrix import DensityMatrix
  from qiskit.quantum_info.states.statevector import Statevector
  from qiskit.quantum_info import negativity
  import numpy as np
  
  # Constructing a two-qubit bell state vector
  state = np.array([0, 1/np.sqrt(2), -1/np.sqrt(2), 0])
  # Calculating negativity of statevector
  negv = negativity(Statevector(state), [1])
  
  # Creating the Density Matrix (DM)
  rho = DensityMatrix.from_label("10+")
  # Calculating negativity of DM
  negv2 = negativity(rho, [0, 1])

• Aggiunta la funzione schmidt_decomposition(). Questa funzione funziona con gli elementi Statevector e DensityMatrix per gli stati puri bipartiti.

• Aggiunge il supporto per la moltiplicazione di SparsePauliOp oggetti con Parameter utilizzando l'operatore *, ad esempio:

  from qiskit.circuit import Parameter
  from qiskit.quantum_info import SparsePauliOp
  
  param = Parameter("a")
  op = SparsePauliOp("X")
  param * op

Caratteristiche di Pulse

• La SymbolicPulse la biblioteca è stata ampliata. Le nuove funzioni di impulso della libreria sono:

  • GaussianDeriv()
  • Sech()
  • SechDeriv()
  • Square()

  Le nuove funzioni restituiscono un'istanza di ScalableSymbolicPulse e corrispondono alle funzionalità delle corrispondenti funzioni della libreria degli impulsi discreti, con l'eccezione di Square() per la quale una fase di $2\pi$ si sposta di un ciclo intero (contrariamente a quanto accadeva con il discreto square() dove tale spostamento era indotto da una fase di $\pi$ ).

• Il metodo filter() è attivato nella classe ScheduleBlock classe. Questo metodo consente agli utenti di conservare solo Instruction oggetti che passano attraverso tutti i filtri forniti. Come condizioni di filtro integrate, l'istanza della sottoclasse Channel e il tipo di sottoclasse Instruction possono essere specificati. Ai filtri possono essere aggiunte anche callback definite dall'utente che prendono Instruction possono essere aggiunti ai filtri.

• Il metodo exclude() è attivato nella classe ScheduleBlock classe. Questo metodo consente agli utenti di conservare solo Instruction gli oggetti che non superano almeno uno dei filtri forniti. Come condizioni di filtro integrate, l'istanza della sottoclasse Channel e il tipo di sottoclasse Instruction possono essere specificati. Ai filtri possono essere aggiunte anche callback definite dall'utente che prendono Instruction possono essere aggiunti ai filtri. Questo metodo è il complemento di filter(), quindi la seguente condizione è sempre soddisfatta: block.filter(*filters) + block.exclude(*filters) == block in termini di istruzioni incluse, dove block è una ScheduleBlock istanza.

• Aggiunta di una nuova funzione gaussian_square_echo() alla libreria degli impulsi. L'impulso restituito è composto da tre GaussianSquare impulsi. I primi due sono impulsi di eco con durata pari alla metà della durata totale e implementano i toni di rotazione. Il terzo impulso è un tono di cancellazione che dura l'intera durata dell'impulso e implementa la correzione delle rotazioni dei singoli qubit.

• QPY supporta gli oggetti Discriminator e Kernel . Questa funzione permette agli utenti di serializzare e deserializzare le Acquire istruzioni con questi oggetti utilizzando QPY.

Caratteristiche della sintesi

• Aggiunta di una nuova funzione di sintesi synth_cx_cz_depth_line_my() che produce la forma circuitale di un circuito CX seguito da un circuito CZ per la connettività linear nearest neighbor (LNN) con profondità di 2 qubit al massimo 5n, utilizzando CX e porte di fase (S, Sdg o Z). L'algoritmo di sintesi si basa sul documento di Maslov e Yang, arXiv:2210.16195.

  L'algoritmo accetta una matrice binaria invertibile mat_x che rappresenta il circuito CX, una matrice binaria simmetrica mat_z che rappresenta il circuito CZ e restituisce un circuito quantistico con profondità di 2 qubit al massimo 5n che calcola la composizione dei circuiti CX e CZ. L'esempio seguente illustra la nuova funzionalità:

  import numpy as np
  from qiskit.synthesis.linear_phase import synth_cx_cz_depth_line_my
  mat_x = np.array([[0, 1], [1, 1]])
  mat_z = np.array([[0, 1], [1, 0]])
  qc = synth_cx_cz_depth_line_my(mat_x, mat_z)

  Questa funzione è ora utilizzata per impostazione predefinita nell'algoritmo di sintesi Clifford synth_clifford_depth_lnn() che ottimizza la profondità di 2 qubit per la connettività LNN, migliorando la profondità di 2 qubit da 9n+4 a 7n+2. L'algoritmo di sintesi clifford può essere utilizzato come segue:

  from qiskit.quantum_info import random_clifford
  from qiskit.synthesis import synth_clifford_depth_lnn
  
  cliff = random_clifford(3)
  qc = synth_clifford_depth_lnn(cliff)

  La sintesi di cui sopra può essere ulteriormente migliorata, come descritto nell'articolo di Maslov e Yang, utilizzando l'ottimizzazione locale tra gli strati a 2-qubit. Questo miglioramento è lasciato al lavoro successivo.

Funzionalità di visualizzazione

• QuantumCircuit.draw() e la funzione circuit_drawer() quando si usa l'opzione output='mpl' ora supporta il disegno dei blocchi di circuiti annidati di ControlFlowOp operazioni, tra cui if, else, while, for e switch/case. I blocchi di circuito sono avvolti da scatole per delineare i circuiti.

• Alcune restrizioni nell'uso di wire_order nei cassetti dei circuiti sono state attenuate. Ora, wire_order può elencare solo i qubit e, in tal caso, può essere utilizzato con cregbundle=True, poiché non influisce sui bit classici.

  from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
  
  qr = QuantumRegister(4, "q")
  cr = ClassicalRegister(4, "c")
  cr2 = ClassicalRegister(2, "ca")
  circuit = QuantumCircuit(qr, cr, cr2)
  circuit.h(0)
  circuit.h(3)
  circuit.x(1)
  circuit.x(3).c_if(cr, 10)
  circuit.draw('text', wire_order=[2, 3, 0, 1], cregbundle=True)

   q_2: ────────────
        ┌───┐ ┌───┐
   q_3: ┤ H ├─┤ X ├─
        ├───┤ └─╥─┘
   q_0: ┤ H ├───╫───
        ├───┤   ║
   q_1: ┤ X ├───╫───
        └───┘┌──╨──┐
   c: 4/═════╡ 0xa ╞
             └─────┘
  ca: 2/════════════

Varie Funzioni

• È disponibile un nuovo tester per l'importazione pigra, HAS_PYGMENTSè disponibile per verificare la presenza della libreria di evidenziazione della sintassi Pygments.

• La magia %qiskit_version_table di qiskit.tools.jupyter ora include tutti i moduli importati con qiskit nel nome.

Note sull'aggiornamento

• Qiskit Terra 0.25 ha abbandonato il supporto per Python 3.7 in seguito agli avvisi di deprecazione iniziati in Qiskit Terra 0.23. Questo è coerente con il termine del ciclo di vita di Python 3.7’s il 27 giugno 2023. Per continuare a utilizzare Qiskit, è necessario aggiornare a una versione più recente di Python.

• Qiskit Terra 0.25 ora richiede la versone 0.13.0 di rustworkx.

• Per impostazione predefinita, Qiskit costruisce le sue estensioni compilate utilizzando l' ABI stabile Python con supporto fino alla versione più vecchia di Python supportata da Qiskit (attualmente 3.8 ). Ciò significa che in futuro ci sarà un'unica ruota precompilata che verrà fornita al momento del rilascio e che funzionerà con tutte le versioni di Python supportate da Qiskit. Non si prevede alcuna differenza di prestazioni in fase di esecuzione utilizzando l'API limitata, per cui ora è abilitata di default per tutte le build. In precedenza, le estensioni compilate erano costruite usando l'API specifica per la versione e funzionavano solo con una singola versione di Python. Questa modifica è stata apportata per ridurre il numero di file di pacchetto che dobbiamo creare e pubblicare in ogni release. Quando si costruisce Qiskit dai sorgenti, non dovrebbero essere necessarie modifiche al processo di compilazione, tranne che per il fatto che i tag predefiniti nei nomi dei file di output saranno diversi per riflettere l'uso dell'API limitata.

Note sull'aggiornamento del transpiler

• Il supporto per il passaggio di elenchi di valori di argomenti alla funzione transpile() è stato rimosso. Questa funzionalità è stata deprecata con la release 0.23.0. È ancora possibile passare un elenco di oggetti QuantumCircuit per il primo argomento posizionale. Ciò che è stato rimosso è la trasmissione degli altri argomenti di ciascun circuito in quell'elenco di ingressi. L'eliminazione di questa funzionalità è stata necessaria per ridurre notevolmente l'overhead dell'esecuzione parallela per il transpiling di più circuiti contemporaneamente. Se si utilizza questa funzionalità al momento, è possibile chiamare il comando transpile() più volte. Ad esempio, se in precedenza si faceva qualcosa come:

  from qiskit.transpiler import CouplingMap
  from qiskit import QuantumCircuit
  from qiskit import transpile
  
  qc = QuantumCircuit(2)
  qc.h(0)
  qc.cx(0, 1)
  qc.measure_all()
  
  cmaps = [CouplingMap.from_heavy_hex(d) for d in range(3, 15, 2)]
  results = transpile([qc] * 6, coupling_map=cmaps)

  invece si dovrebbe eseguire qualcosa come:

  from qiskit.transpiler import CouplingMap
  from qiskit import QuantumCircuit
  from qiskit import transpile
  
  qc = QuantumCircuit(2)
  qc.h(0)
  qc.cx(0, 1)
  qc.measure_all()
  
  cmaps = [CouplingMap.from_heavy_hex(d) for d in range(3, 15, 2)]
  results = [transpile(qc, coupling_map=cm) for cm in cmap]

  Si può anche sfruttare parallel_map() o multiprocessing dalla libreria standard Python, se si vuole eseguire il tutto in parallelo.

• La famiglia di pass transpiler Sabre (ovvero SabreLayout e SabreSwap) sono ora utilizzati di default per tutti i circuiti quando si invoca il transpiler a livello di ottimizzazione 1 (ad esempio, chiamando transpile() o generate_preset_pass_manager() con l'argomento parola chiave optimization_level=1). In precedenza, i circuiti con operazioni di flusso di controllo utilizzavano DenseLayout e StochasticSwap con questo profilo.

Note sull'aggiornamento dei circuiti

• I metodi del costruttore OpenQASM 2 su QuantumCircuit (from_qasm_str() e from_qasm_file()) sono stati cambiati per utilizzare il parser basato su Rust aggiunto in Qiskit Terra 0.24. Questo dovrebbe portare a tempi di parsing significativamente più veloci (non è raro che si arrivi a 10 volte o più) e a una riduzione massiccia dell'uso della memoria intermedia.

  I metodi QuantumCircuit sono stati mantenuti con la stessa interfaccia per continuità; il modo preferito per accedere all'importatore di OpenQASM 2 è quello di usare qasm2.load() e qasm2.loads()che offrono un'interfaccia estesa per controllare il parsing e la costruzione.

• L'argomento deprecato circuit_cregs del costruttore della classe InstructionSet è stato rimosso. È stato deprecato nella versione 0.19.0. Se si usa questo argomento e si costruisce manualmente un oggetto InstructionSet (il che dovrebbe essere abbastanza raro, visto che è usato per lo più internamente), si dovrebbe passare un callable all'argomento della parola chiave resource_requester . Ad esempio:

  from qiskit.circuit import Clbit, ClassicalRegister, InstructionSet
  from qiskit.circuit.exceptions import CircuitError
  
  def my_requester(bits, registers):
      bits_set = set(bits)
      bits_flat = tuple(bits)
      registers_set = set(registers)
  
      def requester(specifier):
          if isinstance(specifer, Clbit) and specifier in bits_set:
              return specifier
          if isinstance(specifer, ClassicalRegster) and specifier in register_set:
              return specifier
          if isinstance(specifier, int) and 0 <= specifier < len(bits_flat):
              return bits_flat[specifier]
          raise CircuitError(f"Unknown resource: {specifier}")
  
      return requester
  
  my_bits = [Clbit() for _ in [None]*5]
  my_registers = [ClassicalRegister(n) for n in range(3)]
  
  InstructionSet(resource_requester=my_requester(my_bits, my_registers))

OpenQASM Note sull'aggiornamento

• I metodi del costruttore OpenQASM 2 su QuantumCircuit (from_qasm_str() e from_qasm_file()) sono stati cambiati per utilizzare il parser basato su Rust aggiunto in Qiskit Terra 0.24. Questo dovrebbe portare a tempi di parsing significativamente più veloci (non è raro che si arrivi a 10 volte o più) e a una riduzione massiccia dell'uso della memoria intermedia.

  I metodi QuantumCircuit sono stati mantenuti con la stessa interfaccia per continuità; il modo preferito per accedere all'importatore di OpenQASM 2 è quello di usare qasm2.load() e qasm2.loads()che offrono un'interfaccia estesa per controllare il parsing e la costruzione.

• Il sito OpenQASM 3 esportatori (qasm3.dump(), dumps() e Exporter) ora useranno meno definizioni di "alias di registro" nel loro output. Il circuito descritto non cambia, ma ora esporterà preferibilmente in termini di tipi diretti bit, qubit e qubit[n] piuttosto che produrre un registro _loose_bits e aliasing di altri registri da questo. Questo per ridurre al minimo il numero di funzioni avanzate di OpenQASM 3 in uso e per evitare di introdurre strutture di array non necessarie in programmi che non ne hanno bisogno.

Note sull'aggiornamento delle informazioni quantistiche

• Clifford.from_circuit() non tenterà più di risolvere istruzioni i cui campi definition sono reciprocamente ricorsivi con altri oggetti. Tali definizioni ricorsive sono già una violazione dell'ordinamento strettamente gerarchico richiesto dal campo definition e il codice non dovrebbe fare affidamento su questa possibilità. Se si vogliono definire equivalenze che possono avere cicli (reciproci), si può usare un elemento EquivalenceLibrary.

Note sull'aggiornamento della visualizzazione

• Nell'oggetto interno ~qiskit.visualization.circuit.matplotlib.MatplotlibDrawer , gli argomenti layout, global_phase, qregs e cregs sono stati rimossi. Sono stati originariamente deprecati in Qiskit Terra 0.20. Questi oggetti sono semplicemente dedotti dal dato circuit ora.

  È una classe di lavoro interna alle routine di visualizzazione. È improbabile che sia necessario modificare il codice.

Varie Note sull'aggiornamento

• Il percorso di importazione qiskit.util è stato rimosso, in quanto deprecato da Qiskit Terra 0.17. Gli utenti devono utilizzare il nuovo percorso di importazione, qiskit.utils.

Note di deprecazione

• Le estensioni degli spazi dei nomi qiskit e qiskit.providers da parte di pacchetti esterni sono ora deprecate e i punti di aggancio che le consentono saranno rimossi in una prossima versione. In passato, il progetto Qiskit era composto da elementi che estendevano uno spazio dei nomi condiviso e questi punti di aggancio consentivano di farlo. Tuttavia, non era previsto che queste interfacce venissero utilizzate da altri pacchetti. Ora che il pacchetto Qiskit nel suo complesso non utilizza più questo modello di packaging, lasciare la possibilità di queste estensioni comporta più rischi che benefici e viene quindi deprecato per la futura rimozione. Se state mantenendo un pacchetto che estende lo spazio dei nomi di Qiskit (cioè i vostri utenti importano da qiskit.x o qiskit.providers.y), dovreste passare a utilizzare uno spazio dei nomi indipendente Python per il vostro pacchetto. Non verrà emesso alcun avviso come parte di questa operazione, perché non esiste un metodo per iniettare un avviso a livello di pacchetto che sarebbe necessario per avvisare i pacchetti esterni di questa modifica.

• Il dizionario qiskit.__qiskit_version__ è deprecato, poiché Qiskit è definito con un unico pacchetto (qiskit-terra). In futuro, qiskit.__version__ sarà il punto unico per interrogare la versione di Qiskit, come stringa standard.

Deprecazioni del transpiler

• La funzione get_vf2_call_limit disponibile tramite il modulo qiskit.transpiler.preset_passmanagers.common è stata deprecata. Questo probabilmente interesserà pochissimi utenti, dato che questa funzione non è stata esplicitamente esportata né documentata. La sua funzionalità è stata sostituita ed estesa da una funzione dello stesso modulo.

Circuiti deprecati

• Il metodo qasm() e tutti i metodi sovrascritti delle sottoclassi di :class:~qiskit.circuit.Instruction sono deprecati. Non esiste un sostituto per la generazione di una stringa OpenQASM2 per un'istruzione isolata, poiché in genere un singolo oggetto istruzione non ha un contesto sufficiente per generare completamente una stringa OpenQASM2 valida. Se attualmente ci si affida a questo metodo, si dovrà invece fare affidamento sull'esportatore OpenQASM2 : QuantumCircuit.qasm() per generare OpenQASM2 per un intero oggetto circuito.

Deprecazioni degli algoritmi

• Il modulo qiskit.algorithms è stato deprecato e sarà rimosso in una prossima versione. È stata sostituita da una nuova libreria standalone qiskit-algorithms che può essere trovata su PyPi o su Github qui:

  https://github.com/qiskit-community/qiskit-algorithms

  Il modulo qiskit.algorithms continuerà a funzionare come prima e verranno apportate correzioni di bug fino alla sua futura rimozione, ma lo sviluppo attivo di nuove funzionalità è passato al nuovo pacchetto. Se ci si affida a qiskit.algorithms si devono aggiornare i requisiti di Python per includere anche qiskit-algorithms e aggiornare le importazioni da qiskit.algorithms a qiskit_algorithms. Si noti che questo nuovo pacchetto non include il codice degli algoritmi già deprecati, compresi gli algoritmi basati su opflow e QuantumInstance. Se non si è ancora migrato dagli algoritmi basati su QuantumInstance a quelli basati sulle primitive, è necessario seguire le linee guida per la migrazione in https://qisk.it/algo \migration. La decisione di migrare il modulo algorithms in un pacchetto separato è stata presa per chiarire lo scopo di Qiskit e fare una distinzione tra gli strumenti e le librerie costruite su di esso.

Deprecazioni Pulse

• Inizializzazione di un ScalableSymbolicPulse con valore complesso per amp. Questa modifica riguarda anche i seguenti impulsi di biblioteca:

  • Gaussian
  • GaussianSquare
  • Drag
  • Constant

  Anche l'inizializzazione di amp con un valore complesso è ora deprecata.

  Invece, quando si specificano i parametri amp e angle , si utilizzano due valori fluttuanti, dove amp rappresenta la grandezza dell'ampiezza complessa e angolo rappresenta l'angolo dell'ampiezza complessa. cioè l'ampiezza complessa è data da $\texttt{amp} \times \exp(i \times \texttt{angle})$.

• L'istruzione Call è stata deprecata e sarà rimossa in una versione futura. Invece, utilizzare la funzione call() da modulo qiskit.pulse.builder all'interno di un contesto edilizio attivo.

Varie Deprecazioni

• La magia di Jupyter %circuit_library_info e gli oggetti di qiskit.tools.jupyter.library che chiama a turno:

  • circuit_data_table
  • properties_widget
  • qasm_widget
  • circuit_digram_widget
  • circuit_library_widget

  sono deprecati e saranno rimossi in una prossima versione. Questi oggetti erano destinati a essere utilizzati solo per la creazione della documentazione. Non sono più utilizzati e quindi non sono più supportati o mantenuti.

Problemi noti

• I circuiti contenenti espressioni classiche realizzate con il modulo expr non sono ancora supportati dai visualizzatori di circuiti.

Correzioni di bug

• È stato risolto un bug in Channel in cui la convalida dell'indice veniva eseguita in modo errato e generava un errore solo quando l'indice era sia non intero che negativo, anziché uno dei due.

• Corretto un problema con la funzione transpile() e tutti i gestori di passaggi preimpostati generati tramite generate_preset_pass_manager() in cui l'oggetto QuantumCircuit dell'oggetto layout dell'oggetto di output aveva un attributo TranspileLayout.final_layout non valido. Ciò si verificherebbe negli scenari in cui il VF2PostLayout e trova un layout iniziale alternativo che presenta tassi di errore inferiori. Quando si modifica il layout iniziale, l'attributo final_layout non è mai stato aggiornato per riflettere questa modifica. Questo problema è stato corretto in modo che final_layout rifletta sempre correttamente la permutazione dell'uscita causata dallo stadio di instradamento. Corretto #10457

• Il parser OpenQASM 2 (qasm2.load() e loads()) in modalità strict emette correttamente un errore se un'istruzione barrier non ha argomenti. Quando viene eseguita nella modalità più permissiva (predefinita), un'istruzione barrier senza argomenti continuerà a causare una barriera su tutti i qubit attualmente in ambito (i qubit su cui influisce una definizione di gate o tutti i qubit definiti da un programma, se l'istruzione si trova rispettivamente nel corpo di un gate o nell'ambito globale).

• L'esportatore di OpenQASM 2 (QuantumCircuit.qasm()) non tenterà più di produrre dichiarazioni barrier che agiscono su nessun qubit. Una dichiarazione di barriera di questo tipo non ha effetto nemmeno in Qiskit, ma non è valida OpenQASM 2.

• Qiskit può rappresentare istruzioni personalizzate che agiscono su zero qubit o su un numero non nullo di bit classici. Questi non possono essere esportati in OpenQASM 2, ma in precedenza QuantumCircuit.qasm() ci provava e restituiva OpenQASM 2 non valido. Al suo posto, verrà correttamente sollevato un QASM2ExportError verrà correttamente sollevato. Vedere #7351 e #10435.

• Corretto un problema con l'uso di Targetsenza accoppiare le mappe con il passaggio FullAncillaAllocation con il passaggio del transpiler. In questo caso, FullAncillaAllocation aggiungerà ora ancilla qubit, in modo che il numero di qubit nel sistema DAGCircuit corrisponde a quello di Target.num_qubits.

• DAGCircuit.substitute_node() non sovrascriverà più silenziosamente una condizione esistente sulla sostituzione data op. Se propagate_condition è impostato su True (l'impostazione predefinita), verrà sollevato un errore DAGCircuitError verrà sollevato al suo posto.

• Un circuito parametrato che contiene un gate personalizzato la cui definizione ha una fase globale parametrata può ora legare con successo il parametro nella fase globale interna. Per maggiori dettagli, vedere il numero 10283.

• Costruzione di un Statevector da un oggetto QuantumCircuit contenente operazioni a zero-qubit non darà più luogo a un errore. Queste operazioni conferiscono una fase globale al vettore di stato risultante.

• L'interfaccia del costruttore di flussi di controllo ora include correttamente le risorse ClassicalRegister delle dichiarazioni di commutazione nidificate negli ambiti dei circuiti che le contengono. Vedere #10398.

• È stato risolto un problema in QuantumCircuit.decompose() in cui il passaggio di un nome di circuito alla funzione che corrisponde a un nome di gate composito non decomponeva il gate se gli era stata assegnata anche un'etichetta. Corretto #9136

• È stato risolto un problema con qiskit.visualization.plot_histogram() per cui la legenda relativa non appariva quando il dataset dato aveva un valore zero nella prima posizione. Per maggiori dettagli, vedere il numero 10158.

• Corretto un errore con il metodo Target.update_from_instruction_schedule_map() attivato dal dato inst_map contenente un elemento Schedule con durate non assegnate.

• Quando il parametro conditional=True è specificato in random_circuit()le operazioni condizionali nel circuito risultante saranno ora precedute da una misurazione completa a metà circuito. Correzioni #9016

• Migliorate le annotazioni sul tipo del metodo QuantumCircuit.assign_parameters() per riflettere il cambiamento del tipo di ritorno a seconda dell'argomento inplace .

• I metodi di costruzione dei circuiti di OpenQASM 2 (QuantumCircuit.from_qasm_str() e from_qasm_file()) non daranno più errore quando incontrano una definizione gate che contiene istruzioni U o CX . Vedere il n. 5536.

• Riduzione dell'overhead del ConsolidateBlocks eseguendo operazioni matriciali su tutti i blocchi a due qubit invece di creare un'istanza di QuantumCircuit e di passarla a un'istanza di Operator. L'aumento di velocità sarà applicabile solo quando si consolidano blocchi a due qubit. Qualsiasi cosa più alta di questa sarà comunque gestita dalla classe Operator classe. Controllare il numero 8779 per i dettagli.

• L'esportatore di OpenQASM 3 (qiskit.qasm3) non emetterà più OpenQASM 3 non valido per le istanze non unitarie Instruction ma solleverà un messaggio QASM3ExporterError spiegando che non sono ancora supportate. Questa funzione è prevista per una versione successiva di Qiskit, quando ci saranno più strutture per l'elaborazione classica in tutta la libreria.

• Corregge il problema #10185.

• È stato risolto un problema con la funzione state_to_latex(). In precedenza, produceva LaTeX non valido con un arrotondamento involontario dei coefficienti, che provocava errori quando si chiamava state_drawer(). Corretto #9297.