Note di rilascio di Qiskit 0.25

0.25.4

Terra 0.17.2

Preludio

Si tratta di una versione con correzione di bug che risolve diversi problemi della versione 0.17.1. La cosa più importante è che questo rilascio risolve la compatibilità della classe QuantumInstance quando viene eseguita su backend che si basano sulla classe BackendV1 classe astratta. Questo risolve tutti gli algoritmi e le applicazioni costruite su qiskit.algorithms o qiskit.opflow quando vengono eseguite su backend più recenti.

Correzioni di bug

È stato risolto un problema con il passaggio BasisTranslator che in alcuni casi traduceva le porte già presenti nella base di destinazione. Ciò comporterebbe potenzialmente tempi di esecuzione più lunghi e risultati meno ottimali. Corretto #6085
Corretto un problema in SPSA quando l'ottimizzatore veniva inizializzato con una funzione di callback tramite il kwarg callback , che poteva causare un errore.
Corretto un problema in cui i kwarg qiskit.quantum_info.Statevector.expectation_value() e qiskit.quantum_info.DensityMatrix.expectation_value`methods where the ``qargs`() kwarg veniva ignorato se l'operatore era un Pauli o SparsePauliOp un oggetto operatore. Corretto #6303
È stato risolto un problema nel metodo qiskit.quantum_info.Pauli.evolve() che poteva causare la restituzione di un Pauli errato quando si evolveva con un metodo CZGate, CYGate, o un SwapGate cancello.
Corretto un problema nel metodo qiskit.opflow.SparseVectorStateFn.to_dict_fn() , che in precedenza aveva al massimo una voce per lo stato tutto zero a causa di un errore di indice.
Corretto un problema nel metodo qiskit.opflow.SparseVectorStateFn.equals() in modo che restituisca correttamente True o False invece di un confronto tra vettori sparsi dei singoli elementi.
Corregge un problema nel file Statevector e DensityMatrix metodi di probabilità qiskit.quantum_info.Statevector.probabilities(), qiskit.quantum_info.Statevector.probabilities_dict(), qiskit.quantum_info.DensityMatrix.probabilities(), qiskit.quantum_info.DensityMatrix.probabilities_dict() dove le probabilità restituite potrebbero avere un ordinamento errato per alcuni valori di qargs kwarg. Corretto #6320
È stato risolto un problema per cui la classe TaperedPauliSumOp non supportava la moltiplicazione con ParameterExpression e inoltre non disponeva di un metodo assign_parameters() necessario per lavorare con gli oggetti ParameterExpression oggetti. Corretto #6127
Corretta la compatibilità della classe QuantumInstance quando viene eseguita su backend che si basano sulla classe BackendV1 classe astratta. Corretto #6280

Aer 0.8.2

Nessuna modifica

Ignis 0.6.0

Nessuna modifica

Acqua 0.9.1

Nessuna modifica

IBM Q Fornitore 0.12.3

Nessuna modifica

0.25.3

Terra 0.17.1

Nessuna modifica

Aer 0.8.2

Problemi noti

SaveExpectationValue e SaveExpectationValueVariance sono stati disabilitati per il metodo extended_stabilizer di QasmSimulator e AerSimulator a causa della restituzione di un valore errato per alcune componenti dell'operatore di Pauli. Per ulteriori informazioni ed esempi, consultare il documento #1227 <https://github.com/Qiskit/qiskit-aer/issues/1227>.

Correzioni di bug

Corregge un problema di prestazioni legato all'impostazione dell'attributo di configurazione basis_gates . In precedenza si verificavano effetti collaterali indesiderati per la classe backend che potevano causare un aumento del tempo di esecuzione della simulazione ripetuta. Per ulteriori informazioni ed esempi, consultare il documento #1229 <https://github.com/Qiskit/qiskit-aer/issues/1229>.
Corregge un bug con l'istruzione del simulatore "multiplexer" in cui l'ordine dei qubit di destinazione e di controllo era invertito rispetto all'ordine dell'istruzione Qiskit.
Corregge un bug introdotto in 0.8.0 per cui le simulazioni su GPU allocavano memoria host non necessaria in aggiunta alla memoria della GPU.
Corregge un errore nel metodo di simulazione stabilizer di QasmSimulator e AerSimulator per cui il valore di aspettativa per save_expectation_value e snapshot_expectation_value poteva avere un segno errato per alcuni Y Pauli.

Ignis 0.6.0

Nessuna modifica

Acqua 0.9.1

Nessuna modifica

IBM Q Fornitore 0.12.3

Nessuna modifica

0.25.2

Terra 0.17.1

Nessuna modifica

Aer 0.8.1

Nessuna modifica

Ignis 0.6.0

Nessuna modifica

Acqua 0.9.1

Nessuna modifica

IBM Q Fornitore 0.12.3

Altre note

L'attributo qiskit.providers.ibmq.experiment.analysis_result.AnalysisResult fit è ora facoltativo.

0.25.1

Terra 0.17.1

Preludio

Si tratta di una versione con correzione di bug che risolve diversi problemi della versione 0.17.0. Soprattutto questo rilascio corregge il pacchetto sdist costruito in modo errato per il rilascio 0.17.0, che non era effettivamente compilabile e bloccava l'installazione su piattaforme senza binari precompilati disponibili.

Correzioni di bug

Corretto un problema per cui l'attributo global_phase non veniva conservato nell'oggetto di output QuantumCircuit quando il metodo qiskit.circuit.QuantumCircuit.reverse_bits() è stato richiamato. Ad esempio:

import math
from qiskit import QuantumCircuit

qc = QuantumCircuit(3, 2, global_phase=math.pi)
qc.h(0)
qc.s(1)
qc.cx(0, 1)
qc.measure(0, 1)
qc.x(0)
qc.y(1)

reversed = qc.reverse_bits()
print(reversed.global_phase)

ora stamperà correttamente $\pi$ .

Corretto un problema per cui il passaggio del transpiler Unroller non preservava la fase globale nel caso di istruzioni annidate con una regola nella loro definizione. Corretto #6134
È stato risolto un problema a causa del quale l'attributo parameter di un oggetto ControlledGate costruito da un oggetto UnitaryGate non veniva impostato sulla matrice unitaria dell'oggetto UnitaryGate . In precedenza, control() costruiva una matrice ControlledGate con l'attributo parameter impostato sulla versione controllata della matrice UnitaryGate . Questo porterebbe a una modifica di parameter dell'oggetto di base UnitaryGate e le successive chiamate a inverse() creava l'inverso di un oggetto UnitaryGate a doppio controllo. Corretto #5750
Corretto un problema con i gestori dei passaggi preimpostati level_0_pass_manager e level_1_pass_manager (che corrispondono a optimization_level 0 e 1 per transpile()) che in alcuni casi producevano circuiti che non rientravano nella base richiesta.
Correzione di un bug a causa del quale l'utilizzo di SPSA con la calibrazione automatica del tasso di apprendimento e della perturbazione (ad es. learning_rate e perturbation sono None nell'inizializzatore), memorizza la calibrazione per tutte le ottimizzazioni future. La calibrazione deve invece essere effettuata per ogni nuova funzione obiettivo.

Aer 0.8.1

Correzioni di bug

È stato risolto un problema relativo all'uso del metodo matrix_product_state dei simulatori AerSimulator e QasmSimulator quando si esegue una simulazione rumorosa con errori di Kraus. In precedenza, il metodo di simulazione di stato del prodotto matriciale non propaga le modifiche ai qubit vicini dopo l'applicazione della matrice di Kraus. Il problema è stato risolto in modo che l'output della simulazione sia corretto. Corretti #1184 e #1205
È stato risolto un problema per cui l'istruzione qiskit.extensions.Initialize disabilitava l'ottimizzazione del campionamento delle misure per i metodi di simulazione statevector e matrix_product_state dei simulatori AerSimulator e QasmSimulator , anche quando era la prima istruzione del circuito o veniva applicata a tutti i qubit e quindi era deterministica. Corretto #1210
Risolvere un problema con le istruzioni SaveStatevector e SnapshotStatevector quando vengono utilizzate con il metodo di simulazione extended_stabilizer dei simulatori AerSimulator e QasmSimulator , che restituisce un vettore di stato non normalizzato. Corretto #1196
Il metodo di simulazione matrix_product_state supporta ora l'istruzione set state, precedentemente mancante, qiskit.providers.aer.library.SetMatrixProductState, che consente di impostare lo stato di una simulazione in un circuito.

Ignis 0.6.0

Nessuna modifica

Acqua 0.9.1

IBM Q Fornitore 0.12.2

Nessuna modifica

0.25.0

Questa versione elimina ufficialmente il progetto Qiskit Aqua. Di conseguenza, in una futura release il pacchetto qiskit-aqua sarà rimosso dal metapacchetto Qiskit, il che significa che in quella futura release pip install qiskit non includerà più qiskit-aqua. I moduli applicativi forniti da qiskit-aqua sono stati suddivisi in diversi nuovi pacchetti: qiskit-optimization, qiskit-nature, qiskit-machine-learning, e qiskit-finance. Questi pacchetti possono essere installati da soli (tramite il comando standard pip install, ad esempio pip install qiskit-nature) o con il resto del metapacchetto Qiskit come extra opzionali (ad es. pip install 'qiskit[finance,optimization]' o pip install 'qiskit[all]' Gli algoritmi di base e il flusso di operatori sono ora disponibili come parte di qiskit-terra all'indirizzo qiskit.algorithms e qiskit.opflow. A seconda dell'uso che si fa di Aqua, si possono utilizzare i pacchetti applicativi o i nuovi moduli di Qiskit Terra. Per maggiori dettagli su come migrare da Qiskit Aqua, potete consultare la guida alla migrazione.

Terra 0.17.0

Preludio

Qiskit Terra 0.17.0 include molte nuove funzionalità e correzioni di bug. La novità principale di questa versione è l'introduzione degli elementi qiskit.algorithms e qiskit.opflow che sono stati migrati e adattati dal progetto qiskit.aqua .

Nuove funzioni

La funzione qiskit.pulse.call() può ora accettare un Parameter insieme a una subroutine parametrizzata. Questo permette di assegnare valori diversi agli Parameter oggetti per ogni chiamata di subroutine.

Ad esempio:

from qiskit.circuit import Parameter
from qiskit import pulse

amp = Parameter('amp')

with pulse.build() as subroutine:
    pulse.play(pulse.Gaussian(160, amp, 40), DriveChannel(0))

with pulse.build() as main_prog:
    pulse.call(subroutine, amp=0.1)
    pulse.call(subroutine, amp=0.3)

Il campo qiskit.providers.models.QasmBackendConfiguration ha un nuovo campo processor_type che può essere usato facoltativamente per fornire informazioni sul processore di un backend nella forma: {"family": <str>, "revision": <str>, segment: <str>}. Ad esempio: {"family": "Canary", "revision": "1.0", segment: "A"}.
Le classi qiskit.pulse.Schedule, qiskit.pulse.Instruction e qiskit.pulse.Channel hanno ora una proprietà parameter che restituisce tutti gli oggetti Parameter utilizzati nell'oggetto e un metodo is_parameterized() che restituisce True se nell'oggetto sono utilizzati dei parametri.

Ad esempio:
```
from qiskit.circuit import Parameter
from qiskit import pulse

shift = Parameter('alpha')

schedule = pulse.Schedule()
schedule += pulse.SetFrequency(shift, pulse.DriveChannel(0))

assert schedule.is_parameterized() == True
print(schedule.parameters)
```

Aggiunto un PiecewiseChebyshev all'opzione qiskit.circuit.library per l'implementazione di un'approssimazione di Chebyshev a tratti di una funzione di ingresso. Per una data funzione $f(x)$ e grado $d$ , questa classe implementa un'approssimazione polinomiale piecewise Chebyshev su $n$ qubit a $f(x)$ sugli intervalli dati. Tutti i polinomi dell'approssimazione sono di grado $d$ .

Ad esempio:

import numpy as np
from qiskit import QuantumCircuit
from qiskit.circuit.library.arithmetic.piecewise_chebyshev import PiecewiseChebyshev
f_x, degree, breakpoints, num_state_qubits = lambda x: np.arcsin(1 / x), 2, [2, 4], 2
pw_approximation = PiecewiseChebyshev(f_x, degree, breakpoints, num_state_qubits)
pw_approximation._build()
qc = QuantumCircuit(pw_approximation.num_qubits)
qc.h(list(range(num_state_qubits)))
qc.append(pw_approximation.to_instruction(), qc.qubits)
qc.draw(output='mpl')

La BackendProperties ha ora un metodo readout_length() che restituisce la lunghezza di lettura [sec] del qubit dato.
Una nuova classe, ScheduleBlockè stata aggiunta al modulo qiskit.pulse modulo. Questa classe fornisce una nuova rappresentazione di un programma a impulsi. Questa rappresentazione è più adatta alla sintassi del costruttore di impulsi e si basa sull'ordinamento relativo delle istruzioni.

Questa rappresentazione prende alignment_context invece di specificare il tempo di inizio t0 per ogni istruzione. Il tempo di inizio dell'istruzione è implicitamente assegnato con la trasformazione specificata e la posizione relativa delle istruzioni.

Il ScheduleBlock permette di programmare le istruzioni in modo pigro, cioè di assegnare parametri arbitrari alla durata delle istruzioni.

Ad esempio:
```
from qiskit.pulse import ScheduleBlock, DriveChannel, Gaussian
from qiskit.pulse.instructions import Play, Call
from qiskit.pulse.transforms import AlignRight
from qiskit.circuit import Parameter

dur = Parameter('rabi_duration')

block = ScheduleBlock(alignment_context=AlignRight())
block += Play(Gaussian(dur, 0.1, dur/4), DriveChannel(0))
block += Call(measure_sched)  # subroutine defined elsewhere
```
questo codice definisce un esperimento di scansione della durata di un impulso gaussiano seguito da una misura measure_sched, cioè un esperimento Rabi. È possibile riutilizzare l'oggetto block per ogni durata scansionata, assegnando un valore di durata target.

Aggiunta di una nuova funzione array_to_latex() al modulo qiskit.visualization che può essere utilizzata per rappresentare e visualizzare vettori e matrici con LaTeX.

from qiskit.visualization import array_to_latex
from numpy import sqrt, exp, pi
mat = [[0, exp(pi*.75j)],
       [1/sqrt(8), 0.875]]
array_to_latex(mat)

Il Statevector e DensityMatrix hanno ora i metodi draw() che consentono di disegnare gli oggetti come matrici di testo, oggetti IPython Latex, sorgenti Latex, sfere Q, sfere Bloch e grafici Hinton. Per impostazione predefinita, il tipo di output è l'output equivalente di __repr__ , ma questo valore predefinito può essere modificato in un file di configurazione utente impostando l'opzione state_drawer . Ad esempio:
```
from qiskit.quantum_info import DensityMatrix
dm = DensityMatrix.from_label('r0')
dm.draw('latex')
```
```
from qiskit.quantum_info import Statevector
sv = Statevector.from_label('+r')
sv.draw('qsphere')
```
Inoltre, il metodo draw() è ora usato per la visualizzazione ipython di queste classi, quindi se si cambia il tipo di output predefinito in un file di configurazione utente, quando un oggetto Statevector o un oggetto DensityMatrix vengono visualizzati in un blocco note di jupyter, verrà utilizzato quel tipo di output per l'oggetto.
Oggetti qiskit.pulse.Instruction e oggetti parametrici a impulsi (ad es Gaussian supporta ora l'uso di Parameter e ParameterExpression per il parametro duration . Ad esempio:
```
from qiskit.circuit import Parameter
from qiskit.pulse import Gaussian

dur = Parameter('x_pulse_duration')
double_dur = dur * 2
rx_pulse = Gaussian(dur, 0.1, dur/4)
double_rx_pulse = Gaussian(double_dir, 0.1, dur/4)
```
Si noti che, mentre è possibile creare un'istruzione con un parametro duration , l'aggiunta di un'istruzione con un parametro non vincolato duration a un programma è supportata solo dalla rappresentazione recentemente introdotta ScheduleBlock. Per maggiori dettagli, consultare la sezione delle note di rilascio sui problemi noti.

Il run() metodo per il QasmSimulatorPy, StatevectorSimulatorPy, e UnitarySimulatorPy accetta ora un elemento QuantumCircuit (o un elenco di oggetti QuantumCircuit ) come input. L'oggetto precedente QasmQobj è ancora supportato per ora, ma sarà deprecato in una versione futura.

Per un esempio di utilizzo si veda:

from qiskit import transpile, QuantumCircuit

from qiskit.providers.basicaer import BasicAer

backend = BasicAer.get_backend('qasm_simulator')

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

tqc = transpile(circuit, backend)
result = backend.run(tqc, shots=4096).result()

Il passo del transpiler CommutativeCancellation ha un nuovo kwarg opzionale sul costruttore basis_gates, che prende un elenco di nomi di porte di base per il backend di destinazione. Se specificato, il passaggio utilizzerà solo i cancelli del kwarg basis_gates . In precedenza, il passaggio sostituiva automaticamente i cancelli consecutivi che si incrociavano con ZGate con la porta U1Gate incondizionatamente. Il kwarg basis_gates consente di specificare quali porte di rotazione z sono presenti nella base di destinazione per evitare questo problema.
I costruttori della Bit e delle sottoclassi, Qubit, Clbit, e AncillaQubitsono stati aggiornati in modo che i loro due parametri, register e index , siano ora opzionali. Ciò consente di creare oggetti bit indipendenti da un registro.

Una nuova classe, BooleanExpressionè stata aggiunta al modulo qiskit.circuit.classicalfunction modulo. Questa classe consente di creare un oracolo a partire da un'espressione booleana Python. Ad esempio:

from qiskit.circuit import BooleanExpression, QuantumCircuit

expression = BooleanExpression('~x & (y | z)')
circuit = QuantumCircuit(4)
circuit.append(expression, [0, 1, 2, 3])
circuit.draw('mpl')

circuit.decompose().draw('mpl')

Il BooleanExpression include anche un metodo, from_dimacs_file()che consente di caricare formule descritte nel formato DIMACS-CNF. Ad esempio:

from qiskit.circuit import BooleanExpression, QuantumCircuit

boolean_exp = BooleanExpression.from_dimacs_file("simple_v3_c2.cnf")
circuit = QuantumCircuit(boolean_exp.num_qubits)
circuit.append(boolean_exp, range(boolean_exp.num_qubits))
circuit.draw('text')

     ┌───────────────────┐
q_0: ┤0                  ├
     │                   │
q_1: ┤1                  ├
     │  SIMPLE_V3_C2.CNF │
q_2: ┤2                  ├
     │                   │
q_3: ┤3                  ├
     └───────────────────┘

circuit.decompose().draw('text')

q_0: ──o────o────────────
       │    │
q_1: ──■────o────■───────
       │    │    │
q_2: ──■────┼────o────■──
     ┌─┴─┐┌─┴─┐┌─┴─┐┌─┴─┐
q_3: ┤ X ├┤ X ├┤ X ├┤ X ├
     └───┘└───┘└───┘└───┘

Aggiunta di una nuova classe, PhaseOracleè stata aggiunta al modulo qiskit.circuit.library modulo. Questa classe consente di costruire circuiti di oracoli di fase a partire da espressioni booleane di Python.

from qiskit.circuit.library.phase_oracle import PhaseOracle

oracle = PhaseOracle('x1 & x2 & (not x3)')
oracle.draw('mpl')

Questi oracoli di fase possono essere utilizzati come parte di un algoritmo più ampio, ad esempio con qiskit.algorithms.AmplificationProblem:

from qiskit.algorithms import AmplificationProblem, Grover
from qiskit import BasicAer

backend = BasicAer.get_backend('qasm_simulator')

problem = AmplificationProblem(oracle, is_good_state=oracle.evaluate_bitstring)
grover = Grover(quantum_instance=backend)
result = grover.amplify(problem)
result.top_measurement

La PhaseOracle include anche un metodo from_dimacs_file() che consente di costruire un oracolo di fase a partire da un file che descrive una formula nel formato DIMACS-CNF.

from qiskit.circuit.library.phase_oracle import PhaseOracle

oracle = PhaseOracle.from_dimacs_file("simple_v3_c2.cnf")
oracle.draw('text')

state_0: ─o───────o──────────────
          │ ┌───┐ │ ┌───┐
state_1: ─■─┤ X ├─■─┤ X ├─■──────
          │ └───┘   └───┘ │ ┌───┐
state_2: ─■───────────────o─┤ Z ├
                            └───┘

Tutti i passaggi del transpiler (cioè tutte le istanze di BasePass) sono ora direttamente richiamabili. La chiamata di un passaggio fornisce una comoda interfaccia per l'esecuzione del passaggio su un oggetto QuantumCircuit oggetto.

Ad esempio, l'esecuzione di un singolo passaggio di trasformazione, come ad esempio BasisTranslatorpuò essere eseguita con:

from qiskit import QuantumCircuit
from qiskit.transpiler.passes import BasisTranslator
from qiskit.circuit.equivalence_library import SessionEquivalenceLibrary as sel

circuit = QuantumCircuit(1)
circuit.h(0)

pass_instance = BasisTranslator(sel, ['rx', 'rz', 'cx'])
result = pass_instance(circuit)
result.draw(output='mpl')

Quando si esegue un passaggio di analisi, un set di proprietà (come dict o come PropertySet) deve essere aggiunto come parametro e può essere modificato "in-place". Ad esempio:

from qiskit import QuantumCircuit
from qiskit.transpiler.passes import Depth

circuit = QuantumCircuit(1)
circuit.h(0)

property_set = {}
pass_instance = Depth()
pass_instance(circuit, property_set)
print(property_set)

La classe QasmQobjConfig ha ora un kwarg opzionale per meas_level e meas_return. Questi campi possono essere utilizzati per generare QasmQobj di lavori che supportano meas_level=1 (dati kerneled) per i lavori di circuito (in precedenza questo era esposto solo per gli PulseQobj oggetti). La funzione assemble() è stata aggiornata per impostare questo campo per gli oggetti QasmQobj oggetti che genera.
Un nuovo tensor() è stato aggiunto alla classe QuantumCircuit classe. Questo metodo consente di tensorizzare un altro circuito con un circuito esistente. Questo metodo funziona in modo analogo a qiskit.quantum_info.Operator.tensor() ed è coerente con la convenzione little-endian di Qiskit.

Ad esempio:
```
from qiskit import QuantumCircuit
top = QuantumCircuit(1)
top.x(0);
bottom = QuantumCircuit(2)
bottom.cry(0.2, 0, 1);
bottom.tensor(top).draw(output='mpl')
```
La classe qiskit.circuit.QuantumCircuit supporta ora metadati liberi arbitrari con l'attributo metadata con l'attributo. Un utente (o un programma costruito sopra QuantumCircuit) può allegare metadati a un circuito per poterlo rintracciare. Ad esempio:
```
from qiskit.circuit import QuantumCircuit

qc = QuantumCircuit(2, user_metadata_field_1='my_metadata',
                    user_metadata_field_2='my_other_value')
```
oppure:
```
from qiskit.circuit import QuantumCircuit

qc = QuantumCircuit(2)
qc.metadata = {'user_metadata_field_1': 'my_metadata',
               'user_metadata_field_2': 'my_other_value'}
```
Questi metadati non vengono utilizzati per influenzare l'esecuzione del circuito, ma solo per tracciare il circuito per tutta la durata dell'oggetto. L'attributo metadata persisterà tra le trasformazioni del circuito, comprese quelle di transpile() e assemble(). L'aspettativa è che i provider associno i metadati ai risultati che restituiscono, in modo che gli utenti possano filtrare i risultati in base ai metadati del circuito, come possono fare attualmente con QuantumCircuit.name.
Aggiungere una nuova classe di operatori CNOTDihedral è stata aggiunta al modulo qiskit.quantum_info al modulo. Questa classe è utilizzata per rappresentare il gruppo CNOT-Diedrale, che è generato dalle porte quantiche CXGate, TGate, e XGate.
Aggiunge un operatore binario & (__and__) alle sottoclassi di BaseOperator (es qiskit.quantum_info.Operator) nel modulo qiskit.quantum_info modulo. Si tratta di un'abbreviazione per chiamare il metodo delle classi compose() (cioè A & B == A.compose(B)).

Ad esempio:
```
import qiskit.quantum_info as qi

qi.Pauli('X') & qi.Pauli('Y')
```
Aggiunge un operatore binario & (__and__) a qiskit.quantum_info.Statevector e qiskit.quantum_info.DensityMatrix classi. Si tratta di un'abbreviazione per chiamare il metodo delle classi evolve() (cioè psi & U == psi.evolve(U)).

Ad esempio:
```
import qiskit.quantum_info as qi

qi.Statevector.from_label('0') & qi.Pauli('X')
```
Un nuovo gate a 2 qubit, ECRGate, la risonanza incrociata dell'eco (ECR), è stato aggiunto al modulo qiskit.circuit.library modulo, insieme a un metodo corrispondente, ecr() per la QuantumCircuit classe. Il gate ECR è costituito da due impulsi $CR(\frac{π}{4})$ con un intervallo di tempo tra di essi per l'eco XGate tra di loro per l'eco. Questo gate è localmente equivalente a un CXGate (può essere convertito in un CNOT con pre- o post-rotazione locale). È il gate nativo sull'hardware attuale di IBM e la compilazione su di esso consente di unire le pre/post-rotazioni al resto del circuito.
È stato aggiunto un nuovo kwarg approximation_degree alla funzione transpile() per abilitare la compilazione approssimativa. I valori validi vanno da 0 a 1, e un valore più alto indica una minore approssimazione. Si tratta di un quadrante euristico per sperimentare le approssimazioni dei circuiti. L'interpretazione concreta di questo numero è lasciata a ciascun passaggio, che può utilizzarlo per eseguire una versione approssimata del passaggio. Esempi specifici sono il UnitarySynthesis o i traduttori di gate discreti. Se un passaggio non supporta questa opzione, implica una trasformazione esatta.
Due nuovi transpiler passess, GateDirection e qiskit.transpiler.passes.CheckGateDirectionsono stati aggiunti al modulo qiskit.transpiler.passes al modulo. Questi nuovi passaggi sono intesi come sostituzioni più generali di CXDirection e CheckCXDirection (che sono entrambi deprecati, si vedano le note di deprecazione per maggiori dettagli) che svolgono la stessa funzione, ma funzionano con altri gate oltre al semplice CXGate.
Quando si esegue su Windows, l'esecuzione parallela con la funzione parallel_map() può essere abilitata (per impostazione predefinita è ancora disabilitata). Per fare ciò, si può impostare parallel = True in un file di configurazione utente, oppure impostare la variabile d'ambiente QISKIT_PARALLEL su TRUE (questo avrà effetto anche su transpile() e assemble() che utilizzano entrambi parallel_map() internamente). È importante notare che quando si abilita il parallelismo su Windows ci sono limitazioni sul modo in cui Python lancia i processi per Windows; per ulteriori dettagli sulle limitazioni dell'esecuzione parallela su Windows, consultare la sezione Problemi noti.
È stata aggiunta una nuova funzione, hellinger_distance()per il calcolo della distanza di Hellinger tra due distribuzioni di conteggi è stata aggiunta al modulo qiskit.quantum_info modulo.
La funzione decompose_clifford() del modulo qiskit.quantum_info (che viene utilizzata internamente dal metodo qiskit.quantum_info.Clifford.to_circuit() ) ha un nuovo kwarg method che consente di selezionare il metodo di sintesi utilizzato impostandolo su 'AG' o 'greedy'. Per impostazione predefinita, per più di tre qubit è impostato su 'greedy' , che utilizza una routine di compilazione greedy non ottimale per la sintesi di elementi Clifford, di Bravyi et al. al, che in genere produce un costo CX migliore rispetto al metodo Aaronson-Gottesman usato in precedenza (per più di due qubit). È possibile utilizzare il kwarg method per tornare al precedente metodo predefinito di Aaronson-Gottesman impostando method='AG'.
La classe Initialize del modulo qiskit.extensions può ora essere costruita utilizzando un intero. I bit '1' dell'intero inseriranno un Reset e un XGate nel circuito del qubit corrispondente. Questo verrà fatto utilizzando la convenzione standard little-endian di qiskit, ovvero il bit più a destra dell'intero imposterà il qubit 0. Ad esempio, impostando il parametro in Initialize uguale a 5 , i qubit 0 e 2 assumono il valore 1.
```
from qiskit.extensions import Initialize

initialize = Initialize(13)
initialize.definition.draw('mpl')
```
La classe Initialize del modulo qiskit.extensions supporta ora la costruzione direttamente da un'etichetta di Pauli (analogamente al metodo qiskit.quantum_info.Statevector.from_label() ). L'etichetta Pauli si riferisce agli stati base degli autostati di Pauli Z, X e Y. Queste etichette utilizzano la notazione little-endian standard di Qiskit, ad esempio un'etichetta di '01' inizializzerebbe il qubit 0 a $|1\rangle$ e il qubit 1 a $|0\rangle$ .
```
from qiskit.extensions import Initialize

initialize = Initialize("10+-lr")
initialize.definition.draw('mpl')
```
Il kwarg, template_list, per il costruttore del passaggio di transpiler qiskit.transpiler.passes.TemplateOptimization supporta ora l'inserimento di un elenco di elementi sia di tipo QuantumCircuit e DAGDependency e di oggetti. In precedenza, venivano accettati solo gli elementi QuantumCircuit (che venivano internamente convertiti in oggetti DAGDependency ) nell'elenco di input.
È stato introdotto un nuovo transpiler pass, qiskit.transpiler.passes.RZXCalibrationBuilderin grado di generare calibrazioni e di aggiungerle a un circuito quantistico. Questo passaggio prende gli oggetti calibrati CXGate e crea le calibrazioni per qiskit.circuit.library.RZXGate oggetti con un angolo di rotazione arbitrario. I programmi vengono creati allungando e comprimendo gli impulsi GaussianSquare delle porte a risonanza incrociata con eco.
Nuovi circuiti di template per l'utilizzo di qiskit.circuit.library.RZXGate vengono aggiunti al modulo qiskit.circuit.library (ad esempio rzx_yz). Questo permette di associare il TemplateOptimization con il passo qiskit.transpiler.passes.RZXCalibrationBuilder per trovare e sostituire automaticamente sequenze di porte, come CNOT - P(theta) - CNOT, con circuiti più efficienti basati su una calibrazione qiskit.circuit.library.RZXGate con una calibrazione.
Il tipo di output di matplotlib per gli elementi circuit_drawer() e il metodo draw() per la classe QuantumCircuit supportano ora i file di configurazione per impostare lo stile di visualizzazione. Nelle versioni precedenti, esisteva una funzionalità di base che consentiva agli utenti di passare un kwarg style che prendeva in considerazione un dict per personalizzare i colori e altre caratteristiche di visualizzazione del cassetto mpl . Questo è stato ampliato in modo che questi dizionari possano essere caricati direttamente da file JSON senza dover passare un dizionario. Ciò consente agli utenti di creare nuovi file di stile e di usare quello stile per le visualizzazioni, passando il nome del file di stile come stringa al kwarg style .

Per sfruttare questa funzione è necessario impostare l'opzione circuit_mpl_style_path in un file di configurazione utente. Questa opzione deve essere impostata sul percorso in cui si desidera che qiskit cerchi i file JSON di stile. Se si specificano più voci di percorso, queste devono essere separate da :. Ad esempio, impostando circuit_mpl_style_path = ~/.qiskit:~/user_styles in un file di configurazione utente, si cercheranno i file JSON sia in ~/.qiskit che in ~/user_styles.

Alla funzione marginal_counts() è stato aggiunto un nuovo kwarg, format_marginal , che, se impostato su True , formatta l'output dei conteggi in base a cregs nel circuito e gli indici mancanti sono rappresentati con un _. Ad esempio:

from qiskit import QuantumCircuit, execute, BasicAer, result
from qiskit.result.utils import marginal_counts
qc = QuantumCircuit(5, 5)
qc.x(0)
qc.measure(0, 0)

result = execute(qc, BasicAer.get_backend('qasm_simulator')).result()
print(marginal_counts(result.get_counts(), [0, 2, 4], format_marginal=True))

Miglioramento delle prestazioni di qiskit.quantum_info.Statevector.expectation_value() e qiskit.quantum_info.DensityMatrix.expectation_value() quando l'operatore argomento è un operatore Pauli o SparsePauliOp .
Il file di configurazione utente ha 2 nuove opzioni di configurazione, num_processes e parallel, che servono a controllare il comportamento predefinito di parallel_map(). L'opzione parallel è un booleano che viene utilizzato per stabilire se il programma parallel_map() verrà eseguito in più processi o meno. Se è impostato su False , le chiamate a parallel_map() saranno eseguite in modo seriale, mentre impostando True si abilita l'esecuzione parallela. L'opzione num_processes accetta un numero intero che imposta il numero di CPU da utilizzare per l'esecuzione in parallelo. Per impostazione predefinita, utilizza il numero di core della CPU di un sistema.
Ci sono due nuove variabili d'ambiente, QISKIT_PARALLEL e QISKIT_NUM_PROCS, che possono essere usate per controllare il comportamento predefinito di parallel_map(). L'opzione QISKIT_PARALLEL può essere impostata all'indirizzo TRUE (qualsiasi capitalizzazione) per impostare l'esecuzione predefinita in più processi quando viene richiamato il comando parallel_map() viene chiamato. Se è impostato su qualsiasi altro valore parallel_map() verrà eseguito in modo seriale. QISKIT_NUM_PROCS prende un numero intero (per esempio QISKIT_NUM_PROCS=5) che sarà usato come numero predefinito di processi da eseguire. Entrambi avranno la precedenza sull'opzione equivalente impostata nel file di configurazione dell'utente.
Un nuovo metodo, gradient()è stato aggiunto alla classe ParameterExpression classe. Questo metodo viene utilizzato per valutare il gradiente di un oggetto ParameterExpression oggetto.
Il metodo __eq__ (ovvero quello che viene chiamato quando si utilizza l'operatore == ) per il parametro ParameterExpression consente ora il confronto con un valore numerico. In precedenza era possibile confrontare solo due istanze di ParameterExpression con ==. Ad esempio:
```
from qiskit.circuit import Parameter

x = Parameter("x")
y = x + 2
y = y.assign(x, -1)

assert y == 1
```
La PauliFeatureMap nel modulo qiskit.circuit.library supporta ora la regolazione del fattore di rotazione, $\alpha$ , sia impostando il kwarg alpha sul costruttore, sia impostando l'attributo alpha dopo la creazione. In precedenza questo valore era fissato a 2.0. La regolazione di questo attributo consente un migliore controllo dei confini decisionali e fornisce un'ulteriore flessibilità nella gestione delle caratteristiche di input senza la necessità di scalarle esplicitamente nel set di dati.
Una nuova Gate classe, PauliGateè stato aggiunto il modulo qiskit.circuit.library e il metodo corrispondente, pauli()è stato aggiunto alla classe QuantumCircuit classe. Questa nuova classe di gate consente di applicare contemporaneamente più gate pauli individuali a diversi qubit. Ciò è utile soprattutto per i simulatori che possono utilizzare questa nuova porta per implementare in modo più efficiente più porte Pauli simultanee.
Migliorare il qiskit.quantum_info.Pauli operatore. Questa classe rappresenta ora un elemento dell'intero gruppo di Pauli a N-qubit, compresi i coefficienti complessi. Ora supporta i metodi API dell'operatore, tra cui compose(), dot(), tensor() eccetera, dove i termini "compose" e "dot" sono definiti rispetto all'intero gruppo di Pauli.

Questa classe consente anche la conversione da e verso la rappresentazione a stringa di Pauli per comodità.

Per esempio
```
from qiskit.quantum_info import Pauli

P1 = Pauli('XYZ')
P2 = Pauli('YZX')
P1.dot(P2)
```
I Pauli possono anche essere aggiunti direttamente agli oggetti QuantumCircuit oggetti
```
from qiskit import QuantumCircuit
from qiskit.quantum_info import Pauli

circ = QuantumCircuit(3)
circ.append(Pauli('XYZ'), [0, 1, 2])
circ.draw(output='mpl')
```
Ulteriori metodi permettono di calcolare quando due Pauli si scambiano (con il metodo commutes() ) o anticommutanti (con il metodo anticommutes() e di calcolare il Pauli risultante dalla coniugazione di Clifford $P^\prime = C.P.C^\dagger$ utilizzando il metodo evolve() metodo.

Per ulteriori informazioni, consultare la documentazione API della classe Pauli per ulteriori informazioni.
Una nuova funzione, random_pauli()per la generazione di un elemento casuale del gruppo di Pauli a N-qubit è stata aggiunta al modulo qiskit.quantum_info modulo.
Una nuova classe, PiecewisePolynomialPauliRotationsè stata aggiunta al modulo qiskit.circuit.library modulo. Questo elemento della libreria di circuiti viene utilizzato per mappare una funzione polinomiale piecewise, $f(x)$ , definita attraverso punti di interruzione e coefficienti, sulle ampiezze dei qubit. I breakpoint $(x_0, ..., x_J)$ sono un sottoinsieme di $[0, 2^n-1]$ , dove $n$ è il numero di qubit di stato. I coefficienti corrispondenti $[a_{j,1},...,a_{j,d}]$ , dove $d$ è il grado più alto tra tutti i polinomi. Allora $f(x)$ è definito come:

\begin{split}f(x) = \begin{cases} 0, x < x_0 \\ \sum_{i=0}^{i=d}a_{j,i} x^i, x_j \leq x < x_{j+1} \end{cases}\end{split}

dove assumiamo implicitamente $x_{J+1} = 2^n$ . E la mappatura applicata alle ampiezze è data da

F|x\rangle |0\rangle = \cos(p_j(x))|x\rangle |0\rangle + \sin(p_j(x))|x\rangle |1\rangle

Questa mappatura si basa su rotazioni Y di Pauli controllate e costruite con la formula PolynomialPauliRotations.

È stato introdotto un nuovo modulo qiskit.algorithms è stato introdotto. Questo modulo contiene funzionalità equivalenti a quelle fornite in precedenza dal modulo qiskit.aqua.algorithms (ora deprecato) e fornisce gli elementi costitutivi per la costruzione di algoritmi quantistici. Per informazioni dettagliate sulla migrazione da qiskit-aqua a questo nuovo modulo, consultare la guida alla migrazione.
È stato introdotto un nuovo modulo qiskit.opflow è stato introdotto. Questo modulo contiene funzionalità equivalenti a quelle precedentemente fornite dal modulo qiskit.aqua.operators (ora deprecato) e fornisce gli operatori e le funzioni di stato utilizzati per costruire algoritmi quantistici. Per informazioni dettagliate sulla migrazione da qiskit-aqua a questo nuovo modulo, consultare la guida alla migrazione.
Questo è il primo rilascio che include ruote binarie precompilate per i sistemi Linux aarch64. Se si utilizza un sistema manylinux2014 compatibile con aarch64 Linux sono ora disponibili ruote precompilate su PyPI, non è più necessario compilare dai sorgenti per installare qiskit-terra.
La funzione qiskit.quantum_info.process_fidelity() può ora essere utilizzata con un canale di destinazione non unitario. In questo caso il valore restituito è equivalente al valore qiskit.quantum_info.state_fidelity() delle matrici normalizzate qiskit.quantum_info.Choi per i canali.

Si noti che gli elementi qiskit.quantum_info.average_gate_fidelity() e qiskit.quantum_info.gate_error() richiedono che il canale di destinazione sia unitario e sollevano un'eccezione in caso contrario.

È stata aggiunta una nuova funzione di creazione di impulsi, qiskit.pulse.macro(). Ciò consente di decorare come macro le normali funzioni di Python. Ciò consente di utilizzare le funzioni di costruttore di impulsi all'interno della funzione decorata. La macro del costruttore può quindi essere richiamata da un contesto di costruzione di impulsi, consentendo il riutilizzo del codice.

Ad esempio:

from qiskit import pulse

@pulse.macro
def measure(qubit: int):
    pulse.play(pulse.GaussianSquare(16384, 256, 15872),
               pulse.MeasureChannel(qubit))
    mem_slot = pulse.MemorySlot(0)
    pulse.acquire(16384, pulse.AcquireChannel(0), mem_slot)
    return mem_slot

with pulse.build(backend=backend) as sched:
    mem_slot = measure(0)
    print(f"Qubit measured into {mem_slot}")

sched.draw()

Una nuova classe, PauliTwoDesignè stata aggiunta al file qiskit.circuit.library che implementa una forma particolare di circuito a 2 disegni da https://arxiv.org/pdf/1803.11173.pdf Ad esempio, questo circuito può avere l'aspetto di
```
from qiskit.circuit.library import PauliTwoDesign
circuit = PauliTwoDesign(4, reps=2, seed=5, insert_barriers=True)
circuit.decompose().draw(output='mpl')
```
È ora disponibile un nuovo cassetto di impulsi qiskit.visualization.pulse_v2.draw() (alias qiskit.visualization.pulse_drawer_v2). Questo nuovo cassetto per impulsi supporta diverse nuove funzioni non presenti nel cassetto per impulsi originale (pulse_drawer()).
- Troncamento delle istruzioni a impulsi lunghi.
- Visualizzazione di impulsi parametrici.
- Nuovi fogli di stile IQXStandard, IQXSimple, IQXDebugging.
- Visualizzazione delle informazioni sul sistema (frequenza dei canali, ecc.) specificando qiskit.providers.Backend oggetti per la visualizzazione.
- Specificare gli oggetti axis per il plottaggio per consentire un'ulteriore estensione dei plot generati, ad esempio per le manipolazioni di pubblicazione.
I nuovi fogli di stile possono accettare funzioni di callback che modificano dinamicamente l'aspetto dell'immagine di output, ad esempio riassemblando un insieme di canali, mostrando i dettagli delle istruzioni, aggiornando l'aspetto degli inviluppi degli impulsi, ecc. È possibile creare funzioni di callback personalizzate e inserirle in un'istanza del foglio di stile per modificare l'aspetto della figura senza modificare il codice del cassetto. Per maggiori dettagli, consultare la documentazione del modulo cassetto degli impulsi.

Si noti che il salvataggio dei file è ora delegato a Matplotlib. Per salvare i file immagine, è necessario chiamare il metodo savefig con l'oggetto Figure restituito.
Aggiunge un metodo reverse_qargs() al metodo qiskit.quantum_info.Statevector e qiskit.quantum_info.DensityMatrix alle classi. Questo metodo inverte l'ordine dei sottosistemi negli stati ed è equivalente al metodo per gli stati a N-qubit qiskit.circuit.QuantumCircuit.reverse_bits() metodo per gli stati a N-qubit. Ad esempio:
```
from qiskit.circuit.library import QFT
from qiskit.quantum_info import Statevector

circ = QFT(3)

state1 = Statevector.from_instruction(circ)
state2 = Statevector.from_instruction(circ.reverse_bits())

state1.reverse_qargs() == state2
```
Aggiunge un metodo reverse_qargs() alla classe qiskit.quantum_info.Operator classe. Questo metodo inverte l'ordine dei sottosistemi nell'operatore ed è equivalente al metodo per gli operatori a N-qubit qiskit.circuit.QuantumCircuit.reverse_bits() per gli operatori a N-qubit. Ad esempio:
```
from qiskit.circuit.library import QFT
from qiskit.quantum_info import Operator

circ = QFT(3)

op1 = Operator(circ)
op2 = Operator(circ.reverse_bits())

op1.reverse_qargs() == op2
```
Il metodo di uscita latex per la funzione qiskit.visualization.circuit_drawer() e il metodo draw() ora utilizzerà un'etichetta definita dall'utente sulle porte nella visualizzazione dell'output. Ad esempio:
```
import math

from qiskit.circuit import QuantumCircuit

qc = QuantumCircuit(2)
qc.h(0)
qc.rx(math.pi/2, 0, label='My Special Rotation')

qc.draw(output='latex')
```
Il kwarg routing_method per la funzione transpile() accetta ora una nuova opzione, 'none'. All'indirizzo routing_method='none' non verrà eseguito alcun passaggio di instradamento come parte della transpilazione. Se il circuito non si adatta alla mappa di accoppiamento, verrà sollevata un'eccezione TranspilerError verrà sollevata un'eccezione.
Una nuova classe di cancelli, RVGateè stata aggiunta al modulo qiskit.circuit.library insieme al corrispondente metodo QuantumCircuit metodo rv(). Il RVGate è un gate di rotazione generale, simile al gate UGatema invece di specificare gli angoli di Eulero, vengono specificate le tre componenti di un vettore di rotazione, dove la direzione del vettore specifica l'asse di rotazione e la grandezza specifica l'angolo di rotazione intorno all'asse in radianti. Ad esempio:
```
import math

import np

from qiskit.circuit import QuantumCircuit

qc = QuantumCircuit(1)
theta = math.pi / 5
phi = math.pi / 3
# RGate axis:
axis = np.array([math.cos(phi), math.sin(phi)])
rotation_vector = theta * axis
qc.rv(*rotation_vector, 0)
```
Non vincolati Parameter utilizzati in un oggetto QuantumCircuit saranno ora ordinati per nome. Questo avrà effetto per i parametri restituiti dall'attributo parameters . Inoltre, il qiskit.circuit.QuantumCircuit.bind_parameters() e qiskit.circuit.QuantumCircuit.assign_parameters() possono ora accettare un elenco di valori a che li legherà/assegnerà ai parametri in ordine di nome. In precedenza, questi metodi accettavano solo un dizionario di parametri e valori. Ad esempio:
```
from qiskit.circuit import QuantumCircuit, Parameter

circuit = QuantumCircuit(1)
circuit.rx(Parameter('x'), 0)
circuit.ry(Parameter('y'), 0)

print(circuit.parameters)

bound = circuit.bind_parameters([1, 2])
bound.draw(output='mpl')
```
I costruttori per le classi qiskit.quantum_info.Statevector e qiskit.quantum_info.DensityMatrix possono ora accettare un oggetto QuantumCircuit per costruire un oggetto Statevector e DensityMatrix da quel circuito, assumendo che i qubit siano inizializzati in $|0\rangle$ . Per esempio:
```
from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector

qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)

statevector = Statevector(qc)
statevector.draw(output='latex')
```
Le nuove classi di backend fasulle sono disponibili all'indirizzo qiskit.test.mock. Questi includono versioni simulate di ibmq_casablanca, ibmq_sydney, ibmq_mumbai, ibmq_lima, ibmq_belem, ibmq_quito. Come per gli altri backend fasulli, questi includono istantanee dei dati di calibrazione (ad esempio backend.defaults()) e i dati relativi all'errore (cioè backend.properties()) presi dal sistema reale e possono essere utilizzati per test, compilazioni e simulazioni locali.

Problemi noti

Si tenta di aggiungere un oggetto qiskit.pulse.Instruction con un oggetto duration parametrizzato (cioè il valore di duration è un oggetto non vincolato o un oggetto Parameter o ParameterExpression ) a un oggetto qiskit.pulse.Schedule non è supportato. Il tentativo di farlo comporterà l'apertura del sito UnassignedDurationError PulseError viene sollevato. Questa è una limitazione del modo in cui vengono valutati attualmente i vincoli di sovrapposizione di Instruction . Questo è supportato da ScheduleBlockin cui i vincoli di sovrapposizione vengono valutati appena prima dell'esecuzione.

Nei sistemi Windows, quando l'esecuzione parallela è abilitata per parallel_map() il parallelismo potrebbe non funzionare quando viene richiamato da uno script in esecuzione al di fuori di un blocco if __name__ == '__main__': . Ciò è dovuto al modo in cui Python lancia i processi paralleli su Windows. Se un RuntimeError o un AttributeError vengono sollevati da script che chiamano parallel_map() (compreso l'uso di funzioni che utilizzano parallel_map() internamente, come ad esempio transpile()) con Windows e il parallelismo abilitato, si può provare a incorporare le chiamate agli script all'interno di if __name__ == '__main__': per risolvere il problema. Ad esempio:

from qiskit import QuantumCircuit, QiskitError
from qiskit import execute, Aer

qc1 = QuantumCircuit(2, 2)
qc1.h(0)
qc1.cx(0, 1)
qc1.measure([0,1], [0,1])
# making another circuit: superpositions
qc2 = QuantumCircuit(2, 2)
qc2.h([0,1])
qc2.measure([0,1], [0,1])
execute([qc1, qc2], Aer.get_backend('qasm_simulator'))

Dovrebbe essere modificata in:

from qiskit import QuantumCircuit, QiskitError
from qiskit import execute, Aer

def main():
    qc1 = QuantumCircuit(2, 2)
    qc1.h(0)
    qc1.cx(0, 1)
    qc1.measure([0,1], [0,1])
    # making another circuit: superpositions
    qc2 = QuantumCircuit(2, 2)
    qc2.h([0,1])
    qc2.measure([0,1], [0,1])
    execute([qc1, qc2], Aer.get_backend('qasm_simulator'))

if __name__ == '__main__':
    main()

se si verificano errori con il parallelismo in Windows.

Note sull'aggiornamento

I gestori dei passaggi preimpostati level_1_pass_manager, level_2_pass_manager, e level_3_pass_manager (che vengono utilizzati per optimization_level 1, 2 e 3 nei modelli transpile() e execute() ) ora utilizzano incondizionatamente il passaggio Optimize1qGatesDecomposition per l'ottimizzazione del gate a 1 qubit. In precedenza, questi gestori di passaggi utilizzavano il passaggio Optimize1qGates se le porte di base contenevano u1, u2, o u3. Se si vuole continuare a utilizzare il vecchio Optimize1qGates è necessario costruire un file PassManager con il pass.
In seguito alla transpilazione di un parametro QuantumCircuitl'attributo global_phase di un circuito di uscita non può più essere restituito in forma semplificata, se la fase globale è una fase ParameterExpression.

Ad esempio:
```
qc = QuantumCircuit(1)
theta = Parameter('theta')

qc.rz(theta, 0)
qc.rz(-theta, 0)

print(transpile(qc, basis_gates=['p']).global_phase)
```
precedentemente restituiva 0, ma ora restituirà -0.5*theta + 0.5*theta. Questa modifica si è resa necessaria per evitare una forte penalizzazione delle prestazioni in fase di esecuzione, poiché la semplificazione delle espressioni simboliche può essere piuttosto lenta, soprattutto se ci sono molti oggetti in un circuito ParameterExpression oggetti in un circuito.
Gli oggetti BasicAerJob restituiti dai backend di BasicAer sono ora istanze sincrone di JobV1. Ciò significa che le chiamate al metodo run() si bloccheranno fino al termine dell'esecuzione della simulazione. Se si vuole ripristinare il precedente comportamento asincrono, è necessario avvolgere il file run() con qualcosa che venga eseguito in un thread o processo separato, come futures.ThreadPoolExecutor o futures.ProcessPoolExecutor.
L'opzione allow_sample_measuring per il simulatore BasicAer QasmSimulatorPy è passata da un valore predefinito di False a True. Questo è stato fatto per riflettere meglio l'effettivo comportamento predefinito del simulatore, che utilizza la misurazione dei campioni se il circuito di ingresso la supporta (anche se non è abilitata). Se si sta eseguendo un circuito che non supporta la misurazione di campioni (cioè ha operazioni Reset o se ci sono operazioni dopo una misurazione su un qubit) bisogna assicurarsi di impostare esplicitamente questa opzione su False quando si chiama run().
Il passaggio CommutativeCancellation è ora consapevole delle porte della base di destinazione, il che significa che userà solo le porte della base specificata. In precedenza, il passaggio sostituiva incondizionatamente le porte consecutive che commutano con ZGate con la porta U1Gate. Tuttavia, ora che il passaggio è consapevole della base e ha un kwarg, basis_gates, per specificare la base di destinazione, c'è un potenziale cambiamento di comportamento se il kwarg non viene impostato. Quando il kwarg basis_gates non viene utilizzato e non ci sono porte a rotazione z variabile nel circuito, non si verifica alcuna cancellazione commutativa.
Register (che è la classe madre di QuantumRegister e ClassicalRegister e Bit (che è la classe genitore di Qubit e Clbit) sono ora immutabili. Nelle versioni precedenti era possibile regolare il valore di a size o name di un oggetto Register e l'opzione index o register di un oggetto Bit dopo la sua creazione iniziale. Tuttavia, questo porterebbe a un comportamento scorretto che corromperebbe le strutture di contenitori che si basano su un hash (come un dict), poiché questi attributi sono trattati come proprietà immutabili di un registro o di un bit (vedere #4705 per maggiori dettagli). Per evitare questo comportamento scorretto, gli attributi di a Register e Bit non sono più impostabili dopo la creazione iniziale. Se in precedenza si regolavano gli oggetti in fase di esecuzione, ora è necessario creare un nuovo oggetto Register o Bit con i nuovi valori.
Il metodo DAGCircuit.__eq__ (utilizzato dall'operatore == ), che viene utilizzato per verificare l'uguaglianza strutturale di DAGCircuit e QuantumCircuit includerà ora il metodo global_phase e calibrations nei campi controllati per l'uguaglianza. Ciò significa che i circuiti che sarebbero stati valutati come uguali nelle versioni precedenti potrebbero non esserlo più se global_phase o calibrations differiscono tra i circuiti. Ad esempio, nelle versioni precedenti questo restituiva True:
```
import math

from qiskit import QuantumCircuit

qc1 = QuantumCircuit(1)
qc1.x(0)

qc2 = QuantumCircuit(1, global_phase=math.pi)
qc2.x(0)

print(qc2 == qc1)
```
Tuttavia, poiché l'attributo global_phase dei circuiti è diverso, ora restituirà False.
I metodi qubits() e clbits() della classe DAGCircuit che erano stati deprecati nella release 0.15.0 Terra, sono stati rimossi. Si devono invece usare gli attributi qubits e clbits della classe DAGCircuit della classe. Ad esempio, se si sta eseguendo:
```
from qiskit.dagcircuit import DAGCircuit

dag = DAGCircuit()
qubits = dag.qubits()
```
Che verrebbe sostituito da:
```
from qiskit.dagcircuit import DAGCircuit

dag = DAGCircuit()
qubits = dag.qubits
```
I dati PulseDefaults restituiti dai backend dei falsi impulsi qiskit.test.mock.FakeOpenPulse2Q e qiskit.test.mock.FakeOpenPulse3Q sono stati aggiornati per avere definizioni di sequenze di impulsi più realistiche. Se si utilizzano queste classi backend false, potrebbe essere necessario aggiornare l'utilizzo a causa di queste modifiche.
Il metodo di sintesi predefinito utilizzato dalla funzione decompose_clifford() del modulo quantum_info (che viene utilizzato internamente dal metodo qiskit.quantum_info.Clifford.to_circuit() ) per più di 3 qubit utilizza ora una routine di compilazione greedy non ottimale per la sintesi degli elementi di Clifford, di Bravyi et al. al, che in genere produce un costo CX migliore rispetto al vecchio default. Se è necessario tornare al precedente metodo Aaronson-Gottesman, è possibile farlo impostando method='AG'.

Il modulo qiskit.visualization.interactive, precedentemente deprecato nella versione 0.15.0, è stato rimosso. Si dovrebbero invece utilizzare le visualizzazioni basate su matplotlib:

Rimossa la funzione Interattiva	Funzione matplotlib equivalente
`iplot_bloch_multivector`	`qiskit.visualization.plot_bloch_multivector()`
`iplot_state_city`	`qiskit.visualization.plot_state_city()`
`iplot_state_qsphere`	`qiskit.visualization.plot_state_qsphere()`
`iplot_state_hinton`	`qiskit.visualization.plot_state_hinton()`
`iplot_histogram`	`qiskit.visualization.plot_histogram()`
`iplot_state_paulivec`	`qiskit.visualization.plot_state_paulivec()`

Gli attributi di primo livello qiskit.Aer e qiskit.IBMQ sono ora caricati in modo pigro. Ciò significa che gli oggetti esisteranno sempre e che non verranno più sollevati avvisi all'importazione se qiskit-aer o qiskit-ibmq-provider non sono installati (o non possono essere trovati da Python ). Se si controllava la presenza di qiskit-aer o qiskit-ibmq-provider usando questi attributi del modulo e si confrontava esplicitamente con None o si cercava l'assenza dell'attributo, questo non funzionerà più perché ora sono sempre definiti come un oggetto. In altre parole, eseguire qualcosa come:
```
try:
    from qiskit import Aer
except ImportError:
    print("Aer not available")

or::

try:
    from qiskit import IBMQ
except ImportError:
    print("IBMQ not available")
```
non funzionerà più. Invece, per determinare se questi provider sono presenti, si può usare esplicitamente qiskit.providers.aer.Aer e qiskit.providers.ibmq.IBMQ:
```
try:
    from qiskit.providers.aer import Aer
except ImportError:
    print("Aer not available")

try:
    from qiskit.providers.ibmq import IBMQ
except ImportError:
    print("IBMQ not available")
```
o controllare invece bool(qiskit.Aer) e bool(qiskit.IBMQ) , ad esempio:
```
import qiskit

if not qiskit.Aer:
    print("Aer not available")
if not qiskit.IBMQ:
    print("IBMQ not available")
```
Questa modifica si è resa necessaria per evitare potenziali problemi di ciclo di importazione tra i pacchetti qiskit e anche per migliorare i tempi di importazione quando non si utilizzano Aer o IBMQ.
L'opzione suppress_packaging_warnings nel file di configurazione utente e la variabile d'ambiente QISKIT_SUPPRESS_PACKAGING_WARNINGS non hanno più alcun effetto e vengono ignorate. Gli avvisi che questa opzione controllava sono stati rimossi e non saranno più emessi al momento dell'importazione dal modulo qiskit .
Il kwarg condition , precedentemente deprecato, per il costruttore qiskit.dagcircuit.DAGNode è stato rimosso. È stato deprecato nella versione 0.15.0. Si dovrebbe invece impostare la condizione classica sull'oggetto Instruction passato nel costruttore DAGNode quando si crea un nuovo nodo op .
Quando si crea una nuova classe Register (che è la classe madre per QuantumRegister e ClassicalRegister) o QuantumCircuit con un numero di bit (ad esempio QuantumCircuit(2)), è ora richiesto che il numero di bit sia specificato come un intero o un altro tipo che sia castabile in numeri interi non ambigui (ad esempio 2.0). I valori non interi sollevano ora un errore, poiché in questi casi l'intento non era chiaro (non si possono avere bit frazionari). Per ulteriori informazioni sul motivo di questa modifica, consultare: #4855
networkx non è più un requisito per qiskit-terra. Tutto l'uso di networkx all'interno di qiskit-terra è stato rimosso ad eccezione di 3 metodi:
- qiskit.dagcircuit.DAGCircuit.to_networkx
- qiskit.dagcircuit.DAGCircuit.from_networkx
- qiskit.dagcircuit.DAGDependency.to_networkx
Se si utilizza uno di questi metodi, è necessario installare manualmente networkx nel proprio ambiente per continuare a utilizzarli.
Per impostazione predefinita su macOS con Python >= 3.8 parallel_map() non verrà più eseguito in processi multipli. Si tratta di una modifica rispetto alle versioni precedenti, in cui il comportamento predefinito era che parallel_map() avrebbe avviato più processi. Questa modifica è stata apportata perché con le nuove versioni di macOS con Python 3.8 e 3.9 la multielaborazione è inaffidabile o aggiunge un overhead significativo a causa del cambiamento in Python 3.8 per lanciare nuovi processi con spawn invece che con fork. Per riattivare l'esecuzione parallela su macOS con Python >= 3.8 si può usare l'opzione del file di configurazione utente parallel o impostare la variabile d'ambiente QISKIT_PARALLEL su True.

Il deprecato kwarg callback sul costruttore della classe PassManager è stato rimosso. Questo kwarg è stato deprecato dalla versione 0.13.0 (9 aprile 2020). Si può invece passare il kwarg callback al metodo qiskit.transpiler.PassManager.run() direttamente. Ad esempio, se si utilizzava:

from qiskit.circuit.random import random_circuit
from qiskit.transpiler import PassManager

qc = random_circuit(2, 2)

def callback(**kwargs)
  print(kwargs['pass_'])

pm = PassManager(callback=callback)
pm.run(qc)

può essere sostituito con:

from qiskit.circuit.random import random_circuit
from qiskit.transpiler import PassManager

qc = random_circuit(2, 2)

def callback(**kwargs)
  print(kwargs['pass_'])

pm = PassManager()
pm.run(qc, callback=callback)

Non è più possibile istanziare un canale di base senza prefisso, come qiskit.pulse.Channel o qiskit.pulse.PulseChannel. Queste classi sono progettate per classificare i tipi di canali diversi rivolti all'utente, come qiskit.pulse.DriveChannel, ma non hanno una definizione di risorsa di destinazione. Se in precedenza si istanziava direttamente qiskit.pulse.Channel o qiskit.pulse.PulseChannel, questo non è più consentito. Utilizzare la sottoclasse appropriata.
Quando i kwarg require_cp e/o require_tp di qiskit.quantum_info.process_fidelity(), qiskit.quantum_info.average_gate_fidelity(), qiskit.quantum_info.gate_error() sono True, ora registreranno solo un avviso, invece del comportamento precedente che sollevava un'eccezione se il canale di ingresso è rispettivamente non-CP o non-TP QiskitError se il canale di ingresso è rispettivamente non-CP o non-TP.
La QFT del modulo qiskit.circuit.library calcola ora la trasformata di Fourier usando una rappresentazione little-endian dei tensori, cioè lo stato $|1\rangle$ mappa a $|0\rangle - |1\rangle + |2\rangle - ..$ assumendo che le basi di calcolo corrispondano all'ordinamento bit little-endian degli interi. $|0\rangle = |000\rangle, |1\rangle = |001\rangle$ ecc. Questo è stato fatto per renderlo più coerente con il resto di Qiskit, che utilizza una convenzione little-endian per l'ordine dei bit. Se l'ordine dei bit dipendeva da quello precedente, è possibile utilizzare il metodo reverse_bits() per ripristinare il comportamento precedente. Ad esempio:
```
from qiskit.circuit.library import QFT

qft = QFT(5).reverse_bits()
```
L'attributo del modulo qiskit.__qiskit_version__ , che in precedenza era un dict , ora restituisce un oggetto Mapping personalizzato di sola lettura che controlla la versione degli elementi di qiskit in fase di esecuzione invece che di importazione. Questo è stato fatto per velocizzare il percorso di importazione di qiskit ed eliminare un possibile ciclo di importazione, importando i pacchetti degli elementi solo in fase di esecuzione, se la versione è necessaria dal pacchetto. Dovrebbe essere pienamente compatibile con il ritorno di dict e per la maggior parte dei casi di utilizzo normale non ci saranno differenze. Tuttavia, se alcune applicazioni si basano sulla mutazione dei contenuti o sul controllo esplicito del tipo, potrebbero essere necessari aggiornamenti per adattarsi a questo cambiamento.
Il modulo qiskit.execute è stato rinominato in qiskit.execute_function. Questo è stato necessario per evitare un conflitto di nomi potente tra la funzione execute() che viene riesportata come qiskit.execute. qiskit.execute la funzione in alcune situazioni potrebbe entrare in conflitto con il modulo qiskit.execute , il che porterebbe a un errore criptico perché Python trattava qiskit.execute come modulo quando l'intento era la funzione o viceversa. La rinominazione del modulo è stata necessaria per evitare questo conflitto. Se si importa qiskit.execute per ottenere il modulo (l'uso tipico era from qiskit.execute import execute), è necessario aggiornare questo modulo per usare qiskit.execute_function . qiskit.execute si risolverà sempre nella funzione.
I moduli qiskit.compiler.transpile, qiskit.compiler.assemble, qiskit.compiler.schedule e qiskit.compiler.sequence sono stati rinominati rispettivamente in qiskit.compiler.transpiler, qiskit.compiler.assembler, qiskit.compiler.scheduler e qiskit.compiler.sequence . Questo è stato necessario per evitare un conflitto di nomi tra i moduli e i percorsi delle funzioni riesportate qiskit.compiler.transpile(), qiskit.compiler.assemble(), qiskit.compiler.schedule(), e qiskit.compiler.sequence(). In alcune situazioni questo conflitto di nomi tra il percorso del modulo e quello della funzione riesportata portava a un errore criptico, perché Python trattava un'importazione come se fosse il modulo, mentre l'intento era di usare la funzione o viceversa. La rinominazione del modulo è stata necessaria per evitare questo conflitto. Se prima si usavano le importazioni per ottenere i moduli (l'uso tipico sarebbe stato come "from qiskit.compiler.transpile import transpile"), sarà necessario aggiornarlo per usare i nuovi percorsi dei moduli. qiskit.compiler.transpile(), qiskit.compiler.assemble(), qiskit.compiler.schedule(), e qiskit.compiler.sequence() ora si risolveranno sempre alle funzioni.
La classe qiskit.quantum_info.Quaternion è stata spostata dal sottomodulo qiskit.quantum_info.operator al sottomodulo qiskit.quantum_info.synthesis per riflettere meglio il suo scopo. Non è necessaria alcuna modifica se lo si importava dal modulo root qiskit.quantum_info ma se lo si importava da qiskit.quantum_info.operator , sarà necessario aggiornare il percorso di importazione.
Rimosso il metodo QuantumCircuit.mcmt , deprecato dal rilascio di Qiskit Terra 0.14.0 nell'aprile 2020. Invece di utilizzare il metodo, utilizzare la classe MCMT per costruire un gate multi-controllo multi-target e utilizzare il metodo qiskit.circuit.QuantumCircuit.append() o qiskit.circuit.QuantumCircuit.compose() per aggiungerlo a un circuito.

Ad esempio, è possibile sostituire:
```
circuit.mcmt(ZGate(), [0, 1, 2], [3, 4])
```
con:
```
from qiskit.circuit.library import MCMT
mcmt = MCMT(ZGate(), 3, 2)
circuit.compose(mcmt, range(5))
```
Rimosso il metodo QuantumCircuit.diag_gate che è stato deprecato dal rilascio di Qiskit Terra 0.14.0 nell'aprile 2020. Utilizzare invece il metodo diagonal() di QuantumCircuit.
Rimosso il metodo QuantumCircuit.ucy che è stato deprecato dal rilascio di Qiskit Terra 0.14.0 nell'aprile 2020. Utilizzare invece il metodo ucry() di QuantumCircuit.
Il metodo mirror() , precedentemente deprecato, per il metodo qiskit.circuit.QuantumCircuit è stato rimosso. È stato deprecato nella versione 0.15.0. Il metodo qiskit.circuit.QuantumCircuit.reverse_ops() poiché il mirroring potrebbe essere confuso con lo scambio dei qubit di uscita del circuito. Il metodo reverse_ops() si limita a invertire l'ordine delle porte applicate, invece di rispecchiarle.
Il supporto precedentemente deprecato che prevedeva il passaggio di un float (per il kwarg di scale ) come primo argomento posizionale del metodo qiskit.circuit.QuantumCircuit.draw() è stato rimosso. È stato deprecato nella versione 0.12.0. Il primo argomento posizionale del metodo qiskit.circuit.QuantumCircuit.draw() è ora il metodo output kwarg, che non accetta un float. Si dovrebbe invece usare scale come un kwarg con nome, invece di usarlo in modo posizionale.

Ad esempio, se prima si chiamava draw con:
```
from qiskit import QuantumCircuit

qc = QuantumCircuit(2)
qc.draw(0.75, output='mpl')
```
questo dovrebbe ora essere:
```
from qiskit import QuantumCircuit

qc = QuantumCircuit(2)
qc.draw(output='mpl', scale=0.75)
```
oppure:
```
qc.draw('mpl', scale=0.75)
```

Le funzionalità di Qiskit Pulse (qiskit.pulse) che sono state deprecate nella release 0.15.0 (agosto 2020) sono state rimosse. La serie completa di modifiche è la seguente:

Modulo	Precedente	Nuovo
`qiskit.pulse.library`	`SamplePulse`	`Waveform`
`qiskit.pulse.library`	`ConstantPulse`	`Constant`
(rinominare il modulo)	`pulse.pulse_lib` Modulo	`qiskit.pulse.library`

Classe	Vecchio metodo	Nuovo metodo
`ParametricPulse`	`get_sample_pulse`	`get_waveform`
`Instruction`	`command`	N/D. I comandi e le istruzioni sono stati unificati. Utilizzare `operands()` per ottenere informazioni sui dati delle istruzioni.
`Acquire`	`acquires`, `mem_slots`, `reg_slots`	`acquire()`, `mem_slot()`, `reg_slot()`. (L'istruzione `Acquire` non trasmette più su più qubit)

Il dizionario precedentemente tenuto sui DAGCircuit è stato rimosso. Invece, i bordi ora contengono l'istanza Bit che era stata precedentemente inclusa nel dizionario come campo 'wire' . Si noti che il grafo NetworkX restituito da to_networkx() avrà ancora un dizionario per gli attributi dei bordi, ma il campo 'name' non sarà più popolato.
L'attributo parameters della classe QuantumCircuit non restituisce più un set. Restituisce invece un oggetto ParameterView che implementa tutti i metodi offerti da set (anche se deprecati). Questo è stato fatto per supportare un modello che conserva i parametri ordinati per nome. Dovrebbe essere pienamente compatibile con qualsiasi uso precedente di set restituito dall'attributo parameters ad eccezione dei casi in cui è stato fatto un controllo esplicito del tipo di un insieme.
Quando si esegue transpile() su un dispositivo QuantumCircuit con delay() le unità saranno convertite in dt se il valore di dt (tempo di campionamento) è noto a transpile(), sia esplicitamente tramite il kwarg dt sia tramite il kwarg BackendConfiguration per un oggetto Backend passato tramite il kwarg backend .
L'interpretazione di meas_map (che è un attributo di un oggetto o come corrispondente kwarg di ) è molto semplice PulseBackendConfiguration o come il corrispondente kwarg di meas_map sull'oggetto schedule(), assemble(), sequence(), o execute() ) è stata aggiornata per corrispondere meglio ai vincoli reali dell'hardware. Il formato di questi dati è un elenco di liste, dove gli elementi della lista interna sono numeri interi che specificano le etichette dei qubit. Per esempio:
```
[[A, B, C], [D, E, F, G]]
```
In precedenza, il vincolo meas_map era interpretato in modo tale che se veniva acquisito un qubit (ad esempio A), tutti gli altri qubit che condividevano un sottogruppo con quel qubit (B e C) dovevano essere acquisiti nello stesso momento e per la stessa durata. Questo vincolo è stato allentato. Un'acquisizione non richiede altre acquisizioni. (Se A viene acquisito, B e C non devono essere acquisiti) Invece, i qubit dello stesso gruppo di misura non possono essere acquisiti in modo parzialmente sovrapposto - si pensi a meas_map come se specificasse una risorsa di acquisizione condivisa (se acquisiamo A da t=1000 a t=2000, non possiamo acquisire B a partire da 1000<t<2000). Ad esempio:
```
# Good
meas_map = [[0, 1]]
# Acquire a subset of [0, 1]
sched = pulse.Schedule()
sched = sched.append(pulse.Acquire(10, acq_q0))

# Acquire 0 and 1 together (same start time, same duration)
sched = pulse.Schedule()
sched = sched.append(pulse.Acquire(10, acq_q0))
sched = sched.append(pulse.Acquire(10, acq_q1))

# Acquire 0 and 1 disjointly
sched = pulse.Schedule()
sched = sched.append(pulse.Acquire(10, acq_q0))
sched = sched.append(pulse.Acquire(10, acq_q1)) << 10

# Acquisitions overlap, but 0 and 1 aren't in the same measurement
# grouping
meas_map = [[0], [1]]
sched = pulse.Schedule()
sched = sched.append(pulse.Acquire(10, acq_q0))
sched = sched.append(pulse.Acquire(10, acq_q1)) << 1

# Bad: 0 and 1 are in the same grouping, but acquisitions
# partially overlap
meas_map = [[0, 1]]
sched = pulse.Schedule()
sched = sched.append(pulse.Acquire(10, acq_q0))
sched = sched.append(pulse.Acquire(10, acq_q1)) << 1
```

Note di deprecazione

Sono stati aggiunti due nuovi argomenti qiskit.dagcircuit.DAGNode.semantic_eq()bit_indices1 e bit_indices2, che dovrebbero mappare le istanze di Bit in ciascuno dei due argomenti DAGNode al loro indice nell'elenco qubits o clbits delle rispettive liste DAGCircuit. Durante il periodo di deprecazione, questi argomenti sono facoltativi e quando non sono specificati le mappature saranno costruite automaticamente in base alle proprietà register e index di ogni istanza Bit istanza. Tuttavia, in una versione futura, saranno argomenti obbligatori e la mappatura dovrà essere fornita dall'utente.
Le pulse funzioni del costruttore:
- qiskit.pulse.call_circuit()
- qiskit.pulse.call_schedule()
sono deprecati e saranno rimossi in una prossima versione. Queste funzioni sono unificate in qiskit.pulse.call() , che dovrebbe essere utilizzato al loro posto.
Il metodo qiskit.pulse.Scheduleqiskit.pulse.Schedule.flatten() è deprecato e sarà rimosso in una prossima versione. Si può invece utilizzare la funzione qiskit.pulse.transforms.flatten() che eseguirà la stessa operazione.
Il sito assign_parameters() per le seguenti classi:
- qiskit.pulse.channels.Channel,
- qiskit.pulse.library.Pulse,
- qiskit.pulse.instructions.Instruction,
e tutte le sue sottoclassi è ora deprecato e sarà rimosso in una prossima versione. Questa funzionalità è stata sostituita ScheduleBlock che è la direzione futura per la costruzione di programmi a impulsi parametrizzati.
L'attributo parameters per le seguenti classi:
- Channel
- Instruction.
è deprecato e sarà rimosso in una prossima versione. Questa funzionalità è stata sostituita ScheduleBlock che è la direzione futura per la costruzione di programmi a impulsi parametrizzati.
Python 3.6 è stato deprecato e sarà rimosso in una prossima versione. Quando il supporto verrà rimosso, sarà necessario aggiornare la versione Python in uso a Python 3.7 o superiore.

Due metodi QuantumCircuitcombine() e extend() e i corrispondenti operatori Python + e += sono deprecati e saranno rimossi in una prossima versione. Invece il metodo QuantumCircuit metodo compose() dovrebbe essere utilizzato. Il metodo compose() consente una maggiore flessibilità nella composizione di due circuiti che non hanno registri corrispondenti. Tuttavia, non aggiunge automaticamente qubit/clbit, a differenza dei metodi deprecati. Per aggiungere un circuito su nuovi qubit/clbit, si può utilizzare il metodo qiskit.circuit.QuantumCircuit.tensor() può essere utilizzato. Ad esempio:

from qiskit.circuit import QuantumRegister, QuantumCircuit

a = QuantumRegister(2, 'a')
circuit_a = QuantumCircuit(a)
circuit_a.cx(0, 1)

b = QuantumRegister(2, 'b')
circuit_b = QuantumCircuit(b)
circuit_b.cz(0, 1)

# same as circuit_a + circuit_b (or combine)
added_with_different_regs = circuit_b.tensor(circuit_a)

# same as circuit_a + circuit_a (or combine)
added_with_same_regs = circuit_a.compose(circuit_a)

# same as circuit_a += circuit_b (or extend)
circuit_a = circuit_b.tensor(circuit_a)

# same as circuit_a += circuit_a (or extend)
circuit_a.compose(circuit_a, inplace=True)

Supporto per il passaggio di Qubit al kwarg qubits del metodo qiskit.transpiler.InstructionDurations.get() è stato deprecato e sarà rimosso in una prossima versione. Si deve invece chiamare il metodo get() con gli indici interi dei qubit desiderati.
L'uso di @ (__matmul__) per invocare il metodo compose delle sottoclassi di BaseOperator (es Operator) è deprecato e sarà rimosso in una prossima versione. Il metodo qiskit.quantum_info.Operator.compose() può essere usato direttamente o anche invocato con l'operatore & (__and__).
Usare * (__mul__) per richiamare il metodo dot() delle sottoclassi di BaseOperator (ad esempio qiskit.quantum_info.Operator) è deprecato e sarà rimosso in una prossima versione. Si può invece chiamare il metodo dot() direttamente.
Utilizzare @ (__matmul__) per invocare il metodo evolve() del metodo qiskit.quantum_info.Statevector e qiskit.quantum_info.DensityMatrix è deprecato e sarà rimosso in una prossima versione. Il metodo evolve può essere utilizzato direttamente o anche invocato con l'operatore & (__and__).

La classe qiskit.pulse.schedule.ParameterizedSchedule è stata deprecata e sarà rimossa in una prossima versione. Si possono invece parametrizzare direttamente gli oggetti pulse Schedule con un oggetto Parameter ad esempio:

from qiskit.circuit import Parameter
from qiskit.pulse import Schedule
from qiskit.pulse import ShiftPhase, DriveChannel

theta = Parameter('theta')
target_schedule = Schedule()
target_schedule.insert(0, ShiftPhase(theta, DriveChannel(0)), inplace=True)

La classe qiskit.pulse.ScheduleComponent del modulo qiskit.pulse è stata deprecata e sarà rimossa in una prossima versione. Il suo utilizzo deve essere sostituito con un qiskit.pulse.Schedule o direttamente qiskit.pulse.Instruction . Inoltre, lo scopo principale della classe ScheduleComponent era quello di essere una classe base comune per entrambi i tipi di input e per qualsiasi luogo che fosse esplicitamente controllato o documentato per accettare un input o Schedule e Instruction , per qualsiasi posto che fosse esplicitamente in grado di controllare il tipo o di documentare l'accettazione di un input ScheduleComponent dovrebbe essere aggiornata per accettare Instruction o Schedule.
I file JSON Schema e l'uso dei payload dell'API IBMQ sono deprecati e saranno rimossi in una versione futura. Questo include tutto ciò che si trova sotto il modulo qiskit.schemas e il modulo qiskit.validation . Questo include anche i kwarg di validate per qiskit.qobj.QasmQobj.to_dict() e qiskit.qobj.QasmQobj.to_dict() insieme ai validatori fastjsonschema a livello di modulo in qiskit.qobj (che non sollevano un avviso di deprecazione). I file dello schema sono stati spostati nel repository Qiskit/ibmq-schemas e devono essere considerati come le versioni canoniche degli schemi API. In futuro solo questi schemi riceveranno gli aggiornamenti e saranno utilizzati come fonte di verità per gli schemi. Se ci si affidava agli schemi forniti da qiskit-terra, si dovrebbe aggiornare per utilizzare questo repository.
Il modulo qiskit.util è stato deprecato e sarà rimosso in una prossima versione. È stato sostituito da qiskit.utils che offre le stesse funzionalità e sarà ampliato in futuro. Si noti che non verrà emesso DeprecationWarning in merito a questa deprecazione, poiché non era possibile su Python 3.6.
Il passaggio del transpiler CXDirection nel modulo qiskit.transpiler.passes è stato deprecato e sarà rimosso in una prossima versione. Si dovrebbe invece utilizzare il sito GateDirection . Si comporta in modo identico a CXDirection , tranne per il fatto che ora supporta anche la trasformazione di un circuito con ECRGate oltre a CXGate porte.
Il passaggio del transpiler CheckCXDirection nel modulo qiskit.transpiler.passes è stato deprecato e sarà rimosso in una prossima versione. Si dovrebbe invece utilizzare il passaggio CheckGateDirection . Si comporta in modo identico a CheckCXDirection , tranne per il fatto che ora supporta anche il controllo della direzione di tutte le porte a 2 qubit, non solo di quelle a 2 qubit CXGate porte.
Il metodo WeightedAddernum_ancilla_qubits() è deprecato e sarà rimosso in una prossima versione. È stato sostituito con l'attributo qiskit.circuit.library.WeightedAdder.num_ancillas che è coerente con le API di altre librerie di circuiti.
I seguenti metodi legacy della classe qiskit.quantum_info.Pauli sono stati deprecati. Vedere la documentazione del metodo per l'uso sostitutivo nella classe Pauli aggiornata.
- from_label()
- sgn_prod()
- to_spmatrix()
- kron()
- update_z()
- update_x()
- insert_paulis()
- append_paulis()
- delete_qubits()
- pauli_single()
- random()
Utilizzando un list o un numpy.ndarray come argomento channel o target per il metodo qiskit.quantum_info.process_fidelity(), qiskit.quantum_info.average_gate_fidelity(), qiskit.quantum_info.gate_error(), e qiskit.quantum_info.diamond_norm() è stato deprecato e non sarà più supportato nelle prossime versioni. Gli input dovrebbero invece essere un oggetto Gate o un oggetto della sottoclasse BaseOperator (ad esempio. Operator, Choi, ecc.)
Accedere ai riferimenti da Qubit e Clbit ai registri che li contengono tramite l'opzione register o index è stato deprecato e sarà rimosso in una prossima versione. Invece, Register possono essere interrogati per trovare gli oggetti Bit oggetti che contengono.
L'attuale funzionalità della funzione qiskit.visualization.pulse_drawer() è deprecata e sarà sostituita da qiskit.visualization.pulse_drawer_v2() (che non è retrocompatibile) in una versione futura.
L'uso dei metodi ereditati dal tipo set sull'uscita dell'attributo parameters (che prima era un set) della classe QuantumCircuit sono deprecati e saranno rimossi in una prossima versione. Questo include i metodi dei siti add(), difference(), difference_update(), discard(), intersection(), intersection_update(), issubset(), issuperset(), symmetric_difference(), symmetric_difference_update(), union(), update(), __isub__() (che è l'operatore -= ) e __ixor__() (che è l'operatore ^= ).
Il nome del primo (e unico) argomento posizionale del metodo qiskit.circuit.QuantumCircuit.bind_parameters() è cambiato da value_dict a values. Il passaggio di un argomento con il nome values_dict è deprecato e sarà rimosso nelle prossime versioni. Per esempio, se in precedenza si chiamava bind_parameters() con una chiamata del tipo: bind_parameters(values_dict={}) questa è deprecata e dovrebbe essere sostituita da bind_parameters(values={}) o meglio ancora passare l'argomento in posizione bind_parameters({}).
Il nome del primo (e unico) argomento posizionale del metodo qiskit.circuit.QuantumCircuit.assign_parameters() è cambiato da param_dict a parameters. Il passaggio di un argomento con il nome param_dict è deprecato e sarà rimosso nelle prossime versioni. Per esempio, se in precedenza si chiamava assign_parameters() con una chiamata del tipo: assign_parameters(param_dict={}) questa è deprecata e dovrebbe essere sostituita da assign_parameters(values={}) o meglio ancora passare l'argomento in posizione assign_parameters({}).

Correzioni di bug

Corretto un problema per cui la funzione execute() sollevava un'eccezione QiskitError quando veniva passato un oggetto ParameterVector veniva passato per il kwarg parameter_bind . parametro. Ad esempio, è ora possibile chiamare qualcosa come:
```
execute(circuit, backend, parameter_binds=[{pv1: [...], pv2: [...]}])
```
dove pv1 e pv2 sono ParameterVector oggetti. Corretto #5467
È stato risolto un problema a causa del quale le etichette degli impulsi parametrici nella classe PulseQobjInstruction non venivano impostate correttamente come nel caso degli impulsi campionati. Questo significa anche che i nomi degli impulsi importati dal file PulseDefaults restituiti da un file Backend, come x90, x90m, ecc. Corretto #5363
Corretto un problema per cui i parametri non vincolati si verificavano solo nell'attributo global_phase di un oggetto QuantumCircuit non venivano visualizzati nell'attributo parameters e non potevano essere vincolati. Corretto #5806
L'attributo calibrations degli oggetti QuantumCircuit sono ora conservati quando si usano i metodi += (cioè il metodo extend() ) e + (cioè il metodo combine() ). Corretto #5930 e #5908
Il metodo name della classe Register (che è la classe madre di QuantumRegister e ClassicalRegister) in precedenza non controllava se la stringa assegnata fosse un nome di registro valido, come previsto dalla specifica OpenQASM. Questo controllo veniva eseguito in precedenza solo quando il nome era specificato nel costruttore; ora è stato corretto in modo che l'impostazione diretta dell'attributo name con un valore non valido sollevi un'eccezione. Corretto #5461
Corretto un problema con la funzione qiskit.visualization.circuit_drawer() e il metodo qiskit.circuit.QuantumCircuit.draw() quando si visualizza un oggetto QuantumCircuit con un elemento Gate che ha una condizione classica dopo un Measure che ha usato lo stesso metodo ClassicalRegisterera possibile che la condizione Gate sia visualizzato a sinistra di Measure. Corretto #5387
Nel passaggio del transpiler qiskit.transpiler.passes.CSPLayout si è osservata una polarizzazione verso i qubit di numero inferiore. Questa indesiderata distorsione è stata risolta rimescolando i candidati per randomizzare i risultati. Inoltre, l'uso del CSPLayout nel campo preset_passmanagers (per i livelli 2 e 3) è stato regolato in modo da utilizzare un seme configurato se il kwarg seed_transpiler è impostato quando viene richiamato il parametro transpile() viene chiamato. Corretto #5990
Corregge un bug per cui il campo channels per un oggetto PulseBackendConfiguration non veniva incluso nell'output del metodo qiskit.providers.models.PulseBackendConfiguration.to_dict del metodo. Corretto #5579
Corretto l'entanglement di 'circular' nella classe dei circuiti qiskit.circuit.library.NLocal per il caso limite in cui il circuito ha la stessa dimensione del blocco di entanglement (ad esempio, un circuito a due qubit e porte di entanglement CZ). In questo caso dovrebbe esserci un solo gate di entanglement, ma ne è stato aggiunto accidentalmente un secondo nella direzione inversa al primo. Fisso qiskit-community/qiskit-aqua#1452
Corretta la gestione dei punti di interruzione nella classe PiecewisePolynomialPauliRotations nella classe qiskit.circuit.library. Ora per gli intervalli n sono consentiti i breakpoint n+1 . Ciò consente di specificare un altro intervallo finale diverso da $2^\text{num qubits}$ . Questo è importante perché dalla fine dell'ultimo intervallo a $2^\text{num qubits}$ la funzione è l'identità.
Corretto un problema nella classe qiskit.circuit.library.Permutation in cui alcune permutazioni non venivano generate correttamente. Questo problema potrebbe avere effetto anche su qiskit.circuit.library.QuantumVolume se fosse stato chiamato con classic_permutation=False`. Corretto #5812
È stato risolto un problema per cui la generazione dell'output QASM con il metodo qasm() per un oggetto QuantumCircuit che ha un controllo ControlledGate con un controllo aperto, l'output sarebbe stato come se tutti i controlli fossero chiusi, indipendentemente dallo stato del controllo specificato. In questo modo si creerebbe un circuito diverso da from_qasm_str() se si analizza il QASM generato.

Questo problema è stato risolto aggiornando l'uscita QASM da qasm() definendo un gate composito che utilizza XGate per implementare i controlli di apertura. Il gate composito è denominato <original_gate_name>_o<ctrl_state> , dove o sta per controllo aperto e ctrl_state è il valore intero dello stato di controllo. Corretto #5443
È stato risolto un problema per cui gli oggetti Parameter in un oggetto QuantumCircuit con la funzione parameter_binds nella funzione execute faceva sì che tutti gli oggetti vincolati QuantumCircuit legati avrebbero avuto lo stesso name, il che significava che anche i nomi dei risultati non erano univoci. Questa correzione fa sì che i campi bind_parameters() e assign_parameters() assegnino un nome di circuito univoco quando inplace=False come:
```
<base name>-<class instance no.>[-<pid name>]
```
dove <base name> è il nome fornito dal kwarg "nome", altrimenti il valore predefinito è "circuito". Il numero di istanza della classe viene incrementato ogni volta che viene generata un'istanza della classe. <pid name> viene aggiunto se viene chiamato al di fuori del processo principale. Corretto #5185
È stato risolto un problema con la funzione scheduler() che sollevava un'eccezione se un circuito di ingresso conteneva un oggetto non vincolato QuantumCircuit non vincolato. Corretto #5304
È stato risolto un problema nei passaggi del qiskit.transpiler.passes.TemplateOptimization in cui i circuiti di template che contenevano oggetti non vincolati si bloccavano in alcuni scenari Parameter si bloccavano in alcuni scenari se i parametri non potevano essere legati durante la corrispondenza dei modelli. Ora, se gli Parameter non possono essere vincolati, i modelli con unbound Parameter vengono scartati e ignorati dal metodo TemplateOptimization pass. Corretto #5533
Corretto un problema con la funzione qiskit.visualization.timeline_drawer() in cui i bit classici non venivano gestiti correttamente. Corretto #5361
Corretto un problema nella funzione qiskit.visualization.circuit_drawer() e nel metodo qiskit.circuit.QuantumCircuit.draw() in cui le Delay in un oggetto QuantumCircuit non venivano trattate correttamente come tempo di inattività. Quindi, quando il kwarg di idle_wires è stato impostato su False , i fili con gli oggetti sarebbero stati visualizzati Delay verrebbero comunque mostrati. Questo problema è stato risolto in modo che i fili inattivi vengano rimossi dalla visualizzazione se ci sono solo oggetti su un filo Delay oggetti su un filo.
In precedenza, quando l'opzione layout_method kwarg veniva fornita alla funzione transpile() e il kwarg optimization_level era impostato a >= 2, in modo che il passaggio qiskit.transpiler.passes.CSPLayout venisse eseguito, se CSPLayout trovava una soluzione, il metodo in layout_method non veniva eseguito. È stato corretto in modo che, se specificato, layout_method venga sempre rispettato. Corretto #5409
Quando l'argomento coupling_map=None (impostato esplicitamente, impostato implicitamente come valore predefinito o tramite il kwarg backend ), il processo di transpiling non "incorporava" il circuito. Cioè, anche quando è stato specificato un initial_layout , i qubit virtuali non sono stati assegnati a qubit fisici. Questo problema è stato risolto in modo che ora la funzione qiskit.compiler.transpile() rispetta l'argomento initial_layout incorporando il circuito:
```
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.compiler import transpile

qr = QuantumRegister(2, name='qr')
circ = QuantumCircuit(qr)
circ.h(qr[0])
circ.cx(qr[0], qr[1])

transpile(circ, initial_layout=[1, 0]).draw(output='mpl')
```
Se initial_layout si riferisce a un numero di qubit superiore a quello del circuito, il processo di transpiling estenderà il circuito con gli ancillas.
```
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.compiler import transpile

qr = QuantumRegister(2, name='qr')
circ = QuantumCircuit(qr)
circ.h(qr[0])
circ.cx(qr[0], qr[1])

transpile(circ, initial_layout=[4, 2], coupling_map=None).draw()
```
Corretto #5345
Un nuovo kwarg, user_cost_dict , è stato aggiunto al costruttore per il passaggio del qiskit.transpiler.passes.TemplateOptimization per il passaggio del transpiler. Ciò consente agli utenti di fornire un dizionario dei costi personalizzato per le porte dell'algoritmo di corrispondenza dei modelli sottostante. Ad esempio:
```
from qiskit.transpiler.passes import TemplateOptimization

cost_dict = {'id': 0, 'x': 1, 'y': 1, 'z': 1, 'h': 1, 't': 1}
pass = TemplateOptimization(user_cost_dict=cost_dict)
```
C'è un problema quando si passa l'oggetto Counts restituito da get_counts() a marginal_counts() produceva un oggetto Counts con determinati input è stato risolto. Correzioni #5424
Migliorata l'allocazione dei qubit helper in PolynomialPauliRotations e PiecewiseLinearPauliRotations che rende più efficiente l'implementazione di questi circuiti. Corretto #5320 e #5322
Correggere l'utilizzo dei qubit helper allocati nel MCXGate nella classe WeightedAdder classe. Prima di questa correzione erano stati assegnati ma non utilizzati. Corretto #5321
In un certo numero di casi, il metodo di uscita latex per la funzione qiskit.visualization.circuit_drawer() e il metodo draw() non mostravano correttamente il nome del gate e, in altri casi, non includevano i parametri del gate dove avrebbero dovuto essere. Ora i nomi dei gate saranno visualizzati nello stesso modo in cui sono visualizzati con il metodo di uscita mpl e i parametri saranno visualizzati per tutti i gate che li hanno. Inoltre, alcuni cancelli non venivano visualizzati nella forma corretta e sono stati corretti. Correzioni #5605, #4938 e #3765
È stato risolto un problema a causa del quale, se il metodo qiskit.circuit.Instruction.to_instruction() veniva utilizzato su un sottocircuito che conteneva registri classici e quell'oggetto veniva poi aggiunto a una classe di registri Instruction veniva poi aggiunto a un oggetto QuantumCircuit l'uscita della funzione qiskit.visualization.circuit_drawer() e del metodo qiskit.circuit.QuantumCircuit.draw() in alcuni casi visualizzava il sottocircuito a sinistra di una misura, mentre avrebbe dovuto essere visualizzato a destra. Corretto #5947
Corretto un problema con gli Delay in un oggetto QuantumCircuit dove qiskit.compiler.transpile() non convertivano le unità dell'oggetto Delay alle unità dell'oggetto Backendse il kwarg di backend è impostato su transpile(). Ciò potrebbe comportare un comportamento errato a causa di una mancata corrispondenza delle unità, ad esempio l'esecuzione:
```
from qiskit import transpile, execute
from qiskit.circuit import QuantumCircuit

qc = QuantumCircuit(1)
qc.delay(100, [0], unit='us')

qc = transpile(qc, backend)
job = execute(qc, backend)
```
in precedenza avrebbe comportato il ritardo del backend per 100 timestep (ciascuno di durata dt) anziché per i timestep previsti ( 100e-6 / dt). Il problema è stato corretto in modo che la qiskit.compiler.transpile() converta correttamente le unità di misura.

Altre note

Le istantanee di tutti i backend falsi/mock in qiskit.test.mock sono state aggiornate per riflettere le recenti modifiche ai dispositivi. Questo include una modifica dell'attributo basis_gates per l'attributo BackendConfiguration a ['cx', 'rz', 'sx', 'x', 'id'], l'aggiunta di una proprietà readout_length alle proprietà dei qubit nella classe BackendPropertiese l'aggiornamento del file PulseDefaults in modo che tutti i backend di mock supportino istanze parametriche basate su impulsi InstructionScheduleMap istanze.

Aer 0.8.0

Preludio

La release 0.8 include diverse nuove funzionalità e correzioni di bug. I punti salienti di questa versione sono: l'introduzione di un backend unificato AerSimulator per l'esecuzione di simulazioni di circuiti utilizzando uno qualsiasi dei metodi di simulazione supportati; una libreria di istruzioni per il simulatore (qiskit.providers.aer.library) che include istruzioni personalizzate per il salvataggio di vari tipi di dati del simulatore; il supporto MPI per l'esecuzione di simulazioni di grandi dimensioni su un ambiente di calcolo distribuito.

Nuove funzioni

Python 3.9 è stato aggiunto in questa versione. È ora possibile eseguire Qiskit Aer utilizzando Python 3.9 senza compilare i sorgenti.
Aggiungere il flag CMake DISABLE_CONAN (default=```OFF``). Quando si installa dai sorgenti, impostare ON consente di bypassare il gestore di pacchetti Conan per trovare le librerie già installate sul sistema. È disponibile anche come variabile d'ambiente DISABLE_CONAN, che ha la precedenza sul flag di CMake. Questa non è la procedura ufficiale per costruire AER. Pertanto, l'utente è responsabile di fornire tutte le librerie necessarie e i file corrispondenti per renderli reperibili a CMake.
Questa versione include il supporto per la creazione di qiskit-aer con supporto MPI per l'esecuzione di simulazioni di grandi dimensioni su un ambiente di calcolo distribuito. Consultare la guida per i contributi per istruzioni sulla compilazione e l'esecuzione in un ambiente MPI.
È ora possibile costruire qiskit-aer con CUDA abilitato in Windows. Si veda la guida alla contribuzione per le istruzioni sulla compilazione dai sorgenti con il supporto per le GPU.
Quando si costruisce l'estensione qiskit-aer Python dai sorgenti, è necessario preinstallare alcune dipendenze di compilazione per consentire la compilazione del C++. Per comodità dell'utente, quando si costruisce l'estensione, le dipendenze mancanti vengono installate automaticamente con pip prima dei normali passaggi di installazione di setuptools , ma in precedenza non era possibile evitare questa installazione automatica. Per risolvere questo problema è stata aggiunta una nuova variabile d'ambiente DISABLE_DEPENDENCY_INSTALL . Se è impostato su 1 o ON quando si costruisce l'estensione python dai sorgenti, si disabilita l'installazione automatica di queste dipendenze mancanti.
Aggiunge il supporto per la porta di Pauli a N-qubit ottimizzata ( qiskit.circuit.library.PauliGate) ai metodi StatevectorSimulator, UnitarySimulator, e ai metodi dei vettori di stato e delle matrici di densità di QasmSimulator e AerSimulator.
Il metodo run() per i backend AerSimulator, QasmSimulator, StatevectorSimulator e UnitarySimulator ora accetta un parametro QuantumCircuit (o un elenco di oggetti QuantumCircuit come input. L'oggetto precedente QasmQobj è ancora supportato per ora, ma sarà deprecato in una versione futura.

Per un esempio di utilizzo si veda:
```
from qiskit import transpile, QuantumCircuit

from qiskit.providers.aer import Aer

backend = Aer.get_backend('aer_simulator')

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

tqc = transpile(circuit, backend)
result = backend.run(tqc, shots=4096).result()
```
Il metodo run() per il backend PulseSimulator ora accetta un parametro Schedule (o un elenco di oggetti Schedule ) come input. L'oggetto precedente PulseQobj è ancora supportato per ora, ma sarà deprecato in una versione futura.
Aggiunge il nuovo backend del simulatore AerSimulator che supporta i seguenti metodi di simulazione
- automatic
- statevector
- stabilizer
- density_matrix
- matrix_product_state
- unitary
- superop
Il metodo automatico predefinito sceglierà automaticamente un metodo di simulazione separatamente per ciascun circuito eseguito, in base alle istruzioni del circuito e al modello di rumore (se presente). L'inizializzazione di un simulatore con un metodo specifico può essere effettuata utilizzando l'opzione metodo.

La simulazione su GPU per i metodi statevector, density matrix e unitary può essere abilitata impostando l'opzione device='GPU' backend.

Si noti che i metodi unitary e superop non supportano la misurazione in quanto simulano la matrice unitaria o la matrice dei superoperatori del circuito di esecuzione, pertanto è necessario utilizzare una delle nuove istruzioni save_unitary(), save_superop(), o save_state() per salvare lo stato del simulatore nei risultati restituiti. Allo stesso modo, lo stato degli altri metodi di simulazione può essere salvato utilizzando le istruzioni appropriate. Per maggiori dettagli, consultare i documenti dell'API qiskit.providers.aer.library .

Si noti che il simulatore AerSimulator sostituisce i backend QasmSimulator, StatevectorSimulator e UnitarySimulator , che saranno deprecati in una versione futura.
Aggiorna la classe AerProvider per includere più backend AerSimulator preconfigurati per tutti i metodi di simulazione e i dispositivi di simulazione disponibili. Si può accedere ai nuovi backend attraverso l'interfaccia del provider utilizzando i nomi
- "aer_simulator"
- "aer_simulator_statevector"
- "aer_simulator_stabilizer"
- "aer_simulator_density_matrix"
- "aer_simulator_matrix_product_state"
- "aer_simulator_extended_stabilizer"
- "aer_simulator_unitary"
- "aer_simulator_superop"
Se Aer è stato installato con il supporto per le GPU su un sistema compatibile, saranno disponibili anche i seguenti backend per le GPU
- "aer_simulator_statevector_gpu"
- "aer_simulator_density_matrix_gpu"
- "aer_simulator_unitary_gpu"
Ad esempio:
```
from qiskit import Aer

# Get the GPU statevector simulator backend
backend = Aer.get_backend('aer_simulator_statevector_gpu')
```
Aggiunto un nuovo metodo norm estimation per l'esecuzione delle misure quando si utilizza il metodo di simulazione "extended_stabilizer" . Questo metodo di stima della norma può essere utilizzato passando le seguenti opzioni ai backend AerSimulator e QasmSimulator
```
simulator = QasmSimulator(
    method='extended_stabilizer',
    extended_stabilizer_sampling_method='norm_estimation')
```
Il metodo di stima della norma è più lento delle opzioni alternative metropolis o resampled_metropolis , ma offre prestazioni migliori su circuiti con distribuzioni di uscita rade. Per ulteriori informazioni, consultare la documentazione di QasmSimulator .
Aggiunge istruzioni per salvare lo stato del simulatore in vari formati. Queste istruzioni sono
- qiskit.providers.aer.library.SaveDensityMatrix
- qiskit.providers.aer.library.SaveMatrixProductState
- qiskit.providers.aer.library.SaveStabilizer
- qiskit.providers.aer.library.SaveState
- qiskit.providers.aer.library.SaveStatevector
- qiskit.providers.aer.library.SaveStatevectorDict
- qiskit.providers.aer.library.SaveUnitary
Queste istruzioni possono essere aggiunte a un circuito quantistico utilizzando i metodi di circuito save_density_matrix, save_matrix_product_state, save_stabilizer, save_state, save_statevector, save_statevector_dict, save_unitary che vengono aggiunti a QuantumCircuit quando si importa Aer.

Per i dettagli sulla compatibilità dei metodi per ciascuna istruzione, consultare la documentazione dell'API qiskit.providers.aer.library .

Si noti che le istruzioni snapshot SnapshotStatevector, SnapshotDensityMatrix, SnapshotStabilizer sono ancora supportate, ma saranno deprecate in una versione futura.
Aggiunge le istruzioni dei circuiti quantistici qiskit.providers.aer.library.SaveExpectationValue e qiskit.providers.aer.library.SaveExpectationValueVariance per salvare il valore di aspettativa $\langle H\rangle = Tr[H\rho]$ , o il valore di aspettativa e la varianza $Var(H) = \langle H^2\rangle - \langle H\rangle^2$ , di un operatore hermitiano $H$ per lo stato del simulatore $\rho$ . Queste istruzioni possono essere aggiunte a un circuito quantistico utilizzando i metodi di circuito save_expectation_value e save_expectation_value_variance che vengono aggiunti a QuantumCircuit quando si importa Aer.

Si noti che l'istruzione snapshot SnapshotExpectationValue è ancora supportata, ma sarà deprecata in una release futura.
Aggiunge qiskit.providers.aer.library.SaveProbabilities e qiskit.providers.aer.library.SaveProbabilitiesDict istruzioni di circuito quantistico per il salvataggio di tutte le probabilità di esito della misurazione per le misure Z-basis dello stato del simulatore. Queste istruzioni possono essere aggiunte a un circuito quantistico utilizzando i metodi di circuito save_probabilities e save_probabilities_dict , che viene aggiunto a QuantumCircuit quando si importa Aer.

Si noti che l'istruzione snapshot SnapshotProbabilities è ancora supportata, ma sarà deprecata in una release futura.
Aggiunge le istruzioni dei circuiti qiskit.providers.aer.library.SaveAmplitudes e qiskit.providers.aer.library.SaveAmplitudesSquared per salvare le ampiezze dei vettori di stato complessi selezionati o le probabilità selezionate (ampiezze al quadrato) per i metodi di simulazione supportati. Queste istruzioni possono essere aggiunte a un circuito quantistico utilizzando i metodi di circuito save_amplitudes e save_amplitudes_squared che viene aggiunto a QuantumCircuit quando si importa Aer.
Aggiunge istruzioni per impostare lo stato dei simulatori. Queste istruzioni devono essere definite sull'intero numero di qubit del circuito. Possono essere applicati in qualsiasi punto di un circuito e sostituiscono lo stato del simulatore con quello specificato. Le istruzioni aggiunte sono
- qiskit.providers.aer.library.SetDensityMatrix
- qiskit.providers.aer.library.SetStabilizer
- qiskit.providers.aer.library.SetStatevector
- qiskit.providers.aer.library.SetUnitary
Queste istruzioni possono essere aggiunte a un circuito quantistico utilizzando i metodi di circuito set_density_matrix, set_stabilizer, set_statevector, set_unitary che vengono aggiunti a QuantumCircuit quando si importa Aer.

Per i dettagli sulla compatibilità dei metodi per ciascuna istruzione, consultare la documentazione dell'API qiskit.providers.aer.library .
Aggiunto il supporto per le porte diagonali al metodo di simulazione "matrix_product_state" .
Aggiunto il supporto dell'istruzione initialize al metodo di simulazione "matrix_product_state" .

Problemi noti

È noto un problema per cui la simulazione di alcuni circuiti con un modello di rumore Kraus utilizzando il metodo di simulazione "matrix_product_state" può causare un arresto anomalo del simulatore. Per ulteriori informazioni, consultare la sezione #306.

Note sull'aggiornamento

La versione minima di Conan è stata aumentata a 1.31.2. Questa operazione si è resa necessaria per risolvere un problema di compatibilità con le versioni più recenti del software urllib3 (che è una dipendenza di Conan). Aggiunge inoltre il supporto nativo per AppleClang 12, utile per gli utenti con i nuovi computer Apple.
pybind11 la versione minima richiesta è 2.6 invece di 2.4. Questo è necessario per supportare la compilazione con CUDA in Windows.
Cython è stato rimosso come dipendenza di compilazione.
Rimossa la decomposizione del gate di x90 dai modelli di rumore, deprecata in qiskit-aer 0.7. Questa decomposizione viene ora effettuata utilizzando le porte di base del modello di rumore regolare e il transpiler qiskit.
Le seguenti opzioni per il metodo di simulazione "extended_stabilizer" sono state modificate.
- extended_stabilizer_measure_sampling: Questa opzione è stata sostituita dall'opzione extended_stabilizer_sampling_method, che controlla il modo in cui simuliamo la misurazione dei qubit.
- extended_stabilizer_mixing_time: Questa opzione è stata rinominata extended_stabilizer_metropolis_mixing_time per chiarire che si applica solo ai metodi di campionamento metropolis e resampled_metropolis .
- extended_stabilizer_norm_estimation_samples: Questa opzione è stata rinominata in extended_stabilizer_norm_estimation_default_samples.
È stata aggiunta l'opzione extended_stabilizer_norm_estimation_repetitions , che controlla parte del comportamento del metodo di campionamento della stima della norma.

Note di deprecazione

Python 3.6 è stato deprecato e sarà rimosso in una prossima versione. Quando il supporto verrà rimosso, sarà necessario aggiornare la versione Python in uso a Python 3.7 o superiore.

Correzioni di bug

Corregge il bug di AerProvider per cui le opzioni impostate sui backend restituiti usando set_options() venivano memorizzate nel provider e persistevano per le successive chiamate a get_backend() per lo stesso backend denominato. Ora ogni chiamata a backends() restituisce una nuova istanza del backend del simulatore, che può essere configurato.
Corregge un errore nel messaggio di errore restituito quando un circuito contiene istruzioni del simulatore non supportate. In precedenza, alcune istruzioni supportate venivano elencate nel messaggio di errore insieme a quelle non supportate.
Corregge il problema dell'impostazione delle porte di base di QasmSimulator quando si usano le opzioni "method" e "noise_model" insieme e quando le si usa con un simulatore costruito con from_backend(). Ora le porte di base elencate saranno l'intersezione delle porte supportate dalla configurazione del backend, dal metodo di simulazione e dalle porte di base del modello di rumore. Se l'intersezione delle porte di base del modello di rumore e delle porte di base del simulatore è vuota, viene registrato un avviso.
Correzione del bug per cui il gate "sx"` SXGate non era elencato come gate supportato nel codice C++, in StateOpSet di matrix_product_state.hp.
Correggere il bug per cui "csx", "cu2", "cu3" erano erroneamente elencati come porte di base supportate per il metodo "density_matrix" di QasmSimulator.
Correzione del bug per cui i parametri venivano passati in modo errato tra le funzioni di matrix_product_state_internal.cpp, causando una simulazione errata e il raggiungimento di stati non validi, che a loro volta causavano un loop infinito.
Corregge un bug che causava il mancato funzionamento di c_if quando la larghezza del registro condizionale era superiore a 64. Vedere il numero 1077.
Corregge il bug #1153 ) per cui il rumore sulle porte condizionali veniva sempre applicato indipendentemente dal fatto che la porta condizionale fosse effettivamente applicata in base al valore del registro classico. Ora il rumore su un gate condizionale verrà applicato solo nel caso in cui il gate condizionale sia applicato.
Corregge un bug con il flag OpenMP annidato che veniva impostato su true quando non doveva esserlo.
Corregge un bug quando si applica il troncamento nel metodo del prodotto matriciale di stato di QasmSimulator.
Corretto il problema #1126 : bug nel riportare la misura di un singolo qubit. L'errore si è verificato durante la copia del valore misurato nella struttura dati di uscita.
In MPS, apply\kraus operava direttamente sui bit di ingresso nei qubit dei parametri, invece che sui qubit interni. Nell'algoritmo MPS, i qubit si muovono continuamente, quindi tutte le operazioni devono essere applicate ai qubit interni.
Quando si invoca MPS::sample_measure, occorre prima ordinare i qubit secondo l'ordinamento predefinito, perché questo è il presupposto di qasm_controller.This, invocando il metodo move_all_qubits_to_sorted_ordering. Era corretto nel campione misura_utilizzo_applicazione_misura, ma mancava nel campione misura_utilizzo_probabilità.
Corregge un bug con il metodo from_backend() di QasmSimulator che impostava l'attributo local della configurazione al valore del backend invece di essere sempre impostato su True.
Corregge il bug di from_backend() e from_backend() per cui basis_gates veniva impostato in modo errato per i dispositivi IBMQ con gate di base impostato su ['id', 'rz', 'sx', 'x', 'cx']. Ora il modello di rumore avrà sempre le stesse porte di base delle porte di base del backend, indipendentemente dal fatto che le istruzioni abbiano o meno errori nel modello di rumore.
Corregge un problema per cui il metodo di simulazione esteso "extended_stabilizer" forniva risultati errati su circuiti quantistici con distribuzioni di uscita rade. Per ulteriori informazioni ed esempi, consultare il documento #306.

Ignis 0.6.0

Nuove funzioni

La funzione qiskit.ignis.mitigation.expval_meas_mitigator_circuits() è stata migliorata in modo da ridurre il numero di circuiti generati dalla funzione utilizzata per la calibrazione con il metodo CTMP da $O(n)$ a $O(\log{n})$ (dove $n$ è il numero di qubit).

Note sull'aggiornamento

La funzione qiskit.ignis.verification.randomized_benchmarking_seq() utilizza ora la classe CNOTDihedral aggiornata, qiskit.ignis.verification.CNOTDihedral, che consente di eseguire il CNOT-Dihedral Randomized Benchmarking su più di due qubit.
Il pacchetto python retworkx è ora un requisito per l'installazione di qiskit-ignis. Sostituisce il precedente utilizzo di networkx (che non è più un requisito) per ottenere prestazioni migliori.
La dipendenza da scikit-learn non è più necessaria e ora è un requisito opzionale. Se si utilizzano i discriminatori di misura IQ (IQDiscriminationFitter, LinearIQDiscriminationFitter, QuadraticIQDiscriminationFitter, o SklearnIQDiscriminator) è necessario installare manualmente scikit-learn, eseguendo pip install scikit-learn o installando anche qiskit-ignis con pip install qiskit-ignis[iq].

Correzioni di bug

Corretto un problema nel metodo del valore di aspettativa expectation_value(), per le classi di attenuazione degli errori TensoredExpvalMeasMitigator e CTMPExpvalMeasMitigator se il kwarg qubits non era specificato, si utilizzava erroneamente il numero totale di qubit del mitigatore, anziché il numero di bit classici nel dizionario dei conteggi, con conseguente riduzione delle prestazioni. Corretto #561
Correggere il metodo "auto" dei metodi TomographyFitter, StateTomographyFitter e ProcessTomographyFitter in modo da utilizzare "cvx" solo se CVXPY è installato e se è disponibile un solutore SDP di terze parti diverso da SCS. Questo perché il solutore SCS ha un'accuratezza inferiore rispetto ad altri metodi di risoluzione e spesso restituisce una matrice di densità o una matrice di Choi che non è completamente positiva e fallisce la convalida quando viene utilizzata con il metodo qiskit.quantum_info.state_fidelity() o qiskit.quantum_info.process_fidelity() .

Acqua 0.9.0

Con questa release il progetto Qiskit Aqua viene ufficialmente deprecato; in futuro (non prima di 3 mesi da questa release) il progetto Aqua avrà il suo rilascio finale e sarà archiviato. Tutte le funzionalità fornite da qiskit-aqua sono state migrate in nuovi pacchetti o in altri pacchetti qiskit. I moduli applicativi forniti da qiskit-aqua sono stati suddivisi in diversi nuovi pacchetti: qiskit-optimization, qiskit-nature, qiskit-machine-learning, e qiskit-finance. Questi pacchetti possono essere installati da soli (tramite il comando standard pip install, cioè pip install qiskit-nature) o con il resto del metapacchetto Qiskit come extra opzionali (cioè pip install 'qiskit[finance,optimization]' o pip install 'qiskit[all]'. I blocchi di base per gli algoritmi e il flusso degli operatori sono ora disponibili come parte di qiskit-terra all'indirizzo qiskit.algorithms e qiskit.opflow. A seconda dell'uso che si fa di Aqua, si possono utilizzare i pacchetti applicativi o i nuovi moduli di Qiskit Terra.

Per maggiori dettagli su come migrare dall'utilizzo di Qiskit Aqua, è possibile consultare la guida alla migrazione.

IBM Q Fornitore 0.12.2

Nessuna modifica

Questa pagina è stata utile?

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