Note di rilascio di Qiskit 0.28

0.28.0

Terra 0.18.0

Preludio

Questa versione include molte nuove funzionalità e correzioni di bug. I punti salienti di questa release sono l'introduzione di due nuovi passaggi del transpiler, BIPMapping e DynamicalDecouplingche, combinati con il nuovo kwarg pulse_optimize sul passaggio UnitarySynthesis permette di ricreare i risultati del Quantum Volume 64 utilizzando le tecniche descritte in: https://arxiv.org/abs/2008.08571. Questi nuovi passaggi e opzioni del transpiler sono applicabili in generale all'ottimizzazione di qualsiasi circuito.

Nuove funzioni

Il kwarg measurement_error_mitgation per il costruttore QuantumInstance può ora essere impostato sulla classe TensoredMeasFitter di qiskit-ignis, oltre a CompleteMeasFitter che era già supportata. Se si usa TensoredMeasFitter si potrà anche impostare il nuovo kwarg mit_pattern per specificare i qubit su cui usare TensoredMeasFitter Si può fare riferimento alla documentazione di mit_pattern nella documentazione di TensoredMeasFitter per il formato previsto.
I metodi di decomposizione per porte a singolo qubit, specificati tramite il kwarg basis , in OneQubitEulerDecomposer è stata ampliata per includere anche la base 'ZSXX' , per fare uso della porta diretta $X$ e della porta $\sqrt{X}$ .
Aggiunti due nuovi passaggi AlignMeasures e ValidatePulseGates al modulo qiskit.transpiler.passes modulo. Questi passaggi sono un'ottimizzazione consapevole dell'hardware e una routine di convalida utilizzata per gestire le restrizioni di allineamento sull'allocazione temporale delle istruzioni per un backend.

Se un backend ha una restrizione sull'allineamento delle istruzioni Measure (in termini di quantizzazione nel tempo), il passaggio viene utilizzato per regolare i ritardi in un circuito programmato per garantire che tutte le istruzioni nel circuito siano allineate in base ai vincoli del backend AlignMeasures viene utilizzato per regolare i ritardi in un circuito programmato, in modo da garantire l'allineamento delle istruzioni Measure nel circuito, in base ai vincoli del backend. Il passaggio ValidatePulseGates è usato per verificare se ci sono gate a impulsi personalizzati (gate che hanno una definizione di impulso personalizzato nell'attributo calibrations dell'attributo QuantumCircuit ) sono validi, dato un vincolo di allineamento per il backend di destinazione.

Nel built-in preset_passmangers utilizzato dalla funzione transpile() questi passaggi vengono automaticamente attivati se il vincolo di allineamento, tramite il kwarg dedicato timing_constraints su transpile() o ha un attributo timing_constraints nell'oggetto BackendConfiguration del backend a cui ci si rivolge.

I backend di IBM Quantum Services (accessibili tramite il pacchetto qiskit-ibmq-provider ) forniranno le informazioni sull'allineamento nel prossimo futuro.

Ad esempio:
```
from qiskit import circuit, transpile
from qiskit.test.mock import FakeArmonk

backend = FakeArmonk()

qc = circuit.QuantumCircuit(1, 1)
qc.x(0)
qc.delay(110, 0, unit="dt")
qc.measure(0, 0)
qc.draw('mpl')
```
```
qct = transpile(qc, backend, scheduling_method='alap',
                timing_constraints={'acquire_alignment': 16})
qct.draw('mpl')
```
È stato aggiunto un nuovo passaggio del transpiler qiskit.transpiler.passes.BIPMapping che cerca di trovare il miglior layout e il miglior instradamento in una sola volta, risolvendo un problema di BIP (programmazione binaria degli interi) come descritto in arXiv:2106.06446 è stata aggiunta.

Il passaggio BIPMapping (denominato "mapping" per riferirsi a "layout e routing") rappresenta il problema del mapping come un problema BIP (programmazione binaria degli interi) e si affida a CPLEX (cplex) per risolvere il problema BIP. Le librerie dipendenti, tra cui CPLEX, possono essere installate insieme a qiskit-terra:
```
pip install qiskit-terra[bip-mapper]
```
Poiché la versione gratuita di CPLEX è in grado di risolvere solo piccoli problemi di BIP, cioè la mappatura di circuiti con meno di 5 qubit circa, per mappare circuiti più grandi potrebbe essere necessaria la versione a pagamento di CPLEX.

Il mappatore BIP scala male rispetto al numero di qubit o di porte. Ad esempio, non funzionerebbe con coupling_map oltre i 10 qubit perché il solutore BIP (CPLEX) non potrebbe trovare alcuna soluzione entro il limite di tempo predefinito.

Si noti che, se si desidera fissare i qubit fisici da utilizzare nella mappatura (ad esempio per l'esecuzione di circuiti Quantum Volume (QV)), è necessario specificare coupling_map che contiene solo i qubit da utilizzare.

Ecco un esempio minimo di codice per costruire un gestore di passaggi per transpilare un circuito QV:
```
num_qubits = 4  # QV16
circ = QuantumVolume(num_qubits=num_qubits)

backend = ...
basis_gates = backend.configuration().basis_gates
coupling_map = CouplingMap.from_line(num_qubits)  # supply your own coupling map

def _not_mapped(property_set):
    return not property_set["is_swap_mapped"]

def _opt_control(property_set):
    return not property_set["depth_fixed_point"]

from qiskit.circuit.equivalence_library import SessionEquivalenceLibrary as sel
pm = PassManager()
# preparation
pm.append([
    Unroll3qOrMore(),
    TrivialLayout(coupling_map),
    FullAncillaAllocation(coupling_map),
    EnlargeWithAncilla(),
    BarrierBeforeFinalMeasurements()
])
# mapping
pm.append(BIPMapping(coupling_map))
pm.append(CheckMap(coupling_map))
pm.append(Error(msg="BIP mapper failed to map", action="raise"),
          condition=_not_mapped)
# post optimization
pm.append([
    Depth(),
    FixedPoint("depth"),
    Collect2qBlocks(),
    ConsolidateBlocks(basis_gates=basis_gates),
    UnitarySynthesis(basis_gates),
    Optimize1qGatesDecomposition(basis_gates),
    CommutativeCancellation(),
    UnrollCustomDefinitions(sel, basis_gates),
    BasisTranslator(sel, basis_gates)
], do_while=_opt_control)

transpile_circ = pm.run(circ)
```
Un nuovo metodo costruttore initialize_from() è stato aggiunto agli elementi Schedule e ScheduleBlock e alle classi. Questo metodo inizializza un nuovo programma vuoto che prende gli attributi da altri programmi. Ad esempio:
```
sched = Schedule(name='my_sched')
new_sched = Schedule.initialize_from(sched)

assert sched.name == new_sched.name
```
È stato aggiunto un nuovo kwarg, line_discipline, alla funzione job_monitor() alla funzione. Questa kwarg consente di modificare i caratteri di ritorno a capo usati nell'output di job_monitor . Il kwarg line_discipline ha come valore predefinito '\r', che è quello utilizzato in precedenza.
La classe astratta Pulse (che è la classe genitore di classi quali Waveform, Constant, e Gaussian ha ora un nuovo kwarg sul costruttore, limit_amplitude, che può essere impostato su False per disabilitare il limite di ampiezza precedentemente codificato di 1. Questo può anche essere impostato direttamente come attributo di classe, per modificare il valore predefinito globale di una classe Pulse. Ad esempio:
```
from qiskit.pulse.library import Waveform

# Change the default value of limit_amplitude to False
Waveform.limit_amplitude = False
wave = Waveform(2.0 * np.exp(1j * 2 * np.pi * np.linspace(0, 1, 1000)))
```
Una nuova classe, PauliListè stata aggiunta al modulo qiskit.quantum_info modulo. Questa classe viene utilizzata per rappresentare in modo efficiente una lista di Pauli operatori. Questa nuova classe eredita dalla stessa classe madre dell'esistente PauliTable (e quindi può essere usata per lo più in modo intercambiabile), ma si differenzia da PauliTable perché la classe può gestire le fasi di qiskit.quantum_info.PauliList può gestire le fasi di Z4.
Aggiunto un nuovo passaggio di transpiler, RemoveBarriers, a qiskit.transpiler.passes. Questo passaggio viene utilizzato per rimuovere tutte le barriere in un circuito.
Aggiungere una nuova classe di ottimizzatori, SciPyOptimizeral modulo qiskit.algorithms.optimizers al modulo. Questa classe è una semplice classe wrapper della funzione scipy.optimize.minimize (documentazione ) che consente di utilizzare tutti i solutori di ottimizzazione e tutti i parametri (ad es. callback) supportati da scipy.optimize.minimize. Ad esempio:
```
from qiskit.algorithms.optimizers import SciPyOptimizer

values = []

def callback(x):
    values.append(x)

optimizer = SciPyOptimizer("BFGS", options={"maxiter": 1000}, callback=callback)
```
Il HoareOptimizer è stato migliorato in modo tale da poter sostituire un ControlledGate in un circuito con la porta di base se tutti i qubit di controllo sono nello stato $|1\rangle$ .
Aggiunti due nuovi metodi, is_successor() e is_predecessor(), alla classe DAGCircuit alla classe. Queste funzioni sono utilizzate per verificare se un nodo è un successore o un predecessore di un altro nodo nella cartella DAGCircuit.
Un nuovo transpiler pass, RZXCalibrationBuilderNoEchoè stato aggiunto al modulo qiskit.transpiler.passes al modulo. Questo passaggio è simile a quello esistente RZXCalibrationBuilder in quanto crea le calibrazioni per un RZXGate(theta), tuttavia RZXCalibrationBuilderNoEcho lo fa senza inserire gli impulsi di eco nel programma degli impulsi. Ciò consente di esporre l'eco nella sequenza di risonanze incrociate come porte, in modo che il transpiler possa semplificarle. Il passaggio RZXCalibrationBuilderNoEcho supporta solo la direzione nativa dell'hardware dell'elemento CXGate.

Un nuovo kwarg, wrap, è stato aggiunto al metodo compose() di QuantumCircuit. Ciò consente di scegliere se i circuiti composti devono essere avvolti o meno in un'istruzione. L'impostazione predefinita è False, cioè senza avvolgimento. Ad esempio:

from qiskit import QuantumCircuit
circuit = QuantumCircuit(2)
circuit.h([0, 1])
other = QuantumCircuit(2)
other.x([0, 1])
print(circuit.compose(other, wrap=True))  # wrapped
print(circuit.compose(other, wrap=False))  # not wrapped

Un nuovo attributo, control_channelsè stato aggiunto alla classe PulseBackendConfiguration classe. Questo attributo rappresenta i canali di controllo di un backend come una mappatura di qubit in un elenco di oggetti ControlChannel oggetti.

Un nuovo kwarg, epsilon, è stato aggiunto al costruttore della classe Isometry e al corrispondente metodo QuantumCircuit metodo isometry(). Questo kwarg consente di impostare facoltativamente la tolleranza epsilon utilizzata da un gate Isometry . Ad esempio:

import numpy as np
from qiskit import QuantumRegister, QuantumCircuit

tolerance = 1e-8
iso = np.eye(2,2)
num_q_output = int(np.log2(iso.shape[0]))
num_q_input = int(np.log2(iso.shape[1]))
q = QuantumRegister(num_q_output)
qc = QuantumCircuit(q)

qc.isometry(iso, q[:num_q_input], q[num_q_input:], epsilon=tolerance)

Aggiunto un passaggio di transpiler, DynamicalDecouplingper qiskit.transpiler.passes per inserire sequenze di disaccoppiamento dinamico nei periodi di inattività di un circuito (dopo la mappatura in qubit fisici e lo scheduling). Il passaggio consente di controllare la sequenza di porte DD, la distanza tra di esse e i qubit da applicare. Ad esempio:

from qiskit.circuit import QuantumCircuit
from qiskit.circuit.library import XGate
from qiskit.transpiler import PassManager, InstructionDurations
from qiskit.transpiler.passes import ALAPSchedule, DynamicalDecoupling
from qiskit.visualization import timeline_drawer

circ = QuantumCircuit(4)
circ.h(0)
circ.cx(0, 1)
circ.cx(1, 2)
circ.cx(2, 3)
circ.measure_all()

durations = InstructionDurations(
    [("h", 0, 50), ("cx", [0, 1], 700), ("reset", None, 10),
     ("cx", [1, 2], 200), ("cx", [2, 3], 300),
     ("x", None, 50), ("measure", None, 1000)]
)

dd_sequence = [XGate(), XGate()]

pm = PassManager([ALAPSchedule(durations),
                  DynamicalDecoupling(durations, dd_sequence)])
circ_dd = pm.run(circ)
timeline_drawer(circ_dd)

Il QuantumCircuit ha un nuovo kwarg,, che può essere utilizzato per impostare facoltativamente la codifica dei caratteri del file QASM generato dalla funzione qasm() ha un nuovo kwarg, encoding, che può essere usato per impostare facoltativamente la codifica dei caratteri di un file QASM di uscita generato dalla funzione. Può essere impostato su qualsiasi codec o stringa alias valida del modulo codec della libreria standard Python.
Aggiunta di una nuova classe, EvolvedOperatorAnsatz, al modulo qiskit.circuit.library al modulo. Questo circuito di libreria, che in precedenza si trovava in Qiskit Nature, può essere utilizzato per costruire circuiti di ansatz che consistono in operatori evoluti nel tempo, dove il tempo di evoluzione è un parametro variazionale. Esempi di circuiti ansatz di questo tipo sono la classe UCCSD nel modulo chemistry di Qiskit Nature o la classe QAOAAnsatz classe.
Sotto qiskit.test.mock è disponibile una nuova classe di backend fittizio per il backend ibmq_guadalupe . Come per gli altri backend fasulli, questo include un'istantanea dei dati di calibrazione (cioè backend.defaults()) e i dati di errore (cioè backend.properties()) presi dal sistema reale e possono essere utilizzati per test, compilazioni e simulazioni locali.
Un nuovo metodo children() per la classe Schedule è stato aggiunto. Questo metodo viene utilizzato per restituire i componenti del programma previsionale figlio dell'oggetto Schedule come tupla. Restituisce i programmi annidati senza appiattimento. Questo metodo è equivalente al metodo privato _children() , ma ha un'interfaccia pubblica e stabile.
Una nuova classe di ottimizzatori, GradientDescentè stata aggiunta al modulo qiskit.algorithms.optimizers modulo. Questa classe di ottimizzatori implementa un algoritmo di ottimizzazione a discesa di gradiente standard da utilizzare con algoritmi variazionali quantistici, come ad esempio VQE. Per una descrizione dettagliata e per esempi sull'uso di questa classe, si rimanda alla documentazione della classe GradientDescent documentazione della classe.
Una nuova classe di ottimizzatori, QNSPSAè stata aggiunta al modulo qiskit.algorithms.optimizers modulo. Questa classe implementa l'algoritmo Quantum Natural SPSA (QN-SPSA), una generalizzazione dell'algoritmo 2-SPSA, e stima la matrice di informazione di Fisher quantistica al posto dell'Hessiano per ottenere una stima stocastica del gradiente naturale quantistico. Per esempi su come utilizzare questo nuovo ottimizzatore, consultare la documentazione della classe QNSPSA documentazione della classe.
Un nuovo kwarg, second_order, è stato aggiunto al costruttore della classe SPSA nel modulo qiskit.algorithms.optimizers modulo. Se impostato su True , consente di utilizzare l' SPSA del secondo ordine. L'SPSA del secondo ordine, o 2-SPSA, è un'estensione dell'algoritmo SPSA ordinario che consente di stimare l'Hessiano insieme al gradiente, che viene utilizzato per precondizionare il gradiente prima della fase di aggiornamento dei parametri. Come metodo del secondo ordine, cerca di migliorare la convergenza dell'SPSA. Per esempi su come utilizzare questa opzione, consultare la documentazione della classe SPSA della classe.
Quando si utilizza la modalità di uscita latex o latex_source di circuit_drawer() o la modalità draw() di QuantumCircuit è possibile utilizzare il kwarg di style come per la formattazione di output di mpl . Tuttavia, a differenza della modalità di uscita mpl , quando si utilizzano le modalità di uscita latex o latex_source viene utilizzato solo il campo displaytext (perché nessuna delle due supporta il colore).
Quando si utilizzano i metodi di uscita mpl o latex per la funzione o la funzione circuit_drawer() o per la funzione draw() di QuantumCircuitè ora possibile utilizzare la formattazione in modalità matematica per il testo e impostare la formattazione del colore (solompl ) impostando il kwarg style come un dict con un nome o un'etichetta generati dall'utente. Ad esempio, per aggiungere pedici e cambiare il colore di un cancello:
```
from qiskit import QuantumCircuit
from qiskit.circuit.library import HGate
qc = QuantumCircuit(3)
qc.append(HGate(label='h1'), [0])
qc.append(HGate(label='h2'), [1])
qc.append(HGate(label='h3'), [2])
qc.draw('mpl', style={'displaytext': {'h1': 'H_1', 'h2': 'H_2', 'h3': 'H_3'},
    'displaycolor': {'h2': ('#EEDD00', '#FF0000')}})
```
Aggiunte tre nuove classi, CDKMRippleCarryAdder, ClassicalAdder e DraperQFTAdder, al modulo qiskit.circuit.library al modulo. Queste nuove classi di circuiti vengono utilizzate per eseguire l'addizione classica di due registri di qubit di uguali dimensioni. Per due registri $|a\rangle_n$ e $|b\rangle_n$ su $n$ qubit, le tre nuove classi eseguono l'operazione:

|a\rangle_n |b\rangle_n \mapsto |a\rangle_n |a + b\rangle_{n + 1}.

Ad esempio:

from qiskit.circuit import QuantumCircuit
from qiskit.circuit.library import CDKMRippleCarryAdder
from qiskit.quantum_info import Statevector

# a encodes |01> = 1
a = QuantumCircuit(2)
a.x(0)

# b encodes |10> = 2
b = QuantumCircuit(2)
b.x(1)

# adder on 2-bit numbers
adder = CDKMRippleCarryAdder(2)

# add the state preparations to the front of the circuit
adder.compose(a, [0, 1], inplace=True, front=True)
adder.compose(b, [2, 3], inplace=True, front=True)

# simulate and get the state of all qubits
sv = Statevector(adder)
counts = sv.probabilities_dict()
state = list(counts.keys())[0]  # we only have a single state

# skip the input carry (first bit) and the register |a> (last two bits)
result = state[1:-2]
print(result)  # '011' = 3 = 1 + 2

Aggiunte due nuove classi, RGQFTMultiplier e HRSCumulativeMultiplier, al modulo qiskit.circuit.library al modulo. Queste classi vengono utilizzate per eseguire la moltiplicazione classica di due registri di qubit di uguali dimensioni. Per due registri $|a\rangle_n$ e $|b\rangle_n$ su $n$ qubit, le due nuove classi eseguono l'operazione

|a\rangle_n |b\rangle_n |0\rangle_{2n} \mapsto |a\rangle_n |b\rangle_n |a \cdot b\rangle_{2n}.

Ad esempio:

from qiskit.circuit import QuantumCircuit
from qiskit.circuit.library import RGQFTMultiplier
from qiskit.quantum_info import Statevector

num_state_qubits = 2

# a encodes |11> = 3
a = QuantumCircuit(num_state_qubits)
a.x(range(num_state_qubits))

# b encodes |11> = 3
b = QuantumCircuit(num_state_qubits)
b.x(range(num_state_qubits))

# multiplier on 2-bit numbers
multiplier = RGQFTMultiplier(num_state_qubits)

# add the state preparations to the front of the circuit
multiplier.compose(a, [0, 1], inplace=True, front=True)
multiplier.compose(b, [2, 3], inplace=True, front=True)

# simulate and get the state of all qubits
sv = Statevector(multiplier)
counts = sv.probabilities_dict(decimals=10)
state = list(counts.keys())[0]  # we only have a single state

# skip both input registers
result = state[:-2*num_state_qubits]
print(result)  # '1001' = 9 = 3 * 3

La classe Delay può ora accettare una classe ParameterExpression o Parameter per il kwarg duration del suo costruttore e per il suo attributo duration per il suo attributo.

Ad esempio:

idle_dur = Parameter('t')
qc = QuantumCircuit(1, 1)
qc.x(0)
qc.delay(idle_dur, 0, 'us')
qc.measure(0, 0)
print(qc)  # parameterized delay in us (micro seconds)

# assign before transpilation
assigned = qc.assign_parameters({idle_dur: 0.1})
print(assigned)  # delay in us
transpiled = transpile(assigned, some_backend_with_dt)
print(transpiled)  # delay in dt

# assign after transpilation
transpiled = transpile(qc, some_backend_with_dt)
print(transpiled)  # parameterized delay in dt
assigned = transpiled.assign_parameters({idle_dur: 0.1})
print(assigned)  # delay in dt

È stato introdotto un nuovo formato di serializzazione binaria, QPY. È stato progettato per essere un formato di serializzazione binaria veloce e retrocompatibile (i file QPY generati con versioni precedenti di Qiskit possono essere caricati da versioni più recenti di Qiskit) che è nativo di Qiskit. Il tool di serializzazione QPY è disponibile tramite il modulo qiskit.circuit.qpy_serialization . Ad esempio, per generare un file QPY:
```
from datetime import datetime

from qiskit.circuit import QuantumCircuit
from qiskit.circuit import qpy_serialization

qc = QuantumCircuit(
  2, metadata={'created_at': datetime.utcnow().isoformat()}
)
qc.h(0)
qc.cx(0, 1)
qc.measure_all()

circuits = [qc] * 5

with open('five_bells.qpy', 'wb') as qpy_file:
    qpy_serialization.dump(circuits, qpy_file)
```
Quindi i cinque circuiti salvati nel file QPY possono essere caricati con:
```
from qiskit.circuit.qpy_serialization

with open('five_bells.qpy', 'rb') as qpy_file:
    circuits = qpy_serialization.load(qpy_file)
```
Le specifiche del formato dei file QPY sono disponibili nella documentazione del modulo.
La classe TwoQubitBasisDecomposer è stata aggiornata per eseguire le decomposizioni ottimali del polso per una base con CX, √X e porte virtuali Rz, come descritto in https://arxiv.org/pdf/2008.08571. Per impulso ottimale si intende che la durata dei gate tra i gate CX della decomposizione è ridotta in cambio di un numero maggiore di gate locali prima o dopo tutti i gate CX, in modo che, quando si compone un circuito, vi sia la possibilità di una compressione a singolo qubit con gate vicini che riducono la durata complessiva della sequenza.

Un nuovo argomento di parola chiave, `pulse_optimize, è stato aggiunto al costruttore di TwoQubitBasisDecomposer per controllare questo aspetto:
- None: Tentativo di decomposizione ottimale dell'impulso. Se non si conosce una decomposizione ottimale dell'impulso per la base del decompositore, si torna alla decomposizione standard senza preavviso. Questa è l'impostazione predefinita.
- True: Tentativo di decomposizione ottimale dell'impulso. Se non si conosce una decomposizione ottimale dell'impulso per la base del decompositore, aumentare QiskitError.
- False: Non tentare la decomposizione ottimale dell'impulso.
Ad esempio:
```
from qiskit.quantum_info import TwoQubitBasisDecomposer
from qiskit.circuit.library import CXGate
from qiskit.quantum_info import random_unitary

unitary_matrix = random_unitary(4)

decomposer = TwoQubitBasisDecomposer(CXGate(), euler_basis="ZSX", pulse_optimize=True)
circuit = decomposer(unitary_matrix)
```
Il passaggio del transpiler UnitarySynthesis situato in qiskit.transpiler.passes è stato aggiornato per supportare l'esecuzione della decomposizione ottimale degli impulsi. Ciò avviene principalmente con l'argomento della parola chiave pulse_optimize , aggiunta al costruttore e utilizzata per controllare se viene eseguita la sintesi ottimale dell'impulso. Il comportamento di questo kwarg rispecchia il kwarg pulse_optimize nel costruttore della classe TwoQubitBasisDecomposer nel costruttore della classe. Inoltre, il costruttore ha un altro argomento chiave, synth_gates, utilizzato per specificare l'elenco dei nomi dei gate su cui tentare la sintesi. Se None e pulse_optimize è False o None, utilizzare "unitary". Se None e pulse_optimize è True, utilizzare "unitary" e "swap". Dato che la direzione del gate CX nella sintesi è arbitraria, viene aggiunto un altro argomento chiave, natural_direction, per considerare prima una mappa di accoppiamento e poi CXGate nella scelta di quale direzione di CX generare la sintesi.
```
from qiskit.circuit import QuantumCircuit
from qiskit.transpiler import PassManager, CouplingMap
from qiskit.transpiler.passes import TrivialLayout, UnitarySynthesis
from qiskit.test.mock import FakeVigo
from qiskit.quantum_info.random import random_unitary

backend = FakeVigo()
conf = backend.configuration()
coupling_map = CouplingMap(conf.coupling_map)
triv_layout_pass = TrivialLayout(coupling_map)
circ = QuantumCircuit(2)
circ.unitary(random_unitary(4), [0, 1])
unisynth_pass = UnitarySynthesis(
    basis_gates=conf.basis_gates,
    coupling_map=None,
    backend_props=backend.properties(),
    pulse_optimize=True,
    natural_direction=True,
    synth_gates=['unitary'])
pm = PassManager([triv_layout_pass, unisynth_pass])
optimal_circ = pm.run(circ)
```
È stata aggiunta una nuova opzione di base, 'XZX', per l'argomento basis OneQubitEulerDecomposer classe.
Aggiunto un nuovo metodo, get_instructions()è stato aggiunto alla classe QuantumCircuit classe. Questo metodo viene utilizzato per restituire tutti gli oggetti Instruction del circuito che hanno un valore name che corrisponde all'argomento name fornito, insieme alle liste associate qargs e cargs di Qubit e Clbit di oggetti.
Al pacchetto qiskit-terra è stato aggiunto un nuovo extra opzionale all . Ciò consente di installare tutti i requisiti opzionali con un unico extra, ad esempio: pip install 'qiskit-terra[all]', In precedenza, era necessario elencare tutti gli extra singolarmente per installare contemporaneamente tutte le dipendenze opzionali.
Aggiunte due nuove classi ProbDistribution e QuasiDistribution per trattare rispettivamente le distribuzioni di probabilità e le distribuzioni di quasiprobabilità. Questi oggetti sono entrambi sottoclassi di dizionari che aggiungono metodi aggiuntivi per lavorare con le distribuzioni di probabilità e quasiprobabilità.
Aggiunta di una nuova proprietà settings alla classe base Optimizer classe base astratta su cui si basano tutte le classi di ottimizzatori del modulo qiskit.algorithms.optimizers del modulo sono basate. Questa proprietà restituisce un dizionario Python delle impostazioni dell'ottimizzatore, che può essere usato per istanziare un'altra istanza della stessa classe di ottimizzatore. Ad esempio:
```
from qiskit.algorithms.optimizers import GradientDescent

optimizer = GradientDescent(maxiter=10, learning_rate=0.01)
settings = optimizer.settings
new_optimizer = GradientDescent(**settings)
```
Il dizionario settings è potenzialmente utile anche per serializzare gli oggetti dell'ottimizzatore usando JSON o un altro formato di serializzazione.
Una nuova funzione, set_config(), è stata aggiunta al modulo qiskit.user_config . Questa funzione consente di impostare i valori di una configurazione utente dall'API di Qiskit. Ad esempio:
```
from qiskit.user_config import set_config
set_config("circuit_drawer", "mpl", section="default", file="settings.conf")
```
che aggiungerà un valore di circuit_drawer = mpl alla sezione default del file settings.conf .

Se non viene specificato alcun argomento file_path , verrà aggiornato il percorso attualmente utilizzato per il file di configurazione utente (il valore della variabile d'ambiente QISKIT_SETTINGS , se impostata, o il percorso predefinito ~/.qiskit/settings.conf). Tuttavia, le modifiche al file di configurazione esistente non si rifletteranno nella sessione corrente, poiché il file di configurazione viene analizzato al momento dell'importazione.
Aggiunta di una nuova classe di stato, StabilizerState, al modulo qiskit.quantum_info al modulo. Questa classe rappresenta lo stato di un simulatore di stabilizzatore secondo la convenzione di Aaronson e Gottesman (2004).
Sono state aggiunte due nuove opzioni, 'value' e 'value_desc' , al kwarg sort della funzione qiskit.visualization.plot_histogram() della funzione. Quando sort è impostato su una di queste opzioni, la visualizzazione di output ordinerà l'asse x in base alla probabilità massima per ciascuna stringa di bit. Ad esempio:
```
from qiskit.visualization import plot_histogram

counts = {
  '000': 5,
  '001': 25,
  '010': 125,
  '011': 625,
  '100': 3125,
  '101': 15625,
  '110': 78125,
  '111': 390625,
}
plot_histogram(counts, sort='value')
```

Problemi noti

Quando si esegue parallel_map() (e le funzioni che chiamano internamente parallel_map() come ad esempio transpile() e assemble()) su Python 3.9 con QISKIT_PARALLEL impostato su True, in alcuni scenari è possibile che il programma si blocchi e non finisca mai di funzionare. Per evitare che ciò accada, l'impostazione predefinita di Python 3.9 è stata modificata in modo che non venga eseguito in parallelo, ma se QISKIT_PARALLEL è esplicitamente abilitato, il problema può ancora verificarsi.

Note sull'aggiornamento

La versione minima della dipendenza da retworkx è stata aumentata alla versione 0.9.0. Questo è stato fatto per utilizzare le nuove API introdotte in quella versione, che hanno migliorato le prestazioni di alcuni passaggi del transpiler.
Il valore predefinito per QISKIT_PARALLEL negli ambienti Python 3.9 è cambiato in False, questo significa che quando viene eseguito su Python 3.9 per impostazione predefinita non viene utilizzato il multiprocessing. Questo è stato fatto per evitare un potenziale problema di deadlock/hanging che può verificarsi quando si esegue il multiprocessing su Python 3.9 (vedere la sezione Problemi noti per maggiori dettagli). È ancora possibile abilitarla manualmente impostando esplicitamente la variabile d'ambiente QISKIT_PARALLEL a TRUE.
Le classi di backend false esistenti in qiskit.test.mock ora implementano rigorosamente l'interfaccia BackendV1 interfaccia. Questo significa che se si sta costruendo manualmente il file QasmQobj o PulseQobj da utilizzare con il metodo run() non funzionerà più. Il metodo run() accetta solo QuantumCircuit o Schedule ora. Ciò si è reso necessario per consentire il test di nuovi backend implementati senza qobj, che in precedenza non avevano alcun test all'interno di qiskit terra. Se si ha bisogno di sfruttare i falsi backend con QasmQobj o PulseQobj sono stati aggiunti nuovi oggetti backend legacy falsi per testare esplicitamente l'interfaccia dei provider legacy. Verrà rimosso dopo che l'interfaccia legacy sarà deprecata e rimossa. In futuro, i nuovi backend fasulli implementeranno solo l'interfaccia BackendV1 e non aggiungeranno nuove classi di backend legacy per i nuovi backend fasulli.
Quando si crea un oggetto Pauli con un'etichetta stringa non valida, viene sollevato un problema QiskitError viene ora sollevato. Questo è un cambiamento rispetto alle versioni precedenti, che sollevavano un AttributeError su un'etichetta di stringa non valida. Questa modifica è stata apportata per garantire che il messaggio di errore sia più informativo e distinto da un generico AttributeError.
La rappresentazione del programma di uscita dal costruttore di impulsi (qiskit.pulse.builder.build()) è cambiata da un Schedule a a ScheduleBlock. Questa nuova rappresentazione disabilita alcune operazioni di temporizzazione come lo spostamento e l'inserimento. Tuttavia, ciò consente di parametrare la durata delle istruzioni nel contesto del costruttore. Ad esempio:
```
from qiskit import pulse
from qiskit.circuit import Parameter

dur = Parameter('duration')

with pulse.build() as sched:
    with pulse.align_sequential():
        pulse.delay(dur, pulse.DriveChannel(1))
        pulse.play(pulse.Gaussian(dur, 0.1, dur/4), pulse.DriveChannel(0))

assigned0 = sched.assign_parameters({dur: 100})
assigned1 = sched.assign_parameters({dur: 200})
```
È possibile passare direttamente i programmi assegnati alla durata all'assemblatore (o al backend), oppure collegarli al circuito quantistico come porte a impulsi.
La libreria tweedledum, che in precedenza era una dipendenza opzionale, è diventata un requisito. Questo è stato fatto a causa dell'ampio uso del programma PhaseOracle (che dipende dall'installazione di tweedledum) con diversi algoritmi di qiskit.algorithms.
L'extra opzionale full-featured-simulators , che in precedenza poteva essere utilizzato per installare qiskit-aer con qualcosa di simile a pip install qiskit-terra[full-featured-simulators] , è stato rimosso dal pacchetto qiskit-terra. Se invece si usa questo per installare qiskit-aer con qiskit-terra , si dovrebbe fare affidamento sul metapacchetto qiskit o installare semplicemente qiskit-terra e qiskit-aer insieme a pip install qiskit-terra qiskit-aer.
È stato aggiunto un nuovo requisito symengine per gli utenti di Linux (su x86_64, aarch64 e ppc64le ) e macOS ( x86_64 e arm64 ). È una dipendenza opzionale su Windows (e disponibile su PyPi come pacchetto precompilato per 64bit Windows) e su altre architetture. Se installato, fornisce prestazioni significativamente migliori per la valutazione di Parameter e ParameterExpression oggetti.

Tutte le classi del circuito della libreria, cioè tutte le classi QuantumCircuit derivate in qiskit.circuit.librarysono ora racchiuse in una classe Instruction (o Gatese sono unitarie). Ad esempio, importando e disegnando il QFT circuito:

prima sembrava

                                          ┌───┐
q_0: ────────────────────■────────■───────┤ H ├─X─
                   ┌───┐ │        │P(π/2) └───┘ │
q_1: ──────■───────┤ H ├─┼────────■─────────────┼─
     ┌───┐ │P(π/2) └───┘ │P(π/4)                │
q_2: ┤ H ├─■─────────────■──────────────────────X─
     └───┘

e ora si presenta come

     ┌──────┐
q_0: ┤0     ├
     │      │
q_1: ┤1 QFT ├
     │      │
q_2: ┤2     ├
     └──────┘

Per ottenere il vecchio circuito, si può chiamare il metodo decompose() sul circuito

Questa modifica è stata fatta principalmente per coerenza, poiché prima di questo rilascio alcune classi di circuiti in qiskit.circuit.library erano precedentemente avvolte in un elemento Instruction o Gate ma non tutte.

Note di deprecazione

La classe qiskit.exceptions.QiskitIndexError è deprecata e sarà rimossa in una prossima versione. Questa eccezione non è stata utilizzata attivamente da nulla in Qiskit; se la si utilizzava, è possibile creare una classe di eccezione personalizzata per sostituirla.
I kwarg epsilon e factr per il costruttore e il kwarg qiskit.algorithms.optimizers.L_BFGS_B per il costruttore e i kwarg factr della classe P_BFGS sono deprecati e saranno rimossi in una prossima versione. Si prega invece di utilizzare eps karg invece di epsilon. factr kwarg è sostituito da ftol. Il rapporto tra i due è ftol = factr * numpy.finfo(float).eps. Questa modifica è stata apportata per essere coerente con l'uso del metodo delle funzioni scipy.optimize.minimize 'L-BFGS-B' . Per ulteriori informazioni sull'uso di questi nuovi parametri, consultare la documentazione di: scipy.optimize.minimize(method='L-BFGS-B') .
L'interfaccia legacy dei provider, che consisteva nelle classi astratte qiskit.providers.BaseBackend, qiskit.providers.BaseJob e qiskit.providers.BaseProvider , è stata deprecata e sarà rimossa in una prossima versione. Si dovrebbe invece utilizzare l'interfaccia versionata, le cui versioni attuali delle classi astratte sono qiskit.providers.BackendV1, qiskit.providers.JobV1, e qiskit.providers.ProviderV1. Gli oggetti di V1 sono per lo più retrocompatibili per facilitare la migrazione dall'interfaccia legacy a quella versionata. Tuttavia, ci si aspetta che le future versioni delle interfacce astratte divergano maggiormente. È possibile fare riferimento alla qiskit.providers per ulteriori dettagli di alto livello sull'interfaccia versionata.
Il kwarg condition al costruttore DAGDepNode e il corrispondente attributo condition dell'oggetto DAGDepNode sono stati deprecati e saranno rimossi in una prossima versione. Si può invece accedere a condition di un nodo DAGDepNode , se il nodo è di tipo op, utilizzando DAGDepNode.op.condition.
L'attributo condition della classe DAGNode è stato deprecato e sarà rimosso in una prossima versione. Invece, si può accedere a condition di un oggetto DAGNode se il nodo è di tipo op, usando DAGNode.op.condition.
Il costruttore di impulsi (qiskit.pulse.builder.build()) qiskit.pulse.builder.inline() è deprecata e sarà rimossa in una prossima versione. Invece di usare questo contesto, è possibile rimuovere i contesti di allineamento all'interno del contesto in linea.
Il costruttore di impulsi (qiskit.pulse.builder.build()) qiskit.pulse.builder.pad() è deprecata e sarà rimossa in una prossima versione. Questo è stato fatto perché il file ScheduleBlock restituito dal costruttore di impulsi non supporta il metodo .insert (e non esiste una sintassi di inserimento nel costruttore). L'uso dei segnaposto per i timeslot per bloccare l'inserimento di altre istruzioni non è più necessario.

Correzioni di bug

Il OneQubitEulerDecomposer e TwoQubitBasisDecomposer per la sintesi di gate a uno e due qubit sono state migliorate per restringere le tolleranze, migliorare la ripetibilità e la semplificazione e correggere diversi bug di tracciamento della fase globale.
Corretto un problema nell'assegnazione dell'attributo name a Gate generato da più chiamate al metodo inverse`() . Prima di questa correzione, quando si chiamava inverse`() si aggiungeva incondizionatamente _dg a ogni chiamata a inverse. Il problema è stato corretto, quindi alla seconda chiamata di inverse`() il suffisso _dg viene rimosso.
Fissa le condizioni di verifica della banalità di CZGate, CRZGate, CU1Gate e MCU1Gate nel HoareOptimizer pass. In precedenza, in alcuni casi l'ottimizzatore rimuoveva queste porte, interrompendo l'equivalenza semantica della trasformazione.
Corretto un problema durante la conversione di un oggetto ListOp di oggetti PauliSumOp utilizzando PauliExpectation o AerPauliExpectation. In precedenza, la conversione in una rappresentazione di Pauli, potenzialmente costosa, sollevava un'avvertenza. Questo problema è stato risolto convertendo internamente l'elemento ListOp in un elemento SummedOp di PauliOp ora crea un oggetto PauliSumOp che è più efficiente. Corretto #6159
Corretto un problema con la classe NLocal nel modulo qiskit.circuit.library che non sollevava correttamente un'eccezione all'inizializzazione dell'oggetto se veniva usato un tipo non valido per il kwarg reps , causando un errore di runtime inatteso. Un TypeError viene ora sollevato correttamente se il kwarg reps non è un valore int . Corretto #6515
È stato risolto un problema per cui la classe TwoLocal nel modulo qiskit.circuit.library non accettava i tipi interi di numpy (ad esempio numpy.int32, numpy.int64, ecc.) come input valido per il kwarg entanglement . Corretto #6455
Quando si carica un file o una stringa OpenQASM2 con i costruttori from_qasm_file() o from_qasm_str() per la classe QuantumCircuit se il circuito OpenQASM2 contiene un'istruzione con il nome delay questa verrà mappata su un'istruzione qiskit.circuit.Delay istruzione. Ad esempio:
```
from qiskit import QuantumCircuit

qasm = """OPENQASM 2.0;
include "qelib1.inc";
opaque delay(time) q;
qreg q[1];
delay(172) q[0];
u3(0.1,0.2,0.3) q[0];
"""
circuit = QuantumCircuit.from_qasm_str(qasm)
circuit.draw()
```
Corretto #6510
È stato risolto un problema con l'aggiunta tra PauliSumOp che avevano ParameterExpression coefficienti. In precedenza questo comportava la generazione di un'eccezione QiskitError , perché l'aggiunta dell'elemento ParameterExpression non era gestita correttamente. Questo problema è stato risolto in modo che l'addizione possa essere eseguita tra oggetti PauliSumOp oggetti con ParameterExpression coefficienti.
Corretto un problema con l'inizializzazione della classe AmplificationProblem della classe. Il kwarg di is_good_state era un campo obbligatorio ma veniva erroneamente trattato come facoltativo (e documentato come tale). Questo problema è stato risolto e anche aggiornato, in modo che, a meno che l'input oracle non sia un oggetto PhaseOracle (che fornisce il suo metodo di valutazione) il campo è obbligatorio e solleverà un TypeError se costruito senza is_good_state.
È stato risolto un problema per cui l'aggiunta di un controllo a un file ControlledGate con controlli aperti, i controlli aperti interni venivano disattivati. Correzioni #5857
Corretto un problema con il metodo convert() della classe PauliExpectation che, se chiamato su un operatore non ermetico, restituiva un risultato errato. Corretto #6307
È stato risolto un problema con la funzione qiskit.pulse.transforms.inline_subroutines() che in precedenza non rimuoveva erroneamente tutti i componenti annidati quando veniva richiamata su pianificazioni annidate. Corretto #6321
Corretto un problema quando si passava un callable parzialmente vincolato creato con la funzione functools.partial() della libreria standard Python come kwarg schedule al metodo add() della classe InstructionScheduleMap della classe, che in precedenza dava luogo a un errore. Corretto #6278
Corretto un problema con l'opzione PiecewiseChebyshev quando l'impostazione del parametro breakpoints a None su un oggetto esistente veniva erroneamente trattato come un punto di interruzione. È stato corretto in modo che, quando è impostato su None , venga ripristinato il comportamento predefinito di approssimazione sull'intero intervallo. Corretto #6198
Corretto un problema con il metodo num_connected_components() di QuantumCircuit che restituiva un numero errato di componenti quando il circuito contiene due o più porte condizionate su registri classici. Corretto #6477
Corretto un problema con il modulo qiskit.opflow.expectations in cui i coefficienti di una funzione di stato non venivano moltiplicati correttamente. Questo sistema corregge anche i calcoli dei gradienti e dei QFI quando si usa l'opzione PauliExpectation o AerPauliExpectation . Ad esempio, in precedenza:
```
from qiskit.opflow import StateFn, I, One

exp = ~StateFn(I) @ (2 * One)
```
valutato a 2 per AerPauliExpectation e a 4 per altri convertitori di aspettative. Poiché ~StateFn(I) @ (2 * One) è una notazione abbreviata per ~(2 * One) @ I @ (2 * One), il coefficiente ora corretto di 4 viene restituito per tutti i convertitori di aspettative. Corretto #6497
Corretto il bug che causava il fallimento di to_circuit() quando PauliOp aveva una fase. Allo stesso tempo, è stato reso più efficiente l'utilizzo di PauliGate.
È stato risolto un problema a causa del quale l'output QASM generato dal metodo qasm() del metodo QuantumCircuit per porte composite come MCXGate e le sue varianti ( MCXGrayCode, MCXRecursive, e MCXVChain) non sarebbe corretto. Se un elemento del circuito non è presente in, la sua definizione viene aggiunta alla stringa QASM di uscita Gate nel circuito non è presente in qelib1.inc, la sua definizione viene aggiunta alla stringa QASM di uscita. Corretto #4943 e #3945
Corretto un problema con la funzione circuit_drawer() e il metodo draw() di QuantumCircuit. Quando si utilizzano le modalità di uscita mpl o latex , con il kwarg cregbundle impostato su False e il kwarg reverse_bits impostato su True, i bit dei registri classici vengono visualizzati nello stesso ordine di quando reverse_bits è impostato su False.
È stato risolto un problema relativo all'utilizzo dell'istruzione qiskit.extensions.Initialize che non impostava correttamente la fase globale della definizione sintetizzata quando veniva costruita. Corretto #5320
È stato risolto un problema per cui l'ordine dei bit in qiskit.circuit.library.PhaseOracle.evaluate_bitstring() non corrispondeva all'ordine della stringa di bit misurata. Questa correzione influisce anche sull'esecuzione della classe Grover se l'oracolo è specificato come un elemento di tipo PhaseOracleche ora identificherà correttamente la stringa di bit corretta. Corretto #6314
Corregge un bug in Optimize1qGatesDecomposition() che in precedenza faceva sì che alcune brevi sequenze di porte non venissero erroneamente riscritte.
Corretto un problema nel metodo qiskit.opflow.gradients.Gradient.gradient_wrapper() con il calcolo del gradiente. In precedenza, se l'operatore non era diagonale, in alcune situazioni veniva restituito un risultato errato. Il problema è stato risolto utilizzando un convertitore di aspettative per garantire che il risultato sia sempre corretto.
Corretto un problema con la funzione circuit_drawer() e il metodo draw() di QuantumCircuit con tutte le modalità di uscita, che in alcune circostanze rendeva erroneamente un'istruzione personalizzata che includeva bit classici. Corretti #3201, #3202 e #6178
Corretto un problema in circuit_drawer() e il metodo draw() della classe QuantumCircuit quando si utilizza la modalità di uscita mpl , le porte controllate-Z venivano disegnate erroneamente come asimmetriche. Corretto #5981
È stato risolto un problema con il passaggio del transpiler di OptimizeSwapBeforeMeasure , a causa del quale in alcune situazioni veniva rimossa una condizione di tipo SwapGate che conteneva una condizione classica veniva rimosso. Corretto #6192
Corretto un problema con la fase della classe qiskit.opflow.gradients.QFI quando qfi_method è impostato su lin_comb_full , che causava la valutazione di un osservabile errato.
È stato risolto un problema con la classe VQE quando viene eseguito con l'opzione L_BFGS_B o P_BFGS e vengono utilizzati i gradienti, il gradiente veniva erroneamente passato come array numpy invece che come elenco di float, con conseguente errore. Questo problema è stato risolto in modo che sia possibile utilizzare i gradienti con VQE e l'opzione L_BFGS_B o P_BFGS ottimizzatori.

Altre note

La deprecazione del metodo parameters() per la classe Instruction è stata invertita. Questo metodo è stato originariamente deprecato nel sito 0.17.0, ma è ancora necessario per diverse applicazioni, tra cui l'esecuzione di esperimenti di calibrazione. Questo metodo continuerà a essere supportato e non verrà rimosso.

Aer 0.8.2

Nessuna modifica

Ignis 0.6.0

Nessuna modifica

Acqua 0.9.4

Nessuna modifica

IBM Q Fornitore 0.15.0

Nuove funzioni

Aggiungere il supporto per il nuovo metodo qiskit.providers.ibmq.runtime.RuntimeJob.error_message() che restituirà una stringa che rappresenta il motivo del fallimento del lavoro.

Il parametro di input del metodo qiskit.providers.ibmq.runtime.IBMRuntimeService.run() può ora essere specificato come istanza di qiskit.providers.ibmq.runtime.ParameterNamespace che supporta le funzioni di completamento automatico. È possibile utilizzare qiskit.providers.ibmq.runtime.RuntimeProgram.parameters() per recuperare un'istanza di ParameterNamespace .

Ad esempio:

from qiskit import IBMQ

provider = IBMQ.load_account()

# Set the "sample-program" program parameters.
params = provider.runtime.program(program_id="sample-program").parameters()
params.iterations = 2

# Configure backend options
options = {'backend_name': 'ibmq_qasm_simulator'}

# Execute the circuit using the "circuit-runner" program.
job = provider.runtime.run(program_id="sample-program",
                           options=options,
                           inputs=params)

L'utente può ora impostare la visibilità (privata/pubblica) di un programma di Qiskit Runtime utilizzando qiskit.providers.ibmq.runtime.IBMRuntimeService.set_program_visibility().
A qiskit.providers.ibmq.runtime.IBMRuntimeService.jobs() è stato aggiunto un parametro booleano opzionale pending che consente di filtrare i lavori in base al loro stato. Se pending non è specificato, tutti i lavori vengono restituiti. Se pending è impostato su True, vengono restituiti i lavori "QUEUED" e "RUNNING". Se pending è impostato su False, vengono restituiti i lavori 'DONE', 'ERROR' e 'CANCELLED'.
Aggiungere il supporto per il flag use_measure_esp nel metodo qiskit.providers.ibmq.IBMQBackend.run() . Se True, il backend utilizzerà la lettura ESP per tutte le misure che costituiscono l'istruzione terminale su quel qubit. Se viene utilizzato e il backend non supporta la lettura dell'ESP, viene generato un errore.

Note sull'aggiornamento

qiskit.providers.ibmq.runtime.RuntimeProgram.parameters() è ora un metodo che restituisce un'istanza di qiskit.providers.ibmq.runtime.ParameterNamespace , che può essere utilizzata per inserire i valori dei parametri del programma in fase di esecuzione e passare a qiskit.providers.ibmq.runtime.IBMRuntimeService.run().
Il flag open_pulse nella configurazione del backend non indica più se un backend supporta il controllo a livello di impulsi. Di conseguenza, qiskit.providers.ibmq.IBMQBackend.configuration() può restituire un'istanza PulseBackendConfiguration anche se il suo flag open_pulse è False.
Il livello di condivisione dei lavori non è più supportato a causa della scarsa adozione e l'interfaccia corrispondente sarà rimossa in una release futura. Ciò significa che non si deve più passare share_level quando si crea un lavoro o usare il metodo qiskit.providers.ibmq.job.IBMQJob.share_level() per ottenere il livello di condivisione di un lavoro.

Note di deprecazione

L'istruzione id è stata deprecata sui backend hardware IBM. Si può invece utilizzare l'istruzione delay che implementa ritardi di lunghezza variabile, specificati in unità di dt. Quando si esegue un circuito contenente un'istruzione id , all'invio del lavoro verrà emesso un avviso e tutte le istruzioni id presenti nel lavoro verranno automaticamente sostituite con l'istruzione delay equivalente.

Questa pagina è stata utile?

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