Note di rilascio di Qiskit 0.39

0.39.5

Terra 0.22.4

Preludio

Qiskit Terra 0.22.4 è una release di correzione di bug minori, che risolve alcuni bug identificati nella serie 0.22.

Correzioni di bug

Corretto un bug in BackendSampler che generava un errore se il suo metodo run() veniva chiamato due volte in sequenza.
Sono stati corretti due bug nel sistema ComposedOp in cui il metodo ComposedOp.to_matrix() non forniva i risultati corretti per le composizioni con StateFn e per le composizioni con un coefficiente globale. Corretto #9283.
Corretto il problema in cui le primitive, Sampler e Estimatornon funzionavano quando si passava un circuito con numpy.ndarray come parametro.
Corretto un bug in SamplingVQE in cui l'argomento aggregation non aveva effetto. Ora è possibile specificare correttamente la funzione di aggregazione e, con essa, il valore di aspettativa CVaR.
È stato risolto un problema di prestazioni per cui SamplingVQE valutava le energie degli autostati in modo lento.
Corretta la valutazione automatica dei parametri beta in VQDe aggiunto il supporto per gli ingressi SparsePauliOp e la funzione di valutazione dell'energia per sfruttare l'esecuzione asincrona delle primitive, recuperando i risultati del lavoro solo dopo che entrambi i lavori sono stati inviati.
Corretto un problema con gli elementi Statevector.probabilities_dict() e DensityMatrix.probabilities_dict() che restituivano risultati errati per i sistemi non-qubit quando veniva specificato l'argomento qargs . Corretto #9210
Corretta la gestione di alcuni classmethodda parte di wrap_method() in Python 3.11. In precedenza, in Python 3.11, wrap_method avvolgeva la funzione non vincolata associata a classmethod e poi falliva quando veniva invocata, perché l'oggetto di classe solitamente vincolato a classmethod non veniva passato alla funzione. A partire da Python 3.11.1, questo problema ha interessato QiskitTestCase, impedendo che venisse importato da altro codice di test. Corretto #9291.

Aer 0.11.2

Nessuna modifica

IBM Q Fornitore 0.19.2

Nessuna modifica

0.39.4

Terra 0.22.3

Nessuna modifica

Aer 0.11.2

Nuove funzioni

Aggiunto il supporto per l'esecuzione di Qiskit Aer con il supporto di Python 3.11.

Problemi noti

Correggere due bug in AerStatevector. AerStatevector utilizza le istruzioni mc*, che non sono abilitate nel metodo matrix_product_state. Questo commit modifica AerStatevector in modo che non utilizzi MC* e utilizzi H, X, Y, Z, U e CX. AerStatevector fallisce anche se un'istruzione viene scomposta in QuantumCircuit vuoto. Questo commit consente tale istruzione.

Correzioni di bug

Supporto fisso nel metodo AerSimulator.from_backend() per l'istanziazione di un'istanza di AerSimulator da un oggetto a BackendV2 oggetto. In precedenza, il tentativo di usare AerSimulator.from_backend() con un oggetto BackendV2 avrebbe generato un AerError che diceva che non era supportato.
Corregge un bug per cui NoiseModel.from_backend() con un oggetto BackendV2 poteva generare un modello di rumore con un numero eccessivo di QuantumError s su istruzioni non-Gate mentre, ad esempio, solo ReadoutError s dovrebbe essere sufficiente per le misure. Questo commit aggiorna NoiseModel.from_backend() con un oggetto BackendV2 in modo che restituisca lo stesso modello di rumore di quello richiamato con il corrispondente oggetto BackendV1 . In altre parole, il modello di rumore risultante non contiene QuantumError s sulle misure e può contenere solo errori di rilassamento termico su altre istruzioni non gate, come i reset. Si noti che contiene ancora ReadoutError s sulle misure.
Corretto un bug in NoiseModel.from_backend() per cui l'uso del kwarg di temperature con un valore non predefinito comportava un calcolo errato della popolazione dello stato eccitato per la temperatura specificata. In precedenza, nel calcolo della distribuzione di Boltzman era presente un fattore aggiuntivo di 2 che portava a un valore minore errato per la popolazione dello stato eccitato.

È stata corretta una logica errata nel compilatore del flusso di controllo che poteva consentire alle istruzioni non correlate di apparire "all'interno" dei corpi del flusso di controllo durante l'esecuzione, causando risultati errati. Ad esempio, in precedenza:

from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator

backend = AerSimulator(method="statevector")

circuit = QuantumCircuit(3, 3)
circuit.measure(0, 0)
circuit.measure(1, 1)

with circuit.if_test((0, True)):
    with circuit.if_test((1, False)):
        circuit.x(2)

with circuit.if_test((0, False)):
    with circuit.if_test((1, True)):
        circuit.x(2)

circuit.measure(range(3), range(3))
print(backend.run(circuit, method=method, shots=100).result())

stamperebbe {'010': 100} poiché le operazioni di controllo annidate salterebbero accidentalmente il primo gate X sul qubit 2, che avrebbe dovuto essere eseguito.

Corregge un bug per cui NoiseModel.from_backend() stampa avvisi verbosi quando fornisce un backend che riporta parametri del dispositivo non fisici come T2 > 2 * T1 a causa di errori statistici nella loro stima. Questo commit rimuove tali avvisi perché non sono perseguibili dagli utenti, nel senso che non ci sono altri mezzi se non quello di troncarli ai limiti teorici come avviene nel modulo noise.device . Per informazioni dettagliate sul bug risolto, consultare il numero 1631.
Si tratta di una correzione per il simulatore di vettori di stato della GPU. La distribuzione dei chunk ha cercato di allocare tutta la memoria libera sulla GPU, ma questo ha causato un errore di allocazione della memoria. Quindi questa soluzione alloca l'80% della memoria libera. Inoltre, fissa la dimensione del buffer della matrice quando si applica il campionamento del rumore.
Si tratta di una correzione di AerState che funziona con il blocco della cache. AerState il transpiler di Aer è stato configurato in modo errato per il blocco della cache, e quindi il suo algoritmo di scambio dei qubit ha funzionato in modo errato. Questa correzione corregge AerState per utilizzare questo transpiler. Più precisamente, dopo la transpilazione, una mappa di qubit scambiati viene riportata alla mappa originale quando si usa AerState. Questa correzione è necessaria per consentire a AerStatevector di utilizzare più GPU.
Questa è la correzione per AerStatevector. Non era possibile creare un'istanza di AerStatevector direttamente dallo Statevector di terra. Questa correzione consente di utilizzare un vettore di stati come input di AerStatevector’s.
SamplerResult.quasi_dists contengono i dati sul numero di qubit. QuasiDistribution.binary_probabilities() restituisce bitstring con la lunghezza corretta.
In precedenza il seme non è stato inizializzato in AerStatevector e quindi i risultati campionati sono sempre gli stessi. Con questo commit, viene inizializzato un seme per ogni campionamento e i risultati campionati possono variare.

IBM Q Fornitore 0.19.2

Nessuna modifica

0.39.3

Terra 0.22.3

Preludio

Qiskit Terra 0.22.3 è una release di correzione di bug minori, che risolve alcuni ulteriori bug della serie 0.22.

Correzioni di bug

AdaptVQE ora indica correttamente che supporta gli operatori ausiliari.
I cassetti del circuito (QuantumCircuit.draw() e circuit_drawer()) non emettono più un avviso sul parametro cregbundle quando si utilizzano gli argomenti predefiniti, se il contenuto del circuito richiede che tutti i bit siano disegnati singolarmente. Questo problema si presentava soprattutto quando si cercava di disegnare circuiti con operazioni di flusso di controllo di tipo nuovo.
È stato corretto un bug che causava l'errore di QNSPSA falliva quando max_evals_grouped era impostato su un valore superiore a 1.
È stato risolto un problema con il passaggio SabreSwap che faceva sì che l'output di esecuzioni multiple del passaggio senza l'argomento seed specificato riutilizzasse lo stesso seme del generatore di numeri casuali tra le esecuzioni, invece di usare semi diversi. In precedenza, ciò causava la restituzione di risultati identici tra un'esecuzione e l'altra anche quando non era specificato seed .
Corretto un problema con le classi primitive, BackendSampler e BackendEstimatorin cui le istanze non potevano essere serializzate con pickle. In generale, queste classi non sono garantite per essere serializzabili come BackendV2 e BackendV1 non è richiesto che le istanze siano serializzabili (e spesso non lo sono), ma le definizioni delle classi di BackendSampler e BackendEstimator non impediscono più l'uso di pickle.
Il metodo pulse.Instruction.draw() avrà successo, come in precedenza. Questo metodo è deprecato e non è prevista una sua sostituzione, ma dovrebbe comunque funzionare per il periodo di deprezzamento.

Aer 0.11.1

Nessuna modifica

IBM Q Fornitore 0.19.2

Nessuna modifica

0.39.2

Terra 0.22.2

Preludio

Qiskit Terra 0.22.2 è una release di correzione di bug minori e segna il primo supporto ufficiale per Python 3.11.

Correzioni di bug

Corretto un problema con le classi primitive del backend BackendSampler e BackendEstimator che impediva l'esecuzione con un'istanza BackendV1 che non ha un campo max_experiments impostato nel suo file BackendConfiguration.
Corretto un bug nel passaggio VF2PostLayout durante la compilazione per i backend con un file definito Targetin cui il grafico delle interazioni veniva costruito in modo errato. Ciò potrebbe comportare tempi di esecuzione eccessivi, poiché il grafo è molto più complesso del necessario.
Il parser delle espressioni Pulse non dovrebbe più bloccarsi periodicamente quando viene richiamato dai notebook Jupyter. Questo si ottiene evitando un deepycopy interno di un oggetto ricorsivo che sembrava essere particolarmente difficile da valutare per la memoizzazione.

Aer 0.11.1

Nessuna modifica

IBM Q Fornitore 0.19.2

Nessuna modifica

0.39.1

Terra 0.22.1

Preludio

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

Note di deprecazione

Il kwarg pauli_list di pauli_basis() è stato deprecato, in quanto pauli_basis() ora restituisce sempre un PauliList. Questo argomento è stato rimosso prematuramente da Qiskit Terra 0.22.0, il che ha rotto la compatibilità per gli utenti che sfruttavano pauli_list``argument. Now, the argument has been restored but will emit a ``DeprecationWarning quando lo usavano. Se utilizzato, non ha alcun effetto perché da quando Qiskit Terra 0.22.0 a PauliList viene sempre restituito.

Correzioni di bug

Corretto il BarrierBeforeFinalMeasurements transpiler quando ci sono condizioni sui livelli sciolti Clbitimmediatamente prima del livello di misura finale. In precedenza, l'operazione falliva sostenendo che il bit non era presente in un circuito interno temporaneo. Corretto #8923
I controllori di uguaglianza per QuantumCircuit e DAGCircuit (con oggetti dello stesso tipo) ora gestiscono correttamente le condizioni su singoli bit. In precedenza, questi producevano falsi negativi per l'uguaglianza, poiché i bit utilizzavano controlli di uguaglianza "esatti" invece dei controlli "semantici" di cui godono il resto delle proprietà delle istruzioni del circuito.
Gestione fissa dei bit classici in StochasticSwap con il flusso di controllo. In precedenza, le operazioni di flusso di controllo venivano espanse per contenere tutti i bit classici del circuito esterno e non si contraevano di nuovo, causando una discrepanza tra il numero di bit di controllo di cui l'istruzione dichiarava di aver bisogno e il numero effettivo che le veniva fornito. Corretto #8903
Corretta la gestione delle istruzioni definite globalmente per la classe Target classe. In precedenza, due metodi, operations_for_qargs() e operation_names_for_qargs() ignoravano o gestivano erroneamente qualsiasi operazione ideale definita a livello globale presente nella destinazione. Ad esempio:
```
from qiskit.transpiler import Target
from qiskit.circuit.library import CXGate

target = Target(num_qubits=5)
target.add_instruction(CXGate())
names = target.operation_names_for_qargs((1, 2))
ops = target.operations_for_qargs((1, 2))
```
restituirà {"cx"} per names e [CXGate()] per ops invece di restituire KeyError o un ritorno vuoto.
È stato risolto un problema nel metodo Target.add_instruction() che in precedenza accettava un argomento con un numero di qubit non valido come parte dell'argomento properties . Ad esempio:
```
from qiskit.transpiler import Target
from qiskit.circuit.library import CXGate

target = Target()
target.add_instruction(CXGate(), {(0, 1, 2): None})
```
Questo ora solleva correttamente un TranspilerError invece di causare problemi di runtime quando si interagisce con il target. Corretto #8914
È stato risolto un problema con la funzione plot_state_hinton() che causava un asse posizionato in modo errato e sfalsato rispetto al grafico reale. Corretto #8446 <https://github.com/Qiskit/qiskit/issues/8446>
Corretto l'output della funzione plot_state_hinton() in modo che le etichette degli stati siano ordinate correttamente e l'immagine corrisponda all'ordinamento naturale della matrice. Corretto #8324
Corretto un problema con le classi primitive, BackendSampler e BackendEstimator quando viene eseguito su backend che hanno un numero limitato di circuiti per ogni lavoro. Non tutti i backend supportano una dimensione di batch illimitata (la maggior parte dei backend hardware non lo fa) e in precedenza le classi primitive del backend avrebbero potenzialmente inviato in modo errato più circuiti di quelli supportati dal backend. Questo è stato corretto in modo che BackendSampler e BackendEstimator divida i circuiti in più lavori se il backend ha un numero limitato di circuiti per lavoro.
È stato risolto un problema con la classe BackendEstimator per cui l'impostazione di un'opzione di esecuzione denominata monitor a un valore che veniva valutato come True avrebbe attivato in modo errato un monitoraggio dei lavori che funzionava solo sui backend del pacchetto qiskit-ibmq-provider . Questa opzione è stata rimossa per consentire di utilizzare l'opzione di esecuzione monitor , se necessario, senza causare problemi.
Corretto un problema con il metodo Target.build_coupling_map() che restituiva erroneamente None per un oggetto con un mix di istruzioni ideali globalmente disponibili e istruzioni con vincoli di qubit Target con un mix di istruzioni ideali globalmente disponibili e istruzioni con vincoli di qubit. In questi casi l'opzione Target.build_coupling_map() restituirà una mappa di accoppiamento per l'istruzione vincolata (a meno che non si tratti di un'operazione a 2 qubit, che restituirà None perché globalmente non c'è alcun vincolo di connettività). Corretto #8971
È stato risolto un problema con l'attributo Target.qargs che restituiva erroneamente None per un oggetto che conteneva qualsiasi istruzione ideale disponibile a livello globale Target che conteneva qualsiasi istruzione ideale disponibile a livello globale.
Corretta la rimozione prematura dell'argomento della parola chiave pauli_list della funzione pauli_basis() che rompeva il codice esistente che utilizzava il percorso di compatibilità futura pauli_list=True durante l'aggiornamento a Qiskit Terra 0.22.0. L'argomento di questa parola chiave è stato aggiunto alla funzione e ora è deprecato e sarà rimosso in una versione futura.
Corretto un problema nella serializzazione di QPY (dump()) quando una sottoclasse personalizzata ControlledGate che ha sovraccaricato il metodo _define() per fornire una definizione personalizzata dell'operazione. In precedenza, questo caso di operazione non veniva serializzato correttamente perché non si teneva conto dell'uso del metodo potenzialmente _define() per fornire una definizione. Correzioni #8794
La deserializzazione di QPY non aggiungerà più istanze extra al circuito Clbit al circuito se ci sono sia istanze sciolte Clbitnel circuito e un numero di istanze Qubits rispetto a Clbits.
La deserializzazione di QPY non aggiunge più i registri denominati q e c se il circuito di ingresso contiene solo bit liberi.
Corretto il metodo SparsePauliOp.dot() quando viene eseguito su due operatori con coefficienti reali. Per risolvere questo problema, il dtype che SparsePauliOp può assumere è limitato a np.complex128 e object. Corretto #8992
È stato risolto un problema nel metodo circuit_drawer() e nel metodo QuantumCircuit.draw() : l'unico stile incorporato utilizzabile per l'output mpl era default. Se si utilizzasse un altro stile incorporato, come ad esempio iqx, verrebbe emesso un avviso di mancato reperimento dello stile e il cassetto tornerebbe a utilizzare lo stile default . Corretto #8991
Corretto un problema con l'opzione transpile() che in precedenza falliva con un errore TypeError se veniva passato un oggetto personalizzato Target veniva passato tramite l'argomento target e per l'argomento circuits veniva specificato un elenco di circuiti multipli.
Corretto un problema con transpile() quando si punta a un oggetto Target (sia direttamente tramite l'argomento target che tramite un'istanza di BackendV2 dall'argomento backend ) che conteneva un'istruzione ideale (un'istruzione che non ha alcuna proprietà definita) Measure ideale (che non ha alcuna proprietà definita). In precedenza, questo sollevava un'eccezione nel tentativo di analizzare il target. Corretto #8969
Corretto un problema con il passaggio VF2Layout che dava errore quando veniva eseguito con un file Target che aveva istruzioni con tassi di errore mancanti. Questo problema è stato corretto, per cui in questi casi l'assenza di un tasso di errore verrà trattata come un'implementazione ideale e se non sono presenti tassi di errore verrà selezionato solo il primo layout corrispondente. Corretto #8970
Corretto un problema con il passaggio VF2PostLayout che dava errore quando veniva eseguito con un file Target con istruzioni mancanti. In questi casi, la mancanza di un tasso di errore sarà considerata come un'implementazione ideale dell'operazione.
Corretto un problema con la classe VQD se vengono calcolati più di k=2 autovalori. In precedenza, questa operazione falliva a causa di una mancata corrispondenza interna del tipo, ma ora viene eseguita come previsto. Corretto #8982
È stato risolto un problema di prestazioni a causa del quale i nuovi algoritmi variazionali basati su primitive minimum_eigensolvers.VQE, eigensolvers.VQD e SamplingVQE non eseguivano le valutazioni energetiche in batch per impostazione predefinita, il che comportava un rallentamento significativo se si utilizzava un backend hardware.
Le porte e le istruzioni a operando zero funzioneranno ora con circuit_to_gate(), QuantumCircuit.to_gate(), Gate.control(), e la costruzione di un oggetto Operator da un file QuantumCircuit contenente istruzioni a operando zero. Questo caso limite è occasionalmente utile per creare porte a fase globale come parte di istruzioni composte più grandi, anche se per molti usi, QuantumCircuit.global_phase può essere più appropriato.
Corregge il problema per cui Statevector.evolve() e DensityMatrix.evolve() sollevava un'eccezione per l'evoluzione dei sottosistemi annidati per i sottosistemi non a qubit. Corregge il problema #8897
Corregge il bug in Statevector.evolve() in cui l'evoluzione del sottosistema restituisce un valore errato in alcuni casi in cui ci sono 2 o più sottosistemi non evoluti con dimensioni diverse. Corregge il problema #8899

Aer 0.11.1

Correzioni di bug

Corretto un potenziale errore di compilazione quando si cerca di usare CMake 3.18 o più recente e si costruisce qiskit-aer con il supporto GPU abilitato. Da CMake 3.18 o successivo, quando si costruisce con CUDA, è necessario impostare CMAKE_CUDA_ARCHITECTURES con il valore dell'architettura della GPU di destinazione. È stato corretto in modo che l'impostazione AER_CUDA_ARCH venga utilizzata se non è stata impostata.
Corregge un bug nella gestione delle istruzioni con clbit in LocalNoisePass. In precedenza, veniva accidentalmente cancellato il clbit delle istruzioni (ad esempio le misure) a cui viene applicato il rumore nel caso di method="append".
Corretto l'overhead delle prestazioni della classe Sampler quando viene eseguita con circuiti identici su più esecuzioni. Ciò è stato ottenuto saltando la trasposizione di questi circuiti identici nelle esecuzioni successive.
Corretta la compatibilità delle classi primitive Sampler e Estimator con la versione qiskit-terra 0.22.0. In qiskit-terra 0.22.0 sono state apportate modifiche all'interfaccia astratta che hanno compromesso la compatibilità con queste classi Sampler e Estimator possono ora essere utilizzate con qiskit-terra >= 0.22.0.

IBM Q Fornitore 0.19.2

Nessuna modifica

0.39.0

Con questa release viene anche ufficialmente deprecato il progetto Qiskit Aer come parte del metapacchetto Qiskit. Ciò significa che in una futura versione pip install qiskit non includerà più qiskit-aer. Se attualmente si sta installando o elencando qiskit come dipendenza per ottenere Aer, si dovrebbe aggiornare questo file per elencare esplicitamente anche qiskit-aer .

Il progetto qiskit-aer è ancora attivo e viene mantenuto in futuro, ma per il metapacchetto Qiskit (cioè ciò che viene installato tramite pip install qiskit) il progetto si sta orientando verso un modello in cui il pacchetto Qiskit contiene solo la funzionalità di base comune per la costruzione e la compilazione di circuiti quantistici, programmi e applicazioni e i pacchetti che si basano su di esso o collegano Qiskit all'hardware o ai simulatori sono pacchetti separati.

Terra 0.22.0

Preludio

La release di Qiskit Terra 0.22.0 è una release importante che include una miriade di nuove funzionalità e correzioni di bug. I punti salienti di questa release sono:

Aggiunta di un supporto iniziale al transpiler per il transpiling di QuantumCircuit che contengono istruzioni di flusso di controllo come ForLoopOp e WhileLoopOp.

Scalabilità e prestazioni notevolmente migliorate per la funzione transpile() con un gran numero di qubit, soprattutto quando si utilizza optimization_level=3 .

Interfaccia per plugin esterni per transpile() che consente ai pacchetti esterni di implementare stadi per i gestori di passaggi predefiniti. Per maggiori dettagli, consultare il sito qiskit.transpiler.preset_passmanagers.plugin. Inoltre, BackendV2 può ora impostare opzionalmente dei plugin predefiniti personalizzati da utilizzare per le fasi di programmazione e traduzione.

Implementazioni aggiornate degli algoritmi in qiskit.algorithms che sfruttano le classi primitives che implementano le classi BaseSampler e BaseEstimator.

Nuove funzioni

Aggiungere il supporto per la rappresentazione di un'operazione con larghezza variabile alla classe Target classe. In precedenza, un Target doveva avere un'istanza di Operation definita per ogni operazione supportata dalla destinazione. Questo è stato utilizzato sia per la validazione degli argomenti che dei parametri dell'operazione. Tuttavia, per le operazioni che hanno un'ampiezza variabile questo non è possibile perché ogni istanza di una classe Operation può avere solo un numero fisso di qubit. Nei casi in cui un backend supporta operazioni a larghezza variabile, l'istruzione può essere aggiunta con la classe dell'operazione invece che con un'istanza. In questi casi l'operazione sarà trattata come globalmente supportata su tutti i qubit. Ad esempio, se si costruisce un obiettivo come:

from qiskit.circuit import Parameter, Measure, IfElseOp, ForLoopOp, WhileLoopOp
from qiskit.circuit.library import IGate, RZGate, SXGate, XGate, CXGate
from qiskit.transpiler import Target, InstructionProperties

theta = Parameter("theta")

ibm_target = Target()
i_props = {
    (0,): InstructionProperties(duration=35.5e-9, error=0.000413),
    (1,): InstructionProperties(duration=35.5e-9, error=0.000502),
    (2,): InstructionProperties(duration=35.5e-9, error=0.0004003),
    (3,): InstructionProperties(duration=35.5e-9, error=0.000614),
    (4,): InstructionProperties(duration=35.5e-9, error=0.006149),
}
ibm_target.add_instruction(IGate(), i_props)
rz_props = {
    (0,): InstructionProperties(duration=0, error=0),
    (1,): InstructionProperties(duration=0, error=0),
    (2,): InstructionProperties(duration=0, error=0),
    (3,): InstructionProperties(duration=0, error=0),
    (4,): InstructionProperties(duration=0, error=0),
}
ibm_target.add_instruction(RZGate(theta), rz_props)
sx_props = {
    (0,): InstructionProperties(duration=35.5e-9, error=0.000413),
    (1,): InstructionProperties(duration=35.5e-9, error=0.000502),
    (2,): InstructionProperties(duration=35.5e-9, error=0.0004003),
    (3,): InstructionProperties(duration=35.5e-9, error=0.000614),
    (4,): InstructionProperties(duration=35.5e-9, error=0.006149),
}
ibm_target.add_instruction(SXGate(), sx_props)
x_props = {
    (0,): InstructionProperties(duration=35.5e-9, error=0.000413),
    (1,): InstructionProperties(duration=35.5e-9, error=0.000502),
    (2,): InstructionProperties(duration=35.5e-9, error=0.0004003),
    (3,): InstructionProperties(duration=35.5e-9, error=0.000614),
    (4,): InstructionProperties(duration=35.5e-9, error=0.006149),
}
ibm_target.add_instruction(XGate(), x_props)
cx_props = {
    (3, 4): InstructionProperties(duration=270.22e-9, error=0.00713),
    (4, 3): InstructionProperties(duration=305.77e-9, error=0.00713),
    (3, 1): InstructionProperties(duration=462.22e-9, error=0.00929),
    (1, 3): InstructionProperties(duration=497.77e-9, error=0.00929),
    (1, 2): InstructionProperties(duration=227.55e-9, error=0.00659),
    (2, 1): InstructionProperties(duration=263.11e-9, error=0.00659),
    (0, 1): InstructionProperties(duration=519.11e-9, error=0.01201),
    (1, 0): InstructionProperties(duration=554.66e-9, error=0.01201),
}
ibm_target.add_instruction(CXGate(), cx_props)
measure_props = {
    (0,): InstructionProperties(duration=5.813e-6, error=0.0751),
    (1,): InstructionProperties(duration=5.813e-6, error=0.0225),
    (2,): InstructionProperties(duration=5.813e-6, error=0.0146),
    (3,): InstructionProperties(duration=5.813e-6, error=0.0215),
    (4,): InstructionProperties(duration=5.813e-6, error=0.0333),
}
ibm_target.add_instruction(Measure(), measure_props)
ibm_target.add_instruction(IfElseOp, name="if_else")
ibm_target.add_instruction(ForLoopOp, name="for_loop")
ibm_target.add_instruction(WhileLoopOp, name="while_loop")

Il IfElseOp, ForLoopOp, e WhileLoopOp sono supportate globalmente per qualsiasi numero di qubit. Questo si riflette poi in altre chiamate dell'API Target API, come instruction_supported():

ibm_target.instruction_supported(operation_class=WhileLoopOp, qargs=(0, 2, 3, 4))
ibm_target.instruction_supported('if_else', qargs=(0, 1))

entrambi restituiscono True.

Aggiunte nuove implementazioni di primitive, BackendSampler e BackendEstimator, a qiskit.primitives. Queste nuove implementazioni di classi primitive avvolgono una classe BackendV1 o BackendV2 come un'istanza di BaseSampler o BaseEstimator rispettivamente. Il caso d'uso previsto per queste implementazioni di primitive è quello di colmare il divario tra i provider che non dispongono di implementazioni native di primitive e l'uso del backend di quel provider con API che funzionano con le primitive. Ad esempio, la classe SamplingVQE richiede un'istanza BaseSampler per funzionare. Se si vuole eseguire questa classe con un backend di un provider senza un'implementazione primitiva nativa, si può costruire un file BackendSampler per farlo:
```
from qiskit.algorithms.minimum_eigensolvers import SamplingVQE
from qiskit.algorithms.optimizers import SLSQP
from qiskit.circuit.library import TwoLocal
from qiskit.primitives import BackendSampler
from qiskit.providers.fake_provider import FakeHanoi
from qiskit.opflow import PauliSumOp
from qiskit.quantum_info import SparsePauliOp

backend = FakeHanoi()
sampler = BackendSampler(backend=backend)

operator = PauliSumOp(SparsePauliOp(["ZZ", "IZ", "II"], coeffs=[1, -0.5, 0.12]))
ansatz = TwoLocal(rotation_blocks=["ry", "rz"], entanglement_blocks="cz")
optimizer = SLSQP()
sampling_vqe = SamplingVQE(sampler, ansatz, optimizer)
result = sampling_vqe.compute_minimum_eigenvalue(operator)
eigenvalue = result.eigenvalue
```
Se si utilizza un provider che ha implementazioni primitive native (come qiskit-ibm-runtime o qiskit-aer), è sempre meglio utilizzare l'implementazione primitiva nativa al posto di BackendEstimator o BackendSampler poiché le implementazioni native saranno molto più efficienti e/o effettueranno una pre e post elaborazione aggiuntiva. BackendEstimator e BackendSampler sono stati progettati per essere generici, in grado di funzionare con qualsiasi backend che restituisca Counts nel loro Results , il che preclude ulteriori ottimizzazioni.

Aggiunta di una nuova classe di algoritmi, AdaptVQE a qiskit.algorithms Questo algoritmo utilizza una classe qiskit.algorithms.minimum_eigensolvers.VQE in combinazione con un pool di operatori da cui costruire un qiskit.circuit.library.EvolvedOperatorAnsatz in modo adattivo. Ad esempio:

from qiskit.algorithms.minimum_eigensolvers import AdaptVQE, VQE
from qiskit.algorithms.optimizers import SLSQP
from qiskit.primitives import Estimator
from qiskit.circuit.library import EvolvedOperatorAnsatz

# get your Hamiltonian
hamiltonian = ...

# construct your ansatz
ansatz = EvolvedOperatorAnsatz(...)

vqe = VQE(Estimator(), ansatz, SLSQP())

adapt_vqe = AdaptVQE(vqe)

result = adapt_vqe.compute_minimum_eigenvalue(hamiltonian)

La classe BackendV2 ha ora il supporto per due nuovi punti di aggancio opzionali che consentono ai backend di iniettare passaggi di compilazione personalizzati come parte di transpile() e generate_preset_pass_manager(). Se un'implementazione BackendV2 include i metodi get_scheduling_stage_plugin() o get_translation_stage_plugin() , il transpiler utilizzerà la stringa restituita come valore predefinito per gli argomenti scheduling_method e translation_method . Ciò consente ai backend di eseguire ulteriori passaggi di transpiler personalizzati quando si rivolgono a quel backend, sfruttando l'interfaccia del transpiler stage plugin dell'interfaccia. Per maggiori dettagli sull'uso di questa funzione, vedere: Pass transpiler personalizzati.
Aggiunto un nuovo argomento di parola chiave, ignore_backend_supplied_default_methods, alla funzione transpile() che può essere usato per disabilitare la selezione personalizzata di un metodo predefinito da parte di un backend se il backend di destinazione ha definito get_scheduling_stage_plugin() o get_translation_stage_plugin() .
Aggiunto un parametro label al costruttore della classe Barrier al costruttore della classe e al metodo barrier() che consente all'utente di assegnare un'etichetta a un'istanza della direttiva Barrier direttiva. Per le visualizzazioni generate con circuit_drawer() o QuantumCircuit.draw() questa etichetta verrà stampata nella parte superiore del sito barrier.
```
from qiskit import QuantumCircuit

circuit = QuantumCircuit(2)
circuit.h(0)
circuit.h(1)
circuit.barrier(label="After H")
circuit.draw('mpl')
```
Aggiungi nuovi cancelli CCZGate, CSGate, e CSdgGate alle porte standard della Libreria dei circuiti (qiskit.circuit.library).

Aggiunto qiskit.algorithms.eigensolvers per includere le interfacce per gli algoritmi abilitati alle primitive. Questo nuovo modulo sostituirà il precedente qiskit.algorithms.eigen_solvers. Questo nuovo modulo contiene un'implementazione alternativa del metodo VQD che invece di prendere un backend o QuantumInstance prende invece un'istanza di BaseEstimator, incluso Estimator, BackendEstimator, o qualsiasi implementazione di provider come quelle presenti in qiskit-ibm-runtime e qiskit-aer.

Ad esempio, per utilizzare la nuova implementazione con un'istanza di Estimator classe:

from qiskit.algorithms.eigensolvers import VQD
from qiskit.algorithms.optimizers import SLSQP
from qiskit.circuit.library import TwoLocal
from qiskit.primitives import Sampler, Estimator
from qiskit.algorithms.state_fidelities import ComputeUncompute
from qiskit.opflow import PauliSumOp
from qiskit.quantum_info import SparsePauliOp

h2_op = PauliSumOp(SparsePauliOp(
    ["II", "IZ", "ZI", "ZZ", "XX"],
    coeffs=[
        -1.052373245772859,
        0.39793742484318045,
        -0.39793742484318045,
        -0.01128010425623538,
        0.18093119978423156,
    ],
))

estimator = Estimator()
ansatz = TwoLocal(rotation_blocks=["ry", "rz"], entanglement_blocks="cz")
optimizer = SLSQP()
fidelity = ComputeUncompute(Sampler())

vqd = VQD(estimator, fidelity, ansatz, optimizer, k=2)
result = vqd.compute_eigenvalues(h2_op)
eigenvalues = result.eigenvalues

Si noti che gli operatori ausiliari valutati sono ora ottenuti tramite il campo aux_operators_evaluated sui risultati. Consisterà in un elenco o in un dict di tuple contenenti i valori di aspettativa per questi operatori, nonché i metadati dell'esecuzione primitiva. aux_operator_eigenvalues non è più un campo valido.

Aggiunti nuovi algoritmi per calcolare le fedeltà/sovrapposizioni di stato per coppie di circuiti quantistici (che possono essere parametrizzati). Oltre alla classe base (BaseStateFidelity) che definisce l'interfaccia, esiste un'implementazione del metodo compute-uncompute che sfrutta le istanze della primitiva BaseSampler primitiva: qiskit.algorithms.state_fidelities.ComputeUncompute.

Ad esempio:

import numpy as np
from qiskit.primitives import Sampler
from qiskit.algorithms.state_fidelities import ComputeUncompute
from qiskit.circuit.library import RealAmplitudes

sampler = Sampler(...)
fidelity = ComputeUncompute(sampler)
circuit = RealAmplitudes(2)
values = np.random.random(circuit.num_parameters)
shift = np.ones_like(values) * 0.01

job = fidelity.run([circuit], [circuit], [values], [values+shift])
fidelities = job.result().fidelities

Aggiunto un nuovo modulo qiskit.algorithms.gradients che contiene classi utilizzate per calcolare i gradienti utilizzando le interfacce primitive definite in qiskit.primitives. Esistono 4 tipi di classi di gradienti: Finite Difference, Parameter Shift, Linear Combination of Unitary e SPSA con implementazioni che utilizzano un'istanza dell'interfaccia BaseEstimator interfaccia:
o un'istanza dell'interfaccia BaseSampler interfaccia:
I gradienti basati sullo stimatore calcolano il gradiente dei valori di aspettativa, mentre i gradienti basati sul campionatore restituiscono i gradienti dei risultati della misurazione (detti anche "gradienti di probabilità").

Ad esempio:
```
estimator = Estimator(...)
gradient = ParamShiftEstimatorGradient(estimator)
job = gradient.run(circuits, observables, parameters)
gradients = job.result().gradients
```
La classe Grover ha un nuovo argomento chiave, sampler , che viene utilizzato per eseguire l'algoritmo utilizzando un'istanza dell'interfaccia BaseSampler per calcolare i risultati. Questo nuovo argomento sostituisce l'argomento quantum_instance e, di conseguenza, quantum_instance è in attesa di deprezzamento e sarà deprecato e successivamente rimosso nelle prossime versioni.

Esempio:
```
from qiskit import QuantumCircuit
from qiskit.primitives import Sampler
from qiskit.algorithms import Grover, AmplificationProblem

sampler = Sampler()
oracle = QuantumCircuit(2)
oracle.cz(0, 1)
problem = AmplificationProblem(oracle, is_good_state=["11"])
grover = Grover(sampler=sampler)
result = grover.amplify(problem)
```
Una nuova opzione, "formatter.control.fill_waveform" , è stata aggiunta ai fogli di stile del cassetto degli impulsi (pulse_v2.draw() e Schedule.draw()) ai fogli di stile. Questa opzione può essere utilizzata per rimuovere il colore della faccia degli impulsi nella visualizzazione di output, consentendo di disegnare gli impulsi solo con linee.

Ad esempio:
```
from qiskit.visualization.pulse_v2 import IQXStandard

my_style = IQXStandard(
    **{"formatter.control.fill_waveform": False, "formatter.line_width.fill_waveform": 2}
)

my_sched.draw(style=my_style)
```
Aggiunto un nuovo passaggio di transpiler, ResetAfterMeasureSimplificationche viene utilizzato per sostituire un'operazione Reset dopo un'operazione Measure con una condizionale XGate. Questo passaggio può essere utilizzato nei backend in cui un'operazione Reset viene eseguita eseguendo una misurazione e poi un gate X condizionale in modo da rimuovere il duplicato implicito Measure dall'operazione Reset operazione. Ad esempio:
```
from qiskit import QuantumCircuit
from qiskit.transpiler.passes import ResetAfterMeasureSimplification

qc = QuantumCircuit(1)
qc.measure_all()
qc.reset(0)
qc.draw('mpl')
```
```
result = ResetAfterMeasureSimplification()(qc)
result.draw('mpl')
```
Aggiunto un nuovo valore supportato, "reverse_linear" , per l'argomento della parola chiave entanglement nel costruttore della classe NLocal circuito. Per TwoLocal (che sono sottoclassi di NLocal), se entanglement_blocks="cx" allora l'uso di entanglement="reverse_linear" fornisce un circuito n-qubit equivalente a quello di entanglement="full" ma con solo $n-1$ CXGate invece di $\frac{n(n-1)}{2}$ .
ScheduleBlock è stato aggiornato in modo da poter gestire subroutine non assegnate, in altre parole, per consentire la chiamata pigra di altri programmi. Ad esempio, questo consente il seguente flusso di lavoro:
```
from qiskit import pulse

with pulse.build() as prog:
  pulse.reference("x", "q0")

with pulse.build() as xq0:
  pulse.play(Gaussian(160, 0.1, 40), pulse.DriveChannel(0))

prog.assign_references({("x", "q0"): xq0})
```
Ora un utente può creare prog senza conoscere l'effettiva implementazione del riferimento ("x", "q0"), e assegnarlo in un secondo momento per l'esecuzione. In questo modo si migliora la modularità dei programmi di impulsi e si può facilmente scrivere un programma di impulsi modello che si basa su altre calibrazioni.

Per realizzare questa funzione, è stata aggiunta la nuova istruzione pulse (direttiva del compilatore) Reference è stata aggiunta. Questa istruzione viene iniettata nell'ambito del costruttore corrente quando viene utilizzato il comando reference() viene utilizzato. Tutti i riferimenti definiti nel programma di impulsi corrente possono essere elencati con la proprietà references .

Inoltre, ogni riferimento è gestito con un ambito per facilitare la gestione dei parametri. scoped_parameters() e search_parameters() sono stati aggiunti a ScheduleBlock. Per maggiori dettagli, consultare la documentazione dell'API.
Aggiunto un nuovo metodo SparsePauliOp.argsort()che restituisce la composizione di permutazioni nell'ordine di ordinamento per coefficiente e ordinamento per Pauli. Utilizzando l'argomento della parola chiave weight per il metodo, l'output può essere ordinato anche in base al numero di termini non identici nei Pauli, dove l'insieme di tutti i Pauli di un determinato peso è ancora ordinato lessicograficamente.
Aggiunto un nuovo metodo SparsePauliOp.sort()che ordina prima i coefficienti usando argsort() di numpy e poi ordina per Pauli, dove l'ordinamento Pauli ha la precedenza. Se l'ordinamento Pauli è lo stesso, verrà ordinato per coefficiente. Utilizzando l'argomento della parola chiave weight , l'output può essere ordinato anche in base al numero di termini non identici nei Pauli, dove l'insieme di tutti i Pauli di un determinato peso è ancora ordinato lessicograficamente.

Aggiunto un nuovo argomento di parola chiave, wire_order, alla funzione circuit_drawer() funzione e QuantumCircuit.draw() che consente di riordinare arbitrariamente sia i bit quantistici che quelli classici nella visualizzazione di uscita. Ad esempio:

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('mpl', cregbundle=False, wire_order=[2, 1, 3, 0, 6, 8, 9, 5, 4, 7])

È stato aggiunto il supporto per gli elementi CSGate, CSdgGate e CCZGate al costruttore della classe operatore CNOTDihedral. I circuiti di ingresso durante la creazione di un CNOTDihedral supporteranno ora i circuiti che utilizzano queste porte. Ad esempio:
```
from qiskit import QuantumCircuit
from qiskit.quantum_info import CNOTDihedral

qc = QuantumCircuit(2)
qc.t(0)
qc.cs(0, 1)
qc.tdg(0)
operator = CNOTDihedral(qc)
```
Le classi dell'algoritmo di stima dell'ampiezza:
Ora hanno un nuovo argomento chiave, sampler sul loro costruttore che prende un'istanza di un oggetto che implementa l'interfaccia BaseSampler compresa l'interfaccia BackendSampler, Sampler, o qualsiasi implementazione di provider come quelle presenti in qiskit-ibm-runtime e qiskit-aer. Questo fornisce un'alternativa all'uso dell'argomento quantum_instance per impostare il target Backend o QuantumInstance su cui eseguire l'algoritmo. L'uso di a QuantumInstance è in attesa di essere deprecato e lo sarà in una prossima versione.
Aggiunta una nuova classe, BackendV2Converterche viene utilizzata per avvolgere un'istanza BackendV1 in un'istanza BackendV2 interfaccia. Permette di avere un'istanza BackendV2 da qualsiasi BackendV1. Questo permette di standardizzare gli schemi di accesso sulla più recente BackendV2 anche se si supporta ancora l'interfaccia BackendV1.
Aggiunta una nuova funzione convert_to_target() che viene utilizzata per prendere un valore BackendConfiguratione, facoltativamente, a BackendProperties e PulseDefaults e creare un oggetto Target equivalente al contenuto di tali oggetti.
qiskit.quantum_info.BaseOperator (come ad esempio ScalarOp, SparsePauliOp e PauliList) possono ora essere utilizzate con la funzione integrata Python sum() .
È stato aggiunto un nuovo transpiler pass, ConvertConditionsToIfOps che può essere utilizzato per convertire istruzioni condizionate di vecchio tipo in istruzioni Instruction.c_if()-istruzioni condizionate in IfElseOp oggetti. Questo per facilitare la transizione dal vecchio al nuovo tipo di backend. Per la maggior parte degli utenti, non è necessario aggiungerlo ai gestori di pass e non è incluso in nessun gestore di pass preimpostato.
Rifattorizzazione dell'analisi della commutatività dei gate in una classe CommutationChecker. Questa classe consente di verificare (sulla base della moltiplicazione matriciale) se due porte commutano o non commutano e di memorizzare i risultati nella cache (in modo che un controllo simile in futuro non richieda più la moltiplicazione matriciale).

Ad esempio, ora possiamo fare:
```
from qiskit.circuit import QuantumRegister, CommutationChecker

comm_checker = CommutationChecker()
qr = QuantumRegister(4)

res = comm_checker.commute(CXGate(), [qr[1], qr[0]], [], CXGate(), [qr[1], qr[2]], [])
```
Poiché le due porte CX commutano (la prima porta CX è sui qubit qr[1] e qr[0], e la seconda porta CX è sui qubit qr[1] e qr[2]), si avrà che res è True.

Questa verifica della commutatività è eccessivamente conservativa per le porte condizionali e parametriche e può restituire False anche quando tali porte commutano.
Aggiunto un nuovo passaggio di transpiler CommutativeInverseCancellation che annulla le coppie di porte inverse sfruttando le relazioni di commutazione tra le porte. Questo passaggio è una generalizzazione del passaggio transpiler InverseCancellation in quanto individua un insieme più ampio di porte inverse e tiene conto della commutatività. Il passaggio evita anche alcuni problemi associati al passaggio del transpiler CommutativeCancellation.

Ad esempio:
```
from qiskit.circuit import QuantumCircuit
from qiskit.transpiler import PassManager
from qiskit.transpiler.passes import CommutativeInverseCancellation

circuit = QuantumCircuit(2)
circuit.z(0)
circuit.x(1)
circuit.cx(0, 1)
circuit.z(0)
circuit.x(1)

passmanager = PassManager(CommutativeInverseCancellation())
new_circuit = passmanager.run(circuit)
```
annulla la coppia di porte Z autoinvertite e la coppia di porte X autoinvertite (poiché le porte in questione commutano con la porta CX), producendo un circuito costituito da una sola porta CX.

Il controllo inverso è eccessivamente conservativo per le porte condizionali e parametrizzate e potrebbe non annullare alcune di queste porte.

QuantumCircuit.compose() accetta ora un operando con bit classici se il circuito di base non ne ha. Il modello di composizione di un circuito con misure su un circuito solo quantistico è ora valido. Ad esempio:

from qiskit import QuantumCircuit

base = QuantumCircuit(3)
terminus = QuantumCircuit(3, 3)
terminus.measure_all()

# This will now succeed, though it was previously a CircuitError.
base.compose(terminus)

I DAGCircuit metodi depth() e size() hanno un nuovo argomento per la parola chiave recurse da usare con circuiti che contengono operazioni di flusso di controllo (come ad esempio IfElseOp, WhileLoopOp, e ForLoopOp). Per impostazione predefinita è False e solleva un errore se sono presenti operazioni di flusso di controllo, per evitare risultati poco definiti. Se impostato su True, viene restituito un valore proxy che tenta di pesare in modo equo ogni blocco di flusso di controllo in relazione alla sua condizione, anche se la profondità o la dimensione di un'esecuzione in calcestruzzo è generalmente inconoscibile. Per sapere come ogni operazione del flusso di controllo influisce sull'output, consultare la documentazione di ciascun metodo.
DAGCircuit.count_ops() ha acquisito un argomento della parola chiave recurse per la ricorsione nei blocchi di flusso di controllo. L'impostazione predefinita è True e verranno restituite tutte le operazioni in tutti i blocchi, oltre alle operazioni del flusso di controllo stesso.
Aggiunto un argomento create_preds_and_succs alle funzioni circuit_to_dagdependency() e dag_to_dagdependency() che convertono da QuantumCircuit e DAGCircuit, rispettivamente, in DAGDependency. Quando il valore di create_preds_and_succs è False, i predecessori e i successori transitivi per i nodi in DAGDependency non vengono costruiti, rendendo le conversioni più veloci e meno impegnative dal punto di vista della memoria. I predecessori e i successori diretti dei nodi in DAGDependency sono costruiti come di consueto.

Ad esempio:
```
from qiskit.converters import circuit_to_dagdependency
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit

circuit_in = QuantumCircuit(2)
circuit_in.h(qr[0])
circuit_in.h(qr[1])

dag_dependency = circuit_to_dagdependency(circuit_in, create_preds_and_succs=False)
```
Aggiunti nuovi attributi Clifford.symplectic_matrix, Clifford.tableau, Clifford.z, Clifford.x, Clifford.phase, Clifford.stab, Clifford.stab_z, Clifford.stab_x, Clifford.stab_phase, Clifford.destab, Clifford.destab_z, Clifford.destab_x, Clifford.destab_phase alla Clifford classe. Questi possono essere usati al posto di Clifford.table, che sarà deprecato in futuro. StabilizerTable e PauliTable sono in attesa di deprecazione e saranno deprecati nella prossima versione e successivamente rimossi.
Il costruttore Commuting2qGateRouter ha ora un nuovo argomento di parola chiave, edge_coloring. Questo argomento viene utilizzato per fornire una colorazione dei bordi della mappa di accoppiamento per determinare l'ordine in cui vengono applicate le porte di commutazione.
Aggiunta una nuova interfaccia algoritmi per la creazione di algoritmi di evoluzione temporale utilizzando le primitive BaseSampler e BaseEstimator. Questa nuova interfaccia è composta da:
Questa nuova interfaccia è un'alternativa all'interfaccia per gli algoritmi di evoluzione temporale già esistente e disponibile definita con EvolutionProblem, EvolutionResult, RealEvolver, e ImaginaryEvolver che funzionavano con un QuantumInstance al posto delle primitive. Questa nuova interfaccia sostituisce quella precedente, che sarà deprecata e quindi rimossa nelle prossime versioni.
Aggiunte nuove classi di backend a qiskit.providers.fake_provider:
Queste nuove classi implementano l'interfaccia BackendV2 e sono create utilizzando le istantanee memorizzate delle informazioni di backend dei sistemi IBM Quantum ibm_auckland, ibm_oslo, ibm_geneva e ibm_perth rispettivamente.
La classe Z2Symmetries ha due nuovi metodi, convert_clifford() e taper_clifford(). Questi due metodi sono le due operazioni necessarie per il taperng di un operatore in base alle simmetrie di Z2 nell'oggetto e sono stati precedentemente eseguiti internamente tramite il metodo taper() metodo. Tuttavia, questi metodi sono ora metodi pubblici della classe, che possono essere richiamati singolarmente se necessario.
Le prestazioni in fase di esecuzione per la coniugazione di un oggetto lungo PauliList con un oggetto Clifford utilizzando l'opzione PauliList.evolve() è migliorata in modo significativo. Ora funzionerà molto più velocemente di prima.
Aggiunta una nuova classe astratta ClassicalIOChannel al modulo qiskit.pulse.channels al modulo. Questa classe viene utilizzata per rappresentare i canali di I/O classici e per differenziarli da altre sottoclassi di Channel. Questa nuova classe è la classe base per la classe MemorySlot, RegisterSlot, e SnapshotChannel . Di conseguenza, la pad() trasformazione dell'impulso di canonicalizzazione in qiskit.pulse.transforms non introdurrà ritardi in nessuna istanza di ClassicalIOChannel
Il passo del transpiler SabreSwap ha un nuovo argomento di parola chiave nel suo costruttore, trials. L'argomento trials viene utilizzato per specificare il numero di tentativi di semina casuale da tentare. Il risultato dell' algoritmo SABRE può variare notevolmente in base al seme utilizzato per il numero casuale. SabreSwap eseguirà ora l'algoritmo con trials numero di semi casuali e sceglierà il migliore (con il minor numero di scambi inseriti). Se trials non è specificato, il passaggio utilizzerà per default il numero di CPU fisiche del sistema locale.
Il passo del transpiler SabreLayout ha un nuovo argomento di parola chiave nel suo costruttore, swap_trials. L'argomento swap_trials viene utilizzato per specificare il numero di prove di seme casuale da eseguire sul SabreSwap internamente. Corrisponde all'arugmento di trials sul SabreSwap passaggio. Se impostato, ogni iterazione di SabreSwap verrà eseguita internamente swap_trials volte. Se swap_trials non è specificato, per impostazione predefinita verrà utilizzato il numero di CPU fisiche del sistema locale.
Aggiunta di una nuova funzione, estimate_observables() che utilizza un'implementazione dell'interfaccia BaseEstimator (ad es. Estimator, BackendEstimator, o qualsiasi implementazione di provider come quelle presenti in qiskit-ibm-runtime e qiskit-aer) per calcolare i valori di aspettativa, le loro medie e le deviazioni standard da un elenco o dizionario di osservabili. Questo ha uno scopo simile alla funzione preesistente eval_observables() che eseguiva il calcolo utilizzando un oggetto QuantumInstance ed è stata sostituita (e sarà deprecata e successivamente rimossa nelle prossime versioni) da questa nuova funzione.
Aggiunta di una nuova Operation che fornisce un'interfaccia astratta e leggera per gli oggetti che possono essere messi su QuantumCircuit. Ciò consente di memorizzare oggetti di "livello superiore" direttamente su un circuito (ad esempio, Clifford oggetti), di combinare direttamente tali oggetti (ad esempio, di comporre più oggetti consecutivi sugli stessi qubit) e di sintetizzare tali oggetti in fase di esecuzione (ad esempio, di sintetizzare oggetti Clifford oggetti consecutivi sugli stessi qubit) e di sintetizzare tali oggetti a tempo di esecuzione (ad esempio, sintetizzare in modo da ottimizzare la profondità e/o sfruttare la connettività dei dispositivi) Clifford in modo da ottimizzare la profondità e/o sfruttare la connettività del dispositivo). In precedenza, solo le sottoclassi di qiskit.circuit.Instruction potevano essere inserite in QuantumCircuitma questa interfaccia è diventata ingombrante e include troppi metodi e attributi per oggetti di uso generale.

La nuova Operation include name, num_qubits e num_clbits (in futuro potrebbe essere leggermente modificata), ma soprattutto non include definition (e quindi non lega la sintesi all'oggetto), non include condition (che dovrebbe far parte di un flusso di controllo classico separato) e non include duration e unit (poiché sono proprietà dell'output del transpiler).

A partire da ora, Operation comprende Gate, Reset, Barrier, Measure, e oggetti di "livello superiore" come Clifford. Questo elenco di oggetti di "livello superiore" è destinato a crescere in futuro.
A Clifford viene ora aggiunto a un circuito quantistico come un Operationsenza dover prima sintetizzare un sottocircuito che implementa questo Clifford. La sintesi vera e propria viene rimandata a un successivo passaggio di HighLevelSynthesis successivo passaggio di transpilazione.

Ad esempio, il codice seguente:
```
from qiskit import QuantumCircuit
from qiskit.quantum_info import random_clifford

qc = QuantumCircuit(3)
cliff = random_clifford(2)
qc.append(cliff, [0, 1])
```
non converte più cliff in qiskit.circuit.Instruction, che include la sintetizzazione della clifford in un circuito, quando viene aggiunto a qc.
Aggiunto un nuovo passaggio del transpiler OptimizeCliffords che raccoglie blocchi di oggetti consecutivi Clifford in un circuito e sostituisce ogni blocco con un singolo oggetto Clifford.

Ad esempio, il codice seguente:
```
from qiskit import QuantumCircuit
from qiskit.quantum_info import random_clifford
from qiskit.transpiler.passes import OptimizeCliffords
from qiskit.transpiler import PassManager

qc = QuantumCircuit(3)
cliff1 = random_clifford(2)
cliff2 = random_clifford(2)
qc.append(cliff1, [2, 1])
qc.append(cliff2, [2, 1])
qc_optimized = PassManager(OptimizeCliffords()).run(qc)
```
memorizza prima i due Clifford cliff1 e cliff2 su qc come oggetti di "livello superiore", e poi il passo di transpiler ottimizza il circuito componendo questi due Clifford in un unico Clifford OptimizeCliffords ottimizza il circuito componendo questi due Clifford in un unico Clifford. Si noti che il Clifford risultante è ancora memorizzato su qc come oggetto di livello superiore. Questo passaggio non è ancora incluso in nessuno dei gestori di passaggi preimpostati.
Aggiunto un nuovo passaggio del transpiler HighLevelSynthesis che sintetizza oggetti di livello superiore (ad esempio, Clifford oggetti).

Ad esempio, il codice seguente:
```
from qiskit import QuantumCircuit
from qiskit.quantum_info import random_clifford
from qiskit.transpiler import PassManager
from qiskit.transpiler.passes import HighLevelSynthesis

qc = QuantumCircuit(3)
qc.h(0)
cliff = random_clifford(2)
qc.append(cliff, [0, 1])

qc_synthesized = PassManager(HighLevelSynthesis()).run(qc)
```
sintetizzerà il Clifford di livello superiore memorizzato in qc usando la funzione predefinita decompose_clifford() .

Questo nuovo pass transpiler HighLevelSynthesis è integrato nei gestori di passaggi preimpostati e viene eseguito subito dopo il UnitarySynthesis pass. Quindi, transpile() sintetizzerà tutti i Clifford di livello superiore presenti nel circuito.

È importante notare che il lavoro svolto per memorizzare gli oggetti come Clifford come oggetti di "livello superiore" e per transpilare questi oggetti usando HighLevelSynthesis dovrebbe essere completamente trasparente e non sono necessarie modifiche al codice.
SparsePauliOppossono ora essere costruiti con array di coefficienti che sono oggetti generali Python. Questo è inteso per l'uso con gli oggetti ParameterExpression ; altri oggetti possono funzionare, ma non hanno un supporto di prima classe. Alcuni metodi (come la conversione in altre rappresentazioni di classi) SparsePauliOp (come la conversione in rappresentazioni di altre classi) potrebbero non funzionare quando si usano gli array di object , se la destinazione desiderata non può rappresentare questi array generali.

Ad esempio, un ParameterExpression SparsePauliOp potrebbe essere costruito da:
```
import numpy as np
from qiskit.circuit import Parameter
from qiskit.quantum_info import SparsePauliOp

print(SparsePauliOp(["II", "XZ"], np.array([Parameter("a"), Parameter("b")])))
```
che dà
```
SparsePauliOp(['II', 'XZ'],
      coeffs=[ParameterExpression(1.0*a), ParameterExpression(1.0*b)])
```
Aggiunta una nuova funzione plot_distribution() per tracciare le distribuzioni di quasi-probabilità. Questo è adatto a Counts, QuasiDistribution e ProbDistribution. È possibile passare anche il dettato grezzo. Ad esempio:
```
from qiskit.visualization import plot_distribution

quasi_dist = {'0': .98, '1': -.01}
plot_distribution(quasi_dist)
```
È stata introdotta una nuova interfaccia per i plugin di sintesi di alto livello, utilizzata per consentire l'utilizzo di tecniche di sintesi alternative incluse in pacchetti esterni senza soluzione di continuità con il HighLevelSynthesis transpiler. Queste tecniche di sintesi alternative possono essere specificate per qualsiasi oggetto di "livello superiore" di tipo Operationcome ad esempio per Clifford e LinearFunction . L'interfaccia del plugin è simile a quella della sintesi unitaria. In quest'ultimo caso, i dettagli sulla scrittura di un nuovo plugin sono riportati nella documentazione del modulo qiskit.transpiler.passes.synthesis.plugin del modulo.
Introdotta una nuova classe HLSConfig che può essere utilizzata per specificare algoritmi di sintesi alternativi per oggetti di "livello superiore" di tipo Operation. Per ogni oggetto di livello superiore di interesse, un oggetto HLSConfig specifica un elenco di metodi di sintesi e i loro argomenti. Questo oggetto può essere passato a HighLevelSynthesis transpiler pass o specificato come parametro hls_config in transpile().

A titolo di esempio, assumiamo che op_a e op_b siano nomi di due oggetti di livello superiore, che gli oggetti op_a abbiano due metodi di sintesi default che non richiede parametri aggiuntivi e other con due parametri interi opzionali option_1 e option_2, che gli oggetti op_b abbiano un unico metodo di sintesi default e che qc sia un circuito quantistico contenente gli oggetti op_a e op_b . Il seguente frammento di codice:
```
hls_config = HLSConfig(op_b=[("other", {"option_1": 7, "option_2": 4})])
pm = PassManager([HighLevelSynthesis(hls_config=hls_config)])
transpiled_qc = pm.run(qc)
```
mostra come eseguire il metodo di sintesi alternativo other per gli oggetti op_b, mentre si utilizzano i metodi default per tutti gli altri oggetti di alto livello, compresi gli oggetti op_a.
Aggiunti nuovi metodi per l'esecuzione delle primitive: BaseSampler.run() e BaseEstimator.run(). Questi metodi vengono eseguiti in modo asincrono e restituiscono oggetti JobV1 che forniscono un handle alle esecuzioni. Questi nuovi metodi di esecuzione possono essere passati QuantumCircuit (e osservabili per BaseEstimator) che non sono registrati nel costruttore. Ad esempio:
```
estimator = Estimator()
result = estimator.run(circuits, observables, parameter_values).result()
```
Questo fornisce un'alternativa al precedente modello di esecuzione (ora deprecato) per gli elementi BaseSampler e BaseEstimator che prendeva tutti gli input tramite il costruttore e chiamava l'oggetto primitivo con la combinazione dei parametri di input da usare nell'esecuzione.

Aggiunta l'opzione shots per le implementazioni di riferimento delle primitive. I numeri casuali possono essere fissati dando seed_primitive. Ad esempio:

from qiskit.primitives import Sampler
from qiskit import QuantumCircuit

bell = QuantumCircuit(2)
bell.h(0)
bell.cx(0, 1)
bell.measure_all()

with Sampler(circuits=[bell]) as sampler:
    result = sampler(circuits=[0], shots=1024, seed_primitive=15)
    print([q.binary_probabilities() for q in result.quasi_dists])

I costruttori per le classi BaseSampler e BaseEstimator hanno un nuovo argomento opzionale, options , che viene utilizzato per impostare i valori predefiniti delle opzioni esposte tramite l'attributo options .

Aggiunta la classe PVQD al framework dell'evoluzione temporale in qiskit.algorithms. Questa classe implementa l'algoritmo di dinamica quantistica variazionale proiettata (p-VQD), di Barison et al.

In ogni passo temporale questo algoritmo calcola lo stato successivo con una formula di Trotter e lo proietta su una forma variazionale. La proiezione viene determinata massimizzando la fedeltà dello stato evoluto da Trotter e dell'ansatz, utilizzando una routine di ottimizzazione classica.

import numpy as np

from qiskit.algorithms.state_fidelities import ComputeUncompute
from qiskit.algorithms.evolvers import EvolutionProblem
from qiskit.algorithms.time_evolvers.pvqd import PVQD
from qiskit.primitives import Estimator, Sampler
from qiskit import BasicAer
from qiskit.circuit.library import EfficientSU2
from qiskit.quantum_info import Pauli, SparsePauliOp
from qiskit.algorithms.optimizers import L_BFGS_B

sampler = Sampler()
fidelity = ComputeUncompute(sampler)
estimator = Estimator()
hamiltonian = 0.1 * SparsePauliOp([Pauli("ZZ"), Pauli("IX"), Pauli("XI")])
observable = Pauli("ZZ")
ansatz = EfficientSU2(2, reps=1)
initial_parameters = np.zeros(ansatz.num_parameters)

time = 1
optimizer = L_BFGS_B()

# setup the algorithm
pvqd = PVQD(
    fidelity,
    ansatz,
    initial_parameters,
    estimator,
    num_timesteps=100,
    optimizer=optimizer,
)

# specify the evolution problem
problem = EvolutionProblem(
    hamiltonian, time, aux_operators=[hamiltonian, observable]
)

# and evolve!
result = pvqd.evolve(problem)

Il metodo QNSPSA.get_fidelity() statico ora supporta un argomento opzionale sampler che viene utilizzato per fornire un'implementazione dell'interfaccia BaseSampler (come ad esempio Sampler, BackendSampler, o qualsiasi implementazione di provider, come quelle presenti in qiskit-ibm-runtime e qiskit-aer) per calcolare la fedeltà di un oggetto QuantumCircuit. Ad esempio:
```
from qiskit.primitives import Sampler
from qiskit.algorithms.optimizers import QNSPSA

fidelity = QNSPSA.get_fidelity(my_circuit, Sampler())
```

Aggiunta di una nuova parola chiave sampler ai costruttori delle classi di stima di fase:

IterativePhaseEstimation

PhaseEstimation

HamiltonianPhaseEstimation

Questo argomento viene utilizzato per fornire un'implementazione dell'interfaccia BaseSampler come ad esempio Sampler, BackendSampler, o qualsiasi implementazione di provider, come quelle presenti in qiskit-ibm-runtime e qiskit-aer.

Ad esempio:

from qiskit.primitives import Sampler
from qiskit.algorithms.phase_estimators import HamiltonianPhaseEstimation
from qiskit.synthesis import MatrixExponential
from qiskit.quantum_info import SparsePauliOp
from qiskit.opflow import PauliSumOp


sampler = Sampler()
num_evaluation_qubits = 6
phase_est = HamiltonianPhaseEstimation(
    num_evaluation_qubits=num_evaluation_qubits, sampler=sampler
)

hamiltonian = PauliSumOp(SparsePauliOp.from_list([("X", 0.5), ("Y", 0.6), ("I", 0.7)]))
result = phase_est.estimate(
    hamiltonian=hamiltonian,
    state_preparation=None,
    evolution=MatrixExponential(),
    bound=1.05,
)

Il passaggio SabreSwap ha migliorato significativamente le prestazioni in fase di esecuzione, grazie alla riscrittura dell'algoritmo in Rust.
Sottoclassi di impulsi simbolici Gaussian, GaussianSquare, Drag e Constant sono state aggiornate per istanziare SymbolicPulse anziché la sottoclasse stessa. Tutti gli oggetti parametrici di impulso nei programmi di impulso devono essere istanze simboliche di impulso, perché non è più necessaria la sottoclasse. Si noti che SymbolicPulse può identificare in modo univoco un particolare involucro con l'oggetto espressione simbolica definito in SymbolicPulse.envelope.
Aggiunta una nuova funzione, sampled_expectation_value()che consente di calcolare i valori di aspettativa per gli operatori diagonali da distribuzioni quali Counts e QuasiDistribution. Gli operatori validi da utilizzare con questa funzione sono: str, Pauli, PauliOp, PauliSumOp, e SparsePauliOp.

A SamplingVQE è stata introdotta una classe ottimizzata per le hamiltoniane diagonali e che sfrutta una primitiva sampler . A QAOA viene aggiunta anche una classe che sottoclasse SamplingVQE.

Per utilizzare il nuovo SamplingVQE con una primitiva di riferimento, si può fare, ad esempio:

from qiskit.algorithms.minimum_eigensolvers import SamplingVQE
from qiskit.algorithms.optimizers import SLSQP
from qiskit.circuit.library import TwoLocal
from qiskit.primitives import Sampler
from qiskit.opflow import PauliSumOp
from qiskit.quantum_info import SparsePauliOp

operator = PauliSumOp(SparsePauliOp(["ZZ", "IZ", "II"], coeffs=[1, -0.5, 0.12]))

sampler = Sampler()
ansatz = TwoLocal(rotation_blocks=["ry", "rz"], entanglement_blocks="cz")
optimizer = SLSQP()

sampling_vqe = SamplingVQE(sampler, ansatz, optimizer)
result = sampling_vqe.compute_minimum_eigenvalue(operator)
eigenvalue = result.eigenvalue

Aggiunto un nuovo argomento della parola chiave atol al metodo SparsePauliOp.equiv() per regolare la tolleranza del controllo di equivalenza,
È stata introdotta una nuova interfaccia plugin per gli stadi del transpiler, che viene utilizzata per abilitare oggetti alternativi PassManager da un pacchetto esterno in un particolare stadio come parte di transpile() o del file StagedPassManager output di generate_preset_pass_manager(), level_0_pass_manager(), level_1_pass_manager(), level_2_pass_manager(), e level_3_pass_manager(). Gli utenti possono selezionare un plugin da utilizzare per uno stadio del transpiler con gli argomenti delle parole chiave init_method, layout_method, routing_method, translation_method, optimization_method e scheduling_method su transpile() e generate_preset_pass_manager(). Un elenco completo dei nomi dei plugin attualmente installati può essere trovato con la funzione list_stage_plugins() funzione. Per la creazione di plugin, consultare la documentazione del modulo qiskit.transpiler.preset_passmanagers.plugin che include una guida per la scrittura dei plugin di stage.
L'opzione transpile() ha due nuovi argomenti chiave, init_method e optimization_method , usati per specificare i plugin alternativi da usare per gli stadi init e optimization rispettivamente.
La classe PassManagerConfig ha due nuovi attributi, init_method e optimization_method , oltre agli argomenti delle parole chiave corrispondenti nei metodi del costruttore. Questi rappresentano i plugin init e optimization specificati dall'utente da usare per la compilazione.

La classe SteppableOptimizer viene aggiunta. Consente di eseguire le ottimizzazioni classiche passo dopo passo utilizzando il metodo step() metodo. Questi ottimizzatori implementano l'interfaccia "ask and tell" che (opzionalmente) consente di calcolare manualmente le valutazioni della funzione o del gradiente richiesti e di reinserirli nell'ottimizzatore. Per ulteriori informazioni su questa interfaccia, vedere: interfaccia ask and tell. Un caso d'uso molto semplice in cui l'utente potrebbe voler eseguire l'ottimizzazione passo per passo è quello della lettura:

import random
import numpy as np
from qiskit.algorithms.optimizers import GradientDescent

def objective(x):
      return (np.linalg.norm(x) - 1) ** 2

def grad(x):
      return 2 * (np.linalg.norm(x) - 1) * x / np.linalg.norm(x)


initial_point = np.random.normal(0, 1, size=(100,))

optimizer = GradientDescent(maxiter=20)
optimizer.start(x0=initial_point, fun=objective, jac=grad)

for _ in range(maxiter):
    state = optimizer.state
    # Here you can manually read out anything from the optimizer state.
    optimizer.step()

result = optimizer.create_result()

Un caso più complesso è la gestione degli errori. Immaginate che la funzione che state valutando abbia una probabilità casuale di fallire. In questo caso è possibile catturare l'errore ed eseguire nuovamente la funzione fino a ottenere il risultato desiderato prima di continuare il processo di ottimizzazione. In questo caso si utilizza l'interfaccia ask and tell.

import random
import numpy as np
from qiskit.algorithms.optimizers import GradientDescent

def objective(x):
    if random.choice([True, False]):
        return None
    else:
        return (np.linalg.norm(x) - 1) ** 2

def grad(x):
    if random.choice([True, False]):
        return None
    else:
        return 2 * (np.linalg.norm(x) - 1) * x / np.linalg.norm(x)


initial_point = np.random.normal(0, 1, size=(100,))

optimizer = GradientDescent(maxiter=20)
optimizer.start(x0=initial_point, fun=objective, jac=grad)

while optimizer.continue_condition():
    ask_data = optimizer.ask()
    evaluated_gradient = None

    while evaluated_gradient is None:
        evaluated_gradient = grad(ask_data.x_center)
        optimizer.state.njev += 1

    optmizer.state.nit += 1

    cf  = TellData(eval_jac=evaluated_gradient)
    optimizer.tell(ask_data=ask_data, tell_data=tell_data)

result = optimizer.create_result()

Trasformato GradientDescent in una sottoclasse di SteppableOptimizer.

Il metodo subset_fitter viene aggiunto alla classe TensoredMeasFitter classe. L'implementazione è limitata a schemi di mitigazione in cui ogni qubit è mitigato individualmente, ad esempio [[0], [1], [2]]. Questo è tuttavia il caso più diffuso. Permette di utilizzare il TensoredMeasFitter nei casi in cui l'ordine numerico dei qubit fisici non corrisponde all'indice del bit classico.
Le operazioni di flusso di controllo sono ora supportate dal transpiler ai livelli di ottimizzazione 0 e 1 (ad esempio, la chiamata a transpile() o generate_preset_pass_manager() con l'argomento parola chiave optimization_level=1). Si può ora costruire un circuito come
```
from qiskit import QuantumCircuit

qc = QuantumCircuit(2, 1)
qc.h(0)
qc.measure(0, 0)
with qc.if_test((0, True)) as else_:
  qc.x(1)
with else_:
  qc.y(1)
```
e trascriverlo con successo, come ad esempio con:
```
from qiskit import transpile
from qiskit_aer import AerSimulator

backend = AerSimulator(method="statevector")
transpiled = transpile(qc, backend)
```
I valori disponibili per l'argomento della parola chiave layout_method sono "banale" e "denso". Per routing_method sono disponibili le opzioni "stocastico" e "nessuno". La traduzione (translation_method) può essere effettuata utilizzando "translator" o "unroller". I livelli di ottimizzazione 2 e 3 non sono ancora supportati con il flusso di controllo, né lo è lo scheduling dei circuiti (cioè la fornitura di un valore a scheduling_method), anche se intendiamo ampliare il supporto per questi e per gli altri metodi di layout, routing e traduzione nelle versioni successive di Qiskit Terra.

Affinché la transpilazione con operazioni di flusso di controllo abbia successo con un backend, quest'ultimo deve avere le operazioni di flusso di controllo richieste nella sua base dichiarata. Qiskit Aer, ad esempio, fa questo. Se si vuole semplicemente provare queste trasposizioni, si consideri la possibilità di sovrascrivere l'argomento basis_gates a transpile().
I seguenti passaggi del transpiler sono stati tutti istruiti per comprendere i costrutti del flusso di controllo sotto forma di ControlFlowOp istruzioni in un circuito:

Relativo al layout
- ApplyLayout
- DenseLayout
- EnlargeWithAncilla
- FullAncillaAllocation
- SetLayout
- TrivialLayout
- VF2Layout
- VF2PostLayout
Relativo al routing
- CheckGateDirection
- CheckMap
- GateDirection
- StochasticSwap
Relativo alla traduzione
- BasisTranslator
- ContainsInstruction
- GatesInBasis
- UnitarySynthesis
- Unroll3qOrMore
- UnrollCustomDefinitions
- Unroller
Relativo all'ottimizzazione
- BarrierBeforeFinalMeasurements
- Depth
- FixedPoint
- Size
- Optimize1qGatesDecomposition
- CXCancellation
- RemoveResetInZeroState
Questi passaggi sono più comunemente utilizzati tramite i gestori di passaggi preimpostati (quelli usati internamente da transpile() e generate_preset_pass_manager()), ma sono disponibili anche per altri usi. Questi passaggi si ricentreranno ora nelle operazioni del flusso di controllo, ove opportuno, aggiornando o analizzando i blocchi interni.
Aggiunta di una nuova TrotterQRTE che implementa l'interfaccia RealTimeEvolver che utilizza una classe qiskit.primitives.BaseEstimator per eseguire il calcolo. Questa nuova classe sostituisce la classe qiskit.algorithms.TrotterQRTE (che sarà deprecata e successivamente rimossa nelle prossime versioni) che utilizzava una classe Backend o QuantumInstance per eseguire il calcolo.
DAGCircuit.substitute_node_with_dag() accetta ora propagate_condition come argomento della parola chiave. L'impostazione predefinita è True, che era il comportamento precedente, e copia qualsiasi condizione sul nodo da sostituire in ogni nodo operazione della sostituzione. Se impostato su False, la condizione non sarà copiata, il che consente di sostituire un nodo condizionale con un sotto-DAG che già implementa fedelmente la condizione.
DAGCircuit.substitute_node_with_dag() può ora accettare una mappatura per il suo parametro wires e una sequenza. La mappatura deve mappare i bit del DAG sostitutivo ai bit del DAG in cui viene inserito. Ciò consente uno stile di costruzione più semplice per i chiamanti quando il nodo di ingresso ha sia bit classici che una condizione, e il DAG sostitutivo può utilizzarli in modo non ordinato.

È stato aggiunto il pacchetto qiskit.algorithms.minimum_eigensolvers per includere le interfacce per gli algoritmi abilitati alle primitive. VQE è stato rifattorizzato in questa implementazione per sfruttare le primitive.

Per utilizzare la nuova implementazione con una primitiva di riferimento, si può fare, ad esempio:

from qiskit.algorithms.minimum_eigensolvers import VQE
from qiskit.algorithms.optimizers import SLSQP
from qiskit.circuit.library import TwoLocal
from qiskit.primitives import Estimator
from qiskit.quantum_info import SparsePauliOp

h2_op = SparsePauliOp(
    ["II", "IZ", "ZI", "ZZ", "XX"],
    coeffs=[
        -1.052373245772859,
        0.39793742484318045,
        -0.39793742484318045,
        -0.01128010425623538,
        0.18093119978423156,
    ],
)

estimator = Estimator()
ansatz = TwoLocal(rotation_blocks=["ry", "rz"], entanglement_blocks="cz")
optimizer = SLSQP()

vqe = VQE(estimator, ansatz, optimizer)
result = vqe.compute_minimum_eigenvalue(h2_op)
eigenvalue = result.eigenvalue

Note sull'aggiornamento

Per Target che contengono solo operazioni a 2 qubit definite a livello globale senza alcun vincolo di connettività, il ritorno del metodo Target.build_coupling_map() restituirà None invece di un oggetto CouplingMap che contiene num_qubits nodi e nessun bordo. Questa modifica è stata apportata per rispecchiare meglio i vincoli di connettività effettivi del sistema Target perché in questo caso non ci sono vincoli di connettività sul backend modellato dall'oggetto Targete non una mancanza di connettività. Se per qualche motivo si desidera il comportamento precedente, è possibile riprodurlo controllando il ritorno di None e costruendo manualmente una mappa di accoppiamento, ad esempio:
```
from qiskit.transpiler import Target, CouplingMap
from qiskit.circuit.library import CXGate

target = Target(num_qubits=3)
target.add_instruction(CXGate())
cmap = target.build_coupling_map()
if cmap is None:
    cmap = CouplingMap()
    for i in range(target.num_qubits):
        cmap.add_physical_qubit(i)
```
Il valore predefinito per l'argomento della parola chiave entanglement nel costruttore degli oggetti RealAmplitudes e EfficientSU2 è cambiato da "full" a "reverse_linear". Questa modifica è stata apportata perché il circuito di uscita è equivalente ma utilizza solo $n-1$ invece di $\frac{n(n-1)}{2}$ CXGate cancelli. Se si desidera il precedente valore predefinito, si può impostare esplicitamente entanglement="full" quando si chiama uno dei due costruttori.
Aggiunto un controllo di validazione a BaseSampler.run(). Se non c'è un bit classico, viene generato un errore.
Il comportamento della funzione call() la funzione di creazione di impulsi è stata aggiornata. Quando un'istanza ScheduleBlock viene richiamato da questo metodo, crea internamente un riferimento al programma Reference nel contesto corrente e assegna immediatamente il programma chiamato al riferimento. Pertanto, l'istruzione Call non viene più generata. Oltre a questa modifica, è proibito chiamare blocchi diversi con lo stesso argomento name . Tale operazione darà luogo a un errore.
Per la maggior parte delle architetture, a partire dalla prossima versione di Qiskit Terra, 0.23, il pacchetto tweedledum diventerà una dipendenza opzionale, anziché un requisito. Questo è attualmente utilizzato da alcune funzioni classiche di oracolo di fase. Se la vostra applicazione o libreria necessita di questa funzionalità, potreste prepararvi aggiungendo immediatamente tweedledum alle dipendenze del vostro pacchetto.

tweedledum non è più un requisito di macOS arm64 ( M1 ) con effetto immediato in Qiskit Terra 0.22. Questo perché le ruote fornite per questa piattaforma sono rotte e la costruzione da sdist non è affidabile per la maggior parte delle persone. Se si installa manualmente una versione funzionante di tweedledum, tutte le funzionalità dipendenti continueranno a funzionare.
L'attributo ._layout dell'oggetto QuantumCircuit è stato modificato, passando dalla memorizzazione di un oggetto Layout a una classe di dati con due attributi, initial_layout che contiene un oggetto per il layout iniziale impostato durante la compilazione e che contiene un dizionario che mappa i qubit agli indici di posizione nel circuito originale Layout per il layout iniziale impostato durante la compilazione e input_qubit_mapping che contiene un dizionario che mappa i qubit agli indici di posizione nel circuito originale. Questa modifica era necessaria per fornire tutte le informazioni necessarie affinché un circuito post-trasporto fosse in grado di invertire completamente la permutazione causata dal layout iniziale in tutte le situazioni. Anche se questo attributo è privato e non dovrebbe essere usato esternamente, è l'unico modo per tenere traccia del layout iniziale attraverso transpile() quindi la modifica viene documentata nel caso in cui si faccia affidamento su di essa. Se avete un caso d'uso per l'attributo _layout che non viene affrontato dall'API di Qiskit, aprite un problema in modo che possiamo risolvere questa lacuna.
I costruttori per gli elementi SetPhase, ShiftPhase, SetFrequency, e ShiftFrequency sollevano ora un problema PulseError se il valore passato tramite l'argomento channel non è un'istanza di PulseChannel. Questa modifica è stata apportata per convalidare la validità degli input ai costruttori, poiché le istruzioni sono valide solo per i canali a impulsi e non per altri tipi di canali.
La funzione plot_histogram() è stata modificata per restituire un istogramma effettivo di valori discreti binnati. Il comportamento precedente della funzione era, nonostante il nome, quello di generare una visualizzazione della distribuzione dell'input. A causa di questa disparità tra il nome della funzione e il suo comportamento, il comportamento della funzione è stato modificato in modo da generare un istogramma corretto di dati discreti. Se si desidera mantenere il comportamento precedente di tracciare una distribuzione di probabilità dei dati dei conteggi, si può sfruttare l'opzione plot_distribution() per generare un grafico equivalente. Ad esempio, il comportamento precedente di plot_histogram({'00': 512, '11': 500}) può essere ricreato con:
```
from qiskit.visualization import plot_distribution
import matplotlib.pyplot as plt

ax = plt.subplot()
plot_distribution({'00': 512, '11': 500}, ax=ax)
ax.set_ylabel('Probabilities')
```
I contesti qiskit.pulse.builder inline e pad sono stati rimossi. Questi sono stati deprecati per la prima volta in Terra 0.18.0 (luglio 2021). Non esiste un sostituto di inline; si possono semplicemente scrivere gli impulsi nell'ambito contenente. Il gestore di contesti pad non ha avuto alcun effetto, poiché è stato deprecato.
L'output del passaggio di SabreSwap (compreso il caso in cui optimization_level=3 o routing_method o layout_method siano impostati su 'sabre' durante la chiamata a transpile()) con un valore di seme fisso può cambiare rispetto alle versioni precedenti. Ciò è dovuto all'utilizzo di un nuovo generatore di numeri casuali nell'ambito della riscrittura del passaggio SabreSwap in Rust, che ha migliorato significativamente le prestazioni. Se si desidera avere un risultato costante, è possibile eseguire il passaggio in una versione precedente di Qiskit e sfruttare la funzione qiskit.qpy per salvare il circuito e poi caricarlo con la versione attuale.
Il comportamento Layout.add() quando non si specifica un physical_bit è cambiato rispetto alle versioni precedenti. Nelle versioni precedenti, veniva aggiunto un nuovo bit fisico in base alla lunghezza dell'oggetto Layout dell'oggetto. Ad esempio, se si ha un file Layout con i bit fisici 1 e 3, le chiamate successive a add() aggiungeranno i bit fisici 2, 4, 5, 6, ecc. Mentre se i bit fisici fossero 2 e 3, le chiamate successive aggiungerebbero 4, 5, 6, 7, ecc. Questo è stato modificato in modo che invece Layout.add() aggiungerà prima tutti i bit fisici mancanti tra 0 e il massimo bit fisico contenuto nel file Layout. Quindi, per l'esempio 1 e 3 ora aggiunge 0, 2, 4, 5 e per l'esempio 2 e 3 aggiunge 0, 1, 4, 5 al valore Layout. Questa modifica è stata apportata sia per aumentare la prevedibilità del risultato, sia per risolvere una classe di bug causati dal comportamento inatteso. Poiché i bit fisici di un backend sono sempre sequenze contigue da 0 a $n$ , l'aggiunta di nuovi bit quando ci sono ancora bit fisici inutilizzati potrebbe potenzialmente far sì che il layout utilizzi più bit di quelli disponibili sul backend. Se si desidera il comportamento precedente, è possibile specificare manualmente il bit fisico desiderato durante la chiamata a Layout.add().
L'attributo deprecato SparsePauliOp.table è stato rimosso. Originariamente era deprecato in Qiskit Terra 0.19. Si deve invece utilizzare il metodo paulis() .
Il supporto per la restituzione di un PauliTable dalla funzione pauli_basis() è stato rimosso. Allo stesso modo, l'argomento pauli_list della funzione pauli_basis() che veniva usato per passare a un tipo PauliList (ora l'unico tipo di ritorno) è stato rimosso. Questa funzionalità è stata deprecata nella versione di Qiskit Terra 0.19.
Gli oggetti backend falsi FakeJohannesburg, FakeJohannesburgV2, FakeAlmaden, FakeAlmadenV2, FakeSingapore, e FakeSingaporeV2 non contengono più i payload delle impostazioni predefinite degli impulsi. Questo significa che per le BackendV1 basato sul metodo BackendV1.defaults() e sulla simulazione degli impulsi tramite BackendV1.run() non sono più disponibili. Per BackendV2 la proprietà calibration per le istruzioni della classe Target non viene più popolata. Questa modifica è stata apportata perché questi sistemi avevano un carico di impulsi predefiniti eccessivamente grande (in totale ~50MB ) a causa dell'utilizzo di forme d'onda campionate anziché di definizioni di impulsi parametrici. Questi tre file di payload hanno occupato oltre il 50% dello spazio su disco necessario per installare qiskit-terra. Se si confronta il valore potenziale della compilazione con la consapevolezza dell'impulso o della simulazione dell'impulso di questi dispositivi in pensione, la dimensione del file non vale il costo. Se si desidera sfruttare queste proprietà, è possibile utilizzare una versione precedente di Qiskit e utilizzare qpy per trasferire i circuiti dalle vecchie versioni di qiskit alla versione attuale.
isinstance controllare con le classi di polso Gaussian, GaussianSquare, Drag e Constant sarà invalidato perché queste sottoclassi di impulsi non sono più istanziate. Funzioneranno ancora in Terra 0.22, ma è necessario iniziare subito la transizione. Invece di usare le informazioni sul tipo, si dovrebbe usare SymbolicPulse.pulse_type . Si presume che questo sia un identificatore di stringa unico per gli inviluppi di impulsi e si può usare l'uguaglianza delle stringhe per indagare sui tipi di impulsi. Ad esempio:
```
from qiskit.pulse.library import Gaussian

pulse = Gaussian(160, 0.1, 40)

if isinstance(pulse, Gaussian):
  print("This is Gaussian pulse.")
```
Questo codice deve essere aggiornato a
```
from qiskit.pulse.library import Gaussian

pulse = Gaussian(160, 0.1, 40)

if pulse.pulse_type == "Gaussian":
  print("This is Gaussian pulse.")
```
Per lo stesso motivo, non si dovrebbe accedere agli attributi della classe, come pulse.__class__.__name__ , per ottenere informazioni sul tipo di impulso.
L'eccezione qiskit.exceptions.QiskitIndexError è stata rimossa e non esiste più, come da avviso di deprecazione di qiskit-terra 0.18.0 (rilasciato il 12 luglio 2021).
Gli argomenti deprecati epsilon e factr per il costruttore della classe L_BFGS_B sono stati rimossi. Questi argomenti sono stati originariamente deprecati nella versione 0.18.0 (rilasciata il 12 luglio 2021). Si deve invece usare l'argomento ftol ; per maggiori dettagli sulla relazione tra questi argomenti, si può fare riferimento ai documenti di scipy sull'ottimizzatore.
I gestori di passaggi preimpostati per i livelli 1 e 2, che saranno utilizzati quando optimization_level=1 o optimization_level=2 con transpile() o generate_preset_pass_manager() e l'output da level_1_pass_manager() e level_2_pass_manager()utilizzeranno ora i file SabreLayout e SabreSwap per impostazione predefinita, al posto di quelli precedenti DenseLayout e StochasticSwap. Questa modifica è stata apportata per migliorare la qualità dell'output del transpiler, la combinazione SabreLayout e SabreSwap di solito si traduce in un minor numero di oggetti SwapGate oggetti inseriti nel circuito di uscita. Se si desidera utilizzare i passaggi predefiniti precedenti, è possibile impostare layout_method='dense' e routing_method='stochastic' su transpile() o generate_preset_pass_manager() per sfruttare DenseLayout e StochasticSwap rispettivamente.
L'uso implicito di approximation_degree!=1.0 per impostazione predefinita nella funzione transpile() quando è impostato optimization_level=3 è stato disabilitato. Il transpiler dovrebbe, per impostazione predefinita, preservare l'unitarietà dell'input fino alle trasformazioni note, come le permutazioni unilaterali e le trasformazioni di somiglianza. Questo è stato interrotto dall'uso precedente di approximation_degree=None che portava a risultati errati in casi come l'evoluzione Trotterizzata con molti passi temporali, dove gli unitari venivano approssimati eccessivamente, portando a risultati errati. È stato deciso che le trasformazioni che rompono l'equivalenza unitaria devono essere attivate esplicitamente dall'utente. Se si desidera il precedente comportamento predefinito, in cui le istruzioni sintetizzate di UnitaryGate sono approssimate fino ai tassi di errore delle istruzioni native del backend di destinazione, si può impostare esplicitamente approximation_degree=None quando si chiama transpile() con optimization_level=3, ad esempio:
```
transpile(circuit, backend, approximation_degree=None, optimization_level=3)
```
Modificare il valore predefinito del numero massimo di valutazioni di funzioni consentite (maxfun) in L_BFGS_B da 1000 a 15000, in modo che corrisponda al valore predefinito di SciPy. Questo numero corrisponde anche al numero di iterazioni predefinito (maxiter).
Aggiornato ProbDistribution e QuasiDistribution per memorizzare le informazioni sul numero di bit se vengono fornite stringhe di bit senza prefisso “0b”. ProbDistribution.binary_probabilities() e QuasiDistribution.binary_probabilities() utilizzare il numero di bit memorizzato come valore predefinito del numero di bit.
RZXCalibrationBuilder e RZXCalibrationBuilderNoEcho sono stati aggiornati per saltare i gate di stretching CX implementati da una sequenza di risonanza incrociata non eco (ECR) per evitare la terminazione del passaggio con errori imprevisti. Questi passaggi accettano il nuovo parametro verbose che controlla se i passaggi avvertono quando ciò si verifica. Se verbose=True è impostato, il passaggio genera un avviso all'utente quando riconosce una sequenza non ECR.
Il modulo di visualizzazione qiskit.visualization ha subito una riorganizzazione interna. Questo non dovrebbe influire sull'interfaccia pubblica, ma se si accedeva agli interni dei cassetti dei circuiti, questi potrebbero trovarsi in posti diversi. Le uniche parti del modulo di visualizzazione considerate pubbliche sono i componenti documentati in questa documentazione online.

Note di deprecazione

L'importazione dei nomi Int1, Int2, classical_function e BooleanExpression direttamente da qiskit.circuit è deprecata. Questo fa parte del progetto di rendere tweedledum una dipendenza opzionale piuttosto che un requisito completo. Si devono invece importare questi nomi da qiskit.circuit.classicalfunction.
I moduli qiskit.algorithms.factorizers e qiskit.algorithms.linear_solvers sono deprecati e saranno rimossi in una prossima versione. Sono sostituiti da esercitazioni nel libro di testo Qiskit: Shor HHL
Il sito random_stabilizer_table() è stato deprecato e sarà rimosso in una prossima versione. Si deve invece utilizzare la funzione random_pauli_list() deve essere utilizzata.
La funzione del modulo a impulsi qiskit.pulse.utils.deprecated_functionality è deprecata e sarà rimossa in una versione futura. Si trattava di una funzione prevalentemente interna. La stessa funzionalità è fornita da qiskit.utils.deprecate_function, che dovrebbe essere utilizzato al suo posto.
Il metodo di esecuzione delle primitive è stato modificato. I metodi BaseSampler.__call__() e BaseEstimator.__call__() sono stati deprecati. Ad esempio:
```
estimator = Estimator(...)
result = estimator(circuits, observables, parameters)

sampler = Sampler(...)
result = sampler(circuits, observables, parameters)
```
dovrebbe essere riscritto come
```
estimator = Estimator()
result = estimator.run(circuits, observables, parameter_values).result()

sampler = Sampler()
result = sampler.run(circuits, parameter_values).result()
```
L'uso di primitive come gestori di contesto è deprecato. Non tutte le primitive hanno un gestore di contesto disponibile. Se disponibile (ad esempio in qiskit-ibm-runtime), il gestore del contesto della sessione fornisce una funzionalità equivalente.

circuits, observables e parameters nel costruttore è stato deprecato. circuits e observables possono essere passati dai metodi run . run i metodi non supportano parameters. Gli utenti devono ricorrere ai valori dei parametri da soli.
L'argomento non utilizzato qubit_channel_mapping nei campi RZXCalibrationBuilder e RZXCalibrationBuilderNoEcho è stato deprecato e sarà rimosso in una prossima versione. Questo argomento non viene più utilizzato e non ha alcun effetto sul funzionamento dei passaggi.

Correzioni di bug

Corretto un problema in cui Pauli.evolve() e PauliList.evolve() sollevava un errore di tipo quando si evolveva con alcune porte di Clifford che modificavano la fase di Pauli. Corretto #8438
Corretto un bug in QuantumCircuit.initialize() e QuantumCircuit.prepare_state() che non accettavano un singolo Qubit come argomento per l'inizializzazione.
Il metodo QuantumCircuit.while_loop() risolverà ora i riferimenti classici ai bit nella sua condizione, nello stesso modo in cui i metodi QuantumCircuit.if_test() e InstructionSet.c_if() .
I DAGCircuit metodi depth(), size() e DAGCircuit.count_ops() in precedenza restituivano silenziosamente risultati che avevano poco o nessun significato se nel circuito era presente un flusso di controllo. Il depth() e size() ora lanciano correttamente un errore in questi casi, ma hanno un nuovo argomento per la parola chiave recurse , per consentire il calcolo di un valore proxy, mentre i metodi count_ops() per impostazione predefinita ricorrerà nei blocchi e conterà le operazioni al loro interno.
È stato risolto un problema nel passaggio DenseLayout in cui tutti gli oggetti sciolti (cioè non facenti parte di una classe) Qubit (cioè non facenti parte di un oggetto QuantumRegister) che facevano parte di un oggetto QuantumCircuit non venivano inclusi nell'output Layout generato dal passaggio.
Il metodo Operator.from_circuit() è stato aggiornato in modo da poter gestire l'output del layout da parte di transpile() e invertire correttamente la permutazione dei qubit causata dalla disposizione in tutti i casi. In precedenza, se il circuito transpilato utilizzava oggetti sciolti, più oggetti Qubit oggetti, più oggetti QuantumRegister o un singolo oggetto QuantumRegister con un nome diverso da "q" , il costruttore non sarebbe riuscito a creare un oggetto Operator dal circuito. Corretto #8800.
È stato risolto un problema a causa del quale la scomposizione di un'istruzione con un qubit e un bit classico contenente una singola porta quantica non riusciva. Ora la seguente decomposizione avviene come previsto:
```
block = QuantumCircuit(1, 1)
block.h(0)

circuit = QuantumCircuit(1, 1)
circuit.append(block, [0], [0])

decomposed = circuit.decompose()
```

Corretta l'inizializzazione della matrice simplettica vuota in from_symplectic() in PauliList ad esempio:

from qiskit.quantum_info.operators import PauliList

x = np.array([], dtype=bool).reshape((1,0))
z = np.array([], dtype=bool).reshape((1,0))
pauli_list = PauliList.from_symplectic(x, z)

Correggere un problema nel passaggio GateDirection per il passaggio di transpiler del file CZGate. Il gate CZ è simmetrico, quindi l'inversione degli argomenti dei qubit è consentita per far corrispondere la mappa di accoppiamento diretto.
Risolti i problemi con il metodo DerivativeBase.gradient_wrapper() quando si riutilizza un campionatore di circuito tra le chiamate e si legano i parametri annidati.
È stato risolto un problema nei cassetti dei circuiti mpl e latex , quando l'impostazione dell'opzione idle_wires su Falso in presenza di un barrier nel circuito causava il fallimento dei cassetti. Corretto #8313
Corretto un problema in circuit_drawer() e QuantumCircuit.draw() con il metodo latex , in cui veniva generato un OSError sui sistemi le cui directory temporanee (ad esempio /tmp) si trovano su un filesystem diverso da quello della directory di lavoro. Correzioni #8542
Annidamento di un elemento FlowController all'interno di un altro in una classe PassManager poteva in precedenza far sì che alcuni passaggi del transpiler venissero "dimenticati" durante la transpilazione, se i passaggi restituivano un nuovo elemento DAGCircuit invece di mutare il loro input. Gli elementi annidati FlowControllerora influenzano correttamente la trasposizione.
Confronto tra QuantumCircuit e DAGCircuitper l'uguaglianza era in precedenza non deterministico se i circuiti contenevano più di un registro dello stesso tipo (ad esempio, due o più registri QuantumRegisters), talvolta restituendo False anche se i registri erano identici. Ora confronta correttamente i circuiti con più registri.
L'esportatore di OpenQASM 2 (QuantumCircuit.qasm()) ora definirà correttamente i parametri dei qubit per le operazioni UnitaryGate che non hanno effetto su tutti i qubit su cui sono definiti. Corretto #8224.
Sono stati risolti due bug nel cassetto del circuito text . Queste apparivano quando vertical_compression era impostato su medium, che è il valore predefinito. La prima causava talvolta la sovrascrittura di testo o di cancelli e la seconda causava talvolta l'interruzione dei collegamenti tra un cancello e i suoi controlli. Vedere il numero 8588.
Corretto un problema con il UnitarySynthesis a causa del quale un circuito con porte a 1 qubit e un ingresso Target a volte falliva invece di elaborare il circuito come previsto.
Il passaggio del transpiler GateDirection rispetterà ora i valori disponibili per i parametri del gate quando gestirà gate parametrati con un parametro Target.
È stato risolto un problema nella classe SNOBFIT quando durante l'esecuzione del metodo veniva generato un errore interno se non erano specificati i limiti di ingresso minimize() se non venivano specificati i limiti di ingresso. Questo viene ora controllato al momento della chiamata per sollevare rapidamente un ValueError se nella chiamata mancano i limiti richiesti minimize() chiamata. Correzioni #8580
Corretto un problema nell'output callable del metodo get_energy_evaluation() del metodo VQD ora chiamerà correttamente il callback specificato quando viene eseguito. In precedenza il callback non veniva utilizzato in questo caso. Corretto #8575
È stato risolto un problema che si verificava quando circuit_drawer() veniva utilizzato con reverse_bits=True su un circuito privo di bit classici e che causava l'emissione di un avviso potenzialmente confuso relativo a cregbundle . Corretto #8690
L'esportatore di OpenQASM 3 (qiskit.qasm3) ora gestisce correttamente i built-in di OpenQASM (come reset e measure) che hanno una condizione classica applicata da c_if(). In precedenza la condizione sarebbe stata ignorata.
È stato risolto un problema con la classe SPSA che internamente cercava di raggruppare i lavori in lotti di dimensioni pari, sollevando un'eccezione se la creazione di lotti pari non era possibile. Il problema è stato risolto in modo che il batch dei lavori vada sempre a buon fine anche se non sono di dimensioni uniformi.
Corretto il comportamento di Layout.add() che potenzialmente causava l'invalidità dell'output di transpile() non fosse valido e contenesse più Qubit di quelli disponibili sul backend di destinazione. Fisso: #8667
Corretto un problema con la funzione state_to_latex() : il passaggio di una stringa latex all'argomento opzionale prefix della funzione generava un errore. Corretto #8460
La funzione state_to_latex() ha prodotto LaTeX non valido in presenza di valori prossimi allo zero, con conseguenti errori quando viene richiamata state_drawer() . Corretto #8169.
GradientDescent ora conterà correttamente il numero di iterazioni, valutazioni di funzioni e valutazioni del gradiente. Inoltre, la documentazione ora indica correttamente che il gradiente è approssimato da un metodo delle differenze finite in avanti.
Correzione degli avvisi di deprezzamento in NaturalGradientche ora utilizza il parametro StandardScaler per scalare i dati prima di applicare il modello se il parametro normalize è impostato su True.

Aer 0.11.0

Nessuna modifica

IBM Q Fornitore 0.19.2

Nessuna modifica

Questa pagina è stata utile?

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

Note di rilascio di Qiskit 0.39

0.39.5

Terra 0.22.4

Preludio

Correzioni di bug

Aer 0.11.2

IBM Q Fornitore 0.19.2

0.39.4

Terra 0.22.3

Aer 0.11.2

Nuove funzioni

Problemi noti

Correzioni di bug

IBM Q Fornitore 0.19.2

0.39.3

Terra 0.22.3

Preludio

Correzioni di bug

Aer 0.11.1

IBM Q Fornitore 0.19.2

0.39.2

Terra 0.22.2

Preludio

Correzioni di bug

Aer 0.11.1

IBM Q Fornitore 0.19.2

0.39.1

Terra 0.22.1

Preludio

Note di deprecazione

Correzioni di bug

Aer 0.11.1

Correzioni di bug

IBM Q Fornitore 0.19.2

0.39.0

Terra 0.22.0

Preludio

Nuove funzioni

Relativo al layout

Relativo al routing

Relativo alla traduzione

Relativo all'ottimizzazione

Note sull'aggiornamento

Note di deprecazione

Correzioni di bug

Aer 0.11.0

IBM Q Fornitore 0.19.2