Note di rilascio di Qiskit 0.33

0.33.1

Terra 0.19.1

Preludio

Qiskit Terra 0.19.1 è una release che risolve alcuni problemi di 0.19.0 riguardanti i circuiti costruiti dall'interfaccia del costruttore di flussi di controllo, le porte condizionali e la serializzazione QPY degli oggetti Terra più recenti.

Note di deprecazione

Le funzioni qiskit.circuit.measure.measure() e qiskit.circuit.reset.reset() sono deprecate e saranno rimosse in una prossima versione. Si dovrebbe invece accedere a questi metodi come metodi su QuantumCircuit:

from qiskit import QuantumCircuit
circuit = QuantumCircuit(1, 1)

# Replace this deprecated form ...
from qiskit.circuit.measure import measure
measure(circuit, 0, 0)

# ... with either of the next two lines:
circuit.measure(0, 0)
QuantumCircuit.measure(circuit, 0, 0)

Correzioni di bug

Corretto un errore nelle funzioni di conversione dei circuiti circuit_to_gate() e circuit_to_instruction() (e i loro metodi di circuito associati QuantumCircuit.to_gate() e QuantumCircuit.to_instruction()) quando si agisce su un circuito con bit senza registro o con bit in più di un registro. In precedenza, il numero di bit necessari per il gate o l'istruzione creata veniva calcolato in modo errato, causando spesso un'eccezione durante la conversione.

È stato risolto un problema per cui la chiamata QuantumCircuit.copy() sui circuiti "body" di un'operazione di flusso di controllo creata con l'interfaccia del costruttore generava un errore. Ad esempio, questo era in precedenza un errore, ma ora viene restituito con successo:

from qiskit.circuit import QuantumCircuit, QuantumRegister, ClassicalRegister

qreg = QuantumRegister(4)
creg = ClassicalRegister(1)
circ = QuantumCircuit(qreg, creg)

with circ.if_test((creg, 0)):
    circ.h(0)

if_else_instruction, _, _ = circ.data[0]
true_body = if_else_instruction.params[0]
true_body.copy()

L'interfaccia del costruttore di flussi di controllo ora supporta l'uso di ClassicalRegistercome condizioni in ambiti di flusso di controllo annidati. In precedenza, questa operazione non sollevava immediatamente un errore, ma i blocchi interni del circuito non avevano definito i registri corretti e quindi la logica successiva che lavorava con i blocchi interni falliva.

Ad esempio, prima i disegnatori fallivano quando cercavano di disegnare un blocco interno condizionato a un registro classico, mentre ora riescono a farlo, come in questo esempio:
```
from qiskit import QuantumCircuit
from qiskit.circuit import QuantumRegister, ClassicalRegister

qreg = QuantumRegister(4)
creg = ClassicalRegister(1)
circ = QuantumCircuit(qreg, creg)

with circ.for_loop(range(10)) as a:
    circ.ry(a, 0)
    with circ.if_test((creg, 1)):
        circ.break_loop()

print(circ.draw(cregbundle=False))
print(circ.data[0][0].blocks[0].draw(cregbundle=False))
```
Corretto il supporto di qpy_serialization per la serializzazione di oggetti QuantumCircuit che utilizzano ParameterVector o ParameterVectorElement come parametri. In precedenza, un parametro di ParameterVectorElement veniva trattato come un parametro Parameter per la serializzazione QPY, il che significava che il contesto ParameterVector veniva perso in QPY e l'ordine di uscita di parameters potrebbe essere errato.

Per risolvere questo problema è stata necessaria una nuova versione del formato QPY, la 3. Questa nuova versione del formato include una rappresentazione della classe ParameterVectorElement , descritta nella documentazione di qpy_serialization alla voce PARAMETER_VECTOR_ELEMENT.
Corretto il supporto di qpy_serialization per la serializzazione di un oggetto PauliEvolutionGate oggetto. In precedenza, l'elemento PauliEvolutionGate veniva trattato come un gate personalizzato per la serializzazione e veniva deserializzato come un oggetto Gate che aveva la stessa definizione e lo stesso nome dell'oggetto originale PauliEvolutionGate. Tuttavia, in questo modo si perderebbe lo stato originale dell'elemento PauliEvolutionGate. Questo problema è stato risolto in modo che a partire da questa versione un elemento del circuito PauliEvolutionGate nel circuito sarà conservato 1:1 attraverso la serializzazione QPY. L'unica limitazione è che non supporta le classi personalizzate EvolutionSynthesis personalizzate. Solo le classi disponibili in qiskit.synthesis possono essere utilizzate con una classe PauliEvolutionGate per la serializzazione di qpy.

Per risolvere questo problema è stata necessaria una nuova versione del formato QPY, la 3. Questa nuova versione del formato include una rappresentazione della classe PauliEvolutionGate descritta nella documentazione di qpy_serialization alla voce PAULI_EVOLUTION.
Due funzioni non utilizzate qiskit.circuit.measure.measure() e qiskit.circuit.reset.reset() sono state accidentalmente rimosse senza un periodo di deprecazione. Sono stati ripristinati, ma sono contrassegnati come deprecati a favore dei metodi QuantumCircuit.measure() e QuantumCircuit.reset(), rispettivamente, e saranno rimossi in una prossima versione.

Altre note

La nuova interfaccia del costruttore di flussi di controllo utilizza vari gestori di contesto e oggetti ausiliari per svolgere il suo lavoro. Questi non devono essere considerati parte dell'API pubblica e possono essere modificati e rimossi senza preavviso. L' uso dell'interfaccia del costruttore ha garanzie di stabilità, nel senso che il comportamento descritto da QuantumCircuit.for_loop(), while_loop() e if_test() per l'interfaccia del costruttore sono soggetti alle politiche di deprezzamento standard, ma gli oggetti effettivi utilizzati per realizzarli non lo sono. Non si deve fare affidamento sul fatto che gli oggetti (come IfContext o ControlFlowBuilderBlock) esistano nella loro posizione attuale o che abbiano metodi o attributi ad essi collegati.

Questo non era chiaro in precedenza nella release 0.19.0. Tutti gli oggetti di questo tipo hanno ora un'avvertenza nelle stringhe di documentazione che lo rende esplicito. È probabile che in futuro le loro sedi e le loro implementazioni di supporto diventino molto diverse.

Aer 0.9.1

Nessuna modifica

Ignis 0.7.0

Nessuna modifica

IBM Q Fornitore 0.18.2

Correzioni di bug

Correzione fornita in #1065 per il problema per cui il lavoro continuava a bloccarsi quando Parameter veniva passato nei metadati del circuito.
Correzione fornita in #1094 per il problema per cui qiskit.providers.ibmq.runtime.RuntimeEncoder esegue un ulteriore decompose() se il circuito da serializzare è un BlueprintCircuit.

0.33.0

Questo rilascio segna ufficialmente la fine del supporto per il progetto Qiskit Aqua in Qiskit. Era originariamente deprecato nella release 0.25.0 e, come documentato in quella release, il pacchetto qiskit-aqua è stato rimosso dal metapacchetto Qiskit, il che significa che pip install qiskit non includerà più qiskit-aqua. Tuttavia, a causa di limitazioni nel packaging di python, non possiamo rimuovere automaticamente un'installazione preesistente di qiskit-aqua quando aggiorniamo una versione precedente di Qiskit a questa release (o a una release futura) con pip install -U qiskit. Se si esegue l'aggiornamento da una versione precedente, si consiglia di disinstallare manualmente Qiskit Aqua con pip uninstall qiskit-aqua o di installarlo in un nuovo ambiente python.

I moduli applicativi forniti da qiskit-aqua sono stati suddivisi in diversi nuovi pacchetti: qiskit-optimization, qiskit-nature, qiskit-machine-learning, e qiskit-finance. Questi pacchetti possono essere installati da soli (tramite il comando standard pip install, ad esempio pip install qiskit-nature) o con il resto del metapacchetto Qiskit come extra opzionali (ad es. pip install 'qiskit[finance,optimization]' o pip install 'qiskit[all]'). Gli algoritmi di base e il flusso dell'operatore esistono ora come parte di Qiskit Terra all'indirizzo qiskit.algorithms e qiskit.opflow. A seconda dell'uso che si fa di Aqua, si possono utilizzare i pacchetti applicativi o i nuovi moduli di Qiskit Terra. Per maggiori dettagli su come migrare da Qiskit Aqua è possibile consultare la Guida alla migrazione di Aqua.

Con questa release viene anche ufficialmente deprecato il progetto Qiskit Ignis. Di conseguenza, in una futura release il pacchetto qiskit-ignis sarà rimosso dal metapacchetto Qiskit, il che significa che in quella futura release pip install qiskit non includerà più qiskit-ignis. Qiskit Ignis è stato sostituito dal progetto Qiskit Experiments e lo sviluppo attivo è cessato. Anche se deprecato, le correzioni di bug critici e di compatibilità continueranno a essere effettuate per dare agli utenti una sufficiente opportunità di migrare da Ignis. Dopo il periodo di deprezzamento (che non sarà inferiore a 3 mesi da questo rilascio) il progetto sarà ritirato e archiviato. Per i dettagli su come passare da Qiskit Ignis a Qiskit Experiments, puoi fare riferimento alla guida alla migrazione.

Terra 0.19.0

Preludio

I punti salienti della release Qiskit Terra 0.19 sono:

Una nuova versione dell'interfaccia astratta Qiskit/hardware, sotto forma di BackendV2con una nuova struttura di dati Target per consentire ai backend di modellare meglio i propri vincoli per il transpiler.
Un' interfaccia plugin estensibile per il UnitarySynthesis che consente agli utenti o ad altri pacchetti di estendere le routine di sintesi di Qiskit Terra con nuovi metodi.
Istruzioni di flusso di controllo, per rappresentare i cicli di for e while e le istruzioni di if/else in QuantumCircuit. I simulatori di Qiskit Aer saranno presto in grado di lavorare con queste nuove istruzioni, consentendo di scrivere programmi quantistici più dinamici.
Supporto preliminare per la specifica OpenQASM 3 in evoluzione. È possibile utilizzare il nuovo modulo qiskit.qasm3 per serializzare i propri file QuantumCircuitin OpenQASM 3, compresi i nuovi costrutti di flusso di controllo.

Questa versione segna la fine del supporto per Python 3.6 in Qiskit. Questa versione di Qiskit Terra, e tutte le successive release di bugfix della serie 0.19.x, saranno le ultime a funzionare con Python 3.6. A partire dalla prossima minor release ( 0.20.0 ) di Qiskit Terra, la versione minima richiesta Python sarà 3.7.

Come sempre, anche in questa release sono presenti molte altre funzionalità e correzioni, che potete leggere di seguito.

Nuove funzioni

QuantumCircuit.decompose() e il corrispondente passaggio di transpiler Decompose accettano ora facoltativamente un parametro contenente un insieme di nomi di porte. Se viene fornito questo parametro, verranno decomposte solo le porte con nomi corrispondenti. Supporta le corrispondenze con i caratteri jolly in stile Unix-shell. Ad esempio:
```
qc.decompose(["h", "r[xz]"])
```
decomporrà qualsiasi porta h, rx o rz , ma lascerà intatte (per esempio) le porte x .

Aggiunto l'argomento termination_checker all'ottimizzatore SPSA ottimizzatore. Ciò consente all'utente di implementare un criterio di terminazione personalizzato.

import numpy as np
from qiskit.algorithms.optimizers import SPSA

def objective(x):
    return np.linalg.norm(x) + .04*np.random.rand(1)

class TerminationChecker:

    def __init__(self, N : int):
        """
        Callback to terminate optimization when the average decrease over
        the last N data points is smaller than the specified tolerance.
        """
        self.N = N
        self.values = []

    def __call__(self, nfev, parameters, value, stepsize, accepted) -> bool:
        """
        Returns:
            True if the optimization loop should be terminated.
        """
        self.values.append(value)

        if len(self.values) > self.N:
            last_values = self.values[-self.N:]
            pp = np.polyfit(range(self.N), last_values, 1)
            slope = pp[0] / self.N

            if slope > 0:
                return True
        return False

maxiter = 400
spsa = SPSA(maxiter=maxiter, termination_checker=TerminationChecker(10))
parameters, value, niter = spsa.optimize(2, objective, initial_point=np.array([0.5, 0.5]))

Aggiunta una nuova versione dell'interfaccia Backend dell'interfaccia, BackendV2. Questa nuova versione rappresenta un grande cambiamento rispetto alla versione precedente, BackendV1 e cambia sia lo schema di accesso dell'utente alle proprietà del backend (come il numero di qubit, ecc.) sia il modo in cui il backend rappresenta i suoi vincoli al transpiler. L'esecuzione dei circuiti (tramite il metodo run() metodo) rimane invariata. Con un BackendV2 invece di avere un file separato configuration(), properties(), e defaults() metodi che costruiscono BackendConfiguration, BackendProperties, e PulseDefaults rispettivamente, come nell'interfaccia BackendV1 gli attributi contenuti in questi oggetti di output sono accessibili direttamente come attributi dell'oggetto BackendV2 dell'oggetto. Ad esempio, per ottenere il numero di qubit per un backend con BackendV1 si dovrebbe fare:
```
num_qubits = backend.configuration().n_qubits
```
mentre con BackendV2 è:
```
num_qubits = backend.num_qubits
```
L'altro cambiamento è che il numero di attributi esposti nella classe astratta è stato progettato per essere un insieme di campi obbligatori o opzionali che il resto di Qiskit può utilizzare oggi con qualsiasi backend BackendV2 è stato progettato per essere un insieme di campi obbligatori o opzionali, indipendenti dall'hardware e dal fornitore, che il resto di Qiskit può utilizzare oggi con qualsiasi backend. Le sottoclassi della classe astratta BackendV2 possono aggiungere il supporto per ulteriori attributi e metodi oltre a quelli definiti in BackendV2ma questi non saranno supportati universalmente in tutto Qiskit.

L'altro cambiamento critico, importante soprattutto per gli autori dei provider, è il modo in cui un fornitore BackendV2 espone le proprietà di un particolare backend al transpiler. Con BackendV2 questo avviene tramite un oggetto Target oggetto. Il Target, esposto tramite l'attributo target è usato per rappresentare l'insieme dei vincoli per l'esecuzione dei circuiti su un particolare backend. Contiene il sottoinsieme di informazioni precedentemente esposte dal file BackendConfiguration, BackendProperties, e PulseDefaults che il transpiler può utilizzare attivamente. Quando si migra un provider per utilizzare BackendV2 (o quando si crea un nuovo pacchetto di provider) la costruzione degli oggetti del backend avverrà principalmente con la creazione di un oggetto Target per il backend.
Aggiunta di una nuova classe Target al modulo transpiler al modulo. La classe Target è progettata per rappresentare i vincoli del backend al compilatore. La classe Target è destinata a essere usata con un BackendV2 ed è il modo in cui i backend modelleranno i loro vincoli per il transpiler in futuro. Unisce in un'unica struttura dati i campi precedentemente distinti utilizzati per il controllo del dispositivo di transpile() (ad esempio basis_gates, coupling_map, instruction_durations, ecc.) in un'unica struttura dati. Aggiunge inoltre ulteriori funzionalità rispetto a quelle disponibili in precedenza, come la rappresentazione di set di gate eterogenei, la connettività di gate multi-qubit e le varianti sintonizzate degli stessi gate. Attualmente il transpiler non tiene conto di tutti questi vincoli, ma col tempo crescerà per sfruttare le funzionalità aggiuntive.
La classe Options ha ora un supporto opzionale per specificare i validatori. Questo permette Backend di specificare una validazione di base sui valori forniti dall'utente per i campi dell'oggetto Options dell'oggetto. Ad esempio, se si ha un oggetto Options definito con:
```
from qiskit.providers.Options
options = Options(shots=1024)
```
è possibile impostare un validatore sugli scatti affinché siano compresi tra 1 e 4096 con:
```
options.set_validator('shots', (1, 4096))
```
Con il validatore impostato, qualsiasi chiamata al metodo update_options() verificherà che se shots viene aggiornato, il nuovo valore proposto rientri nell'intervallo valido.

Aggiunto un nuovo passaggio di analisi del transpiler, ContainsInstructional modulo qiskit.transpiler.passes al modulo. Questo passaggio viene utilizzato per determinare se un circuito contiene un'istruzione specifica. Prende un singolo parametro all'inizializzazione, il nome dell'istruzione da controllare e imposta un booleano nell'insieme di proprietà se il circuito contiene o meno quell'istruzione. Ad esempio:

from qiskit.transpiler.passes import ContainsInstruction
from qiskit.circuit import QuantumCircuit

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

property_set = {}
# Contains Hadamard
contains_h = ContainsInstruction("h")
contains_h(circuit, property_set)
assert property_set["contains_h"] == True
# Not contains SX
contains_sx = ContainsInstruction("sx")
contains_sx(circuit, property_set)
assert property_set["contains_sx"] == False

Aggiunta una funzione di utilità qiskit.utils.detach_prefix() che è una controparte di apply_prefix(). La nuova funzione restituisce una tupla di valore scalare e prefisso da un valore float dato. Ad esempio, il valore 1.3e8 viene convertito in (130, "M") , che può essere utilizzato per visualizzare un valore nel formato user friendly, come 130 MHz.
I valori "gate_error" e "balanced" sono ora disponibili per l'opzione objective nella costruzione dell'oggetto BIPMapping e "balanced" è ora il valore predefinito.

L'obiettivo "gate_error" richiede il passaggio di un BackendProperties istanza nel kwarg backend_prop , che contiene gli errori della porta 2q-gate utilizzati nel calcolo degli obiettivi. L'obiettivo "balanced" utilizzerà l'istanza BackendProperties se viene fornito, ma altrimenti assumerà un tasso di errore CX come indicato nel nuovo parametro default_cx_error_rate. I pesi relativi delle componenti gate-error e depth dell'obiettivo bilanciato possono essere controllati con il nuovo parametro depth_obj_weight .
Ogni attributo della classe VQE impostato all'inizializzazione è ora accessibile con getter e setter. Inoltre, i valori predefiniti degli attributi VQE ansatz e optimizer possono essere ripristinati assegnando loro None :
```
vqe = VQE(my_ansatz, my_optimizer)
vqe.ansatz = None   # reset to default: RealAmplitudes ansatz
vqe.optimizer = None  # reset to default: SLSQP optimizer
```

Aggiunto un nuovo metodo PauliList.group_qubit_wise_commuting() che suddivide a PauliList in insiemi di operatori commutativi reciprocamente qubit-wise Pauli operatori. Ad esempio:

from qiskit.quantum_info import PauliList, Pauli
pauli_list = PauliList([Pauli("IY"), Pauli("XX"), Pauli("YY"), Pauli("YX")])
pauli_list.group_qubit_wise_commuting()

Aggiunto un nuovo metodo costruttore di mappe di accoppiamento CouplingMap.from_hexagonal_lattice() per costruire una mappa di accoppiamento del reticolo esagonale. Ad esempio, per costruire una mappa di accoppiamento del reticolo esagonale 2x2 :
```
from qiskit.transpiler import CouplingMap
cmap = CouplingMap.from_hexagonal_lattice(2, 2)
cmap.draw()
```
Le nuove classi di backend fasulle sono disponibili all'indirizzo qiskit.test.mock. Questi includono le versioni simulate di ibmq_brooklyn, ibmq_manila, ibmq_jakarta e ibmq_lagos. Come per gli altri backend fasulli, questi includono le istantanee dei dati di calibrazione (cioè backend.defaults()) e i dati relativi all'errore (cioè backend.properties()) presi dal sistema reale e possono essere utilizzati per test, compilazioni e simulazioni locali.
È stato aggiunto il metodo OperatorBase.is_hermitian() per verificare se l'operatore è hermitiano o meno. NumPyEigensolver e NumPyMinimumEigensolver utilizzare eigh o eigsh per risolvere il problema degli autovalori quando l'operatore è hermitiano.

Aggiunto un nuovo metodo costruttore PassManagerConfig.from_backend(). Costruisce un PassManagerConfig con le opzioni dell'utente e la configurazione di un backend. Grazie a questa funzione, è possibile creare facilmente un passmanager preimpostato. Ad esempio:

from qiskit.transpiler.passmanager_config import PassManagerConfig
from qiskit.transpiler.preset_passmanagers import level_1_pass_manager
from qiskit.test.mock import FakeMelbourne

pass_manager = level_1_pass_manager(
  PassManagerConfig.from_backend(FakeMelbourne(), seed_transpiler=42)
)

È stato aggiunto un nuovo passaggio transpiler, PulseGatesche estrae automaticamente le calibrazioni fornite dall'utente dalla mappa del programma di istruzioni e collega il programma del gate al circuito quantistico dato (transpilato) come gate a impulsi.

Il passaggio PulseGates viene applicato a tutti i livelli di ottimizzazione da 0 a 3. Nessuna implementazione del gate viene aggiornata, a meno che l'utente finale non sovrascriva esplicitamente il sito backend.defaults().instruction_schedule_map. Questo passaggio evita agli utenti di chiamare individualmente QuantumCircuit.add_calibration() per ogni circuito eseguito sull'hardware.

Per integrare questo nuovo passaggio, è stato aggiunto un calendario a InstructionScheduleMap e viene implicitamente aggiornato con un campo di metadati "publisher". I programmi dei gate calibrati dal backend hanno un tipo di editore speciale per evitare di sovrascrivere i circuiti con calibrazioni di programmi già noti. Di solito, gli utenti finali non devono occuparsi di questi metadati, perché vengono applicati automaticamente. È possibile chiamare InstructionScheduleMap.has_custom_gate() per verificare se la mappa ha una calibrazione personalizzata del cancello.

Vedere il seguente esempio di codice per imparare ad applicare l'implementazione di gate personalizzati per tutti i circuiti in esecuzione.
```
from qiskit.test.mock import FakeGuadalupe
from qiskit import pulse, circuit, transpile

backend = FakeGuadalupe()

with pulse.build(backend, name="x") as x_q0:
    pulse.play(pulse.Constant(160, 0.1), pulse.drive_channel(0))

backend.defaults().instruction_schedule_map.add("x", (0,), x_q0)

circs = []
for _ in range(100):
    circ = circuit.QuantumCircuit(1)
    circ.sx(0)
    circ.rz(1.57, 0)
    circ.x(0)
    circ.measure_active()
    circs.append(circ)

circs = transpile(circs, backend)
circs[0].calibrations  # This returns calibration only for x gate
```
Si noti che la mappa del programma di istruzioni è un oggetto mutabile. Se si sovrascrive una delle voci e si usa quel backend per altri esperimenti, si può accidentalmente aggiornare la definizione del gate.
```
backend = FakeGuadalupe()

instmap = backend.defaults().instruction_schedule_map
instmap.add("x", (0, ), my_x_gate_schedule)

qc = QuantumCircuit(1, 1)
qc.x(0)
qc.measure(0, 0)

qc = transpile(qc, backend)  # This backend uses custom X gate
```
Se si desidera aggiornare le definizioni dei gate di un esperimento specifico, è necessario prima copiare in profondità la mappa del programma di istruzioni e passarla direttamente al transpiler.

Introdotta una nuova opzione qubit_subset nel costruttore di BIPMapping. L'opzione consente di specificare in una riga i qubit fisici da utilizzare (in coupling_map del dispositivo) durante la mappatura:

mapped_circ = BIPMapping(
    coupling_map=CouplingMap([[0, 1], [1, 2], [1, 3], [3, 4]]),
    qubit_subset=[1, 3, 4]
)(circ)

In precedenza, per fare la stessa cosa, bisognava fornire un coupling_map ridotto che contenesse solo i qubit da utilizzare, incorporare il circuito risultante nel coupling_map originale e aggiornare il QuantumCircuit._layout di conseguenza:

reduced_coupling = coupling_map.reduce(qubit_to_use)
mapped = BIPMapping(reduced_coupling)(circ)
# skip the definition of fill_with_ancilla()
# recover circuit on original coupling map
layout = Layout({q: qubit_to_use[i] for i, q in enumerate(mapped.qubits)})
for reg in mapped.qregs:
    layout.add_register(reg)
property_set = {"layout": fill_with_ancilla(layout)}
recovered = ApplyLayout()(mapped, property_set)
# recover layout
overall_layout = Layout({v: qubit_to_use[q] for v, q in mapped._layout.get_virtual_bits().items()})
for reg in mapped.qregs:
    overall_layout.add_register(reg)
recovered._layout = fill_with_ancilla(overall_layout)

Aggiunti gli argomenti ignore_pauli_phase e copy al costruttore di SparsePauliOp. ignore_pauli_phase impedisce la lettura dell'attributo phase di un input PauliList di essere letto, il che è più performante se l'elemento PauliList è già noto per avere tutte le fasi come zero nella convenzione interna ZX. copy permette di evitare la copia dei dati di input quando si imposta esplicitamente copy=False.
Miglioramento delle prestazioni delle seguenti SparsePauliOp operazioni:
- simplify() (vedi #7122 )
- compose() (vedi #7126 )
- _add() (vedi #7138 )
- from_list() e __init__() (vedere altra discussione in #7138 ).
È stato aggiunto il metodo SparsePauliOp.sum() per sommare molti metodi SparsePauliOps. Questo metodo offre prestazioni nettamente migliori rispetto alla somma delle istanze in un ciclo. Ad esempio, il modo precedente per sommare più SparsePauliOpinsieme sarebbe quello di fare:
```
from qiskit.quantum_info import SparsePauliOp, random_pauli_list
sparse_ops = [SparsePauliOp(random_pauli_list(10, 10)) for _ in [None]*1000]

total = sparse_ops[0]
for op in sparse_ops[1:]:
    total += op
```
Ora è possibile eseguire questa operazione in modo molto più efficiente (sia in termini di velocità che di digitazione) Come:
```
SparsePauliOp.sum(sparse_ops)
```
Aggiunto un argomento limit_amplitude al costruttore di ParametricPulse, che è la classe base di Gaussian, GaussianSquare, Drag e Constantper consentire la disabilitazione del limite di ampiezza di 1 su base impulsiva. Con limit_amplitude=False, i singoli impulsi possono avere un'ampiezza superiore all'unità senza sollevare una PulseError. Vedere il numero 6544 per maggiori dettagli.
Utilizzo QuantumCircuit.draw() o circuit_drawer() con il cassetto latex genererà un file in un formato immagine dedotto dall'estensione del nome del file, ad esempio:
```
import qiskit

circuit = qiskit.QuantumCircuit(2)
circuit.h(0)
circuit.cx(0, 1)
circuit.draw('latex', filename='./file.jpg')
```
In questo modo si salverà il disegno del circuito in formato JPEG. In precedenza, l'immagine era sempre in formato PNG. Per maggiori dettagli, consultare il numero 6448.

Ora, se incontra un'estensione del nome del file non supportata, ad esempio:
```
circuit.draw('latex', filename='./file.spooky')
```
solleverà un ValueError per cambiare l'estensione del nome del file in un formato immagine supportato.
Aggiunto il parametro filename a plot_gate_map() e plot_coupling_map()che consente di salvare le immagini risultanti in un file.
Introdotto un compilatore quantistico approssimativo e una corrispondente implementazione del plugin di sintesi unitaria. La classe principale di AQC è AQC per una versione autonoma che compila una matrice unitaria in un circuito approssimato. Il plugin può essere invocato da transpile() quando l'argomento unitary_synthesis_method è impostato su 'aqc'. Vedere qiskit.transpiler.synthesis.aqc per tutti i dettagli.
Aggiunto un argomento filter_function a QuantumCircuit.depth() e QuantumCircuit.size() per analizzare le operazioni dei circuiti secondo alcuni criteri.

Ad esempio, per ottenere il numero di porte a due qubit, si può fare:
```
circuit.size(lambda x: x[0].num_qubits == 2)
```
Oppure per ottenere la profondità delle porte T che agiscono sullo zeroth qubit:
```
circuit.depth(lambda x: x[0].name == 't' and circuit.qubits[0] in x[1])
```
Aggiunto un nuovo passaggio di transpiler, CollectMultiQBlocksal modulo qiskit.transpiler.passes al modulo. Questo passaggio viene utilizzato per raccogliere sequenze di porte ininterrotte che agiscono su gruppi di qubit. Fornisce una funzione simile a quella del passaggio Collect2qBlocks ma mentre quest'ultimo è stato progettato e ottimizzato per trovare blocchi di 2 qubit, questo nuovo passaggio funziona per trovare blocchi di qualsiasi dimensione.
Esiste un'interfaccia costruttore per le nuove operazioni di flusso di controllo su QuantumCircuit, come il nuovo ForLoopOp, IfElseOp, e WhileLoopOp. L'interfaccia utilizza gli stessi metodi di circuito, vale a dire QuantumCircuit.for_loop(), QuantumCircuit.if_test() e QuantumCircuit.while_loop()che sono sovraccaricati in modo che se il parametro body non viene fornito, restituiscono un gestore di contesto. L'ingresso in uno di questi gestori di contesto spinge uno scope nel circuito e cattura tutte le chiamate al gate (e agli altri scope) e le risorse che queste utilizzano, costruendo alla fine la relativa operazione. Ad esempio, ora è possibile farlo:
```
qc = QuantumCircuit(2, 2)
with qc.for_loop(range(5)) as i:
    qc.rx(i * math.pi / 4, 0)
```
Questo produrrà un ForLoopOp su qc, che sa che il qubit 0 è l'unica risorsa utilizzata nel corpo del ciclo. Questi gestori di contesto possono essere annidati e determinano correttamente la loro larghezza. È possibile utilizzare QuantumCircuit.break_loop() e QuantumCircuit.continue_loop() all'interno di un contesto, e si espanderà in modo da avere la larghezza corretta per il ciclo che lo contiene, anche se è annidato in ulteriori blocchi QuantumCircuit.if_test() blocchi.

Il gestore del contesto if_test() fornisce un gestore concatenato che, se lo si desidera, può essere utilizzato per creare un blocco else , come ad esempio da:
```
qreg = QuantumRegister(2)
creg = ClassicalRegister(2)
qc = QuantumCircuit(qreg, creg)
qc.h(0)
qc.cx(0, 1)
qc.measure(0, 0)
with qc.if_test((creg, 0)) as else_:
    qc.x(1)
with else_:
    qc.z(1)
```
Il gestore si assicurerà che i corpi if e else siano definiti sullo stesso insieme di risorse.

Introdotto un nuovo passo di transpiler InverseCancellation che generalizza il passaggio CXCancellation per annullare qualsiasi porta auto-inversa o coppia gate-inversa. Può essere utilizzato inizializzando InverseCancellation e passando un gate da annullare, ad esempio:

from qiskit.transpiler.passes import InverseCancellation
from qiskit import QuantumCircuit
from qiskit.circuit.library import HGate
from qiskit.transpiler import PassManager

qc = QuantumCircuit(2, 2)
qc.h(0)
qc.h(0)
pass_ = InverseCancellation([HGate()])
pm = PassManager(pass_)
new_circ = pm.run(qc)

Il costruttore di RZXCalibrationBuilder ha due nuovi kwarg instruction_schedule_map e qubit_channel_mapping che prendono rispettivamente una lista di nomi di canali e una lista di nomi di canali per ogni qubit InstructionScheduleMap e un elenco di nomi di canali per ogni qubit, rispettivamente. Questi nuovi argomenti sono usati per specificare direttamente le informazioni necessarie da un target di backend. Devono essere usati al posto di passare un BaseBackend o un BackendV1 direttamente al passaggio con l'argomento backend .
I Statevectors di stati composti solo da qubit possono ora essere disegnati in LaTeX in notazione ket. Nella notazione ket le voci del vettore di stato vengono elaborate in modo tale che i fattori esatti, come le frazioni o le radici quadrate di due, vengano disegnati come tali. La convenzione particolare può essere scelta passando l'argomento della parola chiave convention come "ket" o "vector" , a seconda dei casi:
```
import math
from qiskit.quantum_info import Statevector

sv = Statevector([math.sqrt(0.5), 0, 0, -math.sqrt(0.5)])
sv.draw("latex", convention="ket")
sv.draw("latex", convention="vector")
```
Aggiunto un nuovo passaggio di transpiler EchoRZXWeylDecomposition che consente agli utenti di decomporre un gate arbitrario a due-qubit in termini di gate RZX riecheggiati, sfruttando la decomposizione di Cartan. In combinazione con altri passaggi del transpiler, questo può essere usato per transpilare circuiti arbitrari in circuiti basati su porte RZX ed efficienti dal punto di vista degli impulsi che implementano lo stesso unitario.

Il SPSA e QNSPSA sono ora in grado di raggruppare il maggior numero possibile di valutazioni dei circuiti sia per le iterazioni che per le calibrazioni iniziali. Questo può essere sfruttato impostando il kwarg max_evals_grouped sul costruttore di VQE quando si usa SPSA o QNSPSA come parametro optimizer . Ad esempio:

from qiskit.circuit.library import TwoLocal
from qiskit.algorithms import VQE
from qiskit.algorithms.optimizers import QNSPSA
from qiskit.test.mock import FakeMontreal

backend = FakeMontreal()
ansatz = TwoLocal(2, rotation_blocks=["ry", "rz"], entanglement_blocks="cz")
qnspsa = QNSPSA(fidelity, maxiter=5)
vqe = VQE(
    ansatz=ansatz,
    optimizer=qnspsa,
    max_evals_grouped=100,
    quantum_instance=backend,
)

Questa versione introduce un metodo di decomposizione per porte a due qubit che si rivolge a insiemi di porte RZX definiti dall'utente. Gli utenti del transpiler possono abilitare la decomposizione per {RZX(pi/2), RZX(pi/4), and RZX(pi/6)} includendo 'rzx' nell'elenco di basis_gates quando si chiama transpile(). Gli utenti del pacchetto informazioni Quantum possono trovare il metodo stesso sotto la voce XXDecomposer classe.
Aggiunto un transpiler pass Optimize1qGatesSimpleCommutationche ottimizza un circuito secondo una strategia di commutazione di porte a singolo qubit per scoprire opportunità di risintesi.
Aggiunto un parametro max_job_tries a QuantumInstanceper limitare il numero di volte in cui un lavoro tenterà di essere eseguito su un backend. In precedenza, l'invio e il recupero dei risultati venivano tentati all'infinito, anche se il lavoro veniva annullato o veniva interrotto dal backend. Il valore predefinito è ora 50 e il comportamento precedente può essere ottenuto impostando max_job_tries=-1. Correzioni #6872 e #6821.
Il metodo di uscita latex per la funzione circuit_drawer() e il metodo QuantumCircuit.draw() possono ora disegnare circuiti che contengono porte con condizioni a singolo bit. Questo è stato aggiunto per la compatibilità del cassetto Latex con la nuova caratteristica di supportare il condizionamento classico delle porte su singoli bit classici.
Il metodo di uscita "mpl" per la funzione circuit_drawer() e il metodo QuantumCircuit.draw() possono ora disegnare circuiti che contengono porte con condizioni a singolo bit. Questo è stato aggiunto per la compatibilità del cassetto "mpl" con la nuova caratteristica di supportare il condizionamento classico delle porte su singoli bit classici.
Il metodo di uscita text per la funzione circuit_drawer() e il metodo QuantumCircuit.draw() possono ora disegnare circuiti che contengono porte con condizioni a singolo bit. Questo è stato aggiunto per la compatibilità del cassetto di testo con la nuova funzione di supporto del condizionamento classico delle porte su singoli bit classici.
È stato aggiunto un nuovo passaggio del transpiler di analisi, GatesInBasisè stato aggiunto a qiskit.transpiler.passes. Questo passaggio viene utilizzato per verificare se l'oggetto DAGCircuit in fase di trasposizione abbia o meno tutte le porte dell'insieme di basi configurato. L'attributo "all_gates_in_basis" del set di proprietà verrà impostato su True se tutti i cancelli del set di base configurato sono presenti nel set di base configurato, oppure su in caso contrario DAGCircuit sono nell'insieme di base configurato o False se non lo sono. Ad esempio:
```
from qiskit.circuit import QuantumCircuit
from qiskit.transpiler.passes import GatesInBasis

# Instatiate Pass
basis_gates = ["cx", "h"]
basis_check_pass = GatesInBasis(basis_gates)
# Build circuit
circuit = QuantumCircuit(2)
circuit.h(0)
circuit.cx(0, 1)
circuit.measure_all()
# Run pass on circuit
property_set = {}
basis_check_pass(circuit, property_set=property_set)
assert property_set["all_gates_in_basis"]
```
Aggiunti due nuovi metodi costruttori, from_heavy_hex() e from_heavy_square()alla classe CouplingMap alla classe. Questi metodi del costruttore vengono utilizzati per creare un grafo CouplingMap che sono un grafo esagonale pesante o un grafo quadrato pesante come descritto in Chamberland et al., 2020.

Ad esempio:
```
from qiskit.transpiler import CouplingMap

cmap = CouplingMap.from_heavy_hex(5)
cmap.draw()
```
```
from qiskit.transpiler import CouplingMap

cmap = CouplingMap.from_heavy_square(5)
cmap.draw()
```
L'algoritmo HHL può ora trovare soluzioni quando la matrice ha autovalori negativi. Per consentire ciò, l'algoritmo aggiunge un qubit in più per rappresentare il segno del valore e l'algoritmo helper è stato aggiornato per elaborare questa nuova informazione ExactReciprocal è stato aggiornato per elaborare questa nuova informazione. Per maggiori dettagli, vedere il numero #6971.
Aggiunte due nuove classi, CompleteMeasFitter e TensoredMeasFitter al modulo qiskit.utils.mitigation modulo. Queste classi possono essere utilizzate solo come valori per il kwarg measurement_error_mitigation_cls della classe QuantumInstance della classe. L'istanziazione e l'uso di queste classi (o di qualsiasi altra cosa in qiskit.utils.mitigation) al di fuori del kwarg measurement_error_mitigation_cls devono essere considerati come un'API privata interna e non devono essere utilizzati.
La ListOp in qiskit.opflow ha ora un attributo coeffs che restituisce un elenco dei coefficienti della lista di operatori, con il coefficiente complessivo (ListOp.coeff) distribuito in modo moltiplicativo nell'elenco. Si noti che ListOp possono essere annidati (contenuti in oplist di un oggetto ListOp ) e in questi casi viene sollevata un'eccezione se viene richiamato il metodo coeffs. Il metodo ListOp.coeffs si confronta opportunamente con il metodo di proprietà coeffs della classe non nidificata PauliSumOp non nidificante.
La classe Statevector è ora sottoscrivibile. L'utente può ora recuperare l'ennesimo coefficiente in un file Statevector per indice come statevec[n].
Aggiunto il metodo Statevector.inner per calcolare i prodotti interni di Statevector istanze. Ad esempio:
```
statevec_inner_other = statevec.inner(other)
```
restituirà il prodotto interno di statevec con other. Mentre statevec deve essere un Statevector, other può essere qualsiasi cosa che possa essere costruita in un oggetto Statevectorcome ad esempio un array Numpy.
È stato aggiunto un nuovo parametro, add_bits, a QuantumCircuit.measure_all(). Per impostazione predefinita è impostato su True per mantenere il comportamento precedente che prevedeva l'aggiunta di un nuovo ClassicalRegister della stessa dimensione del numero di qubit per memorizzare le misure. Se impostato su False, le misure saranno memorizzate nei bit classici già esistenti. Ad esempio, se si crea un circuito con bit classici esistenti come:
```
from qiskit.circuit import QuantumCircuit, QuantumRegister, ClassicalRegister

qr = QuantumRegister(2)
cr = ClassicalRegister(2, "meas")
circuit = QuantumCircuit(qr, cr)
```
la chiamata a circuit.measure_all(add_bits=False) utilizzerà il registro classico esistente cr come target di uscita degli oggetti Measurement aggiunti al circuito.
ParameterExpression ora delega le conversioni numeriche alla libreria simbolica sottostante, anche se ci sono parametri potenzialmente non vincolati. Ciò consente di convertire espressioni come:
```
>>> from qiskit.circuit import Parameter
>>> x = Parameter('x')
>>> float(x - x + 2.3)
2.3
```
dove l'espressione sottostante ha un valore fisso, ma il parametro x non è ancora vincolato.

Aggiunto un metodo Optimizer.minimize() a tutti gli ottimizzatori: Optimizer e alle classi derivate. Questo metodo imita la firma della funzione SciPy’s minimize() e restituisce un oggetto OptimizerResult.

Per esempio

import numpy as np
from qiskit.algorithms.optimizers import COBYLA

def loss(x):
    return -(x[0] - 1) ** 2 - (x[1] + 1) ** 3

initial_point = np.array([0, 0])
optimizer = COBYLA()
result = optimizer.minimize(loss, initial_point)

optimal_parameters = result.x
minimum_value = result.fun
num_function_evals = result.nfev

Aggiunto un PauliEvolutionGate alla libreria dei circuiti (qiskit.circuit.library) che definisce un gate che esegue l'evoluzione temporale di (somme o somme di) Paulis. La sintesi di questo gate viene eseguita da EvolutionSynthesis ed è disaccoppiata dal gate stesso. I metodi di sintesi attualmente disponibili sono:

LieTrotter: Trotterizzazione del primo ordine
SuzukiTrotter: Trotterizzazione di ordine superiore
MatrixExponential: evoluzione esatta e matriciale

Ad esempio:

from qiskit.circuit import QuantumCircuit
from qiskit.circuit.library import PauliEvolutionGate
from qiskit.quantum_info import SparsePauliOp
from qiskit.synthesis import SuzukiTrotter

operator = SparsePauliOp.from_list([
    ("XIZ", 0.5), ("ZZX", 0.5), ("IYY", -1)
])
time = 0.12  # evolution time
synth = SuzukiTrotter(order=4, reps=2)

evo = PauliEvolutionGate(operator, time=time, synthesis=synth)

circuit = QuantumCircuit(3)
circuit.append(evo, range(3))

È stata introdotta una nuova funzione plot_coupling_map() è stata introdotta, che estende la funzionalità della funzione esistente plot_gate_map()accettando tre parametri: num_qubit, qubit_coordinates, e coupling_map (invece di backend), per consentire di tracciare una mappa di accoppiamento di qubit arbitraria.

Qiskit Terra ha ora il supporto iniziale per la serializzazione di QuantumCircuita OpenQASM 3 :

from qiskit.circuit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit import qasm3

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

print(qasm3.dumps(qc))

Questa versione iniziale ha un supporto limitato per i registri denominati, le istruzioni incorporate di base (come misura, barriera e reset), le porte definite dall'utente, le istruzioni definite dall'utente (come subroutine) e i nuovi costrutti di flusso di controllo introdotti in questa versione:

from qiskit.circuit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit import qasm3
import math

composite_circ_qreg = QuantumRegister(2)
composite_circ = QuantumCircuit(composite_circ_qreg, name="composite_circ")
composite_circ.h(0)
composite_circ.x(1)
composite_circ.cx(0, 1)
composite_circ_gate = composite_circ.to_gate()

qr = QuantumRegister(2, "qr")
cr = ClassicalRegister(2, "cr")
qc = QuantumCircuit(qr, cr)
with qc.for_loop(range(4)) as i:
    qc.rx(i * math.pi / 4, 0)
    qc.cx(0, 1)
qc.barrier()
qc.append(composite_circ_gate, [0, 1])
qc.measure([0, 1], [0, 1])

print(qasm3.dumps(qc))

La QDrift è stata riformulata come un metodo di sintesi per PauliEvolutionGatederivante da TrotterizationBase.

from qiskit.circuit import QuantumCircuit
from qiskit.circuit.library import PauliEvolutionGate
from qiskit.synthesis import QDrift
from qiskit.opflow import X, Y, Z

qdrift = QDrift(reps=2)
operator = (X ^ 3) + (Y ^ 3) + (Z ^ 3)
time = 2.345  # evolution time

evolution_gate = PauliEvolutionGate(operator, time, synthesis=qdrift)

circuit = QuantumCircuit(3)
circuit.append(evolution_gate, range(3))

La serializzazione QPY è ora in grado di rappresentare global_phase attributi di un QuantumCircuit che sono un oggetto int, Parameter oggetto o ParameterExpression oggetto. Le versioni precedenti di QPY accettavano solo un file global_phase che fosse un float.

Ciò richiede il formato QPY versione 2, introdotto in questa versione per rappresentare i tipi aggiuntivi.
Un nuovo find_bit() è stato aggiunto alla classe QuantumCircuit che consente di ricercare l'indice e i registri di un dato circuito Bit sul circuito dato. Il metodo restituisce un namedtuple a due elementi che contiene 0) l'indice di Bit in una delle due sezioni di qubits (per un elemento Qubit) o clbits (per a Clbit) e 1) un elenco di tuple length-2 contenenti ogni circuito Register che contiene il circuito Bit e l'indice di quel Register in cui si trova il circuito Bit .

Ad esempio:
```
from qiskit.circuit import QuantumCircuit, QuantumRegister, Qubit

reg1 = QuantumRegister(3, 'foo')
qubit = Qubit()
reg2 = QuantumRegister(2, 'bar')

qc = QuantumCircuit(reg1, [qubit], reg2)

print(qc.find_bit(reg1[2]))
print(qc.find_bit(qubit))
```
genererebbe:
```
BitLocations(index=2, registers=[(QuantumRegister(3, 'foo'), 2)])
BitLocations(index=3, registers=[])
```
Tre nuove Instruction sono state aggiunte per supportare le operazioni di flusso di controllo nei circuiti dinamici: WhileLoopOp, ForLoopOp, e IfElseOp. Inoltre, due sottoclassi, BreakLoopOpe ContinueLoopOpsono state aggiunte per supportare rispettivamente l'interruzione e la continuazione dell'iterazione successiva di un contesto di ciclo.

Questi possono essere creati come elementi a sé stanti o Instructiono aggiungere a un'istanza QuantumCircuit tramite i rispettivi metodi, QuantumCircuit.while_loop(), for_loop(), if_test(), if_else(), break_loop(), e continue_loop().
Aggiunta la BaseReadoutMitigator classe base astratta per l'implementazione di attenuatori di errori di misura classici. Questi oggetti sono destinati alla mitigazione degli errori di misura in Counts oggetti restituiti dall'esecuzione di circuiti su backend con errori di misura.

Le classi di mitigatori di lettura hanno due metodi principali:
- expectation_value() che calcola un valore di aspettativa attenuato e l'errore standard di un operatore diagonale da un oggetto rumoroso Counts oggetto.
- quasi_probabilities() che calcola un errore attenuato QuasiDistribution, compreso l'errore standard, da un oggetto di conteggio rumoroso.
Si noti che attualmente il modulo qiskit.algorithms e la classe QuantumInstance utilizzano ancora i mitigatori legacy migrati da Qiskit Ignis in qiskit.utils.mitigation. Si prevede di aggiornare il modulo per utilizzare le nuove classi di mitigazione e di deprecare il codice di mitigazione precedente in una versione futura.
È stata aggiunta la classe LocalReadoutMitigator per eseguire la mitigazione degli errori di lettura degli errori di misura locali. Gli errori di misura locali sono quelli descritti da un prodotto tensoriale di errori di misura a singolo qubit.

Questa classe può essere inizializzata con un elenco di $N$ single-qubit di matrici di assegnazione dell'errore di misura o da un backend utilizzando le informazioni sull'errore di lettura nelle proprietà del backend.

La mitigazione è implementata utilizzando l'inversione della matrice di assegnazione locale che ha una complessità di $O(2^N)$ per $N$ -qubit mitigazione di QuasiDistribution e valori di aspettativa.
Aggiunta la classe CorrelatedReadoutMitigator per eseguire la mitigazione degli errori di lettura delle misure correlate. Questa classe può essere inizializzata con una singola matrice di assegnazione degli errori di misura $2^N \times 2^N$ che descrive le probabilità di errore. La mitigazione è implementata tramite l'inversione della matrice di assegnazione che ha una complessità di mitigazione pari a $O(4^N)$ di QuasiDistribution e valori di aspettativa.
Aggiunto un attributo QuasiDistribution.stddev_upper_bound e un kwarg al costruttore della classe QuasiDistribution utilizzata per memorizzare gli errori standard nelle stime di quasi-probabilità. Viene utilizzato dalle BaseReadoutMitigator per memorizzare l'errore standard nelle quasi-probabilità attenuate.
Aggiunto un metodo shots() a qiskit.result.Counts per restituire la somma di tutti i risultati nei conteggi.
Durante l'esecuzione dell'algoritmo Grover se la potenza ottimale è nota e viene eseguito un solo circuito, non è più necessario impostare la funzione di callback e la ricerca di Grover restituirà la stringa di bit più probabile AmplificationProblem.is_good_state non deve più essere impostata e la ricerca di Grover restituirà la stringa di bit più probabile. In genere, se la potenza ottimale dell'operatore di Grover non è nota, l'algoritmo verifica diverse potenze (cioè iterazioni) e applica la potenza ottimale dell'operatore di Grover Grover algoritmo controlla diverse potenze (cioè iterazioni) e applica la funzione di is_good_state per verificare se è stata misurata una buona stringa di bit. Ad esempio, ora è possibile eseguire qualcosa come:
```
from qiskit.algorithms import Grover, AmplificationProblem
from qiskit.providers.aer import AerSimulator
from qiskit.quantum_info import Statevector

# Fixed Grover power: 2.
grover = Grover(iterations=2, quantum_instance=AerSimulator())

# The ``is_good_state`` argument not required here since Grover search
# will be run only once, with a power of 2.
problem = AmplificationProblem(Statevector.from_label("111"))

# Run Grover search and print the best measurement
result = grover.amplify(problem)
print(result.top_measurement)  # should print 111
```
Aggiunto il metodo remove_cregs() alla classe DAGCircuit per supportare la rimozione del registro classico.
Aggiunto il metodo remove_clbits() alla classe DAGCircuit per supportare la rimozione dei bit classici inattivi. Vengono rimossi anche tutti i registri classici che fanno riferimento a un bit rimosso.
Aggiunto un nuovo metodo, replace_block_with_op()alla classe DAGCircuit alla classe. Questo metodo viene utilizzato per sostituire un blocco di nodi nel DAG con una singola operazione. L'esempio canonico è quello del passaggio ConsolidateBlocks che sostituisce blocchi di nodi con nodi equivalenti UnitaryGate .
Aggiunto un nuovo passaggio del transpiler di analisi, Collect1qRunsal modulo qiskit.transpiler.passes al modulo. Questo passaggio viene utilizzato per trovare sequenze di porte ininterrotte che agiscono su un singolo qubit. È simile a quello di Collect2qBlocks e CollectMultiQBlocks ma è ottimizzato per le corse a singolo qubit invece che per i blocchi a qubit multipli.
Diverse funzioni interne di transpilazione utilizzano ora le nuove caratteristiche di retworkx 0.10 quando operano sulla rappresentazione del circuito interno. Questo può spesso portare a una velocizzazione delle chiamate a transpile di circa il 10-40%, con effetti maggiori a livelli di ottimizzazione più elevati. Per maggiori dettagli, vedere il numero 6302.
Il UnitarySynthesis transpiler pass in qiskit.transpiler.passes ha un nuovo kwarg nel costruttore, min_qubits. Se specificato, può essere impostato su un valore int che rappresenta la dimensione minima dell'oggetto UnitaryGate su cui eseguire la sintesi unitaria. Se un UnitaryGate in un QuantumCircuit utilizza un numero inferiore di qubit, verrà saltato da quell'istanza del passaggio.
Le interfacce Eigensolver e MinimumEigensolver supportano ora il tipo Dict[str, Optional[OperatorBase]] per il parametro aux_operators nei rispettivi metodi compute_eigenvalues() e compute_minimum_eigenvalue() . In questo caso, anche gli autovalori ausiliari sono memorizzati in un dizionario con le stesse chiavi fornite dal dizionario aux_operators . I tasti che corrispondono a un operatore che non commuta con l'operatore principale vengono eliminati.
Il BasisTranslator, GateDirection, e CheckGateDirection hanno un nuovo kwarg target nei loro costruttori, che può essere usato per impostare un oggetto Target come destinazione del passaggio. Se è impostata, verrà utilizzata al posto di target_basis (nel caso del BasisTranslator o coupling_map (nel caso dei passaggi GateDirection e CheckGateDirection ).

Consentire due stadi di transpiler nel QuantumInstanceuno per i circuiti parametrizzati e un secondo per i circuiti vincolati (cioè senza parametri liberi). Se un'istanza quantistica con passaggi per circuiti non vincolati e vincolati viene passata in una classe di campionamento CircuitSampleril campionatore cercherà di applicare il passaggio non vincolato una sola volta al circuito parametrizzato, lo memorizzerà e applicherà solo il passaggio vincolato per tutte le valutazioni future.

Ciò consente agli algoritmi variazionali come il VQE di eseguire una volta un gestore di passaggi personalizzato per i circuiti parametrizzati e, in aggiunta, di eseguire nuovamente il transpiler con un gestore di passaggi personalizzato diverso sui circuiti vincolati in ogni iterazione. La possibilità di eseguire diversi gestori di passaggi è importante perché non tutti i passaggi supportano circuiti parametrizzati (per esempio Optimize1qGatesDecomposition funziona solo con i parametri dei circuiti vincolati).

Ad esempio, questa caratteristica consente di utilizzare la decomposizione CX a efficienza di impulso nella VQE, come

from qiskit.algorithms import VQE
from qiskit.opflow import Z
from qiskit.circuit.library.standard_gates.equivalence_library import StandardEquivalenceLibrary as std_eqlib
from qiskit.transpiler import PassManager, PassManagerConfig, CouplingMap
from qiskit.transpiler.preset_passmanagers import level_1_pass_manager
from qiskit.transpiler.passes import (
    Collect2qBlocks, ConsolidateBlocks, Optimize1qGatesDecomposition,
    RZXCalibrationBuilderNoEcho, UnrollCustomDefinitions, BasisTranslator
)
from qiskit.transpiler.passes.optimization.echo_rzx_weyl_decomposition import EchoRZXWeylDecomposition
from qiskit.test.mock import FakeBelem
from qiskit.utils import QuantumInstance

# Replace by a real backend! If not ensure qiskit-aer is installed to simulate the backend
backend = FakeBelem()

# Build the pass manager for the parameterized circuit
rzx_basis = ['rzx', 'rz', 'x', 'sx']
coupling_map = CouplingMap(backend.configuration().coupling_map)
config = PassManagerConfig(basis_gates=rzx_basis, coupling_map=coupling_map)
pre = level_1_pass_manager(config)

# Build a pass manager for the CX decomposition (works only on bound circuits)
post = PassManager([
    # Consolidate consecutive two-qubit operations.
    Collect2qBlocks(),
    ConsolidateBlocks(basis_gates=['rz', 'sx', 'x', 'rxx']),

    # Rewrite circuit in terms of Weyl-decomposed echoed RZX gates.
    EchoRZXWeylDecomposition(backend),

    # Attach scaled CR pulse schedules to the RZX gates.
    RZXCalibrationBuilderNoEcho(backend),

    # Simplify single-qubit gates.
    UnrollCustomDefinitions(std_eqlib, rzx_basis),
    BasisTranslator(std_eqlib, rzx_basis),
    Optimize1qGatesDecomposition(rzx_basis),
])

quantum_instance = QuantumInstance(backend, pass_manager=pre, bound_pass_manager=post)

vqe = VQE(quantum_instance=quantum_instance)
result = vqe.compute_minimum_eigenvalue(Z ^ Z)

È stata introdotta una nuova interfaccia per i plugin di sintesi unitaria, utilizzata per consentire l'utilizzo di tecniche di sintesi alternative incluse in pacchetti esterni senza soluzione di continuità con il passaggio di UnitarySynthesis transpiler. Gli utenti possono selezionare un plugin da utilizzare quando chiamano transpile() impostando il kwarg unitary_synthesis_method sul nome del plugin. L'elenco completo dei plugin installati può essere consultato utilizzando la funzione qiskit.transpiler.passes.synthesis.plugin.unitary_synthesis_plugin_names() funzione. Ad esempio, se si installa un pacchetto che include un plugin di sintesi chiamato special_synth , lo si può utilizzare con:
```
from qiskit import transpile

transpile(qc, unitary_synthesis_method='special_synth', optimization_level=3)
```
Questo sostituirà tutti gli usi del metodo UnitarySynthesis con il metodo incluso nel pacchetto esterno che esporta il plugin special_synth .

L'interfaccia dei plugin è costruita intorno a punti di ingresso setuptools che consentono ai pacchetti esterni a Qiskit di pubblicizzare l'inclusione di un plugin di sintesi. Per i dettagli sulla scrittura di un nuovo plugin, consultare la documentazione del modulo qiskit.transpiler.passes.synthesis.plugin del modulo.
Aggiunto un nuovo passaggio di transpiler, VF2Layout. Questo passaggio modella il problema dell'allocazione del layout come un problema di isomorfismo dei sottografi e utilizza l'implementazione dell' algoritmo VF2 in rustworkx per trovare un layout perfetto (un layout che non richieda instradamenti aggiuntivi), se ne esiste uno. La funzionalità esposta da questo nuovo pass è molto simile a quella esistente CSPLayout ma VF2Layout è significativamente più veloce.

Problemi noti

La convenzione "ket" nel cassetto "latex" di Statevector.draw() è valida solo per gli stati composti esclusivamente da qubit. Se si utilizzano stati con spazi di dimensione superiore a due, è necessario passare convention="vector", oppure utilizzare un cassetto diverso.
Le funzionalità di esportazione di OpenQASM 3 sono in fase beta e alcune caratteristiche di Qiskit Terra non sono ancora supportate QuantumCircuit non sono ancora supportate. In particolare, si possono verificare errori se si cerca di esportare subroutine personalizzate con parametri classici, e non è ancora prevista l'esportazione di operazioni calibrate a impulsi in OpenPulse.

Quando si esegue il programma BasisTranslator in isolamento con l'argomento target impostato su un oggetto Target in cui alcune porte a singolo qubit possono essere applicate solo a insiemi non sovrapposti di qubit, il circuito di uscita potrebbe includere erroneamente operazioni su un qubit non consentite dall'oggetto Target. Ad esempio, se si è eseguito:

from qiskit.circuit import QuantumCircuit, Parameter
from qiskit.circuit.library import UGate, RZGate, XGate, SXGate, CXGate
from qiskit.circuit.equivalence_library import SessionEquivalenceLibrary as sel

from qiskit.transpiler import PassManager, Target, InstructionProperties
from qiskit.transpiler.passes import BasisTranslator

gmap = Target()

# U gate in qubit 0.
theta = Parameter('theta')
phi = Parameter('phi')
lam = Parameter('lambda')
u_props = {
    (0,): InstructionProperties(duration=5.23e-8, error=0.00038115),
}
gmap.add_instruction(UGate(theta, phi, lam), u_props)

# Rz gate in qubit 1.
phi = Parameter("phi")
rz_props = {
    (1,): InstructionProperties(duration=0.0, error=0),
}
gmap.add_instruction(RZGate(phi), rz_props)

# X gate in qubit 1.
x_props = {
    (1,): InstructionProperties(
        duration=3.5555555555555554e-08, error=0.00020056469709026198
    ),
}
gmap.add_instruction(XGate(), x_props)

# SX gate in qubit 1.
sx_props = {
    (1,): InstructionProperties(
        duration=3.5555555555555554e-08, error=0.00020056469709026198
    ),
}
gmap.add_instruction(SXGate(), sx_props)

cx_props = {
    (0, 1): InstructionProperties(duration=5.23e-7, error=0.00098115),
    (1, 0): InstructionProperties(duration=4.52e-7, error=0.00132115),
}
gmap.add_instruction(CXGate(), cx_props)

bt_pass = BasisTranslator(sel, target_basis=None, target=gmap)

qc = QuantumCircuit(2)
qc.iswap(0, 1)
output = bt_pass(qc)

output avrà RZGate e SXGate sul qubit 0, anche se ciò è proibito. Per correggere questo problema si può normalmente eseguire il traduttore di basi una seconda volta (ad es. output = bt_pass(output) nell'esempio precedente) per correggere questo problema. Questo non dovrebbe influire sull'output dell'esecuzione della funzione transpile() ed è un problema solo se si esegue il passaggio da solo.

Note sull'aggiornamento

A partire da questa versione, from qiskit import * non importerà i sottomoduli, ma solo un elenco selezionato di oggetti. Questo potrebbe interrompere il codice esistente che utilizza from qiskit import * e fa riferimento a oggetti che non fanno parte dello spazio dei nomi corrente. Come promemoria, import * è considerato una cattiva pratica e non dovrebbe essere usato nel codice di produzione. Qiskit imposta __all__ su qiskit/__init__.py come un modo per mitigare gli effetti di queste cattive pratiche. Se il codice solleva name '<something>' is not defined, aggiungere from qiskit import <something> e riprovare.
I gestori dei passaggi preimpostati per i livelli di ottimizzazione 0, 1, 2 e 3, generati da level_0_pass_manager(), level_1_pass_manager(), level_2_pass_manager(), e level_3_pass_manager() rispettivamente, non eseguiranno più incondizionatamente l'opzione TimeUnitConversion. In precedenza, i gestori dei passaggi preimpostati eseguivano sempre questo passaggio, indipendentemente dagli ingressi del transpiler e del circuito. Ora questo passaggio verrà eseguito solo se è impostato il parametro scheduling_method o se il circuito contiene un'istruzione e il parametro è impostato Delay e il parametro instruction_durations è impostato. Questa modifica è stata apportata nell'interesse delle prestazioni di runtime, in quanto in alcuni casi l'esecuzione su circuiti con un gran numero di gate e senza l'utilizzo di ritardi o schedulazioni transpile() su circuiti con un gran numero di porte e senza l'utilizzo di ritardi, temporizzazioni o schedulazioni TimeUnitConversion potrebbe essere il più grande collo di bottiglia nella trasposizione.
Il metodo predefinito per BIPMapping è ora balanced anziché depth. Questo nuovo obiettivo ottiene generalmente un risultato migliore, in quanto tiene conto sia della profondità del circuito che dell'errore del gate.
Il sito sort_parameters_by_name della classe VQE è stata rimossa, in seguito alla sua deprecazione in Qiskit Terra 0.18. Non ci sono alternative, poiché il nuovo ordine dei parametri è l'ordine più naturale.
I cassetti del circuito QuantumCircuit.draw() e circuit_drawer() con l'opzione latex salveranno ora le loro immagini in un formato che determina l'estensione del file (se viene fornito un nome di file). In precedenza, venivano sempre salvati in formato PNG. Ora sollevano ValueError se il formato dell'immagine non è noto. Ciò è stato fatto per facilitare il salvataggio dell'immagine in diversi formati.
La dipendenza del nucleo retworkx ha avuto il suo requisito di versione spostato a 0.10.1, da 0.9. Ciò consente di migliorare le prestazioni in diversi passaggi di transpilazione.
Il kwarg condition , precedentemente deprecato con la release 0.15.0, è stato rimosso da DAGCircuit.apply_operation_back() e DAGCircuit.apply_operation_front(). Impostare invece l'attributo condition sulle istanze Instruction che viene aggiunto al file DAGCircuit utilizzando Instruction.c_if().
Il metodo DAGCircuit.extend_back() è stato rimosso. È stato originariamente deprecato nella versione 0.13.0. Si può invece utilizzare il metodo DAGCircuit.compose() che è più generale e fornisce la stessa funzionalità.
Il metodo DAGCircuit.compose_back() è stato rimosso. È stato originariamente deprecato nella versione 0.13.0. Si può invece utilizzare il metodo DAGCircuit.compose() che è più generale e fornisce la stessa funzionalità.
Il kwarg edge_map del metodo DAGCircuit del metodo compose() è stato rimosso. È stato originariamente deprecato nella versione 0.14.0. Il metodo prende un qubits e clbits kwargs per specificare l'ordine posizionale dei bit da comporre, invece di usare una mappatura del dizionario che edge_map forniva in precedenza.
Il metodo DAGCircuit.twoQ_gates() è stato rimosso. È stato originariamente deprecato nella versione 0.13.0. Invece, DAGCircuit.two_qubit_ops() dovrebbe essere utilizzato.
Il metodo DAGCircuit.threeQ_or_more_gates() è stato rimosso. È stato originariamente deprecato nella versione 0.13.0. Invece, DAGCircuit.multi_qubit_ops() deve essere utilizzato il metodo
L'accesso con nome per il primo argomento posizionale del costruttore della classe SingleQubitUnitary con u è stato rimosso. È stato originariamente deprecato nella versione 0.14.0. Invece, il primo argomento posizionale può essere impostato usando il nome unitary_matrix (o semplicemente impostandolo in modo posizionale invece che per nome).
Accesso con nome per il primo argomento posizionale del metodo QuantumCircuit metodo squ con u è stato rimosso. È stato originariamente deprecato nella versione 0.14.0. Invece il primo argomento posizionale può essere impostato usando il nome unitary_matrix (o semplicemente impostandolo in modo posizionale invece che per nome).
Sono stati rimossi i kwarg non utilizzati di proc e nested_scope per il metodo qasm() delle classi di nodi QASM nel modulo qiskit.qasm.node . Sono stati originariamente deprecati nella versione 0.15.0.
Sono stati rimossi i kwarg non utilizzati di proc e nested_scope per il metodo latex() delle classi di nodi QASM nel modulo qiskit.qasm.node . Sono stati originariamente deprecati nella versione 0.15.0.
Sono stati rimossi i kwarg non utilizzati di proc e nested_scope per il metodo real() delle classi di nodi QASM nel modulo qiskit.qasm.node . Sono stati originariamente deprecati nella versione 0.15.0.
L'output di Statevector.draw() quando si usa l'uscita "latex" è ora la nuova convenzione "ket" se si traccia uno stato composto esclusivamente da qubit. Questa modifica è stata apportata per rendere più chiara la lettura dell'output, soprattutto in contesti educativi, perché mostra le etichette dei ket e visualizza solo gli elementi non nulli.
Quando si corre execute() con un BackendV1 i valori predefiniti per i kwarg shots, max_credits, meas_level, meas_return e memory_slot_size saranno ora quelli impostati nell'attributo del backend di destinazione options del backend di destinazione. In precedenza questi valori predefiniti erano impostati in modo da corrispondere ai valori predefiniti quando si chiamava execute() con un backend legacy BaseBackend . Ad esempio:
```
from qiskit.test.mock import FakeMumbai
from qiskit import QuantumCircuit, execute

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

backend = FakeMumbai()
backend.set_options(shots=4096)
execute(qc, backend)
```
funzionerà ora con gli scatti di 4096 . Mentre nelle versioni precedenti veniva eseguito con 1024.
La versione minima supportata di Matplotlib è stata aumentata da 2.1.0 a 3.3.0. A questo punto è necessario che sia installato Matplotlib 3.3.0 se si utilizzano funzioni di visualizzazione basate su Matplotlib, come il backend 'mpl' per la funzione circuit_drawer() o per la funzione plot_bloch_vector() funzione. Questo è stato fatto per due motivi: il primo è che le versioni recenti di Matplotlib hanno deprecato l'uso delle API per le visualizzazioni di 3D che erano compatibili con le versioni precedenti e, in secondo luogo, l'installazione di versioni precedenti di Matplotlib stava diventando sempre più difficile, dato che le dipendenze upstream di matplotlib hanno causato incompatibilità che hanno reso più difficili i test.
L'uso interno del generatore di numeri casuali in random_circuit() è stato modificato, il che cambierà l'output rispetto alle versioni precedenti, anche con un seme fisso. Ciò è stato fatto per migliorare notevolmente la scalabilità del tempo di esecuzione con il numero di qubit utilizzati. Se si dipendeva da un risultato identico di una versione precedente, si raccomanda di usare qpy_serialization.dump() per salvare il circuito casuale generato con una versione precedente e invece di rigenerarlo con la nuova versione, e di usare qpy_serialization.load() per caricare il circuito salvato.
L'uso di * (__mul__) per il metodo dot() e @ (__matmul__) per il metodo compose() di BaseOperator (che è il genitore di tutte le classi di operatori in qiskit.quantum_info comprese le classi come Operator e Pauli) non è più supportato. L'uso di questi operatori è stato precedentemente deprecato nella versione 0.17.0. Si devono invece usare i simboli dot() e compose() oppure si può usare l'operatore & (__and__) per i metodi compose(). Ad esempio, se in precedenza si utilizzava un operatore come:
```
from qiskit.quantum_info import random_hermitian

op_a = random_hermitian(4)
op_b = random_hermitian(4)

new_op = op_a @ op_b
```
questo dovrebbe essere cambiato in:
```
from qiskit.quantum_info import random_hermitian

op_a = random_hermitian(4)
op_b = random_hermitian(4)
new_op = op_a.compose(op_b)
```
oppure:
```
new_op = op_a & op_b
```
Diversi metodi di assegnazione dei parametri agli operandi delle istruzioni del programma di impulsi sono stati eliminati, essendo stati deprecati in Qiskit Terra 0.17. Queste release includono:
- il metodo assign() di pulse.Instruction.
- il metodo assign() di Channel, che è alla base di AcquireChannel, SnapshotChannel, MemorySlot e RegisterSlot.
- i metodi assign() e assign_parameters() di ParametricPulse, che è alla base di pulse.Gaussian, pulse.GaussianSquare, pulse.Drag e pulse.Constant.
Questi parametri devono essere assegnati dal programma di impulsi (pulse.Schedule e pulse.ScheduleBlock) piuttosto che operandi dell'istruzione del programma d'impulso.
Il metodo flatten() di pulse.Instruction e qiskit.pulse.Schedule è stato rimosso e non esiste più come da avviso di deprecazione di Qiskit Terra 0.17. Questa trasformazione è definita come una funzione indipendente in qiskit.pulse.transforms.canonicalization.flatten().
qiskit.pulse.interfaces.ScheduleComponent è stato rimosso e non esiste più, come da avviso di deprecazione di Qiskit Terra 0.15. Non è prevista alcuna classe alternativa.
Gli argomenti del cassetto degli impulsi sono stati rimossi da pulse.Waveform.draw(), Schedule.draw() e ScheduleBlock.draw() e non esistono più come da avviso di deprecazione di Qiskit Terra 0.16. Ora questi metodi di disegno supportano solo gli argomenti del cassetto a impulsi V2. Per maggiori dettagli, consultare la documentazione dei metodi.
Il modulo qiskit.pulse.reschedule è stato rimosso e questo percorso di importazione non esiste più, come da avviso di deprecazione di Qiskit Terra 0.14. Utilizzare qiskit.pulse.transforms invece.
Un metodo protetto Schedule._children() è stato rimosso e sostituito da una variabile di istanza protetta, come da avviso di deprecazione di Qiskit Terra 0.17. Questo è ora fornito come attributo pubblico Schedule.children.
I metodi e le proprietà relativi ai timeslot sono stati rimossi e non esistono più in ScheduleBlock come da avviso di deprezzamento di Qiskit Terra 0.17. Dal momento che questa rappresentazione non ha la nozione di tempo di istruzione t0, le informazioni sui timeslot saranno disponibili dopo la trasformazione in un file di tipo "a" Schedule. Gli attributi corrispondenti sono stati forniti dopo questa conversione, ma non sono più supportati. I seguenti attributi sono stati rimossi:
- timeslots
- start_time
- stop_time
- ch_start_time
- ch_stop_time
- shift
- insert
Le trasformazioni della pianificazione degli impulsi di allineamento sono state rimosse e non esistono più, come da avviso di deprecazione di Qiskit Terra 0.17. Queste trasformazioni sono integrate e implementate nel contesto AlignmentKind del blocco di pianificazione. Le seguenti funzioni di trasformazione esplicite vengono eliminate:
- qiskit.pulse.transforms.align_equispaced
- qiskit.pulse.transforms.align_func
- qiskit.pulse.transforms.align_left
- qiskit.pulse.transforms.align_right
- qiskit.pulse.transforms.align_sequential
I comandi ridondanti del costruttore di impulsi sono stati rimossi e non esistono più, come da avviso di deprecazione di Qiskit Terra 0.17. pulse.builder.call_schedule e pulse.builder.call_circuit sono stati integrati in pulse.builder.call().
È stato rimosso un filtro interno che causava la visualizzazione di tutti gli avvisi di deprezzamento di Qiskit. Ciò significa che il comportamento tornerà a quello standard di Python per le deprecazioni; si dovrebbe vedere un DeprecationWarning solo se è stato attivato da codice nel file di script principale, nella sessione dell'interprete o nel taccuino Jupyter. L'utente non verrà più rimproverato con un avviso se le funzioni interne di Qiskit richiamano un comportamento deprecato. Se si scrivono librerie, di tanto in tanto si dovrebbe eseguire con i filtri di avviso predefiniti disabilitati, oppure avere dei test che vengono eseguiti sempre con essi disabilitati. Si veda la documentazione di Python sugli avvertimenti e in particolare la sezione sui test per le deprecazioni per maggiori informazioni su come farlo.
Alcuni avvisi venivano emessi una sola volta, anche se attivati da più punti. Questo comportamento è stato rimosso, quindi è possibile che se si chiamano funzioni deprecate, si vedano più avvisi rispetto a prima. È necessario modificare tutte le chiamate di funzione deprecate con le versioni suggerite, perché i moduli deprecati saranno rimossi nelle future versioni di Qiskit.
Il modulo deprecato qiskit.schemas e il modulo qiskit.validation , che costruiva il validatore jsonschema dagli schemi, sono stati rimossi. Questo è stato deprecato nella versione 0.17.0 ed è stato sostituito da un repository dedicato per gli schemi dei payload dell'API IBM Quantum.

Se ci si affidava ai file di schema precedentemente impacchettati in qiskit.schemas o ai validatori costruiti su di essi, si deve usare quel repository e creare i validatori dai file di schema che contiene.
Le funzioni qiskit.qobj.validate_qobj_against_schema e qiskit.qobj.common.validator insieme al kwarg validate dei metodi QasmQobj.to_dict(), PulseQobj.to_dict(), e Qobj.to_dict() sono stati rimossi. Questi sono stati deprecati nella versione 0.17.0. Se si utilizzano queste funzioni, è necessario costruire manualmente le funzioni di convalida jsonschema per gli oggetti Qobj , utilizzando i file jsonschema dal repository dedicato agli schemi dei payload dell'API IBM Quantum.
I pacchetti fastjsonschema e jsonschema non sono più presenti nell'elenco dei requisiti di qiskit-terra. L'uso interno di jsonschema è stato rimosso e non è più necessario utilizzare qiskit-terra.
L'eccezione sollevata dalla funzione assemble() quando vengono passati parametri non validi per la costruzione di un file PulseQobj è passata da SchemaValidationError a QiskitError. Questo è stato necessario perché la classe SchemaValidationError è stata rimossa insieme al resto delle classi deprecate qiskit.schemas e qiskit.validation. Questo lo rende anche più coerente con le altre condizioni di errore di assemble() che già sollevavano un errore QiskitError.
Il passaggio di routing e il passaggio di layout predefiniti per il livello di ottimizzazione 3 del transpiler sono stati modificati in modo da usare SabreSwap e SabreLayout rispettivamente. Questo è stato fatto per migliorare la qualità del risultato in uscita, poiché l'uso dei passaggi a sciabola produce risultati migliori rispetto all'uso di StochasticSwap e DenseLayoutche erano utilizzati come predefiniti nelle versioni precedenti. Questa modifica migliorerà la qualità dei risultati durante l'esecuzione di transpile() o execute() con il kwarg optimization_level impostato su 3. Sebbene questo sia generalmente un miglioramento, se per qualche motivo è necessario mantenere il comportamento precedente, è possibile farlo impostando esplicitamente i parametri routing_method="stochastic" e layout_method="dense" quando si richiama il comando transpile() con optimization_level=3.
Il tipo di ritorno di pauli_basis() cambierà da PauliTable a PauliList in una futura versione di Qiskit Terra. Per passare immediatamente al nuovo comportamento, passare l'argomento parola chiave pauli_list=True.
L'attributo name della classe SingleQubitUnitary è stato modificato da unitary a squ. Questo è stato necessario per evitare un conflitto con il nome della classe UnitaryGate , anch'esso unitary , poiché i due gate non sono uguali e non hanno la stessa implementazione (e non possono essere usati in modo intercambiabile).
La versione minima di Symengine richiesta per l'installazione è stata aumentata a 0.8.0. Questo è stato necessario per risolvere alcuni problemi con la gestione dei valori di numpy.float16 e numpy.float32 quando si esegue bind() per vincolare i parametri in un file ParameterExpression.
All'elenco dei requisiti è stato aggiunto un nuovo stivatore dipendente. È richiesto da qiskit-terra perché viene utilizzato per costruire l'interfaccia del plugin di sintesi unitaria.

Note di deprecazione

L'attributo gate e il parametro di inizializzazione di qiskit.transpiler.passes.Decompose è deprecato e sarà rimosso in una versione futura. Invece di questo singolo gate, si deve passare un elenco di nomi di gate al nuovo parametro gates_to_decompose. Questo è stato fatto perché il nuovo modulo consente di selezionare più di un gate come target di decomposizione, il che è più flessibile, e non richiede di rieseguire il passaggio più volte per decomporre un insieme di gate.

C'è stata una significativa riorganizzazione del passaggio del transpiler per quanto riguarda le calibrazioni. I percorsi di importazione:

from qiskit.transpiler.passes.scheduling.calibration_creators import RZXCalibrationBuilder
from qiskit.transpiler.passes.scheduling.calibration_creators import RZXCalibrationBuilderNoEcho

sono deprecati e saranno rimossi in una prossima versione. Il percorso di importazione:

from qiskit.transpiler.passes.scheduling.rzx_templates import rzx_templates

è anch'esso deprecato e sarà rimosso in una prossima versione. È necessario utilizzare i nuovi percorsi di importazione:

from qiskit.transpiler.passes import RZXCalibrationBuilder
from qiskit.transpiler.passes import RZXCalibrationBuilderNoEcho
from qiskit.transpiler.passes.calibration.rzx_templates import rzx_templates

La classe DAGNode viene deprecata come classe a sé stante e sarà utilizzata in futuro solo come classe genitore per le classi DAGOpNode, DAGInNode, e DAGOutNode. Come parte di questa deprecazione, i seguenti kwarg e attributi associati in DAGNode vengono anch'essi deprecati: type, op, e wire.
Per il costruttore della classe RZXCalibrationBuilder passare un backend come primo parametro posizionale o con il kwarg backend è deprecato e non funzionerà più in una prossima versione. Invece un InstructionScheduleMap dovrebbe essere passato direttamente al kwarg instruction_schedule_map e un elenco di liste di nomi di canali per ogni qubit dovrebbe essere passato direttamente a qubit_channel_mapping. Ad esempio, se si chiama il passaggio come:
```
from qiskit.transpiler.passes import RZXCalibrationBuilder
from qiskit.test.mock import FakeMumbai

backend = FakeMumbai()
cal_pass = RZXCalibrationBuilder(backend)
```
invece si dovrebbe chiamare come:
```
from qiskit.transpiler.passes import RZXCalibrationBuilder
from qiskit.test.mock import FakeMumbai

backend = FakeMumbai()
inst_map = backend.defaults().instruction_schedule_map
channel_map = self.backend.configuration().qubit_channel_mapping
cal_pass = RZXCalibrationBuilder(
    instruction_schedule_map=inst_map,
    qubit_channel_mapping=channel_map,
)
```
Questa modifica è necessaria perché di norma gli oggetti del backend non sono serializzabili con pickle e si romperebbe quando viene usato con più processi all'interno di transpile() quando si compilano più circuiti contemporaneamente.
La proprietà label della classe MCMT e sottoclasse MCMTVChain è stata deprecata e sarà rimossa in una prossima versione. Di conseguenza, anche il kwarg label del costruttore di entrambe le classi è deprecato, insieme al kwarg label del metodo MCMT.control(). Attualmente, la proprietà label viene utilizzata per denominare il target controllato quando è composto da più di un qubit target; tuttavia, questa proprietà non è mai stata pensata per essere specificabile dall'utente e può determinare un gate MCMT errato se viene utilizzato il nome di un'operazione nota. Dopo la deprecazione, la proprietà label non sarà più specificabile dall'utente. Tuttavia, è possibile ottenere il nome generato della destinazione controllata tramite
```
MCMT.data[0][0].base_gate.name
```
Il metodo subgraph() della classe CouplingMap è deprecato e sarà rimosso in una prossima versione. Al posto del metodo reduce() che fa la stessa cosa, tranne che per il fatto che preserva l'ordine dell'elenco dei nodi per l'output CouplingMap (mentre subgraph() non preserva l'ordine dell'elenco).

La creazione di un'istanza di InstructionSet con l'argomento della parola chiave circuit_cregs è deprecata. In generale, queste classi non devono mai essere costruite dagli utenti (ma sono usate internamente), ma se fosse necessario, si dovrebbe passare un callable come argomento della parola chiave resource_requester . Ad esempio:

from qiskit.circuit import Clbit, ClassicalRegister, InstructionSet
from qiskit.circuit.exceptions import CircuitError

def my_requester(bits, registers):
    bits_set = set(bits)
    bits_flat = tuple(bits)
    registers_set = set(registers)

    def requester(specifier):
        if isinstance(specifer, Clbit) and specifier in bits_set:
            return specifier
        if isinstance(specifer, ClassicalRegster) and specifier in register_set:
            return specifier
        if isinstance(specifier, int) and 0 <= specifier < len(bits_flat):
            return bits_flat[specifier]
        raise CircuitError(f"Unknown resource: {specifier}")

    return requester

my_bits = [Clbit() for _ in [None]*5]
my_registers = [ClassicalRegister(n) for n in range(3)]

InstructionSet(resource_requester=my_requester(my_bits, my_registers))

L'uso delle classi di attenuazione delle misure qiskit.ignis.mitigation.CompleteMeasFitter e qiskit.ignis.mitigation.TensoredMeasFitter da qiskit-ignis come valori per il kwarg measurement_error_mitigation_cls del costruttore per la classe QuantumInstance è deprecato e sarà rimosso in una prossima versione. Invece le classi equivalenti di qiskit.utils.mitigation, CompleteMeasFitter e TensoredMeasFitter dovrebbero essere utilizzate. Questo si è reso necessario perché il progetto qiskit-ignis è ormai deprecato e non sarà più supportato nel prossimo futuro. Vale la pena notare che, a differenza delle classi equivalenti di qiskit-ignis , le versioni di qiskit.utils.mitigation sono supportate solo nel loro uso con QuantumInstance (cioè come classe e non come istanza con il kwarg measurement_error_mitigation_cls ) e non sono destinate a un uso indipendente.

Il metodo Optimizer.optimize() per tutti gli ottimizzatori (Optimizer e classi derivate) è ora deprecato e sarà rimosso in una prossima versione. Si deve invece utilizzare il metodo Optimizer.minimize() che imita la firma della funzione SciPy’s minimize() .

Per sostituire l'attuale chiamata di ottimizzazione con quella di minimizzazione, si può sostituire

xopt, fopt, nfev = optimizer.optimize(
    num_vars,
    objective_function,
    gradient_function,
    variable_bounds,
    initial_point,
)

con

result = optimizer.minimize(
    fun=objective_function,
    x0=initial_point,
    jac=gradient_function,
    bounds=variable_bounds,
)
xopt, fopt, nfev = result.x, result.fun, result.nfev

L'importazione del modulo qiskit.util emetterà ora un DeprecationWarning. Gli utenti dovrebbero invece importare tutte le stesse funzionalità da qiskit.utils. Il modulo util è stato deprecato da Terra 0.17, ma in precedenza non ha emesso alcun avviso. Verrà rimosso in Terra 0.20.
La proprietà table è deprecata e sarà rimossa in una versione futura. Questo perché SparsePauliOp è stato aggiornato per utilizzare internamente PauliList invece di PauliTable. Questo per migliorare in modo significativo le prestazioni. Ora si dovrebbe accedere ai dati PauliList utilizzando l'attributo SparsePauliOp.paulis .

Correzioni di bug

È stato risolto un problema a causa del quale molti metodi di layout ignoravano le porte a 3 o più qubit, con conseguenti decisioni inattese sull'allocazione del layout. Il passaggio del transpiler Unroll3qOrMore viene ora eseguito prima del passaggio di layout in tutti i gestori di passaggi preimpostati quando viene chiamato transpile() viene chiamato. Corretto #7156.
I circuiti smontati ereditano ora le calibrazioni dei circuiti assemblati e degli esperimenti QasmQobj ed esperimenti. Correzioni #5348.
Corretta l'impostazione degli attributi ansatz o optimizer di un'istanza a che comportava un comportamento anomalo VQE a None , che comportava un comportamento difettoso. Per i dettagli, vedere il numero 7093.
Corretta l'aggiunta di PauliLists con qargs. Il metodo utilizzato per sollevare un errore di runtime se gli operandi hanno un numero diverso di qubit.
Corretto un problema che causava un errore quando si cercava di calcolare un gradiente con la classe CircuitGradient per un cancello che non era un cancello supportato. Questo bugfix trasporta un dato gate nell'insieme dei gate supportati per un metodo di gradiente richiesto. Correzioni #6918.
Rimossi i risultati della calibrazione quando si utilizza la mitigazione degli errori con il metodo di execute() metodo di QuantumInstance. Correzioni #7129.
Corretto un avviso di deprecazione emesso quando si esegue il comando QuantumCircuit.draw() o circuit_drawer() con Sympy 1.9 installato, menzionando la funzione Sympy expr_free_symbols(). I disegnatori di circuiti hanno utilizzato questo metodo per trovare istanze di costanti simboliche.
È stato risolto un problema a causa del quale il kwarg di ax e l'opzione figwidth nel kwarg di style per il cassetto del circuito mpl non venivano scalati correttamente. Gli utenti possono ora passare un ax da una sottotrama Matplotlib al cassetto dei circuiti mpl e il circuito verrà disegnato entro i confini della sottotrama. In alternativa, gli utenti possono impostare figwidth in pollici nel dict kwarg di style e il disegno verrà scalato alla larghezza in pollici impostata. Corretto #6367.
Corretto un problema con la funzione circuit_drawer() e il metodo draw() di QuantumCircuit. Quando si visualizza un'istruzione measure mirata a un bit classico invece che a un registro, utilizzando l'opzione del cassetto latex , il cassetto fallisce.
Corretto un problema con la funzione circuit_drawer() e il metodo draw() di QuantumCircuit. Con una qualsiasi delle 3 opzioni di cassetto, mpl, latex, o text, se si incontra un gate con una condizione classica condizionata su un bit classico senza registro, il cassetto fallisce.
Corretto un problema con la funzione circuit_drawer() e il metodo draw() di QuantumCircuit. Con una qualsiasi delle 3 opzioni di cassetto, mpl, latex, o text, se un cancello con una condizione classica fosse condizionato sullo stesso bit classico di un measure e il bit a cui la misura si rivolge non avesse un registro, il cassetto fallirebbe.
C3SXGate ha ora una decomposizione e una rappresentazione matriciale corretta. In precedenza equivaleva a SdgXGate().control(3), anziché al previsto SXGate().control(3).
Il membro name di qiskit.test.mock.utils.ConfigurableFakeBackend è stato cambiato in backend_name. Questo è stato fatto per evitare un conflitto con il metodo name() ereditato dalla classe madre astratta BackendV1 genitore. Questo rende ConfigurableFakeBackend compatibile con tutto ciò che si aspetta un oggetto BackendV1 oggetto. Tuttavia, se prima si utilizzava direttamente l'attributo name , ora è necessario richiamarlo come metodo o accedere all'attributo backend_name .
È stato risolto un problema per cui la chiamata QuantumCircuit.decompose() su un circuito contenente un elemento Instruction il cui attributo definition era vuoto, lasciava l'istruzione al suo posto, invece di scomporla in zero operazioni. Ad esempio, con un circuito:
```
from qiskit.circuit import QuantumCircuit
empty = QuantumCircuit(1, name="decompose me!")
circuit = QuantumCircuit(1)
circuit.append(empty.to_gate(), [0])
```
In precedenza, chiamando circuit.decompose() non si cambiava il circuito. Ora, la decomposizione corretta decomporrà empty in zero istruzioni. Per saperne di più, vedere il numero 6997.
Corretto un problema con la funzione circuit_drawer() e il metodo draw() di QuantumCircuit. Quando si visualizzava un'istruzione measure contenente un classico condition utilizzando le opzioni mpl o latex , le informazioni di condition a volte sovrascrivevano la visualizzazione di measure .
Corretto un problema con la funzione circuit_drawer() e il metodo draw() di QuantumCircuit. Il cassetto mpl utilizza la notazione esadecimale per visualizzare il valore di condition , mentre i cassetti text e latex utilizzano la notazione decimale. Ora tutti e tre i cassetti utilizzano la notazione esadecimale.
Corretto un bug nel passaggio di transpilazione dell'ottimizzatore Hoare che poteva tentare di rimuovere due volte un cancello se poteva essere combinato separatamente con il suo predecessore e il suo successore per formare l'identità. Per maggiori dettagli, consultare il documento #7271.
La creazione di un'istruzione condizionale con il metodo standard InstructionSet.c_if() con indici interi è ora coerente con lo schema di numerazione utilizzato dal sistema di istruzioni QuantumCircuit di cui le istruzioni fanno parte. In precedenza, se c'erano due ClassicalRegistercon sovrapposizioni di Clbitla numerazione sarebbe stata errata. Vedere #7246 per maggiori dettagli.
La creazione di un'istruzione condizionale con il metodo standard InstructionSet.c_if() avrà successo, anche se non ci sono istruzioni ClassicalRegisternel circuito. Per maggiori dettagli, vedere il numero 7250.
La creazione di un'istruzione condizionale con il metodo standard InstructionSet.c_if() quando si utilizza un elemento Clbit che è contenuto in un registro ClassicalRegister di dimensione uno ora creerà correttamente una condizione sul bit, non sul registro. Vedere #7255 per maggiori dettagli.
Il tentativo di rendere condizionale un'istruzione con il metodo standard InstructionSet.c_if() ora solleva correttamente un errore se la risorsa classica non è presente nel circuito. Vedere #7255 per maggiori dettagli.
È stato risolto un problema di compatibilità con Matplotlib 3.5, a causa del quale la sfera di Bloch non veniva renderizzata se aveva dei vettori collegati, come ad esempio usando plot_bloch_vector. Per maggiori dettagli, vedere #7272.
Corretto un problema con il metodo NLocal.add_layer() aggiungeva erroneamente i livelli se l'oggetto NLocal era già stato costruito.
Corretto un problema con il decapaggio dell'oggetto InstructionScheduleMap quando si usa Python 3.6. Per i dettagli, vedere il numero #6944.

È stata corretta l'assegnazione dei parametri degli impulsi a valore complesso con symengine. Ad esempio:

from qiskit import circuit, pulse
import numpy as np

amp = circuit.Parameter("amp")
phase = circuit.Parameter("phase")

with pulse.build() as sched:
    pulse.play(pulse.Gaussian(160, amp * np.exp(1j * phase), 40), pulse.DriveChannel(0))
sched.assign_parameters({amp: 0.1, phase: 1.57}, inplace=True)

L'ampiezza assegnata è stata indicata come ParameterExpression(0.1*exp(1.57*I)) dopo l'introduzione dell'uso di symengine nella release 0.18.0. Ora viene valutato correttamente e mostrato come 7.96327e-05 + 0.0999999683j.

Corretto un problema per cui QAOA.construct_circuit() con operatori diversi con lo stesso numero di qubit generava ogni volta lo stesso circuito. Per maggiori dettagli, vedere il numero 7223.
È stato risolto un problema per cui QAOAAnsatz aveva un numero errato di parametri se venivano fornite le identità di PauliSumOp , ad esempio PauliSumOp.from_list([("III", 1)]). Per maggiori dettagli, vedere il numero 7225.
È stato risolto un problema per cui il metodo QuantumCircuit.qasm() poteva restituire istruzioni OpenQASM 2 con identificatori non validi. Lo stesso bug è stato risolto per UnitaryGate.
È stato risolto un problema a causa del quale il tentativo di visualizzare i bit senza registro causava un guasto a mpl e ai cassetti del circuito latex . È stato rimosso l'iniziale _ dalla visualizzazione dei numeri dei bit senza registro nel cassetto text . Corretto #6732.
Per i registri a un bit, tutti i cassetti dei circuiti visualizzano ora solo il nome del registro e non mostrano più il pedice 0 . Corretto #5784.
Corrette le collisioni di denominazione dei registri impliciti in QuantumCircuit.qasm quando si tratta di qubit e clbit senza registro. In precedenza, i qubit e i clbit senza registro venivano inseriti nei corrispondenti qreg e creg , entrambi chiamati regless, nonostante la collisione. Ora avranno nomi separati, generati in modo deterministico, che non si scontreranno con i nomi dei registri definiti dall'utente nel circuito.
È stato risolto un problema nella programmazione di circuiti con operazioni di clbits, ad esempio misure, porte condizionali, aggiornamenti, ecc ASAPSchedule, ALAPSchedule, e AlignMeasures. Gli schedulatori aggiornati assumono che tutte le operazioni di I/O in clbit non richiedano tempo, measure scrive il valore misurato in un clbit alla fine e c_if legge il valore condizionale in clbit all'inizio. Corretto #7006.
La chiamata a transpile su un elenco vuoto ora restituisce correttamente un elenco vuoto senza emettere un avviso. Corretto #7287.
Corretto un problema in PiecewiseChebyshev quando la funzione da approssimare era costante. In questi casi, si deve passare la costante direttamente come argomento di f_x , invece di usare una funzione, come ad esempio:
```
from qiskit.circuit.library.arithmetic import PiecewiseChebyshev

PiecewiseChebyshev(1.0, degree=3)
```
Per maggiori dettagli, vedere il numero 6707.
Se un'istanza dell'algoritmo HHL è stata costruita senza un attributo QuantumInstance (il valore predefinito), i tentativi di usare le proprietà getter e setter per leggere o impostare un'istanza in seguito fallirebbero. I getter e i setter ora funzionano come previsto.
Il metodo QuantumCircuit.qasm() modifica ora i nomi delle copie delle istruzioni presenti nel circuito, non le istruzioni originali che vivono in circuit.data. Per maggiori dettagli, consultare il numero 6952.
Corretto un bug in PauliSumOp.permute() che causava un errore:
```
QiskitError: 'Pauli string label "" is not valid.'
```
se la permutazione avesse lo stesso numero di termini di Pauli. La chiamata a permute([2, 1, 0]) su X ^ Y ^ Z non genera più un errore e ora restituisce Z ^ Y ^ X.
È stato risolto un problema a causa del quale i limiti dei parametri del mixer nell'opzione QAOAAnsatz non venivano impostati.
Determinazione fissa delle operazioni finali (barriere e misure) in passaggio RemoveFinalMeasurements e nel metodo remove_final_measurements() della classe QuantumCircuit che in precedenza consideravano solo i nodi immediatamente precedenti a un nodo di uscita.
Determinazione fissa delle operazioni finali in pass RemoveFinalMeasurements e nel metodo remove_final_measurements() della classe QuantumCircuit che poteva considerare erroneamente una barriera come definitiva, anche se altre operazioni del circuito la seguivano.
Rimozione corretta del registro classico a più bit nel passaggio RemoveFinalMeasurements e nel metodo remove_final_measurements() della classe QuantumCircuit in cui i registri classici non venivano rimossi anche se gli altri bit erano inattivi, a meno che non venisse eseguita una misura finale in ogni singolo bit. Ora, i registri classici che diventano inattivi in seguito alla rimozione delle misure e delle barriere finali vengono sempre rimossi. I bit classici vengono rimossi se sono referenziati solo dai registri rimossi o non sono referenziati affatto e sono diventati inattivi a causa della rimozione. Questa correzione aggiunge anche una gestione corretta dei registri con bit sottostanti condivisi.
È stato risolto un problema con RemoveFinalMeasurements che poteva causare l'invalidità del risultato di DAGCircuit diventava non valido. Per maggiori dettagli, vedere il numero 7196.
Corretto un problema con il metodo remove_final_measurements() della classe QuantumCircuit che causava l'errore di QuantumCircuit.clbits non era corretto dopo l'invocazione. Per i dettagli, fare riferimento al numero 7089.
Quando si rastrema un operatore zero vuoto in qiskit.opflowil codice, dopo aver rilevato che si trattava di uno zero, registrava un avviso e restituiva l'operatore originale. Tali operatori si trovano comunemente negli operatori ausiliari, quando si usa Qiskit Nature, e il comportamento di cui sopra ha fatto sì che VQE lanciasse un'eccezione, poiché gli operatori non-zero rastremati erano un numero diverso di qubit rispetto agli operatori zero rastremati (poiché taper ha restituito l'operatore di input invariato). Il codice ora rastremerà correttamente un operatore nullo in modo che il numero di qubit si riduca come previsto e corrisponderà agli operatori non nulli rastremati, ad esempio `0*"IIII"` quando si rastrema di 3 qubit diventerà 0*"I".
Corretto un problema con il metodo draw() e la funzione circuit_drawer() in cui uno stile personalizzato impostato tramite il file di configurazione dell'utente (ad es. settings.conf) ignorerebbe il valore impostato del campo circuit_mpl_style se il kwarg style sulla funzione/metodo non è impostato.

Altre note

Il cast di stringhe per qiskit.circuit.ParameterExpression non ha più una precisione completa. Questo rimuove l'errore di 0s quando si stampano i parametri legati ai float. Ciò ha conseguenze sulla serializzazione QASM e sul cassetto di testo del circuito:
```
>>> from qiskit.circuit import Parameter
>>> x = Parameter('x')
>>> str(x.bind({x:0.5}))
'0.5'   # instead of '0.500000000000000'
```
Il QAOAAnsatz è stato aggiornato per utilizzare il simbolo di parametro γ per l'operatore di costo e β per l'operatore di miscelazione, come da notazione standard nella letteratura QAOA.

Aer 0.9.1

Nessuna modifica

Ignis 0.7.0

Preludio

Questo rilascio depreca il progetto Qiskit Ignis, che è stato sostituito dal progetto Qiskit Experiments e il cui sviluppo attivo è cessato. Anche se deprecato, le correzioni di bug critici e di compatibilità continueranno a essere effettuate per dare agli utenti una sufficiente opportunità di migrare da Ignis. Dopo il periodo di deprezzamento (che non sarà inferiore a 3 mesi da questo rilascio) il progetto sarà ritirato e archiviato.

Nuove funzioni

Aggiornato il protocollo di accreditamento per utilizzare la routine di adattamento da https://arxiv.org/abs/2103.06603. AccreditationFitter ha ora i metodi FullAccreditation (protocollo precedente) e MeanAccreditation (nuovo protocollo). Inoltre, l'inserimento dei dati è stato modificato per utilizzare l'oggetto risultato AppendResult o un elenco di stringhe AppendStrings. qiskit.ignis.verification.QOTPCorrectString() è stato aggiunto.
Aggiunta l'opzione per la generazione analitica veloce dei grafici delle sindromi. RepetitionCode ha ora un nuovo argomento bool brute, che consente di utilizzare ancora il metodo della forza bruta. È stata aggiunta la classe di aiuto RepetitionCodeSyndromeGenerator per facilitare questa operazione.
Il comando RepetitionCode ha ora gli argomenti delle parole chiave resets e delay. Il primo determina se le porte di reset vengono inserite dopo la misurazione. Quest'ultimo consente di specificare un tempo (in dt) per il ritardo dopo ogni misurazione (e l'eventuale reset).

Il metodo syndrome_measurement() di RepetitionCode ha ora gli argomenti delle parole chiave final e delay. Il primo determina se aggiungere le porte di ripristino in base al sito globale resets, o se sovrascriverlo con un comportamento appropriato per il ciclo finale di misurazioni della sindrome. Quest'ultimo consente di specificare un tempo (in dt) per il ritardo dopo ogni misurazione (e l'eventuale reset).
La classe RepetitionCode supporta ora la codifica con stati base x. Questo può essere utilizzato impostando l'argomento della parola chiave xbasis quando si costruisce un oggetto RepetitionCode .

Note sull'aggiornamento

L'argomento parola chiave reset è stato rimosso dal metodo syndrome_measurement() di RepetitionCode. Questo viene sostituito dall'argomento globale resets per la classe e dall'argomento final per syndrome_measurement. Nei casi in cui in precedenza si aggiungeva il giro di misura finale usando reset=False per evitare le porte di reset finali, ora si dovrebbe usare final=True.
Rimuovere ParametrizedSchedule da update_u_gates().

ParametrizedSchedule è stato deprecato come parte di Qiskit-terra 0.17.0 e sarà rimosso nella prossima versione. La funzione ora aggiorna le porte u con i programmi Schedule che coinvolgono oggetti Parameter non assegnati.

Note di deprecazione

Metodi deprecati in AccreditationFitter , ovvero bound_variation_distance e single_protocol_run
Il progetto Qiskit Ignis nel suo complesso è stato deprecato e il progetto sarà ritirato e archiviato in futuro. Anche se deprecato, al progetto verranno apportate solo correzioni di compatibilità e correzioni di bug critici. Invece di utilizzare Qiskit Ignis, dovreste migrare verso Qiskit Experiments. È possibile consultare la guida alla migrazione:

https://github.com/qiskit-community/qiskit-ignis#migration-guide

Questa pagina è stata utile?

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