Note di rilascio di Qiskit 0.23

0.23.6

Terra 0.16.4

Nessuna modifica

Aer 0.7.5

Preludio

Questa release è una release di bugfix che risolve la compatibilità dei pacchetti binari precompilati di wheel con le versioni di numpy < 1.20.0. La precedente versione 0.7.4 costruiva i binari in un modo che richiedeva numpy 1.20.0. Il problema è stato risolto ora, quindi i pacchetti binari precompilati di wheel funzioneranno con qualsiasi versione compatibile di numpy.

Ignis 0.5.2

Nessuna modifica

Acqua 0.8.2

Nessuna modifica

IBM Q Fornitore 0.11.1

Nessuna modifica

0.23.5

Terra 0.16.4

Preludio

Questa versione è un bugfix che risolve principalmente la compatibilità con numpy 1.20.0. Questa release di numpy ha deprecato gli alias locali per i tipi numerici di Python (np.int -> int, np.float -> float, ecc.) e l'uso di questi alias in Qiskit ha comportato l'emissione di un gran numero di avvisi di deprecazione. Questa versione corregge il problema in modo da poter eseguire Qiskit con numpy 1.20.0 senza gli avvisi di deprezzamento.

Aer 0.7.4

Correzioni di bug

Corregge la compatibilità con numpy 1.20.0. Questa release di numpy ha deprecato gli alias locali per i tipi numerici di Python (np.int -> int, np.float -> float, ecc.) e l'uso di questi alias in Qiskit Aer ha comportato l'emissione di un gran numero di avvisi di deprecazione. Questa versione corregge il problema in modo da poter eseguire Qiskit Aer con numpy 1.20.0 senza gli avvisi di deprezzamento.

Ignis 0.5.2

Preludio

Questa versione è un bugfix che risolve principalmente la compatibilità con numpy 1.20.0. È anche la prima versione ad includere il supporto per Python 3.9. Le versioni precedenti (comprese 0.5.0 e 0.5.1 ) funzionavano con Python 3.9 ma non lo indicavano nei metadati del pacchetto e non c'erano test upstream per quelle versioni. Questa versione risolve il problema ed è stata testata su Python 3.9 (oltre che su 3.6, 3.7 e 3.8 ).

Correzioni di bug

networkx è ora esplicitamente elencato come dipendenza. In precedenza era una dipendenza implicita, in quanto necessaria per il modulo qiskit.ignis.verification.topological_codes , ma non era correttamente elencata come dipendenza, in quanto qiskit-terra richiede anche networkx ed è anche una dipendenza di ignis, quindi in pratica verrebbe sempre installata. Tuttavia, è necessario elencarlo come requisito per le future versioni di qiskit-terra che non richiederanno networkx. È anche importante elencare correttamente le dipendenze di ignis, nel caso in cui ci fosse una futura incompatibilità tra i requisiti delle versioni.

Acqua 0.8.2

IBM Q Fornitore 0.11.1

Nessuna modifica

0.23.4

Terra 0.16.3

Correzioni di bug

È stato risolto un problema introdotto in 0.16.2 che causava errori quando si eseguiva transpile() su un circuito con una serie di porte a 1 qubit e un'istruzione non a porte che opera solo su un qubit (ad esempio Reset). Correzioni #5736

Aer 0.7.3

Nessuna modifica

Ignis 0.5.1

Nessuna modifica

Acqua 0.8.1

Nessuna modifica

IBM Q Fornitore 0.11.1

Nessuna modifica

0.23.3

Terra 0.16.2

Nuove funzioni

Python 3.9 è stato aggiunto in questa versione. Ora è possibile eseguire Qiskit Terra utilizzando Python 3.9.

Note sull'aggiornamento

La classe MCXGrayCode creerà ora un C3XGate se num_ctrl_qubits è 3 e un C4XGate se num_ctrl_qubits è 4. Questo si aggiunge alla funzionalità precedente, in cui per qualsiasi modalità della :class:' qiskit.library.standard_gates.x.MCXGate\ , se num_ctrl_bitsè 1, viene creata unaCXGatee se 2, viene creata unaCCXGate` .

Correzioni di bug

Impulso Delay sono ora assemblati esplicitamente come PulseQobjInstruction inclusi nell'output PulseQobj in uscita da assemble().

In precedenza, si potevano ignorare le Delay in un'istruzione Schedule come parte di assemble() poiché il tempo era esplicito negli oggetti PulseQobj oggetti. Ma ora, con i gate a impulsi, ci sono situazioni in cui è possibile programmare SOLO un ritardo, e non includere il ritardo stesso eliminerebbe il ritardo.
I circuiti con calibrazioni personalizzate dei gate possono ora essere programmati con il transpiler senza fornire esplicitamente le durate di ciascuna calibrazione del circuito.
Il BasisTranslator e Unroller in alcuni casi non hanno preservato la fase globale del circuito sotto transpilazione. Il problema è stato risolto.
Un bug in qiskit.pulse.builder.frequency_offset() in cui quando si impostava compensate_phase mancava un fattore di $2\pi$ nella fase di aggiunta.
Fissa la fase globale dell'uscita del metodo QuantumCircuit metodo repeat(). Se un circuito con fase globale viene aggiunto a un altro circuito, la fase globale non viene attualmente propagata. I simulatori si basano su questo, poiché la fase viene altrimenti applicata più volte. In questo modo si imposta la fase globale di repeat() a 0 prima di aggiungere il circuito ripetuto, invece di moltiplicare la fase esistente per il numero di ripetizioni.
Corregge il bug in SparsePauliOp in cui la moltiplicazione per alcuni tipi scalari di Numpy non Python restituiva valori errati. Correzioni #5408
La definizione della fedeltà di Hellinger da è stata corretta dalla precedente definizione di $1-H(P,Q)$ a $[1-H(P,Q)^2]^2$ in modo che sia uguale alla fedeltà di stato quantistica di P, Q come matrici di densità diagonali.
Ridurre il numero di porte CX nella decomposizione della porta X a 3 controlli, C3XGate. Compilato e ottimizzato in base a U CX, ora vengono utilizzate solo 14 porte CX e 16 porte U invece di 20 e 22, rispettivamente.
Corregge il problema per cui l'utilizzo del widget del backend Jupyter o qiskit.tools.backend_monitor() falliva se le porte di base del backend non includevano i tradizionali u1, u2, e u3.
Quando si esegue qiskit.compiler.transpile() su un elenco di circuiti con un singolo elemento, la funzione restituisce un circuito anziché un elenco. Ora, quando qiskit.compiler.transpile() viene richiamato con un elenco, restituirà un elenco anche se questo ha un solo elemento. Vedere il numero 5260.
```
from qiskit import *

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

transpiled = transpile([qc])
print(type(transpiled), len(transpiled))
```
```
<class 'list'> 1
```

Aer 0.7.3

Nuove funzioni

Python 3.9 è stato aggiunto in questa versione. È ora possibile eseguire Qiskit Aer utilizzando Python 3.9 senza compilare i sorgenti.

Correzioni di bug

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.
Corregge un bug che faceva sì che c_if non funzionasse quando la larghezza del registro condizionale era superiore a 64. Vedere il numero 1077.
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 bug quando si applica il troncamento nel metodo del prodotto matriciale di stato di QasmSimulator.

Ignis 0.5.1

Nessuna modifica

Acqua 0.8.1

Nessuna modifica

IBM Q Fornitore 0.11.1

Nessuna modifica

0.23.2

Terra 0.16.1

Nessuna modifica

Aer 0.7.2

Nuove funzioni

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.

Correzioni di bug

Corregge un bug con il flag OpenMP annidato che veniva impostato su true quando non doveva esserlo.

Ignis 0.5.1

Nessuna modifica

Acqua 0.8.1

Nessuna modifica

IBM Q Fornitore 0.11.1

Nessuna modifica

0.23.1

Terra 0.16.1

Correzioni di bug

È stato risolto un problema che causava un errore nell'esecuzione di circuiti validi costruiti con ritardi.
La definizione QASM di ‘c4x’ in qelib1.inc è stata corretta in modo da corrispondere alla definizione della libreria standard per C4XGate.
Corregge un bug nella sottrazione per i canali quantistici $A - B$ dove $B$ era un Operator oggetto. La negazione veniva applicata alla matrice nella rappresentazione dell'Operatore, che non è equivalente alla negazione nella rappresentazione del canale quantistico.
Modifica il modo in cui _evolve_instruction() accede ai qubit per gestire il caso di un'istruzione con più registri.

Aer 0.7.1

Note sull'aggiornamento

La versione minima di cmake per compilare qiskit-aer è passata da 3.6 a 3.8. Questa modifica si è resa necessaria per consentire il fissaggio delle build della versione della GPU che supportano l'esecuzione su CPU x86_64 prive delle istruzioni AVX2.

Correzioni di bug

qiskit-aer con il supporto per le GPU ora funziona sui sistemi con CPU x86_64 prive di istruzioni AVX2. In precedenza, il pacchetto GPU veniva eseguito solo se le istruzioni AVX2 erano disponibili. Correzioni #1023
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.
Correzione di un errore a causa del quale la porta "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.
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à.

Ignis 0.5.1

Correzioni di bug

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 non completamente positiva e fallisce la convalida quando viene utilizzato con il metodo qiskit.quantum_info.state_fidelity() o qiskit.quantum_info.process_fidelity() .

Acqua 0.8.1

0.8.1

Nuove funzioni

È stato aggiunto un nuovo algoritmo: la superficie di energia potenziale di Born Openheimer per il calcolo della superficie di energia potenziale lungo i diversi gradi di libertà della molecola. L'algoritmo è chiamato BOPESSampler. Fornisce inoltre funzionalità di adattamento della superficie di energia potenziale a una funzione analitica di dettagli predefiniti potentials.some.

Problemi critici

Si tenga presente che il parametro initial_state in QAOA ha ora un'implementazione diversa a seguito della correzione di un bug. L'implementazione precedente mescolava erroneamente il sito initial_state fornito dall'utente con le porte di Hadamard. Il problema è stato risolto. Non è necessario prestare attenzione se il codice non utilizza il parametro initial_state fornito dall'utente.

Correzioni di bug

il metodo optimize_svm di qp_solver a volte falliva dando luogo a un errore del tipo ValueError: cannot reshape array of size 1 into shape (200,1) Questo problema è stato risolto aggiungendo un parametro di norma L2, lambda2, che per impostazione predefinita è 0.001 ma che può essere modificato tramite l'algoritmo QSVM, se necessario, per facilitare la convergenza.
Un metodo one_letter_symbol è stato rimosso da VarType nell'ultima versione di DOCplex, rendendo Aqua incompatibile con questa versione. Invece di utilizzare questo metodo, nel modulo di ottimizzazione Aqua è stato introdotto un controllo esplicito dei tipi di variabili.
:meth`~qiskit.aqua.operators.state_fns.DictStateFn.sample()` poteva gestire solo ampiezze reali, ma è stato corretto per gestire ampiezze complesse. #1311 <https://github.com/qiskit-community/qiskit-aqua/issues/1311> per maggiori dettagli.
La classe Trotter non utilizzava l'argomento reps nel costruttore. #1317 <https://github.com/qiskit-community/qiskit-aqua/issues/1317> per maggiori dettagli.
Solleva un AquaError se :class`qiskit.aqua.operators.converters.CircuitSampler` campiona un operatore vuoto. #1321 <https://github.com/qiskit-community/qiskit-aqua/issues/1321> per maggiori dettagli.
to_opflow() restituisce un operatore corretto quando i coefficienti sono numeri complessi. #1381 <https://github.com/qiskit-community/qiskit-aqua/issues/1381> per maggiori dettagli.
Lasciare che i simulatori di backend convalidino il supporto di NoiseModel invece di limitare Aer solo a QuantumInstance.
Gestire correttamente il metodo PassManager su QuantumInstance transpile chiamando il suo metodo run , se esiste.
È stato risolto un bug che mescolava initial_state personalizzato in QAOA con le porte di Hadamard. Questo non cambia la funzionalità di QAOA se l'utente non fornisce alcuno stato iniziale. È necessario prestare attenzione se l'implementazione utilizza QAOA con il parametro cusom initial_state , poiché i risultati dell'ottimizzazione potrebbero differire.
In precedenza, impostando seed_simulator=0 in QuantumInstance non si impostava alcun seme. Il problema riguardava solo il valore 0. Il problema è stato risolto.

IBM Q Fornitore 0.11.1

Nuove funzioni

qiskit.providers.ibmq.experiment.Experiment ora ha tre attributi aggiuntivi, hub, gruppo e progetto, che identificano il provider utilizzato per creare l'esperimento.
I metodi qiskit.providers.ibmq.experiment.ExperimentService.experiments() e qiskit.providers.ibmq.experiment.ExperimentService.analysis_results() supportano ora un parametro limit che consente di limitare il numero di esperimenti e risultati di analisi restituiti.

Note sull'aggiornamento

Un nuovo parametro, limit , è ora il primo parametro per entrambi i metodi qiskit.providers.ibmq.experiment.ExperimentService.experiments() e qiskit.providers.ibmq.experiment.ExperimentService.analysis_results() . Questo limit ha un valore predefinito di 10, il che significa che per deafult verranno restituiti solo 10 esperimenti e risultati di analisi.

Correzioni di bug

Corregge il problema per cui un lavoro potrebbe essere lasciato nello stato CREATING se l'invio del lavoro fallisce a metà strada.
Corregge il loop infinito generato quando si passa un'istanza di IBMQRandomService a un processo figlio.

0.23.0

Terra 0.16.0

Preludio

La release 0.16.0 include diverse nuove funzionalità e correzioni di bug. Le principali caratteristiche di questa versione sono le seguenti:

Introduzione di circuiti programmati, in cui i ritardi possono essere utilizzati per controllare la tempistica e l'allineamento delle operazioni nel circuito.
Compilazione di circuiti quantistici a partire da funzioni classiche, come gli oracoli.
Possibilità di compilare e ottimizzare le rotazioni di un singolo qubit su diverse basi di Eulero e sulla base fase + radice quadrata(X) (cioè ['p', 'sx']), che sostituirà il più vecchio IBM Base quantistica di ['u1', 'u2', 'u3'].
Tracciamento di global_phase() sulla classe QuantumCircuit è stato esteso attraverso le classi transpiler, quantum_info, e assembler e i simulatori BasicAer e Aer. Le simulazioni di matrici unitarie e vettori di stato restituiscono ora matrici unitarie e vettori di stato corretti per la fase globale.

Particolarmente importante per questa versione è che Python 3.5 non è più supportato. Se si utilizza Qiskit Terra con Python 3.5, la versione 0.15.2 è l'ultima che funziona.

Nuove funzioni

Le porte R globali sono state aggiunte a qiskit.circuit.library. Questo include il gate R globale (GR), Rx globale (GRX) e Ry globale (GRY) che derivano dal gate GR e il gate globale Rz ( GRZ) che è definito in modo simile ai gate GR gate. Le porte R globali sono definite su un certo numero di qubit simultaneamente e agiscono come una somma diretta di porte R su ciascun qubit.

Ad esempio:
```
from qiskit import QuantumCircuit, QuantumRegister
import numpy as np

num_qubits = 3
qr = QuantumRegister(num_qubits)
qc = QuantumCircuit(qr)

qc.compose(GR(num_qubits, theta=np.pi/3, phi=2*np.pi/3), inplace=True)
```
creerà un elemento QuantumCircuit su un QuantumRegister di 3 qubit ed eseguirà un RGate di un angolo $\theta = \frac{\pi}{3}$ attorno a un asse nel piano x delle sfere di Bloch che forma un angolo di $\phi = \frac{2\pi}{3}$ con l'asse x su ogni qubit.
Un nuovo schema di colori, iqx, è stato aggiunto al backend di mpl per il cassetto dei circuiti qiskit.visualization.circuit_drawer() e qiskit.circuit.QuantumCircuit.draw(). Utilizza lo stesso schema di colori del Circuit Composer sul sito web IBM Quantum Experience. Sono ora disponibili 3 schemi di colore: default, iqx e bw.

Esistono due modi per selezionare uno schema di colori. Il primo consiste nell'utilizzare un file di configurazione utente, per impostazione predefinita nella directory ~/.qiskit , nel file settings.conf sotto l'intestazione [Default] , l'utente può inserire circuit_mpl_style = iqx per selezionare lo schema di colori iqx .

Il secondo modo consiste nell'aggiungere {'name': 'iqx'} al kwarg style al metodo QuantumCircuit.draw o alla funzione circuit_drawer . La seconda modalità sovrascrive l'impostazione del file settings.conf. Ad esempio:
```
from qiskit.circuit import QuantumCircuit

circuit = QuantumCircuit(2)
circuit.h(0)
circuit.cx(0, 1)
circuit.measure_all()
circuit.draw('mpl', style={'name': 'iqx'})
```
Nel sito style kwarg per il cassetto del circuito qiskit.visualization.circuit_drawer() e qiskit.circuit.QuantumCircuit.draw() il campo displaycolor con il backend mpl consente ora di inserire sia il colore della porta che il colore del testo per ogni tipo di porta nel modulo (gate_color, text_color). Ciò consente di utilizzare i colori chiari e scuri della porta con colori di testo contrastanti. Gli utenti possono comunque impostare solo il colore del cancello, nel qual caso verrà utilizzato il campo gatetextcolor . I colori dei gate possono essere impostati nel dict style per qualsiasi numero di tipi di gate, da uno all'intero dict displaycolor . Ad esempio:
```
from qiskit.circuit import QuantumCircuit

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

style_dict = {'displaycolor': {'h': ('#FA74A6', '#000000')}}
circuit.draw('mpl', style=style_dict)
```
oppure
```
style_dict = {'displaycolor': {'h': '#FA74A6'}}
circuit.draw('mpl', style=style_dict)
```
Al costruttore di impulsi vengono aggiunti due contesti di allineamento (qiskit.pulse.builder) per facilitare la scrittura di una sequenza di impulsi ripetuta con ritardi.
- qiskit.pulse.builder.align_equispaced() inserisce ritardi di lunghezza equivalente tra i programmi di impulsi all'interno del contesto.
- qiskit.pulse.builder.align_func() offre un controllo più avanzato della posizione degli impulsi. Questo contesto accetta una callable che calcola una coordinata frazionaria dell'impulso i-esimo e allinea gli impulsi all'interno del contesto. Questo facilita la codifica del disaccoppiamento dinamico.
È stato aggiunto un parametro rep_delay alla classe QasmQobj nella configurazione di esecuzione, QasmQobjConfig. Questo parametro viene utilizzato per indicare l'intervallo di tempo tra le esecuzioni del programma. Deve essere scelto dall'intervallo di backend fornito dal metodo BackendConfigurationrep_delay_range() . Se non viene fornito un valore, verrà utilizzato il valore predefinito del backend, qiskit.providers.models.BackendConfiguration.default_rep_delay. rep_delay funzionerà solo sui backend che consentono un tempo di ripetizione dinamico. Questo può essere controllato con la proprietà BackendConfigurationdynamic_reprate_enabled .
Il file qobj_schema.json JSON Schema in qiskit.schemas è stato aggiornato per includere rep_delay come proprietà di configurazione opzionale per i Qobj QASM.
Il file backend_configuration_schema.json JSON Schema in qiskit.schemas è stato aggiornato per includere dynamic_reprate_enabled, rep_delay_range e default_rep_delay come proprietà opzionali per un payload di configurazione del backend QASM.
Un nuovo passaggio di ottimizzazione, qiskit.transpiler.passes.TemplateOptimization è stato aggiunto al transpiler. Questo passaggio applica un algoritmo di corrispondenza dei modelli descritto in arXiv:1909.05270 che sostituisce tutte le corrispondenze massime compatibili nel circuito.

Per implementare questo nuovo passaggio di transpiler è stato aggiunto un nuovo modulo, template_circuits, alla libreria dei circuiti (qiskit.circuit.library). Questo nuovo modulo contiene tutti i modelli di circuito Toffoli utilizzati nel programma TemplateOptimization.

Questo nuovo passaggio non è attualmente incluso nei gestori di passaggi preimpostati (qiskit.transpiler.preset_passmanagers), per utilizzarlo è necessario creare un pass personalizzato PassManager.
È stata aggiunta una nuova versione dell'interfaccia dei provider. Questa nuova interfaccia, che si trova in qiskit.providersfornisce un nuovo meccanismo di versionamento che consentirà di apportare modifiche all'interfaccia in modo compatibile nel tempo. La nuova interfaccia dovrebbe essere semplice da migrare per i provider esistenti, in quanto è per lo più identica, tranne che per il versioning esplicito.

Oltre ad avere classi astratte esplicitamente versionate, i cambiamenti chiave per la nuova interfaccia sono che il metodo BackendV1 metodo run() può ora accettare come input un oggetto QuantumCircuit o Schedule come input invece di oggetti Qobj . Inoltre, le opzioni fanno ora parte di una classe di backend, in modo che gli utenti possano configurare le opzioni di esecuzione durante il funzionamento con un circuito. L'ultima modifica è che qiskit.providers.JobV1 può ora essere sincrono o asincrono; la configurazione esatta e il metodo per configurarlo spetta al fornitore, ma ci sono punti di aggancio dell'interfaccia per rendere esplicito il modello di esecuzione di un lavoro nella classe astratta JobV1 .
Un nuovo kwarg, inplace, è stato aggiunto alla funzione qiskit.result.marginal_counts(). Questo kwarg viene utilizzato per controllare se il contenuto viene marginalizzato in posizione o se ne viene restituita una nuova copia, per Result l'input di un oggetto. Questo parametro non ha alcun effetto per un input dict o Counts oggetto.
È stata aggiunta una prima versione di un compilatore di funzioni classiche, qiskit.circuit.classicalfunctionè stata aggiunta. Questo permette di compilare le funzioni tipizzate di python (che al momento operano solo su bit di tipo Int1 ) in QuantumCircuit oggetti. Ad esempio:
```
from qiskit.circuit import classical_function, Int1

@classical_function
def grover_oracle(a: Int1, b: Int1, c: Int1, d: Int1) -> Int1:
     x = not a and b
     y = d and not c
     z = not x or y
     return z

quantum_circuit = grover_oracle.synth()
quantum_circuit.draw()
```
Il parametro registerless=False nel metodo qiskit.circuit.classicalfunction.ClassicalFunction metodo synth() crea un circuito con registri che si riferiscono ai nomi dei parametri. Ad esempio:
```
quantum_circuit = grover_oracle.synth(registerless=False)
quantum_circuit.draw()
```
Una funzione classica decorata può essere utilizzata come qualsiasi altra porta quantistica quando viene aggiunta a un circuito.
```
circuit = QuantumCircuit(5)
circuit.append(grover_oracle, range(5))
circuit.draw()
```
Il gate GROVER_ORACLE viene sintetizzato quando è necessaria la sua scomposizione.
```
circuit.decompose().draw()
```
La funzione richiede tweedledum, una libreria per la sintesi di circuiti quantistici, che può essere installata tramite pip con pip install tweedledum.
È stata aggiunta una nuova classe qiskit.circuit.Delay per rappresentare un'istruzione di ritardo in un circuito. Un nuovo metodo delay() è ora disponibile per aggiungere facilmente ritardi ai circuiti. In questo modo è possibile descrivere esperimenti sensibili ai tempi (ad esempio, l'esperimento T1/T2 ) a livello di circuito.
```
from qiskit import QuantumCircuit

qc = QuantumCircuit(1, 1)
qc.delay(500, 0, unit='ns')
qc.measure(0, 0)

qc.draw()
```
È stato aggiunto un nuovo argomento scheduling_method per qiskit.compiler.transpile() è stato aggiunto. È necessario quando si traspongono circuiti con ritardi. Se viene specificato scheduling_method , il transpiler restituisce un circuito programmato in cui tutti i tempi di inattività sono riempiti di ritardi (cioè l'ora di inizio di ogni istruzione è determinata in modo univoco). In questo modo è possibile vedere come le istruzioni programmate (gates) appaiono a livello di circuito.
```
from qiskit import QuantumCircuit, transpile
from qiskit.test.mock.backends import FakeAthens

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

scheduled_circuit = transpile(qc, backend=FakeAthens(), scheduling_method="alap")
print("Duration in dt:", scheduled_circuit.duration)
scheduled_circuit.draw(idle_wires=False)
```
Vedere anche timeline_drawer() per una migliore visualizzazione dei circuiti programmati.
È stata aggiunta una nuova funzione qiskit.compiler.sequence() è stata aggiunta per poter convertire un circuito programmato in un circuito Schedule per renderlo eseguibile su un backend abilitato agli impulsi.
```
from qiskit.compiler import sequence

sched = sequence(scheduled_circuit, pulse_enabled_backend)
```

Il sistema schedule() è stato aggiornato in modo da poter programmare circuiti con ritardi. Ora ci sono due strade per programmare un circuito con ritardo:

qc = QuantumCircuit(1, 1)
qc.h(0)
qc.delay(500, 0, unit='ns')
qc.h(0)
qc.measure(0, 0)

sched_path1 = schedule(qc.decompose(), backend)
sched_path2 = sequence(transpile(qc, backend, scheduling_method='alap'), backend)
assert pad(sched_path1) == sched_path2

Consultare le note di rilascio e la documentazione per transpile() e sequence() per i dettagli sull'altro percorso.

È stato aggiunto il GroverOperator alla libreria dei circuiti (qiskit.circuit.library) per costruire l'operatore di Grover utilizzato nell'algoritmo di ricerca di Grover e nell'amplificazione/stima dell'ampiezza quantistica. Dotato di un oracolo sotto forma di circuito, GroverOperator crea l'operatore Grover da manuale. Per generalizzare questo principio per l'amplificazione dell'ampiezza e utilizzare un operatore generico al posto delle porte di Hadamard come preparazione dello stato, è possibile utilizzare l'argomento state_in .
I InstructionScheduleMap metodi get() e pop() ora accettano ParameterExpression oltre ai valori numerici per i parametri del generatore di programmi previsionali. Se il generatore è una funzione, le espressioni possono essere legate prima o all'interno della chiamata di funzione. Se il generatore è un ParametrizedSchedule, le espressioni devono essere vincolate prima che il programma stesso venga vincolato/chiamato.
Una nuova classe LinearAmplitudeFunction è stata aggiunta alla libreria dei circuiti (qiskit.circuit.library) per la mappatura di funzioni lineari (piecewise) sulle ampiezze dei qubit,

F|x\rangle |0\rangle = \sqrt{1 - f(x)}|x\rangle |0\rangle + \sqrt{f(x)}|x\rangle |1\rangle

La mappatura si basa su una rotazione di Pauli Y controllata e su un'approssimazione di Taylor, come descritto in https://arxiv.org/abs/1806.06893. Questo circuito può essere utilizzato per calcolare i valori di aspettativa delle funzioni lineari utilizzando l'algoritmo di stima dell'ampiezza quantistica.

Il nuovo jupyter magic monospaced_output è stato aggiunto al modulo qiskit.tools.jupyter al modulo. Questa magia imposta il carattere di output del notebook Jupyter su "Courier New", quando possibile. Se utilizzato, questo font restituisce disegni del circuito di testo meglio allineati.
```
import qiskit.tools.jupyter
%monospaced_output
```
È stato aggiunto un nuovo passaggio di transpiler, Optimize1qGatesDecompositionè stato aggiunto. Questo passaggio di transpiler è un'alternativa all'esistente Optimize1qGates che utilizza la classe OneQubitEulerDecomposer per decomporre e semplificare una catena di porte a singolo qubit. Questo metodo è compatibile con qualsiasi insieme di basi, mentre Optimize1qGates funziona solo per u1, u2 e u3. I gestori dei passaggi predefiniti per optimization_level 1, 2 e 3 sono stati aggiornati per utilizzare questo nuovo passaggio se l'insieme di basi non include u1, u2, o u3.
Il OneQubitEulerDecomposer supporta ora due nuove basi, 'PSX' e 'U'. Questi possono essere specificati con il kwarg basis sul costruttore. Questo decomporrà la matrice in un circuito utilizzando PGate e SXGate per 'PSX', e UGate per 'U'.

Un nuovo metodo remove() è stato aggiunto alla classe qiskit.transpiler.PassManager classe. Questo metodo consente di rimuovere un passaggio da un'istanza PassManager istanza. Funziona sugli indici, in modo simile a replace(). Ad esempio, per rimuovere il passaggio RemoveResetInZeroState dal gestore dei passaggi utilizzato al livello di ottimizzazione 1:

from qiskit.transpiler.preset_passmanagers import level_1_pass_manager
from qiskit.transpiler.passmanager_config import PassManagerConfig

pm = level_1_pass_manager(PassManagerConfig())
pm.draw()

[0] FlowLinear: UnrollCustomDefinitions, BasisTranslator
[1] FlowLinear: RemoveResetInZeroState
[2] DoWhile: Depth, FixedPoint, Optimize1qGates, CXCancellation

Il palco [1] con RemoveResetInZeroState può essere rimosso in questo modo:

pass_manager.remove(1)
pass_manager.draw()

[0] FlowLinear: UnrollCustomDefinitions, BasisTranslator
[1] DoWhile: Depth, FixedPoint, Optimize1qGates, CXCancellation

Alla libreria dei circuiti sono state aggiunte diverse classi per caricare le distribuzioni di probabilità nelle ampiezze dei qubit: UniformDistribution, NormalDistribution e LogNormalDistribution (qiskit.circuit.library). Le distribuzioni normale e log-normale supportano distribuzioni univariate e multivariate. Questi circuiti sono fondamentali per le applicazioni in finanza in cui si utilizza la stima dell'ampiezza quantistica.
Il supporto per le porte a impulsi è stato aggiunto alla classe QuantumCircuit classe. Ciò consente a un utente di QuantumCircuit di sovrascrivere (per le porte base) o specificare (per le porte standard e personalizzate) la definizione di un'operazione in termini di segnali ordinati nel tempo attraverso i canali hardware Gate in termini di segnali ordinati nel tempo attraverso i canali hardware. In altre parole, consente di fornire calibrazioni personalizzate del gate a livello di impulsi.

I circuiti sono costruiti esattamente come prima. Ad esempio:
```
from qiskit import pulse
from qiskit.circuit import QuantumCircuit, Gate

class RxGate(Gate):
    def __init__(self, theta):
        super().__init__('rxtheta', 1, [theta])

circ = QuantumCircuit(1)
circ.h(0)
circ.append(RxGate(3.14), [0])
```
Quindi, la calibrazione del gate può essere registrata con il metodo QuantumCircuit metodo add_calibration() che prende una Schedule nonché i qubit e i parametri per cui è stato definito:
```
# Define the gate implementation as a schedule
with pulse.build() as custom_h_schedule:
    pulse.play(pulse.library.Drag(...), pulse.DriveChannel(0))

with pulse.build() as q1_x180:
    pulse.play(pulse.library.Gaussian(...), pulse.DriveChannel(1))

# Register the schedule to the gate
circ.add_calibration('h', [0], custom_h_schedule)  # or gate.name string to register
circ.add_calibration(RxGate(3.14), [0], q1_x180)   # Can accept gate
```
In precedenza, questa funzionalità poteva essere utilizzata solo attraverso pianificazioni complete di impulsi. Inoltre, i circuiti possono ora essere inviati ai backend con le vostre definizioni personalizzate (a seconda del supporto del backend).

I circuiti con porte a impulsi possono ancora essere abbassati a una Schedule utilizzando la funzione schedule() funzione.

Il gate calibrato può anche essere transpilato utilizzando il normale processo di transpilatura:
```
transpiled_circuit = transpile(circ, backend)
```
Il circuito transpilato lascerà le porte calibrate sullo stesso qubit del circuito originale e non le srotolerà alle porte di base.

Il supporto per il disassemblaggio di PulseQobj è stato aggiunto alla funzione qiskit.assembler.disassemble() funzione. Ad esempio:

from qiskit import pulse
from qiskit.assembler.disassemble import disassemble
from qiskit.compiler.assemble import assemble
from qiskit.test.mock import FakeOpenPulse2Q

backend = FakeOpenPulse2Q()

d0 = pulse.DriveChannel(0)
d1 = pulse.DriveChannel(1)
with pulse.build(backend) as sched:
    with pulse.align_right():
        pulse.play(pulse.library.Constant(10, 1.0), d0)
        pulse.shift_phase(3.11, d0)
        pulse.measure_all()

qobj = assemble(sched, backend=backend, shots=512)
scheds, run_config, header = disassemble(qobj)

Un nuovo kwarg, coord_type è stato aggiunto a qiskit.visualization.plot_bloch_vector(). Questo kwarg consente di cambiare il sistema di coordinate utilizzato per il parametro di input che descrive il posizionamento del vettore sulla sfera di Bloch nella visualizzazione generata. Ci sono due valori supportati per questo nuovo kwarg, 'cartesian' (il valore predefinito) e 'spherical'. Se il kwarg coord_type è impostato su 'spherical' , l'elenco dei parametri inseriti è della forma [r, theta, phi] dove r è il raggio, theta è l'inclinazione dalla direzione +z e phi è l'azimut dalla direzione +x. Ad esempio:
```
from numpy import pi

from qiskit.visualization import plot_bloch_vector

x = 0
y = 0
z = 1
r = 1
theta = pi
phi = 0


# Cartesian coordinates, where (x,y,z) are cartesian coordinates
# for bloch vector
plot_bloch_vector([x,y,z])
```
```
plot_bloch_vector([x,y,z], coord_type="cartesian")  # Same as line above
```
```
# Spherical coordinates, where (r,theta,phi) are spherical coordinates
# for bloch vector
plot_bloch_vector([r, theta, phi], coord_type="spherical")
```

Impulso Schedule supporta ora l'uso di oggetti ParameterExpression per i parametri.

Ad esempio:

from qiskit.circuit import Parameter
from qiskit import pulse

alpha = Parameter('⍺')
phi = Parameter('ϕ')
qubit = Parameter('q')
amp = Parameter('amp')

schedule = pulse.Schedule()
schedule += SetFrequency(alpha, DriveChannel(qubit))
schedule += ShiftPhase(phi, DriveChannel(qubit))
schedule += Play(Gaussian(duration=128, sigma=4, amp=amp),
                 DriveChannel(qubit))
schedule += ShiftPhase(-phi, DriveChannel(qubit))

L'assegnazione dei parametri avviene tramite il metodo assign_parameters() metodo:

schedule.assign_parameters({alpha: 4.5e9, phi: 1.57,
                            qubit: 0, amp: 0.2})

Funzionano anche le espressioni e le assegnazioni parziali, come ad esempio:

beta = Parameter('b')
schedule += SetFrequency(alpha + beta, DriveChannel(0))
schedule.assign_parameters({alpha: 4.5e9})
schedule.assign_parameters({beta: phi / 6.28})

Una nuova funzione di visualizzazione timeline_drawer() è stata aggiunta al modulo qiskit.visualization modulo.

Ad esempio:

from qiskit.visualization import timeline_drawer
from qiskit import QuantumCircuit, transpile
from qiskit.test.mock import FakeAthens

qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0,1)
timeline_drawer(transpile(qc, FakeAthens(), scheduling_method='alap'))

Note sull'aggiornamento

Il controllo del tipo per il kwarg params del costruttore della classe e delle sue sottoclassi è stato modificato Gate e delle sue sottoclassi è stato modificato. In precedenza tutti i Gate dovevano rientrare in un insieme di tipi consentiti, definiti nella classe Instruction classe. Ora un nuovo metodo, validate_parameter() è usato per determinare se un tipo di parametro è valido o meno. La definizione di questo metodo in una sottoclasse avrà la priorità rispetto al suo genitore. Ad esempio, UnitaryGate accetta un parametro di tipo numpy.ndarray e definisce un metodo personalizzato validate_parameter() che restituisce il parametro se è un numpy.ndarray. Questo ha la priorità sulla funzione definita nella sua classe padre Gate. Se UnitaryGate dovesse essere usato come genitore per una nuova classe, verrebbe usato questo metodo di validate_parameter , a meno che la nuova classe figlia non definisca un proprio metodo.
I metodi, gli argomenti e le proprietà precedentemente deprecati, denominati n_qubits e numberofqubits , sono stati rimossi. Questi sono stati deprecati nella versione 0.13.0. La serie completa di modifiche è la seguente:

Classe
Precedente
Nuovo
QuantumCircuit n_qubits num_qubits
Pauli numberofqubits num_qubits

Funzione
Vecchio argomento
Nuovo argomento
qiskit.circuit.random.random_circuit() n_qubits num_qubits
qiskit.circuit.library.MSGate n_qubits num_qubits
L'inserimento di un'istanza parametrizzata Gate in un oggetto QuantumCircuit crea ora una copia di quel gate che viene utilizzata nel circuito. Se vengono apportate modifiche all'istanza inserita nel circuito, queste non si rifletteranno più sul gate del circuito. Questa modifica è stata apportata per risolvere un problema durante l'inserimento di un singolo oggetto parametrizzato Gate in più circuiti.
La funzione qiskit.result.marginal_counts() ora, per impostazione predefinita, non modifica il parametro qiskit.result.Result il parametro istanza. In precedenza, l'oggetto Result veniva sempre modificato sul posto. È stato aggiunto un nuovo kwarg inplace marginal_counts() che consente di utilizzare il comportamento precedente quando è impostato inplace=True .
La definizione U3Gate è stata modificata per essere in termini di classe UGate classe. La UGate non ha una definizione. Non è quindi più possibile srotolare ogni circuito in termini di U3 e CX. Invece, U e CX possono essere utilizzati per ogni circuito.
Il supporto deprecato per l'esecuzione di Qiskit Terra con Python 3.5 è stato rimosso. Per utilizzare Qiskit Terra a partire da questa versione è necessario utilizzare almeno Python 3.6. Se si utilizza Python 3.5 l'ultima versione che funziona è Qiskit Terra 0.15.2.
Negli attributi PulseBackendConfiguration negli attributi hamiltonian il campo vars viene ora restituito in un'unità di misura di Hz, anziché in GHz come in precedenza. Questa modifica è stata apportata per essere coerente con le unità utilizzate con gli altri attributi della classe.
Il supporto, precedentemente deprecato, per il passaggio di un dizionario come primo parametro posizionale del costruttore DAGNode è stato rimosso. L'uso di un dettatore per il primo argomento posizionale è stato deprecato nella versione 0.13.0. Per creare un DAGNode si devono passare direttamente gli attributi come kwarg nel costruttore.
Gli argomenti delle parole chiave per i metodi delle porte di circuito (ad esempio: qiskit.circuit.QuantumCircuit.cx) q, ctl* e tgt*, che sono stati deprecati nella versione 0.12.0, sono stati rimossi. Invece, solo qubit, control_qubit* e target_qubit* possono essere usati come argomenti denominati per questi metodi.
Il modulo qiskit.extensions.standard , precedentemente deprecato, è stato rimosso. Questo modulo è stato deprecato dalla versione 0.14.0. Il qiskit.circuit.library può essere utilizzato al suo posto. Inoltre, tutte le classi di gate precedentemente presenti in qiskit.extensions.standard sono ancora importabili da qiskit.extensions.
Le porte precedentemente deprecate nel modulo qiskit.extensions.quantum_initializer: DiagGate, UCG`, UCPauliRotGate, UCRot, UCRXGate, UCX, UCRYGate, UCY, UCRZGate, UCZ sono state rimosse. Questi sono stati tutti deprecati nella versione 0.14.0 e hanno alternative disponibili nella libreria dei circuiti (qiskit.circuit.library).
Il metodo qiskit.circuit.QuantumCircuitiden() è stato rimosso. Questo è stato deprecato nella versione 0.13.0 e i() o id() può essere utilizzato al suo posto.

Classe	Precedente	Nuovo
`QuantumCircuit`	`n_qubits`	`num_qubits`
`Pauli`	`numberofqubits`	`num_qubits`

Funzione	Vecchio argomento	Nuovo argomento
`qiskit.circuit.random.random_circuit()`	`n_qubits`	`num_qubits`
`qiskit.circuit.library.MSGate`	`n_qubits`	`num_qubits`

Note di deprecazione

L'uso di un numpy.ndarray per un parametro nel kwarg params per il costruttore della classe e delle sottoclassi Gate e delle sottoclassi è stato deprecato e sarà rimosso nelle prossime versioni. Questo è stato fatto come parte della rifattorizzazione del modo in cui viene gestito il controllo di tipo parms per la classe Gate della classe. Se si ha una classe gate personalizzata che è una sottoclasse di Gate direttamente (o tramite un altro genitore nella gerarchia) che accetta un parametro ndarray , si deve definire un metodo personalizzato per la propria classe che restituisca il tipo di parametro consentito validate_parameter() per la propria classe, che restituisca il tipo di parametro consentito. Ad esempio:
```
def validate_parameter(self, parameter):
    """Custom gate parameter has to be an ndarray."""
    if isinstance(parameter, numpy.ndarray):
        return parameter
    else:
        raise CircuitError("invalid param type {0} in gate "
                           "{1}".format(type(parameter), self.name))
```
La num_ancilla_qubits della proprietà PiecewiseLinearPauliRotations e PolynomialPauliRotations è stata deprecata e sarà rimossa in una prossima versione. Si deve invece utilizzare la proprietà num_ancillas dovrebbe essere utilizzata al suo posto. Questo è stato fatto per renderlo coerente con il metodo QuantumCircuit metodo num_ancillas().
La classe qiskit.circuit.library.MSGate è stata deprecata, ma rimarrà per consentire il caricamento dei vecchi lavori. È stata sostituita con la classe qiskit.circuit.library.GMS che dovrebbe essere utilizzata al suo posto.
Il passaggio del transpiler MSBasisDecomposer è stato deprecato e sarà rimosso in una prossima versione. Il qiskit.transpiler.passes.BasisTranslator può essere utilizzato al suo posto.

I metodi QuantumCircuitu1 , u2 e u3 sono ora deprecati. Si possono invece utilizzare le seguenti sostituzioni.

u1(theta) = p(theta) = u(0, 0, theta)
u2(phi, lam) = u(pi/2, phi, lam) = p(pi/2 + phi) sx p(pi/2 lam)
u3(theta, phi, lam) = u(theta, phi, lam) = p(phi + pi) sx p(theta + pi) sx p(lam)

Le classi del gate stesso, U1Gate, U2Gate e U3Gate per consentire il caricamento dei vecchi lavori.

Correzioni di bug

I metodi della Result metodi della classe data(), get_memory(), get_counts(), get_unitary(), e get_statevector ` will now emit a warning when the ``experiment`() kwarg è specificato per tentare di recuperare i risultati utilizzando un metodo di tipo QuantumCircuit o Schedule quando nell'oggetto Result è presente più di una voce corrispondente al nome dell'istanza. Si noti che verrà restituita solo la prima voce corrispondente a questo nome. Correzioni #3207
Il qiskit.circuit.QuantumCircuit metodo append() può ora essere usato per inserire un'istanza di gate parametrizzata in più circuiti. In questo modo si risolve un problema precedente per cui l'inserimento di un singolo oggetto parametrizzato Gate in più circuiti provocava errori quando a un circuito era assegnato un parametro. Correzioni #4697
In precedenza la funzione qiskit.execute.execute() non consentiva di specificare contemporaneamente i kwarg backend e pass_manager . Il problema è stato risolto in modo che sia backend che pass_manager possano essere utilizzati insieme nelle chiamate a execute(). Correzioni #5037
Il QuantumCircuit metodo unitary() è stato corretto per accettare un singolo intero per l'argomento qarg (quando si aggiunge un unitario a 1 qubit). I tipi consentiti per l'argomento qargs sono ora int, Qubit, o un elenco di numeri interi. Correzioni #4944
In precedenza, la chiamata a inverse() su un oggetto BlueprintCircuit poteva fallire se la sua proprietà interna dei dati non era ancora popolata. Questo problema è stato risolto in modo che la chiamata a inverse() popoli i dati interni prima di generare l'inverso del circuito. Correzioni #5140
È stato risolto un problema durante la creazione di un oggetto qiskit.result.Counts da un dizionario dati vuoto. Ora questo creerà un oggetto Counts vuoto. Il metodo most_frequent() è stato aggiornato per sollevare un'eccezione più descrittiva quando l'oggetto è vuoto. Correzioni #5017
Corregge un bug per cui l'impostazione di ctrl_state di un UnitaryGate veniva applicata due volte; una volta nella creazione della matrice per l'unitario controllato e un'altra volta quando si chiamava il metodo definition() della classe qiskit.circuit.ControlledGate classe. Questo darebbe l'impressione che l'impostazione di ctrl_state non abbia alcun effetto.
In precedenza il metodo ControlledGate metodo inverse() non conservava il parametro ctrl_state in alcuni casi. Questo problema è stato risolto in modo che la chiamata a inverse() conservi il valore ctrl_state nel suo output.
Corretto un bug nel backend dell'uscita mpl del cassetto dei circuiti qiskit.circuit.QuantumCircuit.draw() e qiskit.visualization.circuit_drawer() che causava il fallimento del cassetto se il kwarg di style era impostato su una stringa. Il comportamento corretto sarebbe quello di trattare questa stringa come un percorso a un file JSON contenente il foglio di stile per la visualizzazione. Questo problema è stato risolto e vengono emessi avvisi se il file JSON per il foglio di stile non può essere caricato.
È stato corretto un errore per cui il caricamento di un file QASM tramite from_qasm_file() o from_qasm_str() falliva se nel file QASM era presente una porta u, phase(p), sx o sxdg . Correzioni #5156
Corretto un bug che potenzialmente causava una mappatura errata dei registri quando si srotolava/decomponeva un gate definito con una sola operazione a 2 qubit.

Aer 0.7.0

Preludio

Questa versione di 0.7.0 include numerosi miglioramenti delle prestazioni e miglioramenti significativi dell'interfaccia del simulatore, e abbandona il supporto per Python 3.5. Le principali modifiche all'interfaccia sono i backend configurabili dei simulatori e la costruzione di simulatori preconfigurati dai backend IBMQ. Il supporto del modello di rumore e delle porte di base è stato esteso anche alla maggior parte delle porte standard della libreria di circuiti Qiskit, compreso il nuovo supporto per le porte di rotazione a 1 e 2 qubit. I miglioramenti delle prestazioni includono l'aggiunta del supporto SIMD ai metodi di simulazione a matrice di densità e unitaria, la riduzione della memoria utilizzata e il miglioramento delle prestazioni dei circuiti che utilizzano snapshot di matrici di stato e di densità e l'aggiunta del supporto per le istruzioni Kraus all'ottimizzazione dei circuiti di fusione dei gate per migliorare notevolmente le prestazioni delle simulazioni rumorose a matrice di stato.

Nuove funzioni

Aggiunge il supporto del gate di base per l'istruzione qiskit.circuit.Delay alle istruzioni StatevectorSimulator, UnitarySimulator e QasmSimulator. Si noti che questo gate viene trattato come un gate di identità durante la simulazione e il parametro della lunghezza del ritardo viene ignorato.
Aggiunge il supporto per il gate di base per il gate a singolo qubit qiskit.circuit.library.UGate ai metodi StatevectorSimulator, UnitarySimulator e "statevector", "density_matrix", "matrix_product_state" e "extended_stabilizer" di QasmSimulator.
Aggiunge il supporto del gate di base per il gate di fase qiskit.circuit.library.PhaseGate ai metodi StatevectorSimulator, StatevectorSimulator, UnitarySimulator e "statevector", "density_matrix", "matrix_product_state" e "extended_stabilizer" di QasmSimulator.
Aggiunge il supporto per il gate di base per il gate a fase controllata qiskit.circuit.library.CPhaseGate ai metodi StatevectorSimulator, StatevectorSimulator, UnitarySimulator e "statevector", "density_matrix" e "matrix_product_state" di QasmSimulator.
Aggiunge il supporto per il gate di fase multi-controllato qiskit.circuit.library.MCPhaseGate ai metodi StatevectorSimulator, UnitarySimulator e "statevector" di QasmSimulator.
Aggiunge il supporto per il gate $\sqrt(X)$ qiskit.circuit.library.SXGate ai moduli StatevectorSimulator, UnitarySimulator e QasmSimulator.
Aggiunge il supporto per le porte di rotazione della libreria di circuiti Qiskit a 1 e 2 qubit RXGate, RYGate, RZGate, RGate, RXXGate, RYYGate, RZZGate, RZXGate ai metodi StatevectorSimulator, UnitarySimulator, e "statevector" e "density_matrix" di QasmSimulator.
Aggiunge il supporto per le porte di rotazione multicontrollate "mcr", "mcrx", "mcry", "mcrz" ai metodi StatevectorSimulator, UnitarySimulator, e "statevector" al metodo QasmSimulator.
Rendere configurabili i backend del simulatore. Ciò consente di impostare opzioni persistenti, come il metodo di simulazione e il modello di rumore, per ciascun oggetto backend del simulatore.

QasmSimulator e PulseSimulator possono essere configurati anche da un oggetto backend IBMQBackend , utilizzando il metodo :meth:`~qiskit.providers.aer.QasmSimulator.from_backend. Per il sito QasmSimulator configura la mappa di accoppiamento, le porte di base e il modello di rumore di base del dispositivo in base alla configurazione e alle proprietà del backend. Per il sito PulseSimulator il modello di sistema e le impostazioni predefinite saranno configurate automaticamente dalla configurazione, dalle proprietà e dalle impostazioni predefinite del backend.

Ad esempio, un backend per la simulazione di una matrice di densità rumorosa può essere costruito come QasmSimulator(method='density_matrix', noise_model=noise_model), o un simulatore di stato del prodotto matriciale ideale come QasmSimulator(method='matrix_product_state').

Un vantaggio è che un'istanza di PulseSimulator configurata da un backend serve meglio a sostituire il backend originale, rendendo più facile l'inserimento e il disinserimento di un simulatore e di un backend reale, ad esempio per testare il codice su un simulatore prima di utilizzare un backend reale. Ad esempio, nel seguente blocco di codice, PulseSimulator è istanziato dal backend FakeArmonk() . Tutti i dati di configurazione e di default vengono copiati nell'istanza del simulatore, quindi quando vengono passati come argomento a assemble, si comportano come se fosse stato fornito il backend originale (ad esempio, i default di FakeArmonk saranno presenti e utilizzati da assemble).
```
armonk_sim = qiskit.providers.aer.PulseSimulator.from_backend(FakeArmonk())
pulse_qobj = assemble(schedules, backend=armonk_sim)
armonk_sim.run(pulse_qobj)
```
Sebbene l'esempio precedente sia di piccole dimensioni, il comportamento dimostrato di "sostituzione a cascata" dovrebbe migliorare notevolmente l'usabilità in flussi di lavoro più complicati, ad esempio quando gli esperimenti di calibrazione vengono costruiti utilizzando gli attributi del backend.
Aggiunge il supporto per la fase globale qobj ai metodi StatevectorSimulator, UnitarySimulator e statevector di QasmSimulator.
Migliora le prestazioni delle simulazioni di vettori di stato rumorosi in generale aggiungendo un metodo Kraus all'ottimizzazione del circuito di fusione di gate che consente di applicare la fusione di gate a simulazioni di vettori di stato rumorosi con rumore Kraus generale.
Utilizzare la semantica di spostamento per le istantanee del vettore di stato e della matrice di densità per i metodi "statevector" e "density_matrix" di QasmSimulator se sono l'istruzione finale di un circuito. Questo riduce l'utilizzo della memoria del simulatore e migliora le prestazioni evitando di copiare un array di grandi dimensioni nei risultati.
Aggiunge il supporto per gli errori generali della porta di Kraus QauntumError nel metodo NoiseModel al metodo "matrix_product_state" di QasmSimulator.
Aggiunge il supporto per l'istruzione snapshot della matrice di densità qiskit.providers.aer.extensions.SnapshotDensityMatrix al metodo "matrix_product_state" del metodo QasmSimulator.
Estende la vettorizzazione SIMD del metodo di simulazione statevector ai metodi di simulazione a matrice unitaria, a matrice di superoperatori e a matrice di densità. In questo modo si ottiene un aumento delle prestazioni di 2x simulazione generale utilizzando il metodo UnitarySimulator, il metodo "density_matrix" di QasmSimulator, la fusione dei gate e la simulazione del rumore.
Aggiunge una classe vettoriale personalizzata al codice C++ che ha una migliore integrazione con Pybind11. Questo riduce il fabbisogno di memoria di StatevectorSimulator , evitando una copia della memoria durante il binding di Python dello stato finale del simulatore.

Note sull'aggiornamento

AER utilizza ora Lapack per eseguire alcuni calcoli relativi alle matrici. Utilizza la libreria Lapack in bundle con OpenBlas (già disponibile nelle distribuzioni Linux e Macos tipiche di OpenBlas; la versione per Windows è distribuita con AER) o con il framework accelerate di MacOS.
Il supporto deprecato per l'esecuzione di qiskit-aer con Python 3.5 è stato rimosso. Per utilizzare qiskit-aer >= 0.7.0 è necessario almeno Python 3.6. Se state usando Python 3.5 l'ultima versione che funzionerà è qiskit-aer 0.6.x.
Aggiorna le soglie predefinite della gate fusion in modo che la gate fusion venga applicata ai circuiti con più di 14 qubit per le simulazioni statevector su StatevectorSimulator e QasmSimulator.

Per il metodo "density_matrix" di QasmSimulator e per la fusione dei gate di UnitarySimulator si applicherà a circuiti con più di 7 qubit.

I valori di soglia personalizzati dei qubit possono essere impostati utilizzando l'opzione di backend fusion_threshold , ovvero backend.set_options(fusion_threshold=10)
Modifica l'opzione del backend fusion_threshold per applicare la fusione quando il numero di qubit è superiore alla soglia, e non uguale o superiore alla soglia, in modo da corrispondere al comportamento del parametro di soglia dei qubit di OpenMP.

Note di deprecazione

qiskit.providers.aer.noise.NoiseModel.set_x90_single_qubit_gates() è stato deprecato, in quanto il transpiler qiskit ha aggiunto lo scorrimento verso porte di base personalizzate. Il modo corretto di utilizzare un modello di rumore basato su X90 è quello di definire il rumore sulla porta Sqrt(X) "sx" o "rx" e su una delle porte di fase a singolo qubit "u1", "rx", o "p" nel modello di rumore.
Il kwarg variance delle istruzioni Snapshot è stato deprecato. Questa funzione calcolava la varianza del campione nell'istantanea dovuta al campionamento del modello di rumore e non la varianza dovuta alle statistiche di misurazione, pertanto veniva spesso utilizzata in modo errato. Se è richiesta la varianza per la modellazione del rumore, è opportuno utilizzare istantanee a scatto singolo, in modo che la varianza possa essere calcolata manualmente in post-elaborazione.

Correzioni di bug

Corregge un bug in StatevectorSimulator che faceva sì che venisse sempre eseguito come CPU con doppia precisione senza il supporto di SIMD/AVX2 anche su sistemi con AVX2, o quando nelle opzioni del backend era specificata la singola precisione o il metodo GPU.
Corretti alcuni cicli for nel codice C++ che iteravano su copie anziché su riferimenti di elementi del contenitore.
Corregge un bug per cui i dati delle istantanee venivano sempre copiati da C++ a Python anziché spostati, ove possibile. Questo dimezza l'uso della memoria e migliora i tempi di simulazione quando si utilizzano snapshot di matrici di densità o di vettori di stato di grandi dimensioni.
Correggere State::snapshot\pauli_expval per restituire il valore corretto dell'aspettativa Y nel simulatore dello stabilizzatore. Per maggiori dettagli, consultare il documento #895 <https://github.com/Qiskit/qiskit-aer/issues/895>.
I wrapper controller_execute sono stati adattati per essere funtori (oggetti) piuttosto che funzioni libere. Ciò consente, tra l'altro, di utilizzarli nelle chiamate a multiprocessing.pool.map.
Aggiungere controlli sulla memoria disponibile mancante per StatevectorSimulator e UnitarySimulator. Questo lancia un'eccezione se la memoria richiesta per simulare il numero di qubit in un circuito supera la memoria disponibile del sistema.

Ignis 0.5.0

Preludio

Questa versione include un nuovo modulo per la mitigazione dell'errore di misurazione del valore di aspettativa, una migliore funzionalità di plottaggio per gli esperimenti di volume quantistico, diverse correzioni di bug e il supporto delle gocce per Python 3.5.

Nuove funzioni

La funzione qiskit.ignis.verification.randomized_benchmarking.randomized_benchmarking_seq() consente l'inserimento facoltativo di oggetti gate come interleaved_elem. Inoltre, la classe CNOT-Dihedral qiskit.ignis.verification.randomized_benchmarking.CNOTDihedral ha un nuovo metodo to_instruction e il metodo esistente from_circuit ha come input opzionale un'istruzione (oltre a QuantumCircuit ).
Il sito qiskit.ignis.verification.randomized_benchmarking.CNOTDihedral contiene ora le seguenti novità. Inizializzazione da vari tipi di oggetti: CNOTDihedral, ScalarOp, QuantumCircuit, Instruction e Pauli. Conversione in una matrice usando to_matrix e in un operatore usando to_operator. Metodi di prodotto tensoriale e di espansione. Calcolo dell'adiacente, del coniugato e del trasposto con i metodi del coniugato, dell'adiacente e del trasposto. Verificare che un elemento sia CNOTDiedrico utilizzando il metodo is_cnotdiedrico. Il metodo di decomposizione di un elemento CNOTDihedral in un circuito è stato esteso per consentire un numero qualsiasi di qubit, sulla base della funzione decompose_cnotdihedral_general.
Aggiunge la mitigazione dell'errore di misurazione del valore di aspettativa al modulo di mitigazione. Questo supporta l'uso di matrici di assegnazione complete a N-qubit, matrici di assegnazione tensored a singolo-qubit o processi di Markov in tempo continuo (CTMP) [1] con attenuazione dell'errore di misura quando si calcolano i valori di aspettativa degli operatori diagonali dai dizionari dei conteggi. I valori di aspettativa vengono calcolati utilizzando la funzione qiskit.ignis.mitigation.expectation_value() .

I circuiti di calibrazione per la taratura di un attenuatore di errori di misura vengono generati con la funzione qiskit.ignis.mitigation.expval_meas_mitigator_circuits() e il risultato viene adattato con la classe qiskit.ignis.mitigation.ExpvalMeasMitigatorFitter . Il fitter restituisce un oggetto mitigatore che può essere fornito come argomento alla funzione expectation_value() per applicare la mitigazione.

[1] S Bravyi, S Sheldon, A Kandala, DC Mckay, JM Gambetta,

Mitigazione degli errori di misura negli esperimenti multi-qubit, arXiv:2006.14044 [quant-ph].

Esempio:
L'esempio seguente mostra la calibrazione di un attenuatore di errore di misura del valore di aspettativa a 5 qubit utilizzando il metodo 'tensored' .
```
from qiskit import execute
from qiskit.test.mock import FakeVigo
import qiskit.ignis.mitigation as mit

backend = FakeVigo()
num_qubits = backend.configuration().num_qubits

# Generate calibration circuits
circuits, metadata = mit.expval_meas_mitigator_circuits(
    num_qubits, method='tensored')
result = execute(circuits, backend, shots=8192).result()

# Fit mitigator
mitigator = mit.ExpvalMeasMitigatorFitter(result, metadata).fit()

# Plot fitted N-qubit assignment matrix
mitigator.plot_assignment_matrix()
```
Di seguito viene mostrato come utilizzare il mitigatore di cui sopra per applicare la mitigazione dell'errore di misura ai calcoli del valore di aspettativa
```
from qiskit import QuantumCircuit

# Test Circuit with expectation value -1.
qc = QuantumCircuit(num_qubits)
qc.x(range(num_qubits))
qc.measure_all()

# Execute
shots = 8192
seed_simulator = 1999
result = execute(qc, backend, shots=8192, seed_simulator=1999).result()
counts = result.get_counts(0)

# Expectation value of Z^N without mitigation
expval_nomit, error_nomit = mit.expectation_value(counts)
print('Expval (no mitigation): {:.2f} \u00B1 {:.2f}'.format(
    expval_nomit, error_nomit))

# Expectation value of Z^N with mitigation
expval_mit, error_mit = mit.expectation_value(counts,
    meas_mitigator=mitigator)
print('Expval (with mitigation): {:.2f} \u00B1 {:.2f}'.format(
    expval_mit, error_mit))
```
Aggiunge Numba come dipendenza opzionale. Numba viene utilizzato per aumentare significativamente le prestazioni della classe qiskit.ignis.mitigation.CTMPExpvalMeasMitigator utilizzata per la mitigazione dell'errore di misura del valore di aspettativa con il metodo CTMP.
Aggiungere due metodi a qiskit.ignis.verification.quantum_volume.QVFitter.
- qiskit.ignis.verification.quantum_volume.QVFitter.calc_z_value() per calcolare il valore z nella distribuzione normale standard utilizzando la media e la deviazione standard sigma. Se sigma = 0, viene emesso un avviso e viene assegnato un valore piccolo ( 1e-10 ) per sigma, in modo che il codice venga eseguito.
- qiskit.ignis.verification.quantum_volume.QVFitter.calc_confidence_level() per calcolare il livello di confidenza utilizzando il valore z.
Memorizzare il livello di confidenza anche quando hmean \ 2/3 in qiskit.ignis.verification.quantum_volume.QVFitter.qv_success().
Aggiungere spiegazioni su come calcolare le statistiche basate sulla distribuzione binomiale in qiskit.ignis.verification.quantum_volume.QVFitter.calc_statistics().
Il metodo qiskit.ignis.verification.QVFitter plot_qv_data() è stato aggiornato per restituire un oggetto matplotlib.Figure . In precedenza non restituiva nulla. La restituzione di una figura facilita l'integrazione delle visualizzazioni in un flusso di lavoro più ampio matplotlib .
Le barre di errore nella figura prodotta dal metodo qiskit.ignis.verification.QVFitter qiskit.ignis.verification.QVFitter.plot_qv_data() sono state aggiornate per rappresentare gli intervalli di confidenza a due sigle. In precedenza, le barre di errore rappresentano intervalli di confidenza di un sigma. Il criterio di successo del benchmarking Quantum Volume richiede una probabilità di uscita pesante > 2/3 con una confidenza unilaterale a due sigma ( ~97.7 %). La modifica delle barre di errore per rappresentare gli intervalli di confidenza a due sigle consente di identificare facilmente i successi nella figura.
Al metodo qiskit.ignis.verification.QVFitter qiskit.ignis.verification.QVFitter.plot_qv_data() è stato aggiunto un nuovo kwarg, figsize . Questo kwarg accetta una tupla della forma (x, y) dove x e y sono le dimensioni in pollici per realizzare il grafico generato.
È stato aggiunto il metodo qiskit.ignis.verification.quantum_volume.QVFitter.plot_hop_accumulative() per tracciare la probabilità di uscita pesante (HOP) rispetto al numero di prove, come nella Figura 2a del documento Quantum Volume 64 ( arXiv:2008.08571 ). Gli HOP delle singole prove sono rappresentati in forma di dispersione e gli HOP cumulativi sono rappresentati in linea rossa. Gli intervalli di confidenza a due sigle sono indicati come area ombreggiata e la soglia di successo dei 2/3 è indicata come linea tratteggiata.
È stato aggiunto il metodo qiskit.ignis.verification.quantum_volume.QVFitter.plot_qv_trial() per tracciare le singole prove, sfruttando il metodo di Qiskit Terra qiskit.visualization.plot_histogram() di Qiskit Terra. I conteggi delle stringhe di bit sono rappresentati come istogrammi sovrapposti per i valori ideali (vuoti) e sperimentali (pieni). La probabilità di uscita pesante sperimentale è indicata nella legenda. La probabilità mediana è rappresentata dalla linea rossa tratteggiata.

Note sull'aggiornamento

Il supporto deprecato per l'esecuzione di qiskit-ignis con Python 3.5 è stato rimosso. Per utilizzare qiskit-ignis >= 0.5.0 è necessario almeno Python 3.6. Se si utilizza Python 3.5 l'ultima versione funzionante è qiskit-ignis 0.4.x.

Correzioni di bug

Correzione di un bug nella classe qiskit.ignis.verification.randomized_benchmarking.CNOTDihedral per gli elementi con più di 5 abbandoni.
Fissare la soglia del livello di confidenza per qiskit.ignis.verification.quantum_volume.QVFitter.qv_success() a 0.977 corrispondente a z = 2, come definito dall'algoritmo 1 del documento QV.
Correzione di un bug in qiskit.ignis.verification.randomized_benchmarking.randomized_benchmarking_seq() che faceva sì che tutti i sottosistemi con la stessa dimensione nel dato rb_pattern avessero le stesse porte quando veniva dato un parametro 'rand_seed' alla funzione.

Acqua 0.8.0

Preludio

Questa versione introduce un'interfaccia per l'esecuzione dei metodi disponibili per i problemi bosonici. In particolare, abbiamo introdotto un'interfaccia completa per eseguire calcoli di struttura vibronica.

Questa versione introduce un'interfaccia per il calcolo degli stati eccitati. Ora è più facile per l'utente creare un calcolo generale degli stati eccitati. Questo calcolo si basa su un Driver che fornisce le informazioni rilevanti sulla molecola, una Trasformazione che fornisce le informazioni sulla mappatura del problema in un qubit hamiltoniano e infine un Risolutore. Il risolutore è il modo specifico in cui viene eseguito il calcolo degli stati eccitati (l'algoritmo). Questa struttura segue quella dei calcoli dello stato fondamentale. I risultati vengono modificati in modo da accettare elenchi di valori di aspettativa invece di uno singolo. Il QEOM e il sito NumpyEigensolver sono stati adattati alla nuova struttura. Viene introdotto un factory per eseguire un eigensolver numpy con un filtro specifico (per puntare a stati di simmetrie specifiche).

Il calcolo dell'aspettativa VQE con Aer qasm_simulator è ora impostato su un calcolo che presenta il comportamento atteso del rumore di scatto.

Nuove funzioni

È stata introdotta l'opzione warm\start, da utilizzare quando la messa a punto delle altre opzioni non è utile. Quando questa opzione è attivata, viene risolto prima un problema rilassato (tutte le variabili sono continue) e la soluzione viene utilizzata per inizializzare lo stato dell'ottimizzatore prima di avviare il processo iterativo nel metodo di risoluzione.

Gli algoritmi di stima dell'ampiezza utilizzano ora gli oggetti QuantumCircuit come input per specificare gli operatori A e Q. Questa modifica va di pari passo con l'introduzione di GroverOperator nella libreria dei circuiti, che consente di costruire in modo intuitivo e rapido diversi operatori Q. Per esempio, un esperimento di Bernoulli può ora essere costruito come

import numpy as np
from qiskit import QuantumCircuit
from qiskit.aqua.algorithms import AmplitudeEstimation

probability = 0.5
angle = 2 * np.sqrt(np.arcsin(probability))
a_operator = QuantumCircuit(1)
a_operator.ry(angle, 0)

# construct directly
q_operator = QuantumCircuit(1)
q_operator.ry(2 * angle, 0)

# construct via Grover operator
from qiskit.circuit.library import GroverOperator
oracle = QuantumCircuit(1)
oracle.z(0)  # good state = the qubit is in state |1>
q_operator = GroverOperator(oracle, state_preparation=a_operator)

# use default construction in QAE
q_operator = None

ae = AmplitudeEstimation(a_operator, q_operator)

Aggiungere la possibilità di calcolare i valori di aspettativa del Conditional Value at Risk ( CVaR ).

Data un'osservabile diagonale H, spesso corrispondente alla funzione obiettivo di un problema di ottimizzazione, spesso non siamo interessati a minimizzare l'energia media delle nostre misure osservate. In questo contesto, siamo soddisfatti se almeno alcune delle nostre misure raggiungono una bassa energia. (Si noti che questo non è assolutamente il caso dei problemi di chimica).

A tal fine, si potrebbe pensare di utilizzare il miglior campione osservato come funzione di costo durante l'ottimizzazione variazionale. Il problema è che in questo modo si può ottenere una superficie di ottimizzazione non liscia. Per risolvere questo problema, possiamo smussare la superficie di ottimizzazione utilizzando non solo il miglior campione osservato, ma piuttosto la media di una frazione dei migliori campioni osservati. Questo è esattamente ciò che fa lo stimatore CVaR [.]

Sia $\alpha$ un numero reale in $[0,1]$ che specifica la frazione di campioni osservati migliori che vengono utilizzati per calcolare la funzione obiettivo. Si osservi che se $\alpha = 1$ , CVaR è equivalente a un valore di aspettativa standard. Analogamente, se $\alpha = 0$ , allora CVaR corrisponde all'utilizzo del miglior campione osservato. I valori intermedi di $\alpha$ interpolano tra queste due funzioni obiettivo.

La funzionalità per l'utilizzo di CVaR è inclusa nel flusso degli operatori attraverso una nuova sottoclasse di OperatorStateFn chiamata CVaRMeasurement. Questo nuovo oggetto StateFn viene istanziato nello stesso modo di un OperatorMeasurement, con l'eccezione che accetta anche un parametro alfa e che impone automaticamente che l'attributo is_measurement sia True. Si noti che non è chiaro cosa rappresenterebbe un CVaRStateFn se non fosse una misura.

Esempi:
```
qc = QuantumCircuit(1)
qc.h(0)
op = CVaRMeasurement(Z, alpha=0.5) @ CircuitStateFn(primitive=qc, coeff=1.0)
result = op.eval()
```
Analogamente, un operatore corrispondente a un valore di aspettativa standard può essere convertito in un'aspettativa CVaR utilizzando il convertitore CVaRExpectation.

Esempi:
```
qc = QuantumCircuit(1)
qc.h(0)
op = ~StateFn(Z) @ CircuitStateFn(primitive=qc, coeff=1.0)
cvar_expecation = CVaRExpectation(alpha=0.1).convert(op)
result = cvar_expecation.eval()
```
Per ulteriori dettagli su questa tecnica e sulle sue prestazioni empiriche, si veda il punto [1].

Riferimenti:

[1] : Barkoutsos, P. K., Nannicini, G., Robert, A., Tavernelli, I., e Woerner, S.,

"Miglioramento dell'ottimizzazione quantistica variazionale utilizzando CVaR” arXiv:1907.04769
Nuova interfaccia Eigensolver per gli algoritmi di Eigensolver.
Al modulo di chimica è stata aggiunta un'interfaccia per il calcolo degli stati eccitati. Ora è più facile per l'utente creare un calcolo generale degli stati eccitati. Questo calcolo si basa su Driver che fornisce le informazioni rilevanti sulla molecola, su Transformation che fornisce le informazioni sulla mappatura del problema in un qubit hamiltoniano e infine su un risolutore. Il risolutore è il modo specifico in cui viene eseguito il calcolo degli stati eccitati (l'algoritmo). Questa struttura segue quella dei calcoli dello stato fondamentale. I risultati vengono modificati in modo da accettare elenchi di valori di aspettativa invece di uno singolo. I siti QEOM e NumpyEigensolver sono adattati alla nuova struttura. Viene introdotto un factory per eseguire un eigensolver numpy con un filtro specifico (per puntare a stati di simmetrie specifiche).
Oltre ai flussi di lavoro per la risoluzione di problemi fermionici, sono state aggiunte interfacce per il calcolo degli stati fondamentali ed eccitati bosonici. In particolare, abbiamo introdotto un'interfaccia completa per eseguire calcoli di struttura vibronica.
OrbitalOptimizationVQE è stato aggiunto come nuovo solutore di stato fondamentale nel modulo di chimica. Questo solutore consente l'ottimizzazione simulata dei parametri variazionali e degli orbitali della molecola. L'algoritmo è introdotto in Sokolov et al, Il Journal of Chemical Physics 152 (12).
È stato aggiunto un nuovo algoritmo: la superficie di energia potenziale di Born Openheimer per il calcolo della superficie di energia potenziale lungo i diversi gradi di libertà della molecola. L'algoritmo è chiamato BOPESSampler. Fornisce inoltre funzionalità di adattamento della superficie di energia potenziale a una funzione analitica di potenziali predefiniti.
A tutti gli ottimizzatori dello stack di ottimizzazione è stato aggiunto un controllo di fattibilità della soluzione ottenuta. Questo è stato implementato aggiungendo due nuovi metodi a QuadraticProgram: * get_feasibility_info(self, x: Union[List[float], np.ndarray]) accetta un array e restituisce se la soluzione è fattibile e un elenco di variabili violate (limiti violati) e un elenco di vincoli violati. * is_feasible(self, x: Union[List[float], np.ndarray]) accetta un array e restituisce se la soluzione è fattibile o meno.
Aggiungere le versioni circuitali di FixedIncomeExpectedValue, EuropeanCallDelta, GaussianConditionalIndependenceModel e EuropeanCallExpectedValue a qiskit.finance.applications.
Quadro dei gradienti. qiskit.operators.gradients Dato un operatore che rappresenta uno stato quantistico risp. il quadro dei gradienti consente di valutare i gradienti, i gradienti naturali, gli Hessiani e l'informazione di Fisher quantistica.

Supponiamo uno stato quantistico parametrizzato |ψ(θ)〉 = V(θ)|ψ〉 con stato di ingresso |ψ〉 e Ansatz parametrizzato V(θ), e un Operatore O(ω).

Gradienti: Vogliamo calcolare $d⟨ψ(θ)|O(ω)|ψ(θ)〉/ dω$ risp. $d⟨ψ(θ)|O(ω)|ψ(θ)〉/ dθ$ risp. $d⟨ψ(θ)|i〉⟨i|ψ(θ)〉/ dθ$ .

L'ultimo caso corrisponde al gradiente w.r.t. le probabilità di campionamento di |ψ(θ). Questi gradienti possono essere calcolati con diversi metodi, ad esempio uno spostamento di parametri, una combinazione lineare di unitari e un metodo delle differenze finite.

Esempi:
```
x = Parameter('x')
ham = x * X
a = Parameter('a')

q = QuantumRegister(1)
qc = QuantumCircuit(q)
qc.h(q)
qc.p(params[0], q[0])
op = ~StateFn(ham) @ CircuitStateFn(primitive=qc, coeff=1.)

value_dict = {x: 0.1, a: np.pi / 4}

ham_grad = Gradient(grad_method='param_shift').convert(operator=op, params=[x])
ham_grad.assign_parameters(value_dict).eval()

state_grad = Gradient(grad_method='lin_comb').convert(operator=op, params=[a])
state_grad.assign_parameters(value_dict).eval()

prob_grad = Gradient(grad_method='fin_diff').convert(operator=CircuitStateFn(primitive=qc, coeff=1.),
                                                     params=[a])
prob_grad.assign_parameters(value_dict).eval()
```
Hessiani: Vogliamo calcolare $d^2⟨ψ(θ)|O(ω)|ψ(θ)〉/ dω^2$ risp. $d^2⟨ψ(θ)|O(ω)|ψ(θ)〉/ dθ^2$ risp. $d^2⟨ψ(θ)|O(ω)|ψ(θ)〉/ dθdω$ risp. $d^2⟨ψ(θ)|i〉⟨i|ψ(θ)〉/ dθ^2$ .

L'ultimo caso corrisponde alla Hessiana w.r.t. le probabilità di campionamento di |ψ(θ). Come i gradienti del primo ordine, anche gli Hessiani possono essere valutati con diversi metodi, ad esempio con uno spostamento dei parametri, una combinazione lineare di unitari e un metodo delle differenze finite. Data una tupla di parametri Hessian().convert(op, param_tuple) restituisce il valore della derivata seconda. Se viene fornito un elenco di parametri, Hessian().convert(op, param_list) restituisce l'Hessiano completo per tutti i parametri indicati secondo l'ordine dei parametri.

QFI: La Quantum Fisher Information QFI è un tensore metrico rappresentativo della capacità di rappresentazione di uno stato quantistico parametrizzato |ψ(θ)〉 = V(θ)|ψ〉 generato da uno stato di ingresso |ψ〉 e da un Ansatz parametrizzato V(θ). Le voci del QFI per uno stato puro si leggono $[QFI]kl= Re[〈∂kψ|∂lψ〉−〈∂kψ|ψ〉〈ψ|∂lψ〉] * 4$ .

Come per i tipi di derivate precedenti, il QFI può essere calcolato con diversi metodi: una rappresentazione completa basata su una combinazione lineare di implementazioni unitari, una rappresentazione a blocchi e diagonale basata su un metodo di sovrapposizione.

Esempi:
```
q = QuantumRegister(1)
qc = QuantumCircuit(q)
qc.h(q)
qc.p(params[0], q[0])
op = ~StateFn(ham) @ CircuitStateFn(primitive=qc, coeff=1.)

value_dict = {x: 0.1, a: np.pi / 4}
qfi = QFI('lin_comb_full').convert(operator=CircuitStateFn(primitive=qc, coeff=1.), params=[a])
qfi.assign_parameters(value_dict).eval()
```
La combinazione del QFI e del gradiente porta a una forma speciale di gradiente, vale a dire

NaturalGradients: Il gradiente naturale è un metodo di gradiente speciale che ridimensiona un gradiente w.r.t. un parametro di stato con l'inverso della corrispondente Quantum Fisher Information (QFI) $QFI^-1 d⟨ψ(θ)|O(ω)|ψ(θ)〉/ dθ$ . In questo modo, possiamo scegliere un gradiente, un metodo QFI e un metodo di regolarizzazione che viene utilizzato insieme a un risolutore ai minimi quadrati invece dell'inversione esatta del QFI:

Esempi:
```
op = ~StateFn(ham) @ CircuitStateFn(primitive=qc, coeff=1.)
nat_grad = NaturalGradient(grad_method='lin_comb, qfi_method='lin_comb_full', \
                           regularization='ridge').convert(operator=op, params=params)
```
Il framework del gradiente è compatibile anche con gli ottimizzatori di qiskit.aqua.components.optimizers. Le classi derivate sono dotate di una funzione gradient_wrapper() che restituisce il callable corrispondente.
Introduce transformations per la trasformazione fermionica e bosonica di un'istanza del problema. Trasforma l'operatore fermionico in operatore qubit. La classe corrispondente alla trasformazione è fermionic_transformation Introduce negli algoritmi ground_state_solvers per il calcolo delle proprietà dello stato fondamentale. Il calcolo può essere eseguito con MinimumEigensolver o con AdaptVQE Introduce chemistry/results dove il risultato dell'autostato e della struttura elettronica vengono utilizzati anche per gli algoritmi. Introduce le fabbriche di Eigensolver Minimo minimum_eigensolver_factories dove possono essere inizializzati eigensolver minimi specifici per la chimica Introduce l'ottimizzazione orbitale vqe oovqe come solutore di stato fondamentale per le applicazioni della chimica
Nuove classi di risultati dell'algoritmo:

Grover il metodo _run() restituisce la classe GroverResult. AmplitudeEstimation il metodo _run() restituisce la classe AmplitudeEstimationResult. IterativeAmplitudeEstimation il metodo _run() restituisce la classe IterativeAmplitudeEstimationResult. MaximumLikelihoodAmplitudeEstimation il metodo _run() restituisce la classe MaximumLikelihoodAmplitudeEstimationResult.

Tutte le nuove classi di risultati sono compatibili con i precedenti dizionari dei risultati.
Nuove classi di risultati del risolutore lineare:

HHL il metodo _run() restituisce la classe HHLResult. NumPyLSsolver il metodo _run() restituisce la classe NumPyLSsolverResult.

Tutte le nuove classi di risultati sono compatibili con i precedenti dizionari dei risultati.
MinimumEigenOptimizationResult ora espone le proprietà: samples e eigensolver_result. Quest'ultimo è ottenuto dall'algoritmo sottostante utilizzato dall'ottimizzatore ed è specifico dell'algoritmo. RecursiveMinimumEigenOptimizer ora restituisce un'istanza della classe di risultati RecursiveMinimumEigenOptimizationResult che a sua volta può contenere risultati intermedi ottenuti dagli algoritmi sottostanti. La classe dedicata ai risultati espone le proprietà replacements e history che sono specifiche di questo ottimizzatore. La profondità della cronologia è gestita dal parametro history dell'ottimizzatore.
GroverOptimizer ora restituisce un'istanza di GroverOptimizationResult e questa classe di risultati espone direttamente le proprietà operation_counts, n_input_qubits e n_output_qubits . Queste proprietà non sono più disponibili nel dizionario raw_results .
SlsqpOptimizer restituisce ora un'istanza di SlsqpOptimizationResult e questa classe di risultati espone proprietà aggiuntive specifiche dell'implementazione SLSQP.
Supporta il passaggio di oggetti QuantumCircuit come circuiti di generatori in QuantumGenerator.
Rimuove la restrizione ai vettori di input reali in CircuitStateFn.from_vector. Il metodo chiama extensions.Initialize. Quest'ultimo supporta esplicitamente (nell'API e nella documentazione) vettori di ingresso complessi. Questa restrizione sembra quindi superflua.
AbelianGrouper semplificato utilizzando un algoritmo di colorazione dei grafi di retworkx. È più veloce dell'algoritmo di colorazione basato su numpy.
Consente di chiamare eval su oggetti funzione di stato senza argomenti, restituendo la rappresentazione VectorStateFn della funzione di stato. Questo è un comportamento coerente con OperatorBase.eval, che restituisce la rappresentazione MatrixOp , se non viene passato alcun argomento.
Aggiunge max_iterations alla classe VQEAdapt per consentire di limitare il numero massimo di iterazioni eseguite dall'algoritmo.
Il calcolo dell'aspettativa VQE con Aer qasm_simulator è ora impostato su un calcolo che presenta il comportamento atteso del rumore di scatto. Il calcolo speciale basato su istantanee Aer, che è molto più veloce, con l'uscita ideale simile a quella del simulatore di vettori di stato, può ancora essere scelto, ma come prima di Aqua 0.7 ora non è più predefinito, ma può essere scelto.

Note sull'aggiornamento

Estensione del precedente ottimizzatore classico Analytic Quantum Gradient Descent (AQGD) con l'AQGD con epoche. Ora AQGD esegue l'ottimizzazione per discesa del gradiente con un termine di quantità di moto, gradienti analitici e un programma di lunghezza dei passi personalizzato per porte quantistiche parametrizzate. I gradienti vengono calcolati "analiticamente" utilizzando il circuito quantistico durante la valutazione della funzione obiettivo.
Il supporto deprecato per l'esecuzione di qiskit-aqua con Python 3.5 è stato rimosso. Per utilizzare qiskit-aqua >= 0.8.0 è necessario almeno Python 3.6. Se si utilizza Python 3.5 l'ultima versione che funziona è qiskit-aqua 0.7.x.
Aggiunto retworkx come nuova dipendenza.

Note di deprecazione

L'argomento i_objective degli algoritmi di stima dell'ampiezza è stato rinominato in objective_qubits.
TransformationType
QubitMappingType

Deprecare i tipi CircuitFactory e derivati. La classe CircuitFactory è stata introdotta come classe temporanea quando alla classe QuantumCircuit mancavano alcune caratteristiche necessarie per le applicazioni in Aqua. Ora che il circuito ha tutte le funzionalità richieste, la fabbrica del circuito può essere rimossa. Le sostituzioni sono riportate nella tabella seguente.

Circuit factory class               | Replacement
------------------------------------+-----------------------------------------------
CircuitFactory                      | use QuantumCircuit
                                    |
UncertaintyModel                    | -
UnivariateDistribution              | -
MultivariateDistribution            | -
NormalDistribution                  | qiskit.circuit.library.NormalDistribution
MultivariateNormalDistribution      | qiskit.circuit.library.NormalDistribution
LogNormalDistribution               | qiskit.circuit.library.LogNormalDistribution
MultivariateLogNormalDistribution   | qiskit.circuit.library.LogNormalDistribution
UniformDistribution                 | qiskit.circuit.library.UniformDistribution
MultivariateUniformDistribution     | qiskit.circuit.library.UniformDistribution
UnivariateVariationalDistribution   | use parameterized QuantumCircuit
MultivariateVariationalDistribution | use parameterized QuantumCircuit
                                    |
UncertaintyProblem                  | -
UnivariateProblem                   | -
MultivariateProblem                 | -
UnivariatePiecewiseLinearObjective  | qiskit.circuit.library.LinearAmplitudeFunction

Le classi di conversione ising qiskit.optimization.converters.QuadraticProgramToIsing e qiskit.optimization.converters.IsingToQuadraticProgram sono state deprecate e saranno rimosse in una prossima versione. Si devono invece utilizzare i metodi qiskit.optimization.QuadraticProgram to_ising() e from_ising() .
Deprecare WeightedSumOperator che è stato portato nella libreria dei circuiti come WeightedAdder in qiskit.circuit.library.
Core Hamiltonian è deprecata in favore della classe FermionicTransformation Chemistry Operator è deprecata in favore della classe tranformations minimum_eigen_solvers/vqe_adapt è anch'essa deprecata e spostata come implementazione dell'interfaccia ground_state_solver applications/molecular_ground_state_energy è deprecata in favore di ground_state_solver
Optimizer.SupportLevel l'enum annidato è sostituito da OptimizerSupportLevel e Optimizer.SupportLevel è stato rimosso. Utilizzare, ad esempio, OptimizerSupportLevel.required invece di Optimizer.SupportLevel.required.
Deprecare UnivariateVariationalDistribution e MultivariateVariationalDistribution come input per QuantumGenerator. Si possono invece usare i semplici oggetti di QuantumCircuit .
Le opzioni ignorate fast e use_nx di AbelianGrouper.group_subops saranno rimosse nella prossima versione.
La classe di ottimizzazione GSLS ha deprecato il parametro __init__ max_iter a favore di maxiter. La classe di ottimizzazione SPSA ha deprecato il parametro __init__ max_trials a favore di maxiter. la funzione optimize_svm ha deprecato il parametro max_iters a favore di maxiter. La classe ADMMParameters ha deprecato il parametro __init__ max_iter a favore di maxiter.

Correzioni di bug

L'elenco di eccitazioni UCCSD, comprendente eccitazioni singole e doppie, non veniva generato correttamente quando uno spazio attivo veniva fornito esplicitamente a UCSSD tramite i parametri active_(un)occupied.
Per gli algoritmi di stima dell'ampiezza, definiamo il numero di interrogazioni dell'oracolo come il numero di volte in cui viene applicato l'operatore Q/Grover. Questo include il numero di scatti. Questo fattore è stato incluso nel MLAE e nell'IQAE, ma mancava nel QAE "standard".
Correggere CircuitSampler.convert, in modo che la proprietà is_measurement sia propagata a StateFns convertito.
Correggere il doppio calcolo dei coefficienti in :meth`~qiskit.aqua.operators.VectorStateFn.to_circuit_op`.
Chiamando PauliTrotterEvolution.convert su un operatore che include un termine che è un multiplo scalare dell'identità si otteneva un circuito errato, che ignorava il coefficiente scalare. Questa correzione include l'effetto del coefficiente nella proprietà global_phase del circuito.
Fare in modo che ListOp.num_qubits verifichi che tutti gli operatori nell'elenco abbiano lo stesso num_qubits In precedenza, veniva restituito il numero di qubit del primo operatore in ListOp. Con questa modifica, viene effettuato un ulteriore controllo per verificare che anche tutti gli altri operatori abbiano lo stesso numero di qubit.
Fare in modo che PauliOp.exp_i() generi la matrice corretta con le seguenti modifiche. 1) In precedenza c'era un errore nella fase di un fattore 2. 2) La fase globale è stata ignorata quando si è convertito il circuito in una matrice. Ora usiamo qiskit.quantum_info.Operator, che è generalmente utile per convertire un circuito in una matrice unitaria, quando possibile.
Corregge il rilevamento della ciclicità come segnalato come difettoso in https://github.com/qiskit-community/qiskit-aqua/issues/1184.

IBM Q Fornitore 0.11.0

Note sull'aggiornamento

Il supporto deprecato per l'esecuzione di qiskit-ibmq-provider con Python 3.5 è stato rimosso. Per utilizzare qiskit-ibmq-provider >= 0.11.0 è necessario almeno Python 3.6. Se si utilizza Python 3.5 l'ultima versione che funziona è qiskit-ibmq-provider 0.10.x.
Prima di questa versione, websockets 7.0 veniva utilizzato per Python 3.6. Con questa versione, per tutte le versioni di Python è richiesto websockets 8.0 o superiore. I requisiti del pacchetto sono stati aggiornati per tenerne conto.

Questa pagina è stata utile?

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

Note di rilascio di Qiskit 0.23

0.23.6

Terra 0.16.4

Aer 0.7.5

Preludio

Ignis 0.5.2

Acqua 0.8.2

IBM Q Fornitore 0.11.1

0.23.5

Terra 0.16.4

Preludio

Aer 0.7.4

Correzioni di bug

Ignis 0.5.2

Preludio

Correzioni di bug

Acqua 0.8.2

IBM Q Fornitore 0.11.1

0.23.4

Terra 0.16.3

Correzioni di bug

Aer 0.7.3

Ignis 0.5.1

Acqua 0.8.1

IBM Q Fornitore 0.11.1

0.23.3

Terra 0.16.2

Nuove funzioni

Note sull'aggiornamento

Correzioni di bug

Aer 0.7.3

Nuove funzioni

Correzioni di bug

Ignis 0.5.1

Acqua 0.8.1

IBM Q Fornitore 0.11.1

0.23.2

Terra 0.16.1

Aer 0.7.2

Nuove funzioni

Correzioni di bug

Ignis 0.5.1

Acqua 0.8.1

IBM Q Fornitore 0.11.1

0.23.1

Terra 0.16.1

Correzioni di bug

Aer 0.7.1

Note sull'aggiornamento

Correzioni di bug

Ignis 0.5.1

Correzioni di bug

Acqua 0.8.1

0.8.1

Nuove funzioni

Problemi critici

Correzioni di bug

IBM Q Fornitore 0.11.1

Nuove funzioni

Note sull'aggiornamento

Correzioni di bug

0.23.0

Terra 0.16.0

Preludio

Nuove funzioni

Note sull'aggiornamento

Note di deprecazione

Correzioni di bug

Aer 0.7.0

Preludio

Nuove funzioni

Note sull'aggiornamento

Note di deprecazione

Correzioni di bug

Ignis 0.5.0

Preludio

Nuove funzioni

[1] S Bravyi, S Sheldon, A Kandala, DC Mckay, JM Gambetta,

Note sull'aggiornamento

Correzioni di bug