Notes de publication de Qiskit 0.28

0.28.0

Terra 0.18.0

Prélude

Cette version comprend de nombreuses nouvelles fonctionnalités et corrections de bugs. Les points forts de cette version sont l'introduction de deux nouvelles passes de transpilation, BIPMapping et DynamicalDecouplingqui, combinées au nouveau kwarg pulse_optimize sur la passe UnitarySynthesis permet de recréer les résultats du volume 64 de Quantum en utilisant les techniques décrites dans : https://arxiv.org/abs/2008.08571. Ces nouvelles passes et options du transpilateur sont également applicables de manière générale à l'optimisation de n'importe quel circuit.

Nouvelles fonctions

Le kwarg measurement_error_mitgation pour le constructeur QuantumInstance peut maintenant être défini sur la classe TensoredMeasFitter de qiskit-ignis en plus de CompleteMeasFitter qui était déjà supporté. Si vous utilisez TensoredMeasFitter , vous pourrez également définir le nouveau kwarg mit_pattern pour spécifier les qubits sur lesquels utiliser TensoredMeasFitter . Vous pouvez vous référer à la documentation de mit_pattern dans la documentation de TensoredMeasFitter pour le format attendu.
Les méthodes de décomposition pour les portes à un qubit, spécifiées via le kwarg basis , dans OneQubitEulerDecomposer a été élargie pour inclure la base 'ZSXX' , afin d'utiliser la porte directe $X$ ainsi que la porte $\sqrt{X}$ .
Ajout de deux nouvelles passes AlignMeasures et ValidatePulseGates au module qiskit.transpiler.passes module. Ces passes sont une optimisation adaptée au matériel et une routine de validation qui sont utilisées pour gérer les restrictions d'alignement sur l'allocation temporelle des instructions pour un backend.

Si un backend a une restriction sur l'alignement des instructions Measure (en termes de quantification dans le temps), la passe AlignMeasures est utilisée pour ajuster les délais dans un circuit programmé afin de garantir que toutes les instructions Measure dans le circuit sont alignées compte tenu des contraintes du backend. Le passage ValidatePulseGates est utilisé pour vérifier si des portes à impulsions personnalisées (portes qui ont une définition d'impulsions personnalisées dans l'attribut calibrations d'un objet QuantumCircuit ) sont valides compte tenu d'une contrainte d'alignement pour le backend cible.

Dans la version intégrée de preset_passmangers utilisée par la fonction transpile() ces passes sont automatiquement déclenchées si la contrainte d'alignement, soit via le kwarg dédié timing_constraints sur transpile() soit possède un attribut timing_constraints dans l'objet BackendConfiguration du backend ciblé.

Les backends de IBM Quantum Services (accessibles via le package qiskit-ibmq-provider ) fourniront les informations d'alignement dans un futur proche.

Par exemple :
```
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')
```
Un nouveau pass transpiler de classe qiskit.transpiler.passes.BIPMapping qui tente de trouver la meilleure disposition et le meilleur routage en même temps en résolvant un problème de BIP (programmation binaire en nombres entiers) comme décrit dans arXiv:2106.06446 a été ajoutée.

La passe BIPMapping (nommée "mapping" pour faire référence à "layout and routing") représente le problème de mapping comme un problème BIP (binary integer programming) et s'appuie sur CPLEX (cplex) pour résoudre le problème BIP. Les bibliothèques dépendantes, y compris CPLEX, peuvent être installées avec qiskit-terra :
```
pip install qiskit-terra[bip-mapper]
```
Étant donné que la version gratuite de CPLEX ne peut résoudre que les petits problèmes BIP, c'est-à-dire la cartographie des circuits de moins de 5 qubits, la version payante de CPLEX peut être nécessaire pour cartographier des circuits plus importants.

Le mappeur BIP s'adapte mal au nombre de qubits ou de portes. Par exemple, il ne fonctionnerait pas avec coupling_map au-delà de 10 qubits parce que le solveur BIP (CPLEX) ne pourrait pas trouver de solution dans le temps imparti.

Notez que si vous souhaitez fixer les qubits physiques à utiliser dans le mappage (par exemple pour l'exécution de circuits QV), vous devez spécifier coupling_map qui contient uniquement les qubits à utiliser.

Voici un exemple de code minimal pour construire un gestionnaire de passe pour transpiler un circuit 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)
```
Une nouvelle méthode de construction initialize_from() a été ajoutée aux Schedule et ScheduleBlock ont été ajoutées. Cette méthode initialise un nouveau programme vide qui reprend les attributs des autres programmes. Par exemple :
```
sched = Schedule(name='my_sched')
new_sched = Schedule.initialize_from(sched)

assert sched.name == new_sched.name
```
Un nouveau kwarg, line_discipline, a été ajouté à la fonction job_monitor() fonction. Ce kwarg permet de modifier les caractères de retour chariot utilisés dans la sortie de job_monitor . Le kwarg line_discipline prend par défaut la valeur '\r', qui était utilisée auparavant.
La classe abstraite Pulse (qui est la classe mère de classes telles que Waveform, Constant, et Gaussian dispose désormais d'un nouveau kwarg sur le constructeur, limit_amplitude, qui peut être défini à False pour désactiver la limite d'amplitude précédemment codée en dur de 1. Il peut également être défini directement en tant qu'attribut de classe pour modifier la valeur par défaut globale d'une classe Pulse. Par exemple :
```
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)))
```
Une nouvelle classe, PauliLista été ajoutée au module qiskit.quantum_info module. Cette classe est utilisée pour représenter efficacement une liste d'opérateurs Pauli opérateurs. Cette nouvelle classe est issue de la même classe mère que la classe existante PauliTable (et peut donc être utilisée de manière interchangeable), mais elle diffère de la classe PauliTable parce qu'elle peut traiter les phases qiskit.quantum_info.PauliList peut gérer les phases Z4.
Ajout d'une nouvelle passe de transpilation, RemoveBarriers, pour qiskit.transpiler.passes. Cette passe est utilisée pour supprimer toutes les barrières dans un circuit.
Ajouter une nouvelle classe d'optimiseur, SciPyOptimizerau module qiskit.algorithms.optimizers module. Cette classe est une simple classe enveloppante de la fonction scipy.optimize.minimize (documentation ) qui permet d'utiliser tous les solveurs d'optimisation et tous les paramètres (par exemple, le rappel) qui sont pris en charge par scipy.optimize.minimize. Par exemple :
```
from qiskit.algorithms.optimizers import SciPyOptimizer

values = []

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

optimizer = SciPyOptimizer("BFGS", options={"maxiter": 1000}, callback=callback)
```
La passe HoareOptimizer a été améliorée de telle sorte qu'elle peut désormais remplacer une ControlledGate dans un circuit avec la porte de base si tous les qubits de contrôle sont dans l'état $|1\rangle$ .
Ajout de deux nouvelles méthodes, is_successor() et is_predecessor()à la classe DAGCircuit à la classe. Ces fonctions sont utilisées pour vérifier si un nœud est le successeur ou le prédécesseur d'un autre nœud de la base de données DAGCircuit.
Un nouveau passeur de transpondeurs, RZXCalibrationBuilderNoEchoa été ajoutée au module qiskit.transpiler.passes a été ajoutée au module. Cette passe est similaire à la passe existante RZXCalibrationBuilder en ce sens qu'elle crée des étalonnages pour un site RZXGate(theta), mais elle le fait sans insérer d'impulsions d'écho dans le programme d'impulsions RZXCalibrationBuilderNoEcho le fait sans insérer les impulsions d'écho dans le programme d'impulsions. Cela permet d'exposer l'écho dans la séquence de résonance croisée en tant que portes afin que le transpondeur puisse les simplifier. La passe RZXCalibrationBuilderNoEcho ne prend en charge que la direction native du matériel de la passe CXGate.
Un nouveau kwarg, wrap, a été ajouté à la compose() de QuantumCircuit. Cela permet de choisir si les circuits composés doivent être intégrés dans une instruction ou non. Par défaut, il s'agit de False, c'est-à-dire qu'il n'y a pas d'emballage. Par exemple :
```
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 nouvel attribut, control_channelsa été ajouté à la classe PulseBackendConfiguration classe. Cet attribut représente les canaux de contrôle d'un backend sous la forme d'une correspondance entre des qubits et une liste d'objets ControlChannel objets.

Un nouveau kwarg, epsilon, a été ajouté au constructeur de la classe Isometry et à la méthode correspondante QuantumCircuit méthode isometry(). Ce kwarg permet de définir facultativement la tolérance epsilon utilisée par une porte Isometry . Par exemple :

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)

Ajout d'une passe de transpilation, DynamicalDecoupling, pour qiskit.transpiler.passes pour insérer des séquences de découplage dynamique dans les périodes d'inactivité d'un circuit (après la mise en correspondance avec les qubits physiques et l'ordonnancement). La passe permet de contrôler la séquence des portes DD, l'espacement entre elles et les qubits sur lesquels s'appliquer. Par exemple :

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)

La QuantumCircuit a un nouveau kwarg, qasm() dispose d'un nouveau kwarg, encoding, qui peut être utilisé pour définir éventuellement le codage des caractères d'un fichier QASM généré par la fonction. Il peut s'agir de n'importe quel codec valide ou d'une chaîne d'alias provenant du module codec de la bibliothèque standard Python.
Ajout d'une nouvelle classe, EvolvedOperatorAnsatzau module qiskit.circuit.library module. Ce circuit de bibliothèque, qui se trouvait auparavant dans Qiskit Nature, peut être utilisé pour construire des circuits d'ansatz constitués d'opérateurs évoluant dans le temps, où le temps d'évolution est un paramètre variationnel. Parmi les exemples de tels circuits d'ansatz, on peut citer la classe UCCSD dans le module chemistry de Qiskit Nature ou la classe QAOAAnsatz classe.
Une nouvelle classe de faux backend est disponible sous qiskit.test.mock pour le backend ibmq_guadalupe . Comme pour les autres faux backends, il s'agit d'un instantané des données d'étalonnage (c'est-à-dire backend.defaults()) et les données d'erreur (c'est-à-dire backend.properties()) prises dans le système réel, et peuvent être utilisées pour les tests locaux, la compilation et la simulation.
Une nouvelle méthode children() pour la classe Schedule a été ajoutée. Cette méthode est utilisée pour renvoyer les composantes de l'horaire enfant de l'objet Schedule sous la forme d'un tuple. Il renvoie des horaires imbriqués sans aplatissement. Cette méthode est équivalente à la méthode privée _children() mais possède une interface publique et stable.
Une nouvelle classe d'optimiseur, GradientDescenta été ajoutée au module qiskit.algorithms.optimizers a été ajoutée au module. Cette classe d'optimiseur met en œuvre un algorithme standard d'optimisation par descente de gradient à utiliser avec des algorithmes variationnels quantiques, tels que VQE. Pour une description détaillée et des exemples d'utilisation de cette classe, veuillez vous référer à la GradientDescent documentation de la classe.
Une nouvelle classe d'optimiseur, QNSPSAa été ajoutée au module qiskit.algorithms.optimizers a été ajoutée au module. Cette classe met en œuvre l'algorithme Quantum Natural SPSA (QN-SPSA ), une généralisation de l'algorithme 2-SPSA, et estime la matrice d'information de Fisher quantique au lieu du hessien pour obtenir une estimation stochastique du gradient naturel quantique. Pour des exemples d'utilisation de ce nouvel optimiseur, voir la documentation de la classe QNSPSA documentation de la classe.
Un nouveau kwarg, second_order, a été ajouté au constructeur de la classe SPSA dans le module qiskit.algorithms.optimizers module. Lorsqu'il est réglé sur True , il permet d'utiliser le SPSA de deuxième ordre. La SPSA de second ordre, ou 2-SPSA, est une extension de l'algorithme SPSA ordinaire qui permet d'estimer le Hessien en même temps que le gradient, ce qui est utilisé pour préconditionner le gradient avant l'étape de mise à jour des paramètres. En tant que méthode de second ordre, elle tente d'améliorer la convergence de la SPSA. Pour des exemples d'utilisation de cette option, voir la documentation de la classe SPSA documentation de la classe.
Lorsque vous utilisez le mode de sortie latex ou latex_source de circuit_drawer() ou le mode de sortie draw() de QuantumCircuit le kwarg style peut maintenant être utilisé comme pour le formatage de sortie mpl . Toutefois, contrairement au mode de sortie mpl , seul le champ displaytext sera utilisé en cas d'utilisation des modes de sortie latex ou latex_source (car aucun de ces modes ne prend en charge la couleur).
Lors de l'utilisation des méthodes de sortie mpl ou latex pour la fonction circuit_drawer() ou la fonction draw() de QuantumCircuitvous pouvez désormais utiliser le formatage en mode mathématique pour le texte et définir le formatage en couleur (mpl uniquement) en définissant le kwarg style comme un dict avec un nom ou une étiquette généré(e) par l'utilisateur. Par exemple, pour ajouter des indices et changer la couleur d'une porte :
```
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')}})
```
Ajout de trois nouvelles classes, CDKMRippleCarryAdderClassicalAdder et DraperQFTAdderau module qiskit.circuit.library module. Ces nouvelles classes de circuits sont utilisées pour effectuer l'addition classique de deux registres de qubits de taille égale. Pour deux registres $|a\rangle_n$ et $|b\rangle_n$ sur des qubits $n$ , les trois nouvelles classes effectuent l'opération :

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

Par exemple :

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

Ajout de deux nouvelles classes, RGQFTMultiplier et HRSCumulativeMultiplierau module qiskit.circuit.library module. Ces classes sont utilisées pour effectuer la multiplication classique de deux registres de qubits de taille égale. Pour deux registres $|a\rangle_n$ et $|b\rangle_n$ sur des qubits $n$ , les deux nouvelles classes effectuent l'opération suivante

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

Par exemple :

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 peut maintenant accepter un ParameterExpression ou Parameter pour le kwarg duration de son constructeur et pour son attribut duration pour son attribut

Par exemple :

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

Un nouveau format de sérialisation binaire, QPY, a été introduit. Il est conçu pour être un format de sérialisation binaire rapide qui est compatible avec les versions antérieures (les fichiers QPY générés avec les anciennes versions de Qiskit peuvent être chargés par les versions plus récentes de Qiskit) et qui est natif de Qiskit. L'outil de sérialisation QPY est disponible via le module qiskit.circuit.qpy_serialization . Par exemple, pour générer un fichier 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)
```
Les cinq circuits enregistrés dans le fichier QPY peuvent ensuite être chargés avec :
```
from qiskit.circuit.qpy_serialization

with open('five_bells.qpy', 'rb') as qpy_file:
    circuits = qpy_serialization.load(qpy_file)
```
La spécification du format de fichier QPY est disponible dans la documentation du module.
La classe TwoQubitBasisDecomposer a été mise à jour pour effectuer des décompositions optimales par impulsion pour une base avec CX, √X, et des portes Rz virtuelles comme décrit dans https://arxiv.org/pdf/2008.08571. Une impulsion optimale signifie ici que la durée des portes entre les portes CX de la décomposition est réduite en échange d'un plus grand nombre de portes locales avant ou après toutes les portes CX, de sorte que, lorsqu'elles sont composées dans un circuit, il est possible de comprimer un seul qubit avec les portes voisines, ce qui réduit la durée totale de la séquence.

Un nouveau mot-clé, `pulse_optimize, a été ajouté au constructeur de TwoQubitBasisDecomposer pour contrôler cela :
- None: Tentative de décomposition optimale de l'impulsion. Si une décomposition optimale par impulsion est inconnue pour la base du décomposeur, revenir à la décomposition standard sans avertissement. Il s'agit du paramètre par défaut.
- True: Tentative de décomposition optimale de l'impulsion. Si une décomposition optimale par impulsion est inconnue pour la base du décomposeur, soulever QiskitError.
- False: Ne pas tenter de décomposition optimale de l'impulsion.
Par exemple :
```
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)
```
La passe de transpilation UnitarySynthesis située dans qiskit.transpiler.passes a été mis à jour pour permettre la décomposition optimale de l'impulsion. Cela se fait principalement avec l'argument du mot-clé pulse_optimize qui a été ajouté au constructeur et utilisé pour contrôler si la synthèse optimale des impulsions est effectuée. Le comportement de ce kwarg reflète le kwarg pulse_optimize dans le constructeur de la classe TwoQubitBasisDecomposer dans le constructeur de la classe. En outre, le constructeur possède un nouvel argument clé, synth_gates, qui est utilisé pour spécifier la liste des noms de portes sur lesquels la synthèse doit être tentée. Si None et pulse_optimize sont False ou None, utilisez "unitary". Si None et pulse_optimize est True, utiliser "unitary" et "swap". Comme la direction de la porte CX dans la synthèse est arbitraire, un autre argument de mot-clé, natural_direction, est ajouté pour tenir compte d'abord d'une carte de couplage et ensuite des durées dans le choix de la direction de la porte CX à générer dans la synthèse CXGate les durées pour choisir la direction de la porte CX pour générer la synthèse.
```
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)
```
Une nouvelle option de base, 'XZX', a été ajoutée pour l'argument basis OneQubitEulerDecomposer classe.
Ajout d'une nouvelle méthode, get_instructions()a été ajoutée à la classe QuantumCircuit classe. Cette méthode est utilisée pour renvoyer tous les objets Instruction dans le circuit qui ont un name qui correspond à l'argument name fourni, ainsi que les listes qargs et cargs de Qubit et Clbit qui lui sont associées.
Une nouvelle option all a été ajoutée à l'ensemble qiskit-terra. Cela permet d'installer toutes les exigences optionnelles avec un seul supplément, par exemple : pip install 'qiskit-terra[all]' auparavant, il était nécessaire de lister tous les extras individuellement pour installer toutes les dépendances optionnelles simultanément.
Ajout de deux nouvelles classes ProbDistribution et QuasiDistribution pour traiter respectivement les distributions de probabilité et les distributions de quasi-robabilité. Ces objets sont tous deux des sous-classes de dictionnaires qui ajoutent des méthodes supplémentaires pour travailler avec des distributions de probabilité et de quasi-robabilité.
Ajout d'une nouvelle propriété settings à la classe de base abstraite Optimizer sur laquelle sont basées toutes les classes d'optimiseurs du module qiskit.algorithms.optimizers sont basées. Cette propriété renvoie un dictionnaire Python des paramètres de l'optimiseur qui peut être utilisé pour instancier une autre instance de la même classe d'optimiseur. Par exemple :
```
from qiskit.algorithms.optimizers import GradientDescent

optimizer = GradientDescent(maxiter=10, learning_rate=0.01)
settings = optimizer.settings
new_optimizer = GradientDescent(**settings)
```
Le dictionnaire settings est également potentiellement utile pour sérialiser les objets de l'optimiseur en utilisant JSON ou un autre format de sérialisation.
Une nouvelle fonction, set_config(), a été ajoutée au module qiskit.user_config . Cette fonction permet de définir des valeurs dans une configuration utilisateur à partir de l'API Qiskit. Par exemple :
```
from qiskit.user_config import set_config
set_config("circuit_drawer", "mpl", section="default", file="settings.conf")
```
ce qui aura pour effet d'ajouter la valeur circuit_drawer = mpl à la section default du fichier settings.conf .

Si aucun argument file_path n'est spécifié, le chemin actuellement utilisé pour le fichier de configuration de l'utilisateur (soit la valeur de la variable d'environnement QISKIT_SETTINGS si elle est définie, soit l'emplacement par défaut ~/.qiskit/settings.conf) sera mis à jour. Toutefois, les modifications apportées au fichier de configuration existant ne seront pas prises en compte dans la session en cours, car le fichier de configuration est analysé au moment de l'importation.
Ajout d'une nouvelle classe d'état, StabilizerStateau module qiskit.quantum_info module. Cette classe représente l'état d'un simulateur de stabilisateur en utilisant la convention d' Aaronson et Gottesman (2004).
Deux nouvelles options, 'value' et 'value_desc' , ont été ajoutées au kwarg sort de la fonction qiskit.visualization.plot_histogram() de la fonction. Lorsque sort est défini sur l'une de ces options, la visualisation de sortie triera l'axe des x en fonction de la probabilité maximale pour chaque chaîne de bits. Par exemple :
```
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')
```

Problèmes connus

Lors de l'exécution parallel_map() (et les fonctions qui appellent en interne parallel_map() telles que transpile() et assemble()) sur Python 3.9 avec QISKIT_PARALLEL fixé à True, il est possible, dans certains scénarios, que le programme se bloque et ne finisse jamais de s'exécuter. Pour éviter cela, la valeur par défaut de Python 3.9 a été modifiée pour ne pas être exécutée en parallèle, mais si QISKIT_PARALLEL est explicitement activée, cela peut toujours se produire.

Mise à niveau

La version minimale de la dépendance retworkx a été augmentée à la version 0.9.0. Cela a été fait pour utiliser les nouvelles API introduites dans cette version, qui ont amélioré les performances de certaines passes de transpilation.
La valeur par défaut de QISKIT_PARALLEL sur les environnements Python 3.9 a été modifiée en False, ce qui signifie que lors de l'exécution sur Python 3.9, le multiprocessus ne sera pas utilisé par défaut. Ceci a été fait pour éviter un problème de blocage potentiel qui peut se produire lors de l'exécution de traitements multiples sur Python 3.9 (voir la section des problèmes connus pour plus de détails). Il est toujours possible de l'activer manuellement en définissant explicitement la variable d'environnement QISKIT_PARALLEL sur TRUE.
Les classes de faux backend existantes dans qiskit.test.mock implémentent désormais strictement l'interface BackendV1 l'interface. Cela signifie que si vous construisez manuellement QasmQobj ou PulseQobj pour l'utiliser avec la méthode run() , cela ne fonctionnera plus. La méthode run() n'accepte que QuantumCircuit ou Schedule pour l'instant. Ceci était nécessaire pour permettre de tester les nouveaux backends implémentés sans qobj qui n'avaient auparavant aucun test dans qiskit terra. Si vous avez besoin d'utiliser les faux backends avec QasmQobj ou PulseQobj de nouveaux objets "fake legacy backend" ont été ajoutés pour tester explicitement l'interface des fournisseurs traditionnels. Elle sera supprimée lorsque l'ancienne interface sera obsolète et supprimée. À l'avenir, les nouveaux faux backends n'implémenteront que l'interface BackendV1 et n'ajouteront pas de nouvelles classes de backend pour les nouveaux faux backends.
Lors de la création d'un objet Pauli avec un libellé de chaîne invalide, un QiskitError est maintenant levée. Il s'agit d'un changement par rapport aux versions précédentes qui généraient un message AttributeError en cas d'étiquette de chaîne invalide. Cette modification a été apportée afin que le message d'erreur soit plus informatif et distinct du message générique AttributeError.
La représentation du programme de sortie du générateur d'impulsions (qiskit.pulse.builder.build()) est passée d'un Schedule à un ScheduleBlock. Cette nouvelle représentation désactive certaines opérations liées à la synchronisation, telles que le décalage et l'insertion. Toutefois, cela permet de paramétrer les durées d'instruction dans le contexte du constructeur. Par exemple :
```
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})
```
Vous pouvez transmettre directement les programmes assignés à la durée à l'assembleur (ou au backend), ou vous pouvez les attacher à votre circuit quantique en tant que portes d'impulsion.
La bibliothèque tweedledum, qui était auparavant une dépendance optionnelle, est désormais obligatoire. Cela a été fait en raison de la large utilisation de l'algorithme PhaseOracle (qui dépend de l'installation de tweedledum) avec plusieurs algorithmes de qiskit.algorithms.
L'option full-featured-simulators qui pouvait être utilisée auparavant pour installer qiskit-aer avec quelque chose comme pip install qiskit-terra[full-featured-simulators] a été supprimée du paquet qiskit-terra. Si cela était utilisé pour installer qiskit-aer avec qiskit-terra à la place, vous devriez vous appuyer sur le métapackage qiskit ou simplement installer qiskit-terra et qiskit-aer en même temps que pip install qiskit-terra qiskit-aer.
Une nouvelle exigence symengine a été ajoutée pour les utilisateurs de Linux (sur x86_64, aarch64, et ppc64le ) et macOS ( x86_64 et arm64 ). Il s'agit d'une dépendance optionnelle pour Windows (et disponible sur PyPi en tant que paquet précompilé pour 64bit Windows) et d'autres architectures. S'il est installé, il permet d'améliorer considérablement les performances de l'évaluation de Parameter et ParameterExpression objets.

Toutes les classes de circuits de la bibliothèque, c'est-à-dire toutes les classes dérivées de la bibliothèque QuantumCircuit les classes dérivées de qiskit.circuit.librarysont désormais enveloppées dans un Instruction (ou Gatesi elles sont unitaires). Par exemple, l'importation et le dessin du QFT circuit :

avant ressemblait à

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

et ressemble maintenant à

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

Pour obtenir l'ancien circuit, vous pouvez appeler la méthode decompose() sur le circuit

Ce changement a été effectué principalement pour des raisons de cohérence, car avant cette version, certaines classes de circuits dans qiskit.circuit.library étaient auparavant enveloppées dans un Instruction ou Gate mais pas toutes.

Remarques concernant la dépréciation

La classe qiskit.exceptions.QiskitIndexError est obsolète et sera supprimée dans une prochaine version. Cette exception n'était pas utilisée activement par Qiskit, si vous l'utilisiez, vous pouvez créer une classe d'exception personnalisée pour la remplacer.
Les kwargs epsilon et factr pour le qiskit.algorithms.optimizers.L_BFGS_B et factr pour le constructeur de la classe d'optimiseur sont obsolètes et seront supprimés dans une prochaine version P_BFGS sont obsolètes et seront supprimés dans une prochaine version. Au lieu de cela, veuillez utiliser eps karg au lieu de epsilon. Le kwarg factr est remplacé par ftol. La relation entre les deux est ftol = factr * numpy.finfo(float).eps. Cette modification a été apportée par souci de cohérence avec l'utilisation de la méthode des fonctions scipy.optimize.minimize 'L-BFGS-B' . Voir la documentation : scipy.optimize.minimize(method='L-BFGS-B') pour plus d'informations sur l'utilisation de ces nouveaux paramètres.
L'ancienne interface des fournisseurs, qui se composait des classes abstraites qiskit.providers.BaseBackend, qiskit.providers.BaseJob et qiskit.providers.BaseProvider , a été abandonnée et sera supprimée dans une prochaine version. Vous devez plutôt utiliser l'interface versionnée, dont les versions actuelles des classes abstraites sont les suivantes qiskit.providers.BackendV1, qiskit.providers.JobV1, et qiskit.providers.ProviderV1. Les objets V1 sont pour la plupart rétrocompatibles afin de faciliter la migration de l'ancienne interface vers l'interface versionnée. Toutefois, il faut s'attendre à ce que les versions futures des interfaces abstraites divergent davantage. Vous pouvez vous référer à la qiskit.providers pour plus de détails sur l'interface versionnée.
Le kwarg condition du constructeur DAGDepNode ainsi que l'attribut condition correspondant de l'élément DAGDepNode sont obsolètes et seront supprimés dans une prochaine version. En revanche, vous pouvez accéder à condition d'un DAGDepNode si le nœud est de type op, en utilisant DAGDepNode.op.condition.
L'attribut condition de la classe DAGNode est obsolète et sera supprimé dans une prochaine version. En revanche, vous pouvez accéder à condition d'un objet DAGNode si le nœud est de type op, en utilisant DAGNode.op.condition.
La syntaxe du constructeur d'impulsions (qiskit.pulse.builder.build()) qiskit.pulse.builder.inline() est obsolète et sera supprimée dans une prochaine version. Au lieu d'utiliser ce contexte, vous pouvez simplement supprimer les contextes d'alignement dans le contexte en ligne.
La syntaxe du constructeur d'impulsions (qiskit.pulse.builder.build()) qiskit.pulse.builder.pad() est obsolète et sera supprimée dans une prochaine version. Cela a été fait parce que le fichier ScheduleBlock renvoyée par le constructeur d'impulsions ne prend pas en charge la méthode .insert (et il n'y a pas de syntaxe d'insertion dans le constructeur). L'utilisation d'espaces réservés pour bloquer l'insertion d'autres instructions n'est plus nécessaire.

Corrections des erreurs

Les OneQubitEulerDecomposer et TwoQubitBasisDecomposer pour la synthèse de portes à un et deux qubits ont été améliorées afin de resserrer les tolérances, d'améliorer la répétabilité et la simplification, et de corriger plusieurs bogues de suivi de phase global.
Correction d'un problème dans l'attribution de l'attribut name à l'attribut Gate généré par des appels multiples à la méthode inverse`() . Avant cette correction, lorsque inverse`() était appelé, il ajoutait inconditionnellement _dg à chaque appel à inverse. Cette erreur a été corrigée de sorte que lors d'un deuxième appel de inverse`() , le suffixe _dg est désormais supprimé.
Fixe les conditions de vérification de la trivialité de CZGate, CRZGate, CU1Gate et MCU1Gate dans la passe de HoareOptimizer passer. Auparavant, dans certains cas, l'optimiseur supprimait ces portes, ce qui rompait l'équivalence sémantique de la transformation.
Correction d'un problème lors de la conversion d'un ListOp d'objets PauliSumOp en utilisant PauliExpectation ou AerPauliExpectation. Auparavant, un avertissement était émis concernant la conversion à une représentation de Pauli, qui est potentiellement coûteuse. Ce problème a été résolu en remplaçant la conversion interne de l'élément ListOp en un SummedOp d'objets PauliOp il crée maintenant un objet PauliSumOp ce qui est plus efficace. Corrigé #6159
Correction d'un problème avec la classe NLocal dans le module qiskit.circuit.library qui ne levait pas correctement une exception lors de l'initialisation de l'objet si un type invalide était utilisé pour le kwarg reps , ce qui entraînait une erreur d'exécution inattendue par la suite. Un TypeError sera désormais correctement soulevé si le kwarg reps n'est pas une valeur int . Corrigé #6515
Correction d'un problème où la classe TwoLocal dans le module qiskit.circuit.library n'acceptait pas les types entiers numpy (par exemple numpy.int32, numpy.int64, etc) comme une entrée valide pour le kwarg entanglement . Corrigé #6455
Lors du chargement d'un fichier ou d'une chaîne OpenQASM2 avec les constructeurs from_qasm_file() ou from_qasm_str() pour la classe QuantumCircuit si le circuit OpenQASM2 contient une instruction portant le nom delay , celle-ci sera mise en correspondance avec une instruction qiskit.circuit.Delay instruction. Par exemple :
```
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()
```
Corrigé #6510
Correction d'un problème d'addition entre PauliSumOp ayant des coefficients ParameterExpression coefficients. Auparavant, cela entraînait la levée d'une exception QiskitError , car l'ajout de l'élément ParameterExpression n'était pas géré correctement. Ce problème a été corrigé de manière à ce que l'addition puisse être effectuée entre des objets PauliSumOp objets avec ParameterExpression coefficients.
Correction d'un problème d'initialisation de la AmplificationProblem classe. Le kwarg is_good_state était un champ obligatoire, mais il était traité à tort comme un champ facultatif (et documenté comme tel). Ce problème a été corrigé et mis à jour de sorte que, à moins que l'entrée oracle soit un objet PhaseOracle (qui fournit sa propre méthode d'évaluation), le champ est obligatoire et soulèvera un TypeError s'il est construit sans is_good_state.
Correction d'un problème où l'ajout d'un contrôle à un ControlledGate avec des contrôles ouverts annulait les contrôles ouverts internes. Corrige #5857
Correction d'un problème avec la méthode convert() de la classe PauliExpectation dont l'appel sur un opérateur non hermitien renvoyait un résultat incorrect. Corrigé #6307
Correction d'un problème avec la fonction qiskit.pulse.transforms.inline_subroutines() qui, auparavant, ne supprimait pas tous les composants imbriqués lorsqu'elle était appelée sur des calendriers imbriqués. Corrigé #6321
Correction d'un problème lors du passage d'un appelable partiellement lié créé avec la fonction functools.partial() de la bibliothèque standard Python en tant que kwarg schedule à la méthode add() de la classe InstructionScheduleMap ce qui provoquait auparavant une erreur. Corrigé #6278
Correction d'un problème avec l'option PiecewiseChebyshev lorsque le réglage de l'option breakpoints à None sur un objet existant était incorrectement traité comme un point d'arrêt. Cette erreur a été corrigée de sorte que lorsqu'elle est réglée sur None , le comportement par défaut de l'approximation sur l'ensemble de l'intervalle est rétabli. Corrigé #6198
Correction d'un problème avec la méthode num_connected_components() qui renvoyait un nombre incorrect de composants lorsque le circuit contient deux ou plusieurs portes conditionnées par des registres classiques QuantumCircuit qui renvoyait un nombre incorrect de composants lorsque le circuit contenait au moins deux portes conditionnées sur des registres classiques. Corrigé #6477
Correction d'un problème avec le module qiskit.opflow.expectations où les coefficients d'une fonction d'état n'étaient pas multipliés correctement. Cette modification a également permis de corriger les calculs de gradients et de QFI lors de l'utilisation de l'option PauliExpectation ou AerPauliExpectation dans les classes. Par exemple, précédemment :
```
from qiskit.opflow import StateFn, I, One

exp = ~StateFn(I) @ (2 * One)
```
évaluée à 2 pour AerPauliExpectation et à 4 pour les autres convertisseurs d'attente. Étant donné que ~StateFn(I) @ (2 * One) est une notation abrégée pour ~(2 * One) @ I @ (2 * One), le coefficient désormais correct de 4 est renvoyé pour tous les convertisseurs d'attentes. Corrigé #6497
Correction du bug qui faisait échouer to_circuit() lorsque PauliOp avait une phase. Dans le même temps, l'utilisation de PauliGate a été rendue plus efficace.
Correction d'un problème où la sortie QASM générée par la méthode qasm() de QuantumCircuit pour les portes composites telles que MCXGate et ses variantes ( MCXGrayCode, MCXRecursive, et MCXVChain) serait incorrecte. Maintenant, si un Gate dans le circuit n'est pas présent dans qelib1.inc, sa définition est ajoutée à la chaîne QASM de sortie. Corrigé #4943 et #3945
Correction d'un problème avec la fonction circuit_drawer() et la méthode draw() de la méthode QuantumCircuit. Lors de l'utilisation des modes de sortie mpl ou latex , avec le kwarg cregbundle réglé sur False et le kwarg reverse_bits réglé sur True, les bits des registres classiques s'affichent dans le même ordre que lorsque reverse_bits est réglé sur False.
Correction d'un problème lors de l'utilisation de l'instruction qiskit.extensions.Initialize qui ne définissait pas correctement la phase globale de la définition synthétisée lors de sa construction. Corrigé #5320
Correction d'un problème où l'ordre des bits dans qiskit.circuit.library.PhaseOracle.evaluate_bitstring() ne correspondait pas à l'ordre de la chaîne de bits mesurée. Cette correction affecte également l'exécution de la classe d'algorithmes Grover si l'oracle est spécifié en tant que PhaseOraclequi identifiera désormais correctement la chaîne de bits correcte. Corrigé #6314
Corrige un bogue dans Optimize1qGatesDecomposition() qui faisait que certaines courtes séquences de portes n'étaient pas réécrites.
Correction d'un problème dans la méthode qiskit.opflow.gradients.Gradient.gradient_wrapper() avec le calcul du gradient. Auparavant, si l'opérateur n'était pas diagonal, un résultat incorrect était renvoyé dans certaines situations. Ce problème a été résolu par l'utilisation d'un convertisseur d'espérance afin de garantir que le résultat est toujours correct.
Correction d'un problème avec la fonction circuit_drawer() et la méthode draw() de QuantumCircuit avec tous les modes de sortie, qui rendait incorrectement une instruction personnalisée comprenant des bits classiques dans certaines circonstances. Corrigé #3201, #3202, et #6178
Correction d'un problème dans circuit_drawer() et la méthode draw() de la classe QuantumCircuit lors de l'utilisation du mode de sortie mpl , les portes en Z contrôlées étaient incorrectement dessinées comme étant asymétriques. Corrigé #5981
Correction d'un problème avec la passe de transposition OptimizeSwapBeforeMeasure où dans certaines situations un SwapGate contenant une condition classique était supprimée. Corrigé #6192
Correction d'un problème avec la phase de la classe qiskit.opflow.gradients.QFI lorsque la valeur de qfi_method est fixée à lin_comb_full , ce qui entraînait l'évaluation d'un observable incorrect.
Correction d'un problème avec la classe VQE lorsqu'elle est exécutée avec l'option L_BFGS_B ou P_BFGS et que des gradients sont utilisés, le gradient était incorrectement passé comme un tableau numpy au lieu de la liste de flottants attendue, ce qui entraînait une erreur. Ce problème a été résolu et vous pouvez désormais utiliser des dégradés avec VQE et l'option L_BFGS_B ou P_BFGS et les optimiseurs.

Autres remarques

La dépréciation de la méthode parameters() pour la classe Instruction a été annulée. Cette méthode a été supprimée à l'origine dans le site 0.17.0, mais elle reste nécessaire pour plusieurs applications, notamment lors de l'exécution d'expériences d'étalonnage. Cette méthode continuera à être soutenue et ne sera pas supprimée.

Aer 0.8.2

Pas de modification

Ignis 0.6.0

Pas de modification

Aqua 0.9.4

Pas de modification

IBM 0.15.0 du fournisseur Q

Nouvelles fonctions

Ajout de la prise en charge de la nouvelle méthode qiskit.providers.ibmq.runtime.RuntimeJob.error_message() qui renvoie une chaîne de caractères représentant la raison de l'échec du travail.

Le paramètre d'entrée de la méthode qiskit.providers.ibmq.runtime.IBMRuntimeService.run() peut désormais être spécifié sous la forme d'une instance qiskit.providers.ibmq.runtime.ParameterNamespace , ce qui permet d'utiliser les fonctions d'auto-complétion. Vous pouvez utiliser qiskit.providers.ibmq.runtime.RuntimeProgram.parameters() pour récupérer une instance ParameterNamespace .

Par exemple :

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'utilisateur peut désormais définir la visibilité (privée/publique) d'un programme Qiskit Runtime à l'aide de qiskit.providers.ibmq.runtime.IBMRuntimeService.set_program_visibility().
Un paramètre booléen facultatif "pending" a été ajouté à qiskit.providers.ibmq.runtime.IBMRuntimeService.jobs() et permet de filtrer les travaux en fonction de leur statut. Si l'option "en attente" n'est pas spécifiée, tous les travaux sont renvoyés. Si la valeur True est attribuée à l'option pending, les travaux "QUEUED" et "RUNNING" sont renvoyés. Si la valeur "pending" est définie sur "False", les travaux "DONE", "ERROR" et "CANCELLED" sont renvoyés.
Ajout de la prise en charge de l'indicateur use_measure_esp dans la méthode qiskit.providers.ibmq.IBMQBackend.run() . Si True, le backend utilisera la lecture ESP pour toutes les mesures qui constituent l'instruction terminale sur ce qubit. Si elle est utilisée et que le backend ne prend pas en charge la lecture des ESP, une erreur est levée.

Mise à niveau

qiskit.providers.ibmq.runtime.RuntimeProgram.parameters() est maintenant une méthode qui renvoie une instance de qiskit.providers.ibmq.runtime.ParameterNamespace , que vous pouvez utiliser pour remplir les valeurs des paramètres du programme d'exécution et les transmettre à qiskit.providers.ibmq.runtime.IBMRuntimeService.run().
Le drapeau open_pulse dans la configuration du backend n'indique plus si un backend supporte le contrôle du niveau d'impulsion. Par conséquent, qiskit.providers.ibmq.IBMQBackend.configuration() peut renvoyer une instance PulseBackendConfiguration même si son indicateur open_pulse est False.
Le niveau de partage des tâches n'est plus pris en charge en raison du faible taux d'adoption et l'interface correspondante sera supprimée dans une prochaine version. Cela signifie que vous ne devez plus transmettre share_level lors de la création d'un travail ou utiliser la méthode qiskit.providers.ibmq.job.IBMQJob.share_level() pour obtenir le niveau de partage d'un travail.

Remarques concernant la dépréciation

L'instruction id a été supprimée sur les serveurs matériels IBM. Au lieu de cela, veuillez utiliser l'instruction delay qui met en œuvre des délais de longueur variable, spécifiés en unités de dt. Lors de l'exécution d'un circuit contenant une instruction id , un avertissement est émis lors de la soumission de la tâche et toutes les instructions id de la tâche sont automatiquement remplacées par leur instruction équivalente delay .

Cette page a-t-elle été utile ?

Signaler un bogue, une coquille ou proposer du contenu sur GitHub.