Note di rilascio di Qiskit 0.18

0.18.3

Terra 0.13.0

Nessuna modifica

Aer 0.5.1

Note sull'aggiornamento

Modifica il modo in cui vengono gestiti i passaggi di transpilazione nelle classi Controller C++, in modo che ogni passaggio debba essere chiamato esplicitamente. Ciò consente una maggiore personalizzazione del momento in cui ogni passaggio deve essere richiamato e con quali parametri. In particolare, ciò consente di impostare parametri diversi per il passaggio di ottimizzazione della fusione dei gate a seconda del metodo di simulazione QasmController.
Aggiungere gate_length_units kwarg a qiskit.providers.aer.noise.NoiseModel.from_device() per specificare gate_lengths personalizzato nella funzione del modello di rumore del dispositivo per gestire le conversioni di unità per il codice interno.
Aggiunta del gate Controlled-Y ("cy") ai metodi di simulazione dello stabilizzatore supportati dal gateset.
Per il backend di Aer la validazione jsonschema degli oggetti qobj in ingresso da terra è ora opt-in invece di essere abilitata di default. Se si vuole abilitare la validazione jsonschema di qobj, impostare il kwarg validate sul metodo qiskit.providers.aer.QasmSimualtor.run() per l'oggetto backend a True.

Correzioni di bug

Rimuovere "extended_stabilizer" dai metodi di simulazione selezionati automaticamente. Questo è necessario perché il metodo dello stabilizzatore esteso non è esatto e può dare risultati errati per alcuni circuiti, a meno che l'utente non sappia come ottimizzare i suoi parametri di configurazione.

Il metodo automatico ora seleziona solo i metodi "stabilizzatore", "matrice_densità" e "vettore di stato". Se viene eseguito un circuito non-Clifford troppo grande per il metodo statevector, viene sollevata un'eccezione che suggerisce di provare a usare esplicitamente i metodi "extended_stabilizer" o "matrix_product_state".
Corregge le classi Controller in modo che il passaggio di transpilazione ReduceBarrier sia applicato per primo. In questo modo si evita che le istruzioni barriera impediscano il troncamento dei qubit inutilizzati se l'unica istruzione definita su di essi è una barriera.
Disabilita la fusione dei gate per il metodo di simulazione di stato del prodotto matriciale, poiché in alcuni casi causava problemi con la restituzione di risultati errati.
Correzione dell'errore di conversione dell'unità di tempo del gate per il modello di rumore del dispositivo con errori di rilassamento termico ed errori del gate. La probabilità di errore di depolarizzazione veniva calcolata con il tempo di gate in microsecondi, mentre per il rilassamento termico veniva calcolata in nanosecondi. In questo modo non è stato applicato alcun errore di depolarizzazione, poiché le unità errate avrebbero fatto sembrare il dispositivo limitato nella coerenza.
Correzione del bug della composizione errata di QuantumErrors quando i qubit delle istruzioni composte differiscono.
Correzione del problema per cui il gate "diagonale" viene controllato come unitario con una tolleranza troppo alta. In questo modo le diagonali generate dalle funzioni Numpy spesso non superavano il test.
Correggere il passaggio di ottimizzazione del circuito remove-barrier da applicare prima della trucazione dei qubit. In questo modo si risolve un problema per cui le barriere inserite dal transpiler Terra attraverso qubit altrimenti inattivi impedivano il loro troncamento.

Ignis 0.3.0

Nessuna modifica

Acqua 0.6.6

Nessuna modifica

IBM Q Fornitore 0.6.1

Nessuna modifica

0.18.0

Terra 0.13.0

Preludio

La release 0.13.0 include molti cambiamenti importanti. Alcuni punti salienti di questa release sono:

Per il transpiler abbiamo cambiato la libreria di grafi usata per costruire la classe qiskit.dagcircuit.DAGCircuit che è la struttura dati sottostante a tutte le operazioni, si basa su retworkx per migliorare notevolmente le prestazioni. La velocità di transpilazione dei circuiti nella versione 0.13.0 dovrebbe essere significativamente più veloce rispetto alle versioni precedenti.

Lo stile di costruzione delle istruzioni Pulse è stato notevolmente semplificato. Ora, gli Command s sono deprecati e viene supportato un insieme unificato di Instruction sono supportati.

Il modulo qiskit.quantum_info include diverse nuove funzioni per la generazione di operatori casuali (come i canali Cliffords e quantistici) e per il calcolo della norma di diamante dei canali quantistici; aggiornamenti alle funzioni Statevector e DensityMatrix per supportare il calcolo delle probabilità di misura e il campionamento delle misure; diverse nuove classi sono basate sulla rappresentazione simplettica delle matrici di Pauli. Queste nuove classi includono gli operatori di Clifford (Clifford), matrici di N-qubit che sono rade nella base di Pauli (SparsePauliOp), liste di Pauli (PauliTable) e liste di stabilizzatori (StabilizerTable).

Questa versione presenta anche una documentazione notevolmente migliorata in tutto Qiskit, compresa la documentazione migliorata per i file qiskit.circuit, qiskit.pulse e qiskit.quantum_info .

Inoltre, la denominazione degli oggetti e dei metodi dei gate QuantumCircuit sono stati aggiornati per essere più coerenti. Ciò ha comportato la deprecazione di diverse classi e metodi, in quanto si è passati a uno schema di nomi più coerente.

Per tutti i dettagli su tutte le modifiche apportate in questa versione, consultare le note di rilascio dettagliate riportate di seguito.

Nuove funzioni

Aggiunto un nuovo modulo di libreria di circuiti qiskit.circuit.library. Questo sarà un luogo per i costruttori di circuiti di uso comune che possono essere utilizzati come blocchi di costruzione per circuiti o applicazioni più grandi.
La classe qiskit.providers.BaseJob ha quattro nuovi metodi:
- done()
- running()
- cancelled()
- in_final_state()
Questi metodi vengono utilizzati per verificare se un lavoro si trova in un determinato stato.
Aggiungere la possibilità di specificare il controllo condizionato alla presenza di un qubit nello stato di massa. Lo stato dei qubit di controllo è rappresentato da un numero intero. Ad esempio:
```
from qiskit import QuantumCircuit
from qiskit.extensions.standard import XGate

qc = QuantumCircuit(4)
cgate = XGate().control(3, ctrl_state=6)
qc.append(cgate, [0, 1, 2, 3])
```
Crea un gate a quattro qubit in cui il quarto qubit viene invertito se il primo qubit è allo stato terreno e il secondo e il terzo qubit sono allo stato eccitato. Se ctrl_state è None, il valore predefinito, il controllo è condizionato all'eccitazione di tutti i qubit di controllo.
Un nuovo widget di jupyter, %circuit_library_info , è stato aggiunto a qiskit.tools.jupyter. Questo widget viene utilizzato per visualizzare i dettagli dei circuiti costruiti dalla libreria di circuiti. Per esempio
```
from qiskit.circuit.library import XOR
import qiskit.tools.jupyter
circuit = XOR(5, seed=42)
%circuit_library_info circuit
```
Una nuova opzione kwarg, formatted , è stata aggiunta a qiskit.circuit.QuantumCircuit.qasm() . Se impostato su True , il metodo stamperà una versione evidenziata dalla sintassi (usando pygments) su stdout e restituirà None (che differisce dal comportamento normale di restituzione del codice QASM come stringa).
Una nuova opzione kwarg, filename , è stata aggiunta a qiskit.circuit.QuantumCircuit.qasm(). Se impostato su un percorso, il metodo scriverà il codice QASM in quel file. Continuerà quindi a produrre normalmente.
Una nuova istruzione SetFrequency che consente agli utenti di modificare la frequenza di PulseChannel. Ciò avviene nel modo seguente:
```
from qiskit.pulse import Schedule
from qiskit.pulse import SetFrequency

sched = pulse.Schedule()
sched += SetFrequency(5.5e9, DriveChannel(0))
```
In questo esempio, la frequenza di tutti gli impulsi prima del comando SetFrequency sarà quella predefinita e tutti gli impulsi applicati al canale di azionamento zero dopo il comando SetFrequency saranno a 5.5 GHz. Gli utenti di SetFrequency devono tenere conto di eventuali limitazioni hardware.
Un nuovo metodo, assign_parameters() è stato aggiunto alla classe qiskit.circuit.QuantumCircuit classe. Questo metodo accetta un dizionario di parametri con oggetti float e Parameters in un unico dizionario. In altre parole, questo nuovo metodo consente di associare i float, i parametri o entrambi in un singolo dizionario.

Inoltre, utilizzando il kwarg di inplace si può specificare che è possibile modificare il circuito originale in modo opzionale. L'impostazione predefinita è False e il metodo restituisce una copia del circuito originale.
Un nuovo metodo num_nonlocal_gates() è stato aggiunto alla classe qiskit.circuit.QuantumCircuit classe. Questo metodo restituisce il numero di porte di un circuito che coinvolgono 2 o più qubit. Questi cancelli sono più costosi in termini di tempo ed errori da implementare.
Il qiskit.circuit.QuantumCircuit metodo iso() per aggiungere una porta Isometry al circuito ha un nuovo alias. Ora è possibile chiamare qiskit.circuit.QuantumCircuit.isometry() oltre a chiamare iso.
È stato aggiunto un attributo description alla classe CouplingMap per memorizzare una breve descrizione per le diverse mappe di accoppiamento (ad esempio, pieno, griglia, linea, ecc.).

Un nuovo metodo compose() è stato aggiunto alla classe DAGCircuit per comporre due circuiti attraverso i loro DAG.

dag_left.compose(dag_right, edge_map={right_qubit0: self.left_qubit1,
                                  right_qubit1: self.left_qubit4,
                                  right_clbit0: self.left_clbit1,
                                  right_clbit1: self.left_clbit0})

            ┌───┐                    ┌─────┐┌─┐
lqr_1_0: ───┤ H ├───     rqr_0: ──■──┤ Tdg ├┤M├
            ├───┤               ┌─┴─┐└─┬─┬─┘└╥┘
lqr_1_1: ───┤ X ├───     rqr_1: ┤ X ├──┤M├───╫─
         ┌──┴───┴──┐            └───┘  └╥┘   ║
lqr_1_2: ┤ U1(0.1) ├  +  rcr_0: ════════╬════╩═  =
         └─────────┘                    ║
lqr_2_0: ─────■─────     rcr_1: ════════╩══════
            ┌─┴─┐
lqr_2_1: ───┤ X ├───
            └───┘
lcr_0:   ═══════════

lcr_1:   ═══════════

            ┌───┐
lqr_1_0: ───┤ H ├──────────────────
            ├───┤        ┌─────┐┌─┐
lqr_1_1: ───┤ X ├─────■──┤ Tdg ├┤M├
         ┌──┴───┴──┐  │  └─────┘└╥┘
lqr_1_2: ┤ U1(0.1) ├──┼──────────╫─
         └─────────┘  │          ║
lqr_2_0: ─────■───────┼──────────╫─
            ┌─┴─┐   ┌─┴─┐  ┌─┐   ║
lqr_2_1: ───┤ X ├───┤ X ├──┤M├───╫─
            └───┘   └───┘  └╥┘   ║
lcr_0:   ═══════════════════╩════╬═
                                 ║
lcr_1:   ════════════════════════╩═

I mock backend in qiskit.test.mock hanno ora un metodo funzionale run() che restituisce risultati simili a quelli dei dispositivi reali. Se qiskit-aer è installato, verrà eseguita una simulazione con un modello di rumore costruito a partire dall'istantanea del dispositivo nel backend fasullo. Altrimenti, qiskit.providers.basicaer.QasmSimulatorPy verrà utilizzato per eseguire una simulazione ideale. Inoltre, se un esperimento a impulsi viene passato a run e qiskit-aer è installato, PulseSimulator verrà utilizzato per simulare gli orari degli impulsi.
Il qiskit.result.Result() restituirà un elenco di tutti i conteggi disponibili quando ci sono più circuiti nel lavoro get_counts() restituirà ora un elenco di tutti i conteggi disponibili quando ci sono più circuiti in un lavoro. Questo funziona quando get_counts() viene chiamato senza argomenti.

La considerazione principale per questa funzione è stata quella di disegnare tutti i risultati di più circuiti nello stesso istogramma. Ad esempio, è ora possibile fare qualcosa di simile:
```
from qiskit import execute
from qiskit import QuantumCircuit
from qiskit.providers.basicaer import BasicAer
from qiskit.visualization import plot_histogram

sim = BasicAer.get_backend('qasm_simulator')

qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.measure_all()
result = execute([qc, qc, qc], sim).result()

plot_histogram(result.get_counts())
```
Un nuovo kwarg, initial_state , è stato aggiunto alla funzione qiskit.visualization.circuit_drawer() e al metodo QuantumCircuit metodo draw(). Se impostato su True , lo stato iniziale sarà incluso nelle visualizzazioni dei circuiti per tutti i backend. Ad esempio:
```
from qiskit import QuantumCircuit

circuit = QuantumCircuit(2)
circuit.measure_all()
circuit.draw(output='mpl', initial_state=True)
```

È ora possibile inserire un callable in un oggetto qiskit.pulse.InstructionScheduleMap che restituisce un nuovo oggetto qiskit.pulse.Schedule quando viene richiamato con dei parametri. Ad esempio:

def test_func(x):
   sched = Schedule()
   sched += pulse_lib.constant(int(x), amp_test)(DriveChannel(0))
   return sched

inst_map = InstructionScheduleMap()
inst_map.add('f', (0,), test_func)
output_sched = inst_map.get('f', (0,), 10)
assert output_sched.duration == 10

Due nuove classi di porte, qiskit.extensions.iSwapGate e qiskit.extensions.DCXGate, e i loro metodi QuantumCircuit metodi iswap() e dcx() sono stati aggiunti alle estensioni standard. Queste porte, localmente equivalenti tra loro, possono essere utilizzate per realizzare particolari interazioni XY. Una breve motivazione di questi cancelli si trova in: arxiv.org/abs/quant-ph/0209035
La classe qiskit.providers.BaseJob ha ora un nuovo metodo wait_for_final_state() che esegue il polling dello stato del lavoro fino a quando il lavoro non raggiunge uno stato finale (come DONE o ERROR). Questo metodo prende anche un kwarg opzionale callback che prende un callable Python che sarà chiamato durante ogni iterazione del ciclo di polling.
Gli attributi search_width e search_depth del metodo qiskit.transpiler.passes.LookaheadSwap sono ora impostabili durante l'inizializzazione del passo. Uno spazio di ricerca più ampio può spesso portare a circuiti più ottimizzati, al costo di tempi di esecuzione più lunghi.
Il numero di qubit in BackendConfiguration è ora accessibile tramite la proprietà num_qubits. In precedenza era accessibile solo tramite l'attributo n_qubits .
Due nuovi metodi, angles() e angles_and_phase()sono stati aggiunti alla classe qiskit.quantum_info.OneQubitEulerDecomposer della classe. Questi metodi restituiranno i parametri pertinenti senza convalida, mentre chiamando l'oggetto OneQubitEulerDecomposer si eseguirà la sintesi completa con convalida.
Una base di decomposizione RR è stata aggiunta al programma qiskit.quantum_info.OneQubitEulerDecomposer per decomporre un 2x2 unitario arbitrario in un circuito a due RGate .
Aggiunge la possibilità di impostare qargs agli oggetti che sono sottoclassi della classe astratta BaseOperator . Questo avviene chiamando l'oggetto op(qargs) (dove op è una classe di operatori) e restituirà una copia superficiale dell'oggetto originale con una proprietà qargs impostata. Quando un oggetto di questo tipo viene utilizzato con l'opzione compose() o dot() verrà utilizzato il valore interno di qargs quando il metodo qargs kwarg non viene utilizzato. Ciò consente la composizione di sottosistemi utilizzando, ad esempio, operatori binari:
```
from qiskit.quantum_info import Operator

init = Operator.from_label('III')
x = Operator.from_label('X')
h = Operator.from_label('H')
init @ x([0]) @ h([1])
```
Aggiunge qiskit.quantum_info.Clifford al modulo quantum_info. Questo operatore è una rappresentazione simplettica efficiente di un operatore unitario a N-qubit del gruppo di Clifford. Questa classe include un to_circuit() per la compilazione in un sito QuantumCircuit di porte Clifford con un numero minimo di porte CX per un massimo di 3 qubit. Fornisce anche una compilazione generale per N > 3 qubit, ma questo metodo non è ottimale per il numero di porte a due qubit.
Aggiunge qiskit.quantum_info.SparsePauliOp classe di operatori. Si tratta di una rappresentazione efficiente di una matrice di N-qubit che è rada nella base di Pauli e utilizza un qiskit.quantum_info.PauliTable e un vettore di coefficienti complessi per la sua struttura dati.

Questa classe supporta molte delle stesse funzionalità della classe qiskit.quantum_info.Operator classe, per cui SparsePauliOp gli oggetti possono essere decimati, composti, moltiplicati scalarmente, aggiunti e sottratti.

Gli array o gli oggetti Numpy Operator possono essere convertiti in oggetti SparsePauliOp utilizzando il metodo :class:`~qiskit.quantum_info.SparsePauliOp.from_operator. SparsePauliOp può essere convertito in una matrice csr sparse o in un array Numpy denso usando il metodo to_matrix o a un oggetto Operator utilizzando il metodo to_operator metodo.

A SparsePauliOp può essere iterato in termini di componenti e coefficienti di PauliTable , di coefficienti e di etichette delle stringhe di Pauli utilizzando il metodo label_iter() e le componenti (dense o rade) della matrice usando il metodo matrix_iter() metodo.
Aggiungi qiskit.quantum_info.diamond_norm() funzione per il calcolo della norma di diamante (norma di traccia completamente limitata) di un canale quantistico. Questo può essere utilizzato per calcolare la distanza tra due canali quantistici utilizzando diamond_norm(chan1 - chan2).
È stata aggiunta una nuova classe qiskit.quantum_info.PauliTable . Si tratta di un'efficiente rappresentazione simplettica di una lista di operatori di Pauli a N-qubit. Alcune caratteristiche di questa classe sono:
- PauliTable gli oggetti possono essere composti e tensored che restituirà un oggetto PauliTable con la combinazione delle operazioni ( compose(), dot(), expand(), tensor()) tra ogni elemento della prima tabella, con ogni elemento della seconda tabella.
- L'addizione di due tabelle agisce come una concatenazione di termini in ciascuna tabella (+).
- Le tabelle Pauli possono essere ordinate per ordine lessicografico (prodotto tensoriale) o per pesi Pauli (sort()).
- Gli elementi duplicati possono essere contati ed eliminati (unique()).
- PauliTable può essere iterato sia nella sua rappresentazione nativa di array booleano simplettico, come etichette di stringhe Pauli (label_iter()), sia come array Numpy denso o matrici CSR rade (matrix_iter()).
- Verifica della commutazione tra elementi della tabella Pauli e un'altra tabella Pauli (commutes()) o Pauli (commutes_with_all())
Per ulteriori dettagli, consultare la documentazione dell'API della classe qiskit.quantum_info.PauliTable .
Aggiunge la classe qiskit.quantum_info.StabilizerTable . Si tratta di una sottoclasse della classe qiskit.quantum_info.PauliTable che include un vettore di fase booleano insieme all'array di tabelle Pauli. Rappresenta una lista di operatori stabilizzatori che sono operatori reali-Pauli con coefficiente +1 o -1. Poiché le matrici stabilizzatrici sono reali, la matrice di etichetta "Y" è definita come [[0, 1], [-1, 0]]. Per ulteriori informazioni, consultare la documentazione dell'API.
Aggiunge qiskit.quantum_info.pauli_basis() che restituisce una base di Pauli a N-qubit come oggetto qiskit.quantum_info.PauliTable . L'ordinamento di questa base può essere di tipo lessicografico (prodotto tensoriale) o in base al numero di termini Pauli non identici (peso).
Aggiunge qiskit.quantum_info.ScalarOp che rappresenta un multiplo scalare di un operatore di identità. Può essere usato per inizializzare un'identità su sottosistemi di dimensione arbitraria e sarà implicitamente convertito in altre sottoclassi di BaseOperator (come un oggetto qiskit.quantum_info.Operator o qiskit.quantum_info.SuperOp) quando viene composta o aggiunta ad esse.

Esempio: Operatore di identità
```
from qiskit.quantum_info import ScalarOp, Operator

X = Operator.from_label('X')
Z = Operator.from_label('Z')

init = ScalarOp(2 ** 3)  # 3-qubit identity
op = init @ X([0]) @ Z([1]) @ X([2])  # Op XZX
```
Alla classe è stato aggiunto un nuovo metodo, reshape()è stato aggiunto alla classe qiskit.quantum_innfo.Operator che restituisce una copia superficiale di una sottoclasse di operatore con le dimensioni di ingresso o di uscita del sottosistema rimodellate. Le dimensioni combinate di tutti i sottosistemi devono essere uguali a quelle dell'operatore originale, altrimenti verrà sollevata un'eccezione.
Aggiunge qiskit.quantum_info.random_clifford() per generare un operatore casuale qiskit.quantum_info.Clifford operatore.
Aggiungi qiskit.quantum_info.random_quantum_channel() per generare un canale quantistico casuale con rango fisso Choi-rango nella Stinespring rappresentazione.
Aggiungi qiskit.quantum_info.random_hermitian() per la generazione di un'ermetica casuale Operator.
Aggiungi qiskit.quantum_info.random_statevector() per la generazione di un file casuale Statevector.
Aggiunge qiskit.quantum_info.random_pauli_table() per generare un qiskit.quantum_info.PauliTable casuale.
Aggiunge qiskit.quantum_info.random_stabilizer_table() per generare un qiskit.quantum_info.StabilizerTable casuale.
Aggiungere un attributo num_qubits alle classi qiskit.quantum_info.StateVector e qiskit.quantum_info.DensityMatrix classi. Restituisce il numero di qubit per gli stati N-qubit e restituisce None per gli stati non-qubit.

Aggiunge to_dict() e to_dict() per convertire qiskit.quantum_info.Statevector e qiskit.quantum_info.DensityMatrix nel dizionario della notazione Bra-Ket.

Esempio

from qiskit.quantum_info import Statevector

state = Statevector.from_label('+0')
print(state.to_dict())

from qiskit.quantum_info import DensityMatrix

state = DensityMatrix.from_label('+0')
print(state.to_dict())

Aggiunge probabilities() e probabilities() a qiskit.quantum_info.Statevector e qiskit.quantum_info.DensityMatrix che restituiscono una serie di probabilità di esito della misurazione nella base computazionale per i sottosistemi specificati.

Esempio

from qiskit.quantum_info import Statevector

state = Statevector.from_label('+0')
print(state.probabilities())

from qiskit.quantum_info import DensityMatrix

state = DensityMatrix.from_label('+0')
print(state.probabilities())

Aggiunge probabilities_dict() e probabilities_dict() a qiskit.quantum_info.Statevector e qiskit.quantum_info.DensityMatrix che restituiscono un array di dizionari in stile conteggio delle probabilità di esito delle misure nella base computazionale per i sottosistemi specificati.
```
from qiskit.quantum_info import Statevector

state = Statevector.from_label('+0')
print(state.probabilities_dict())
```
```
from qiskit.quantum_info import DensityMatrix

state = DensityMatrix.from_label('+0')
print(state.probabilities_dict())
```

Aggiungi sample_counts() e sample_memory() ai metodi Statevector e DensityMatrix per il campionamento dei risultati delle misure sui sottosistemi.

Esempio:

Generare un dizionario di conteggi campionando da un vettore di stati

from qiskit.quantum_info import Statevector

psi = Statevector.from_label('+0')
shots = 1024

# Sample counts dictionary
counts = psi.sample_counts(shots)
print('Measure both:', counts)

# Qubit-0
counts0 = psi.sample_counts(shots, [0])
print('Measure Qubit-0:', counts0)

# Qubit-1
counts1 = psi.sample_counts(shots, [1])
print('Measure Qubit-1:', counts1)

Restituisce l'array dei risultati delle misurazioni per ciascun campione

from qiskit.quantum_info import Statevector

psi = Statevector.from_label('-1')
shots = 10

# Sample memory
mem = psi.sample_memory(shots)
print('Measure both:', mem)

# Qubit-0
mem0 = psi.sample_memory(shots, [0])
print('Measure Qubit-0:', mem0)

# Qubit-1
mem1 = psi.sample_memory(shots, [1])
print('Measure Qubit-1:', mem1)

Aggiunge un metodo measure() al metodo qiskit.quantum_info.Statevector e qiskit.quantum_info.DensityMatrix alle classi di stati quantici. Ciò consente di campionare un singolo risultato di misura dai sottosistemi specificati e di collassare lo statevector allo stato di base computazionale post-misura. Per esempio

from qiskit.quantum_info import Statevector

psi = Statevector.from_label('+1')

# Measure both qubits
outcome, psi_meas = psi.measure()
print("measure([0, 1]) outcome:", outcome, "Post-measurement state:")
print(psi_meas)

# Measure qubit-1 only
outcome, psi_meas = psi.measure([1])
print("measure([1]) outcome:", outcome, "Post-measurement state:")
print(psi_meas)

Aggiunge un metodo reset() al metodo qiskit.quantum_info.Statevector e qiskit.quantum_info.DensityMatrix alle classi di stati quantici. Ciò consente di ripristinare alcuni o tutti i sottosistemi allo stato $|0\rangle$ . Per esempio

from qiskit.quantum_info import Statevector

psi = Statevector.from_label('+1')

# Reset both qubits
psi_reset = psi.reset()
print("Post reset state: ")
print(psi_reset)

# Reset qubit-1 only
psi_reset = psi.reset([1])
print("Post reset([1]) state: ")
print(psi_reset)

È stata aggiunta una nuova funzione di visualizzazione qiskit.visualization.visualize_transition() per visualizzare le transizioni di gate di un singolo qubit. Il programma prende in considerazione un singolo circuito di qubit e restituisce un'animazione delle transizioni di stato dei qubit su una sfera di Bloch. Per utilizzare questa funzione è necessario aver installato le dipendenze e configurato globalmente uno scrittore di animazioni matplotlib. Per maggiori dettagli a riguardo, consultare la documentazione di matplotlib. Tuttavia, nel caso predefinito, è sufficiente assicurarsi che FFmpeg sia installato per utilizzare questa funzione.

Supporta circuiti con le seguenti porte:
- HGate
- XGate
- YGate
- ZGate
- RXGate
- RYGate
- RZGate
- SGate
- SdgGate
- TGate
- TdgGate
- U1Gate
Ad esempio:
```
from qiskit.visualization import visualize_transition
from qiskit import *

qc = QuantumCircuit(1)
qc.h(0)
qc.ry(70,0)
qc.rx(90,0)
qc.rz(120,0)

visualize_transition(qc, fpg=20, spg=1, trace=True)
```
execute() ha un nuovo kwarg schedule_circuit. L'impostazione di schedule_circuit=True consente di programmare il circuito in un Schedule. Questo permette agli utenti che costruiscono qiskit.circuit.QuantumCircuit di utilizzare metodi di programmazione personalizzati, come i metodi as_late_as_possible e as_soon_as_possible . Ad esempio:
```
job = execute(qc, backend, schedule_circuit=True,
              scheduling_method="as_late_as_possible")
```
Una nuova variabile d'ambiente QISKIT_SUPPRESS_PACKAGING_WARNINGS può essere impostata a Y o y che sopprimerà gli avvertimenti relativi a qiskit-aer e qiskit-ibmq-provider non installati al momento dell'importazione. Questo è utile per gli utenti che eseguono solo qiskit-terra (o semplicemente non qiskit-aer e/o qiskit-ibmq-provider) e gli avvisi non sono un'indicazione di un potenziale problema di packaging. È possibile impostare la variabile d'ambiente a N o n per assicurarsi che gli avvisi siano sempre abilitati, anche se il file di configurazione utente è impostato per disabilitarli.
È stata aggiunta una nuova opzione per il file di configurazione utente, suppress_packaging_warnings . Se impostato su true nel file di configurazione dell'utente, come ad esempio:
```
[default]
suppress_packaging_warnings = true
```
sopprimerà gli avvisi relativi alla mancata installazione di qiskit-aer e qiskit-ibmq-provider al momento dell'importazione. Questo è utile per gli utenti che eseguono solo qiskit-terra (o semplicemente non qiskit-aer e/o qiskit-ibmq-provider) e gli avvisi non sono un'indicazione di un potenziale problema di packaging. Se il file di configurazione dell'utente è impostato per disabilitare gli avvisi, questo può essere annullato impostando QISKIT_SUPPRESS_PACKAGING_WARNINGS a N o a n
qiskit.compiler.transpile() ha due nuovi kwarg, layout_method e routing_method. Queste consentono di selezionare un metodo particolare per il posizionamento e l'instradamento dei circuiti su architetture vincolate. Ad esempio:
```
transpile(circ, backend, layout_method='dense',
          routing_method='lookahead')
```
eseguirà DenseLayout passaggio di layout e LookaheadSwap passaggio di instradamento.

Lo stile di costruzione delle istruzioni Pulse è stato notevolmente semplificato.

Con lo stile precedente, Command s veniva chiamato con i canali per fare un Instruction. L'uso di comandi e istruzioni è stato un punto di confusione. Questo era lo stile precedente:

sched += Delay(5)(DriveChannel(0))
sched += ShiftPhase(np.pi)(DriveChannel(0))
sched += SamplePulse([1.0, ...])(DriveChannel(0))
sched += Acquire(100)(AcquireChannel(0), MemorySlot(0))

o, in modo equivalente (anche se meno utilizzato):

sched += DelayInstruction(Delay(5), DriveChannel(0))
sched += ShiftPhaseInstruction(ShiftPhase(np.pi), DriveChannel(0))
sched += PulseInstruction(SamplePulse([1.0, ...]), DriveChannel(0))
sched += AcquireInstruction(Acquire(100), AcquireChannel(0),
                            MemorySlot(0))

Ora, invece di costruire un comando e un 'istruzione, ogni comando è stato migrato in un'istruzione:

sched += Delay(5, DriveChannel(0))
sched += ShiftPhase(np.pi, DriveChannel(0))
sched += Play(SamplePulse([1.0, ...]), DriveChannel(0))
sched += SetFrequency(5.5, DriveChannel(0))  # New instruction!
sched += Acquire(100, AcquireChannel(0), MemorySlot(0))

Ora esiste un'istruzione Play che accetta la descrizione di un inviluppo di impulsi e di un canale. C'è una nuova classe Pulse in pulse_lib da cui la descrizione dell'inviluppo dell'impulso dovrebbe sottoclasse.

Ad esempio:
```
Play(SamplePulse([0.1]*10), DriveChannel(0))
Play(ConstantPulse(duration=10, amp=0.1), DriveChannel(0))
```

Note sull'aggiornamento

Il metodo qiskit.dagcircuit.DAGNodepop , deprecato nella versione 0.9.0, è stato rimosso. del Se si utilizza questo metodo, si può sfruttare l'istruzione Python 'o la funzione delattr() per eseguire lo stesso compito.
È stato aggiunto un nuovo requisito di visualizzazione opzionale, pygments. È usato per fornire l'evidenziazione della sintassi del codice di OpenQASM 2.0 nei widget Jupyter e, facoltativamente, per il metodo qiskit.circuit.QuantumCircuit.qasm() metodo. Deve essere installato (con pip install pygments o pip install qiskit-terra[visualization]) prima di utilizzare il widget %circuit_library_info in qiskit.tools.jupyter o il kwarg formatted nel metodo qasm() metodo.
L'opzione pulse buffer , presente in qiskit.pulse.Channel e in qiskit.pulse.Schedule è stata deprecata in Terra 0.11.0 e ora è stata rimossa. Per aggiungere un ritardo a un canale o a una pianificazione, specificarlo esplicitamente nella pianificazione con un ritardo:
```
sched = Schedule()
sched += Delay(5)(DriveChannel(0))
```
PulseChannelSpecche era deprecato in Terra 0.11.0, è stato rimosso. Utilizzare invece BackendConfiguration :
```
config = backend.configuration()
drive_chan_0 = config.drives(0)
acq_chan_0 = config.acquires(0)
```
oppure, semplicemente, fare riferimento al canale direttamente, come ad esempio DriveChannel(index).
Un percorso di importazione era deprecato in Terra 0.10.0 e ora è stato rimosso: per PulseChannel, DriveChannel, MeasureChannel, e ControlChannel, usare from qiskit.pulse.channels import X al posto di from qiskit.pulse.channels.pulse_channels import X.
Il passaggio qiskit.transpiler.passes.CSPLayout (introdotto nella versione 0.11.0 ) è stato aggiunto al gestore dei passaggi preimpostati per i livelli di ottimizzazione 2 e 3. Per il livello 2, il limite di chiamate è di 1.000 e il timeout di 10 secondi. Per il livello 3, il limite di chiamate è 10.000 e il timeout è di 1 minuto.

Ora che il passaggio è incluso nei gestori dei passaggi preimpostati, il pacchetto python-constraint non è più una dipendenza opzionale ed è stato aggiunto all'elenco dei requisiti.
La classe TranspileConfig , utilizzata in precedenza per impostare la configurazione in fase di esecuzione di un file di tipo qiskit.transpiler.PassManager è stata rimossa e sostituita da una nuova classe qiskit.transpile.PassManagerConfig. Questa nuova classe è stata strutturata in modo da includere solo le informazioni necessarie per la costruzione di un PassManager. Gli attributi di questa classe sono:
- initial_layout
- basis_gates
- coupling_map
- backend_properties
- seed_transpiler
La funzione transpile_circuit in qiskit.transpiler è stata rimossa. Per transpilare un circuito con un PassManager si deve utilizzare il metodo run() dell'oggetto :class:~qiskit.transpiler.PassManager`.
Il QuantumCircuit metodo draw() e qiskit.visualization.circuit_drawer() non includeranno più lo stato iniziale incluso nelle visualizzazioni per impostazione predefinita. Se si desidera mantenere lo stato iniziale nella visualizzazione di output, è necessario impostare il kwarg initial_state su True. Ad esempio, la corsa:
```
from qiskit import QuantumCircuit

circuit = QuantumCircuit(2)
circuit.measure_all()
circuit.draw(output='text')
```
Questo non include più lo stato iniziale. Se volete conservarlo, potete candidarvi:
```
from qiskit import QuantumCircuit

circuit = QuantumCircuit(2)
circuit.measure_all()
circuit.draw(output='text', initial_state=True)
```
qiskit.compiler.transpile() (e qiskit.execute.execute(), che usa internamente transpile ) ora solleverà un errore quando il kwarg pass_manager viene impostato e viene impostato un valore per altri kwarg già impostati in un oggetto istanziato PassManager istanziato. In precedenza, questi kwarg in conflitto venivano semplicemente ignorati e venivano utilizzati i valori dell'istanza PassManager . Ad esempio:
```
from qiskit.circuit import QuantumCircuit
from qiskit.transpiler.pass_manager_config import PassManagerConfig
from qiskit.transpiler import preset_passmanagers
from qiskit.compiler import transpile

qc = QuantumCircuit(5)

config = PassManagerConfig(basis_gates=['u3', 'cx'])
pm = preset_passmanagers.level_0_pass_manager(config)
transpile(qc, optimization_level=3, pass_manager=pm)
```
solleverà ora un errore, mentre prima di questa versione il valore in pm veniva usato silenziosamente e il valore del kwarg optimization_level veniva ignorato. I kwarg di transpile a cui si applica sono:
- optimization_level
- basis_gates
- coupling_map
- seed_transpiler
- backend_properties
- initial_layout
- layout_method
- routing_method
- backend
Il Operator, Clifford, SparsePauliOp, PauliTable, StabilizerTable, le classi di operatori hanno aggiunto il metodo call che permette di assegnare un qargs all'operatore da utilizzare con il metodo compose(), dot(), evolve(), ```+``` e - .
Il metodo di aggiunta della classe qiskit.quantum_info.Operatoraccetta ora un kwarg qarg per consentire l'aggiunta di un operatore più piccolo a uno più grande, assumendo identità sugli altri sottosistemi (come per qargs su compose() e dot() ). Ciò consente di aggiungere un sottosistema utilizzando il metodo di chiamata come nel caso della composizione. Questo supporto viene aggiunto a tutte le sottoclassi di BaseOperator (ScalarOp, Operator, QuantumChannel).

Ad esempio:
```
from qiskit.quantum_info import Operator, ScalarOp

ZZ = Operator.from_label('ZZ')

# Initialize empty Hamiltonian
n_qubits = 10
ham = ScalarOp(2 ** n_qubits, coeff=0)

# Add 2-body nearest neighbour terms
for j in range(n_qubits - 1):
    ham = ham + ZZ([j, j+1])
```
La classe BaseOperator è stata aggiornata in modo che l'addizione, la sottrazione e la moltiplicazione scalare non siano più metodi astratti. Ciò significa che non è più necessario implementarli nelle sottoclassi se non sono supportati. La classe base solleverà un NotImplementedError quando i metodi non sono definiti.
La funzione qiskit.quantum_info.random_density_matrix() restituirà un oggetto casuale DensityMatrix casuale. Nelle versioni precedenti restituiva un array numpy.
Il qiskit.quantum_info.Statevector e qiskit.quantum_info.DensityMatrix non copiano più l'array di input se è già del tipo corretto.
fastjsonschema è aggiunto come dipendenza. Questo viene utilizzato per una validazione molto più rapida dei dizionari qobj rispetto allo schema JSON, quando il metodo to_dict() viene chiamato sugli oggetti qobj con l'argomento della parola chiave validate impostato su True.
Le classi di costruzione qobj in qiskit.qobj non saranno più validate rispetto al jsonschema di qobj per impostazione predefinita. Queste includono le seguenti classi:
- qiskit.qobj.QasmQobjInstruction
- qiskit.qobj.QobjExperimentHeader
- qiskit.qobj.QasmQobjExperimentConfig
- qiskit.qobj.QasmQobjExperiment
- qiskit.qobj.QasmQobjConfig
- qiskit.qobj.QobjHeader
- qiskit.qobj.PulseQobjInstruction
- qiskit.qobj.PulseQobjExperimentConfig
- qiskit.qobj.PulseQobjExperiment
- qiskit.qobj.PulseQobjConfig
- qiskit.qobj.QobjMeasurementOption
- qiskit.qobj.PulseLibraryItem
- qiskit.qobj.QasmQobjInstruction
- qiskit.qobj.QasmQobjExperimentConfig
- qiskit.qobj.QasmQobjExperiment
- qiskit.qobj.QasmQobjConfig
- qiskit.qobj.QasmQobj
- qiskit.qobj.PulseQobj
Se ci si affida a questa validazione o si desidera validarli rispetto allo schema qobj, lo si può fare impostando il kwarg validate a True su to_dict() da una delle classi Qobj di primo livello QasmQobj oppure PulseQobj. Ad esempio:

che convaliderà il dizionario di output rispetto al jsonschema di Qobj.

Il dizionario di uscita da qiskit.qobj.QasmQobj.to_dict() e qiskit.qobj.PulseQobj.to_dict() non è più in un formato per la serializzazione json diretta, come previsto dall'API di IBMQ. Questi oggetti Qobj sono il formato attuale che usiamo per passare gli esperimenti ai provider/backend e, mentre avere un formato di dizionario che può essere passato direttamente all'API IBMQ è stato moderatamente utile per qiskit-ibmq-provider, ha reso le cose più difficili per altri provider. Soprattutto per i fornitori che avvolgono i simulatori locali. In futuro le definizioni di ciò che viene passato tra i provider e il formato di richiesta dell'API IBMQ saranno ulteriormente disaccoppiate (in modo retrocompatibile), il che dovrebbe alleggerire l'onere di scrivere provider e backend.

In pratica, l'unica differenza funzionale tra l'output di questi metodi e le versioni precedenti è che i numeri complessi sono rappresentati con il tipo complex e gli array di numpy non vengono più convertiti silenziosamente in liste. Se in precedenza si chiamava json.dumps() direttamente sull'output di to_dict() , dopo questo rilascio sarà necessario un codificatore json personalizzato per gestire questi casi. Ad esempio:

import json

from qiskit.circuit import ParameterExpression
from qiskit import qobj

my_qasm = qobj.QasmQobj(
    qobj_id='12345',
    header=qobj.QobjHeader(),
    config=qobj.QasmQobjConfig(shots=1024, memory_slots=2,
                               max_credits=10),
    experiments=[
        qobj.QasmQobjExperiment(instructions=[
            qobj.QasmQobjInstruction(name='u1', qubits=[1],
                                     params=[0.4]),
            qobj.QasmQobjInstruction(name='u2', qubits=[1],
                                     params=[0.4, 0.2])
        ])
    ]
)
qasm_dict = my_qasm.to_dict()

class QobjEncoder(json.JSONEncoder):
    """A json encoder for pulse qobj"""
    def default(self, obj):
        # Convert numpy arrays:
        if hasattr(obj, 'tolist'):
            return obj.tolist()
        # Use Qobj complex json format:
        if isinstance(obj, complex):
            return (obj.real, obj.imag)
        if isinstance(obj, ParameterExpression):
            return float(obj)
        return json.JSONEncoder.default(self, obj)

json_str = json.dumps(qasm_dict, cls=QobjEncoder)

genererà una stringa json esattamente come faceva json.dumps(my_qasm.to_dict()) nelle versioni precedenti.

CmdDef è stato deprecato da Terra 0.11.0 ed è stato rimosso. Si prega di continuare a utilizzare InstructionScheduleMap al suo posto.
I metodi cmds e cmd_qubits in InstructionScheduleMap sono stati deprecati da Terra 0.11.0 e sono stati rimossi. Utilizzare invece instructions e qubits_with_instruction .
PulseDefaults hanno riportato qubit_freq_est e meas_freq_est in Hz anziché in GHz dal rilascio di Terra 0.11.0. L'avviso che segnalava questa modifica è stato rimosso.
Il supporto precedentemente deprecato (nella versione 0.11.0 ) per il passaggio di parametri di tipo qiskit.circuit.Instruction dei tipi sympy.Basic, sympy.Expr, qiskit.qasm.node.node.Node (nodo QASM AST) e sympy.Matrix è stato rimosso. I tipi di parametri di istruzione supportati sono:
- int
- float
- complex
- str
- list
- np.ndarray
- qiskit.circuit.ParameterExpression
Le seguenti proprietà di BackendConfiguration:
- dt
- dtm
- rep_time
hanno tutti unità di misura di secondi. Prima del rilascio 0.11.0, dt e dtm avevano unità di misura di nanosecondi. Prima della release 0.12.0, rep_time aveva unità di misura in microsecondi. Le avvertenze che avvisavano gli utenti di queste modifiche sono state rimosse da BackendConfiguration.
All'elenco dei requisiti è stato aggiunto un nuovo requisito, retworkx. Si tratta di una libreria di grafi con licenza Apache 2.0 che ha un'API simile a quella di networkx e viene utilizzata per accelerare in modo significativo le operazioni di transpiler qiskit.dagcircuit.DAGCircuit operazioni come parte del transpiler. Ci sono binari pubblicati su PyPI per tutte le piattaforme supportate da Qiskit Terra, ma se si utilizza una piattaforma per la quale non sono stati pubblicati binari precompilati, consultare la documentazione di retworkx per le istruzioni sull'installazione con pip da sdist.

Se si riscontrano problemi con il transpiler o con la classe DAGCircuit durante la transizione, si può tornare alla precedente implementazione di networkx impostando la variabile d'ambiente USE_RETWORKX su N. Questa opzione sarà rimossa nella versione 0.14.0.

Note di deprecazione

Il passaggio dei dati al costruttore di qiskit.dagcircuit.DAGNode come arg dizionario data_dict è deprecato e sarà rimosso in una prossima versione. Invece si devono passare i campi come kwarg al costruttore. Ad esempio il comportamento precedente di:
```
from qiskit.dagcircuit import DAGNode

data_dict = {
    'type': 'in',
    'name': 'q_0',
}
node = DAGNode(data_dict)
```
dovrebbe ora essere:
```
from qiskit.dagcircuit import DAGNode

node = DAGNode(type='in', name='q_0')
```

La denominazione degli oggetti e dei metodi dei gate è stata aggiornata per essere più coerente. Sono state apportate le seguenti modifiche:

Le porte di Pauli hanno tutte una sola lettera maiuscola (I, X, Y, Z)
Le porte di Pauli parametrizzate (cioè le rotazioni) precedono la lettera maiuscola R (RX, RY, RZ)
Una versione controllata antepone la lettera maiuscola C (CX, CRX, CCX)
Le porte sono denominate in base alla loro azione, non ai loro nomi alternativi (CCX, non Toffoli)

I vecchi nomi sono stati deprecati e saranno rimossi in una versione futura. Questo è un elenco delle modifiche che mostra la vecchia e la nuova classe, l'attributo del nome e i metodi. Se una nuova colonna è vuota, non viene modificata.

Vecchia classe	Nuova classe	Vecchio nome Attributo	Nuovo attributo Nome	Vecchio `qiskit.circuit.QuantumCircuit` metodo	Nuovo `qiskit.circuit.QuantumCircuit` metodo
`ToffoliGate`	`CCXGate`	`ccx`		`ccx()` e `toffoli()`
`CrxGate`	`CRXGate`	`crx`		`crx()`
`CryGate`	`CRYGate`	`cry`		`cry()`
`CrzGate`	`CRZGate`	`crz`		`crz()`
`FredkinGate`	`CSwapGate`	`cswap`		`cswap()` e `fredkin()`
`Cu1Gate`	`CU1Gate`	`cu1`		`cu1()`
`Cu3Gate`	`CU3Gate`	`cu3`		`cu3()`
`CnotGate`	`CXGate`	`cx`		`cx()` e `cnot()`
`CyGate`	`CYGate`	`cy`		`cy()`
`CzGate`	`CZGate`	`cz`		`cz()`
`DiagGate`	`DiagonalGate`	`diag`	`diagonal`	`diag_gate`	`diagonal()`
`IdGate`	`IGate`	`id`		`iden`	`i()` e `id()`
`Isometry`		`iso`	`isometry`	`iso()`	`isometry()` e `iso()`
`UCG`	`UCGate`	`multiplexer`		`ucg`	`uc()`
`UCRot`	`UCPauliRotGate`
`UCX`	`UCRXGate`	`ucrotX`	`ucrx`	`ucx`	`ucrx()`
`UCY`	`UCRYGate`	`ucroty`	`ucry`	`ucy`	`ucry()`
`UCZ`	`UCRZGate`	`ucrotz`	`ucrz`	`ucz`	`ucrz()`

Il kwarg period per le funzioni square(), sawtooth() e triangle() in qiskit.pulse.pulse_lib è ora deprecato e sarà rimosso in una prossima versione. Per impostare la frequenza si deve invece utilizzare il kwarg di freq .
I metodi DAGCircuit.compose_back() e DAGCircuit.extend_back() sono deprecati e saranno rimossi in una versione futura. Si dovrebbe invece utilizzare il metodo qiskit.dagcircuit.DAGCircuit.compose() che è un metodo più generale e più flessibile che fornisce la stessa funzionalità.
Il kwarg callback del costruttore della classe qiskit.transpiler.PassManager del costruttore della classe è stato deprecato e sarà rimosso in una prossima versione. Invece di impostarlo a livello di oggetto durante la creazione, ora dovrebbe essere impostato come parametro kwarg sul metodo qiskit.transpiler.PassManager.run() del metodo.
Le parole chiave n_qubits e numberofqubits sono deprecate in tutto Terra e sostituite da num_qubits. I vecchi nomi saranno rimossi in una versione futura. Gli oggetti interessati da questa modifica sono elencati di seguito:

Classe
Vecchio metodo
Nuovo metodo
QuantumCircuit n_qubits num_qubits()
Pauli numberofqubits num_qubits()

Funzione
Vecchio argomento
Nuovo argomento
random_circuit() n_qubits num_qubits
MSGate n_qubit num_qubits
La funzione qiskit.quantum_info.synthesis.euler_angles_1q è ora deprecata. È stata sostituita dalla classe qiskit.quantum_info.OneQubitEulerDecomposer che fornisce la stessa funzionalità attraverso:
```
OneQubitEulerDecomposer().angles(mat)
```
Il kwarg pass_manager per l'elemento qiskit.compiler.transpile() è stato deprecato e sarà rimosso in una prossima versione. In futuro, il modo preferito per transpilare un circuito con un oggetto personalizzato PassManager è utilizzare il metodo run() dell'oggetto PassManager .
La funzione qiskit.quantum_info.random_state() è stata deprecata e sarà rimossa in una versione futura. Si deve invece utilizzare la funzione qiskit.quantum_info.random_statevector() funzione.
I metodi add, subtract, e multiply del qiskit.quantum_info.Statevector e qiskit.quantum_info.DensityMatrix sono deprecati e saranno rimossi in una prossima versione. Si dovrebbero invece utilizzare gli operatori binari +, -, * .
Depreca qiskit.quantum_info.Statevector.to_counts(), qiskit.quantum_info.DensityMatrix.to_counts() e qiskit.quantum_info.counts.state_to_counts(). Queste funzioni sono sostituite dai metodi della classe qiskit.quantum_info.Statevector.probabilities_dict() e qiskit.quantum_info.DensityMatrix.probabilities_dict().
SamplePulse e ParametricPulse s (ad esempio Gaussian) ora sottoclasse di Pulse e sono stati spostati in qiskit.pulse.pulse_lib. Il precedente percorso attraverso pulse.commands è deprecato e sarà rimosso in una prossima versione.
DelayInstruction è stato deprecato e sostituito da Delay. Questa nuova istruzione è stata sostituita dalla precedente Command Delay. Il modello di migrazione è:
```
Delay(<duration>)(<channel>) -> Delay(<duration>, <channel>)
DelayInstruction(Delay(<duration>), <channel>)
    -> Delay(<duration>, <channel>)
```
Fino al termine del periodo di deprecazione, sarà supportata anche la precedente sintassi Delay per chiamare un comando su un canale:
```
Delay(<phase>)(<channel>)
```
La nuova istruzione Delay non supporta l'attributo command .
FrameChange e FrameChangeInstruction sono stati deprecati e sostituiti da ShiftPhase. Le modifiche sono:
```
FrameChange(<phase>)(<channel>) -> ShiftPhase(<phase>, <channel>)
FrameChangeInstruction(FrameChange(<phase>), <channel>)
    -> ShiftPhase(<phase>, <channel>)
```
Fino a quando il periodo di deprecazione non sarà terminato, sarà supportata la precedente sintassi di FrameChange per chiamare un comando su un canale:
```
ShiftPhase(<phase>)(<channel>)
```
Il metodo call di SamplePulse e ParametricPulse è stato deprecato. La migrazione è la seguente:
```
Pulse(<*args>)(<channel>) -> Play(Pulse(*args), <channel>)
```
AcquireInstruction è stato deprecato e sostituito da Acquire. Le modifiche sono:
```
Acquire(<duration>)(<**channels>) -> Acquire(<duration>, <**channels>)
AcquireInstruction(Acquire(<duration>), <**channels>)
    -> Acquire(<duration>, <**channels>)
```
Fino a quando il periodo di deprecazione non sarà terminato, sarà supportata la precedente sintassi di Acquire che prevede la chiamata del comando su un canale:
```
Acquire(<duration>)(<**channels>)
```

Classe	Vecchio metodo	Nuovo metodo
`QuantumCircuit`	`n_qubits`	`num_qubits()`
`Pauli`	`numberofqubits`	`num_qubits()`

Funzione	Vecchio argomento	Nuovo argomento
`random_circuit()`	`n_qubits`	`num_qubits`
`MSGate`	`n_qubit`	`num_qubits`

Correzioni di bug

Il BarrierBeforeFinalMeasurements incluso nei livelli di transpiler preimpostati quando si punta a un dispositivo fisico, in precedenza inseriva una barriera solo sui qubit misurati. In alcuni casi, ciò ha permesso al transpiler di inserire uno swap dopo un'operazione di misura, rendendo il circuito non valido per i dispositivi attuali. Il passaggio è stato aggiornato in modo che la barriera inserita comprenda tutti i qubit del dispositivo. Correzioni #3937
Quando si estende un'istanza QuantumCircuit istanza (estensore) con un altro circuito (estensione), il circuito viene preso come riferimento. Se un circuito viene esteso con se stesso, si verifica un ciclo infinito, poiché l'estensore e l'estensione sono uguali. Questo bug è stato risolto copiando l'estensione se è lo stesso oggetto dell'estensore. Correzioni #3811
Corregge un caso in qiskit.result.Result.get_counts()in cui non si poteva fare riferimento ai risultati di una scadenza se l'esperimento era inizializzato come Schedule senza nome. Correzioni #2753
In precedenza, sostituendo gli oggetti Parameter di un circuito con nuovi oggetti Parametro prima di decomporre un circuito, i valori sostituiti non venivano inseriti correttamente nelle porte decomposte. Questo problema è stato risolto in modo che il legame e la decomposizione possano avvenire in qualsiasi ordine.
Il backend di output di matplotlib per la funzione qiskit.visualization.circuit_drawer() funzione e qiskit.circuit.QuantumCircuit.draw() è stato corretto per rendere correttamente le porte CU1Gate . Correzioni #3684

Un bug in qiskit.circuit.QuantumCircuit.from_qasm_str() e qiskit.circuit.QuantumCircuit.from_qasm_file() quando si carica QASM con porte personalizzate definite è stato risolto. Ora, caricando questo QASM:

OPENQASM 2.0;
include "qelib1.inc";
gate rinv q {sdg q; h q; sdg q; h q; }
qreg q[1];
rinv q[0];

è equivalente al seguente circuito:

rinv_q = QuantumRegister(1, name='q')
rinv_gate = QuantumCircuit(rinv_q, name='rinv')
rinv_gate.sdg(rinv_q)
rinv_gate.h(rinv_q)
rinv_gate.sdg(rinv_q)
rinv_gate.h(rinv_q)
rinv = rinv_gate.to_instruction()
qr = QuantumRegister(1, name='q')
expected = QuantumCircuit(qr, name='circuit')
expected.append(rinv, [qr[0]])

Correzioni #1566

Consentire alle Istruzioni di circuito quantistico di avere valori di parametri di elenco. Questo viene utilizzato in Aer per i parametri istantanei del valore di aspettativa, ad esempio params = [[1.0, 'I'], [1.0, 'X']]] per $\langle I + X\rangle$ .
In precedenza, per i circuiti che contenevano porte composite (quelle create mediante qiskit.circuit.QuantumCircuit.to_gate() o qiskit.circuit.QuantumCircuit.to_instruction() o i convertitori corrispondenti), se si tentava di vincolare il circuito più di una volta, al momento della trasposizione veniva applicato a tutti i circuiti solo il primo valore di vincolo. Questo problema è stato risolto in modo da rispettare correttamente i valori forniti per i successivi binding.

Altre note

Le classi qasm e pulse qobj:
da qiskit.qobj sono stati tutti reimplementati senza utilizzare la libreria marsmallow. Queste nuove implementazioni sono state progettate per essere sostituite (ad eccezione di quanto indicato nelle note di rilascio dell'aggiornamento), ma alcune specifiche ereditate da marshmallow potrebbero non funzionare. Si prega di presentare i problemi per qualsiasi incompatibilità riscontrata.

Aer 0.5.0

Aggiunto

Aggiungere il supporto per il cancello diagonale terra

Aggiungere il supporto per qobj parametrizzati

Fisso

Aggiunto postfix per linux su Raspberry Pi

Gestire gli input di array numpy da qobj

Ignis 0.3.0

Aggiunto

documentazione API
Analisi comparativa randomizzata CNOT-Dihedral
Modulo di accreditamento per l'accreditamento in uscita di dispositivi rumorosi
Calibrazioni di impulsi per qubit singoli
Discriminatore di impulsi
Circuiti di verifica dell'entanglement
Tomografia di gateet per set di gate a singolo qubit
Aggiunge le funzioni di utilità per il benchmarking randomizzato calculate_1q_epg, calculate_2q_epg funzioni per calcolare l'errore a 1 e 2 qubit per gate dall'errore per Clifford
Aggiunge le funzioni di utilità di benchmarking randomizzate calculate_1q_epc, calculate_2q_epc per calcolare l'errore a 1 e 2 qubit per Clifford dall'errore per gate

Modificato

Supporto delle etichette intere per i qubit nella tomografia
Supporto delle etichette intere per la mitigazione degli errori di misura

Obsoleto

Depreca la funzione twoQ_clifford_error . Utilizzare invece calculate_2q_epc .
Python 3.5 in qiskit-ignis è deprecato. Il supporto sarà rimosso alla data di fine vita della versione da parte della comunità upstream di python, che è il 13/09/2020.

Acqua 0.6.5

Nessuna modifica

IBM Q Fornitore 0.6.0

Nessuna modifica

Questa pagina è stata utile?

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