Notes de publication de Qiskit 0.25

0.25.4

Terra 0.17.2

Prélude

Il s'agit d'une version de correction de bogues qui corrige plusieurs problèmes de la version 0.17.1. Plus important encore, cette version corrige la compatibilité de la classe QuantumInstance lorsqu'elle est exécutée sur des backends basés sur la classe abstraite BackendV1 classe abstraite. Cela corrige tous les algorithmes et applications construits sur qiskit.algorithms ou qiskit.opflow lorsqu'ils sont exécutés sur des serveurs plus récents.

Corrections des erreurs

Correction d'un problème avec la passe de BasisTranslator qui, dans certains cas, traduisait des portes déjà présentes dans la base cible. Il en résulterait un temps d'exécution plus long et des résultats moins optimaux. Corrigé #6085
Correction d'un problème dans SPSA lorsque l'optimiseur était initialisé avec une fonction de rappel via le kwarg callback , ce qui pouvait provoquer une erreur.
Correction d'un problème dans les kwarg qiskit.quantum_info.Statevector.expectation_value() et qiskit.quantum_info.DensityMatrix.expectation_value`methods where the ``qargs`() kwarg était ignoré si l'opérateur était un Pauli ou SparsePauliOp objet opérateur. Corrigé #6303
Correction d'un problème dans la méthode qiskit.quantum_info.Pauli.evolve() qui pouvait entraîner le retour d'un Pauli incorrect en cas d'évolution par un CZGate, CYGate, ou une SwapGate porte.
Correction d'un problème dans la méthode qiskit.opflow.SparseVectorStateFn.to_dict_fn() , qui avait auparavant au plus une entrée pour l'état "all zero" en raison d'une erreur d'index.
Correction d'un problème dans la méthode qiskit.opflow.SparseVectorStateFn.equals() afin qu'elle renvoie correctement True ou False au lieu d'une comparaison de vecteurs épars des éléments individuels.
Correction d'un problème dans les Statevector et DensityMatrix méthodes de probabilité qiskit.quantum_info.Statevector.probabilities(), qiskit.quantum_info.Statevector.probabilities_dict(), qiskit.quantum_info.DensityMatrix.probabilities(), qiskit.quantum_info.DensityMatrix.probabilities_dict() où les probabilités renvoyées pourraient avoir un ordre incorrect pour certaines valeurs de qargs kwarg. Corrigé #6320
Correction d'un problème où la classe TaperedPauliSumOp ne prenait pas en charge la multiplication avec l'objet ParameterExpression et ne disposait pas non plus de la méthode assign_parameters() nécessaire pour travailler avec les objets ParameterExpression objets. Corrigé #6127
Correction de la compatibilité de la classe QuantumInstance lorsqu'elle est exécutée sur des backends basés sur la classe abstraite BackendV1 classe abstraite. Corrigé #6280

Aer 0.8.2

Pas de modification

Ignis 0.6.0

Pas de modification

Aqua 0.9.1

Pas de modification

IBM 0.12.3 du fournisseur Q

Pas de modification

0.25.3

Terra 0.17.1

Pas de modification

Aer 0.8.2

Problèmes connus

Les sites SaveExpectationValue et SaveExpectationValueVariance ont été désactivés pour la méthode extended_stabilizer des sites QasmSimulator et AerSimulator car ils renvoient une valeur incorrecte pour certains composants de l'opérateur de Pauli. Pour plus d'informations et d'exemples, consultez le site #1227 <https://github.com/Qiskit/qiskit-aer/issues/1227>.

Corrections des erreurs

Correction d'un problème de performance lié à la manière dont l'attribut de configuration basis_gates a été défini. Auparavant, il y avait des effets secondaires involontaires sur la classe backend qui pouvaient entraîner une augmentation progressive de la durée d'exécution des simulations répétées. Pour plus d'informations et d'exemples, consultez le site #1229 <https://github.com/Qiskit/qiskit-aer/issues/1229>.
Correction d'un bogue avec l'instruction du simulateur "multiplexer" où l'ordre des qubits cibles et de contrôle était inversé par rapport à l'ordre de l'instruction Qiskit.
Correction d'un bogue introduit dans 0.8.0 où les simulations GPU allouaient de la mémoire hôte inutile en plus de la mémoire GPU.
Corrige un bogue dans la méthode du simulateur stabilizer de QasmSimulator et AerSimulator où la valeur de l'espérance pour save_expectation_value et snapshot_expectation_value pouvait avoir le mauvais signe pour certaines Y Pauli.

Ignis 0.6.0

Pas de modification

Aqua 0.9.1

Pas de modification

IBM 0.12.3 du fournisseur Q

Pas de modification

0.25.2

Terra 0.17.1

Pas de modification

Aer 0.8.1

Pas de modification

Ignis 0.6.0

Pas de modification

Aqua 0.9.1

Pas de modification

IBM 0.12.3 du fournisseur Q

Autres remarques

L'attribut qiskit.providers.ibmq.experiment.analysis_result.AnalysisResult fit est désormais facultatif.

0.25.1

Terra 0.17.1

Prélude

Il s'agit d'une version de correction de bogues qui corrige plusieurs problèmes de la version 0.17.0. Plus important encore, cette version corrige le paquet sdist incorrectement construit pour la version 0.17.0 qui n'était pas réellement compilable et bloquait l'installation sur les plates-formes ne disposant pas de binaires précompilés.

Corrections des erreurs

Correction d'un problème où l'attribut global_phase n'était pas conservé dans l'objet de sortie QuantumCircuit lorsque la méthode qiskit.circuit.QuantumCircuit.reverse_bits() était appelée. Par exemple :
```
import math
from qiskit import QuantumCircuit

qc = QuantumCircuit(3, 2, global_phase=math.pi)
qc.h(0)
qc.s(1)
qc.cx(0, 1)
qc.measure(0, 1)
qc.x(0)
qc.y(1)

reversed = qc.reverse_bits()
print(reversed.global_phase)
```
imprimera désormais correctement $\pi$ .
Correction d'un problème où la passe du transpileur Unroller ne préservait pas la phase globale dans le cas d'instructions imbriquées ayant une règle dans leur définition. Corrigé #6134
Correction d'un problème où l'attribut parameter d'un objet ControlledGate construit à partir d'un objet UnitaryGate ne prenait pas la valeur de la matrice unitaire de l'objet UnitaryGate . Auparavant, control() construisait une matrice ControlledGate dont l'attribut parameter correspondait à la version contrôlée de la matrice UnitaryGate . Cela entraînerait une modification de l'objet parameter de la base UnitaryGate et des appels ultérieurs à l'objet inverse() créait l'inverse d'une UnitaryGate à double contrôle. Corrigé #5750
Correction d'un problème avec les gestionnaires de passes prédéfinies level_0_pass_manager et level_1_pass_manager (qui correspondent à optimization_level 0 et 1 pour transpile()) qui, dans certains cas, produisaient des circuits ne correspondant pas à la base demandée.
Correction d'un bug où l'utilisation de SPSA avec une calibration automatique du taux d'apprentissage et de la perturbation (i.e. learning_rate et perturbation sont None dans l'initialisateur), stocke la calibration pour toutes les optimisations futures. Au lieu de cela, l'étalonnage doit être effectué pour chaque nouvelle fonction objective.

Aer 0.8.1

Corrections des erreurs

Correction d'un problème lié à l'utilisation de la méthode matrix_product_state des simulateurs AerSimulator et QasmSimulator lors de l'exécution d'une simulation bruyante avec des erreurs de Kraus. Auparavant, la méthode de simulation de l'état du produit matriciel ne propageait pas les changements aux qubits voisins après l'application de la matrice de Kraus. Cette erreur a été corrigée afin que les résultats de la simulation soient corrects. Corrigé #1184 et #1205
Correction d'un problème où l'instruction qiskit.extensions.Initialize désactivait l'optimisation de l'échantillonnage des mesures pour les méthodes de simulation statevector et matrix_product_state des simulateurs AerSimulator et QasmSimulator , même s'il s'agissait de la première instruction de circuit ou qu'elle s'appliquait à tous les qubits et qu'elle était donc déterministe. Corrigé #1210
Correction d'un problème avec les instructions SaveStatevector et SnapshotStatevector lorsqu'elles sont utilisées avec la méthode de simulation extended_stabilizer des simulateurs AerSimulator et QasmSimulator et qu'elles renvoient un vecteur d'état non normalisé. Corrigé #1196
La méthode de simulation matrix_product_state est désormais compatible avec l'instruction set state, qiskit.providers.aer.library.SetMatrixProductState, qui n'existait pas auparavant et qui permet de définir l'état d'une simulation dans un circuit.

Ignis 0.6.0

Pas de modification

Aqua 0.9.1

IBM 0.12.2 du fournisseur Q

Pas de modification

0.25.0

Cette version met officiellement fin au projet Qiskit Aqua. En conséquence, dans une prochaine version, le paquet qiskit-aqua sera retiré du métapaquet Qiskit, ce qui signifie que dans cette future version, pip install qiskit n'inclura plus qiskit-aqua. Les modules d'application fournis par qiskit-aqua ont été divisés en plusieurs nouveaux paquets : qiskit-optimization, qiskit-nature, qiskit-machine-learning, et qiskit-finance. Ces paquets peuvent être installés seuls (via la commande pip install standard, par exemple pip install qiskit-nature) ou avec le reste du métapackage Qiskit en tant qu'éléments optionnels (par ex. pip install 'qiskit[finance,optimization]' ou pip install 'qiskit[all]' Les algorithmes de base et le flux d'opérateurs font maintenant partie de qiskit-terra à l'adresse qiskit.algorithms et qiskit.opflow. En fonction de votre utilisation actuelle d'Aqua, vous devriez utiliser soit les paquets d'application, soit les nouveaux modules de Qiskit Terra. Pour plus de détails sur la façon de migrer depuis Qiskit Aqua, vous pouvez vous référer au guide de migration.

Terra 0.17.0

Prélude

Le Qiskit Terra 0.17.0 inclut de nombreuses nouvelles fonctionnalités et corrections de bugs. La principale nouveauté de cette version est l'introduction des fonctions qiskit.algorithms et qiskit.opflow qui ont été migrés et adaptés à partir du projet qiskit.aqua .

Nouvelles fonctions

La fonction qiskit.pulse.call() peut désormais prendre en charge un objet Parameter ainsi qu'un sous-programme paramétré. Cela permet d'attribuer des valeurs différentes aux Parameter pour chaque appel de sous-programme.

Exemple :

from qiskit.circuit import Parameter
from qiskit import pulse

amp = Parameter('amp')

with pulse.build() as subroutine:
    pulse.play(pulse.Gaussian(160, amp, 40), DriveChannel(0))

with pulse.build() as main_prog:
    pulse.call(subroutine, amp=0.1)
    pulse.call(subroutine, amp=0.3)

Le champ qiskit.providers.models.QasmBackendConfiguration dispose d'un nouveau champ processor_type qui peut éventuellement être utilisé pour fournir des informations sur le processeur d'un backend sous la forme suivante : {"family": <str>, "revision": <str>, segment: <str>}. Par exemple : {"family": "Canary", "revision": "1.0", segment: "A"}.
Les classes qiskit.pulse.Schedule, qiskit.pulse.Instruction, et qiskit.pulse.Channel ont maintenant une propriété parameter qui renverra tous les objets Parameter utilisés dans l'objet et une méthode is_parameterized() qui renvoie True si des paramètres sont utilisés dans l'objet.

Par exemple :
```
from qiskit.circuit import Parameter
from qiskit import pulse

shift = Parameter('alpha')

schedule = pulse.Schedule()
schedule += pulse.SetFrequency(shift, pulse.DriveChannel(0))

assert schedule.is_parameterized() == True
print(schedule.parameters)
```

Ajout d'un PiecewiseChebyshev à l'élément qiskit.circuit.library pour implémenter une approximation de Chebyshev par morceaux d'une fonction d'entrée. Pour une fonction donnée $f(x)$ et un degré $d$ , cette classe met en œuvre une approximation de Chebyshev polynomiale par morceaux sur $n$ qubits pour $f(x)$ sur les intervalles donnés. Tous les polynômes de l'approximation sont de degré $d$ .

Par exemple :

import numpy as np
from qiskit import QuantumCircuit
from qiskit.circuit.library.arithmetic.piecewise_chebyshev import PiecewiseChebyshev
f_x, degree, breakpoints, num_state_qubits = lambda x: np.arcsin(1 / x), 2, [2, 4], 2
pw_approximation = PiecewiseChebyshev(f_x, degree, breakpoints, num_state_qubits)
pw_approximation._build()
qc = QuantumCircuit(pw_approximation.num_qubits)
qc.h(list(range(num_state_qubits)))
qc.append(pw_approximation.to_instruction(), qc.qubits)
qc.draw(output='mpl')

La classe BackendProperties possède désormais une méthode readout_length() qui renvoie la longueur de lecture [sec] du qubit donné.
Une nouvelle classe, ScheduleBlocka été ajoutée au module qiskit.pulse module. Cette classe fournit une nouvelle représentation d'un programme d'impulsions. Cette représentation est la mieux adaptée à la syntaxe du constructeur d'impulsions et est basée sur l'ordre relatif des instructions.

Cette représentation prend alignment_context au lieu de spécifier l'heure de début t0 pour chaque instruction. L'heure de début de l'instruction est implicitement attribuée avec la transformation spécifiée et la position relative des instructions.

Le système ScheduleBlock permet une programmation paresseuse des instructions, ce qui signifie que nous pouvons attribuer des paramètres arbitraires à la durée des instructions.

Par exemple :
```
from qiskit.pulse import ScheduleBlock, DriveChannel, Gaussian
from qiskit.pulse.instructions import Play, Call
from qiskit.pulse.transforms import AlignRight
from qiskit.circuit import Parameter

dur = Parameter('rabi_duration')

block = ScheduleBlock(alignment_context=AlignRight())
block += Play(Gaussian(dur, 0.1, dur/4), DriveChannel(0))
block += Call(measure_sched)  # subroutine defined elsewhere
```
ce code définit une expérience qui consiste à balayer une impulsion gaussienne suivie d'une mesure measure_sched, c'est-à-dire une expérience Rabi. Vous pouvez réutiliser l'objet block pour chaque durée analysée en lui attribuant une valeur de durée cible.
Ajout d'une nouvelle fonction array_to_latex() au module qiskit.visualization qui peut être utilisée pour représenter et visualiser des vecteurs et des matrices à l'aide de LaTeX.
```
from qiskit.visualization import array_to_latex
from numpy import sqrt, exp, pi
mat = [[0, exp(pi*.75j)],
       [1/sqrt(8), 0.875]]
array_to_latex(mat)
```
Les Statevector et DensityMatrix ont maintenant des méthodes draw() qui permettent de dessiner des objets sous forme de matrices textuelles, d'objets Latex IPython, de sources Latex, de sphères Q, de sphères de Bloch et de tracés de Hinton. Par défaut, le type de sortie est la sortie équivalente de __repr__ , mais cette valeur par défaut peut être modifiée dans un fichier de configuration utilisateur en définissant l'option state_drawer . Par exemple :
```
from qiskit.quantum_info import DensityMatrix
dm = DensityMatrix.from_label('r0')
dm.draw('latex')
```
```
from qiskit.quantum_info import Statevector
sv = Statevector.from_label('+r')
sv.draw('qsphere')
```
En outre, la méthode draw() est désormais utilisée pour l'affichage ipython de ces classes, de sorte que si vous modifiez le type de sortie par défaut dans un fichier de configuration utilisateur, lorsqu'un élément Statevector ou un objet DensityMatrix sont affichés dans un notebook jupyter, c'est ce type de sortie qui sera utilisé pour l'objet.
Les objets Pulse qiskit.pulse.Instruction et les objets Pulse paramétriques (par ex Gaussian permet désormais d'utiliser Parameter et ParameterExpression pour le paramètre duration . Par exemple :
```
from qiskit.circuit import Parameter
from qiskit.pulse import Gaussian

dur = Parameter('x_pulse_duration')
double_dur = dur * 2
rx_pulse = Gaussian(dur, 0.1, dur/4)
double_rx_pulse = Gaussian(double_dir, 0.1, dur/4)
```
Notez que si nous pouvons créer une instruction avec un paramètre duration , l'ajout d'une instruction avec un paramètre non lié duration à un programme n'est pris en charge que par la représentation nouvellement introduite ScheduleBlock. Pour plus de détails, voir la section des notes de mise à jour sur les problèmes connus.

La run() pour le QasmSimulatorPy, StatevectorSimulatorPy, et UnitarySimulatorPy prend maintenant un QuantumCircuit (ou une liste d'objets QuantumCircuit comme entrée. L'objet précédent QasmQobj est encore pris en charge pour l'instant, mais il sera supprimé dans une version ultérieure.

Pour un exemple d'utilisation, voir :

from qiskit import transpile, QuantumCircuit

from qiskit.providers.basicaer import BasicAer

backend = BasicAer.get_backend('qasm_simulator')

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

tqc = transpile(circuit, backend)
result = backend.run(tqc, shots=4096).result()

La passe CommutativeCancellation a un nouveau kwarg optionnel sur le constructeur basis_gates, qui prend la liste des noms des portes de base pour le backend cible. Lorsque cela est spécifié, le laissez-passer n'utilisera que les portes du site basis_gates kwarg. Auparavant, le laissez-passer remplaçait automatiquement les portes consécutives qui font la navette avec ZGate par la porte U1Gate sans condition. Le kwarg basis_gates vous permet de spécifier les portes de rotation z présentes dans la base cible afin d'éviter ce problème.
Les constructeurs de la classe Bit et des sous-classes, Qubit, Clbitet AncillaQubitont été mis à jour de telle sorte que leurs deux paramètres, register et index , sont désormais facultatifs. Cela permet de créer des objets binaires indépendants d'un registre.

Une nouvelle classe, BooleanExpressiona été ajoutée au module qiskit.circuit.classicalfunction module. Cette classe permet de créer un oracle à partir d'une expression booléenne Python. Par exemple :

from qiskit.circuit import BooleanExpression, QuantumCircuit

expression = BooleanExpression('~x & (y | z)')
circuit = QuantumCircuit(4)
circuit.append(expression, [0, 1, 2, 3])
circuit.draw('mpl')

circuit.decompose().draw('mpl')

L'article BooleanExpression comprend également une méthode, from_dimacs_file()qui permet de charger des formules décrites dans le format DIMACS-CNF. Par exemple :

from qiskit.circuit import BooleanExpression, QuantumCircuit

boolean_exp = BooleanExpression.from_dimacs_file("simple_v3_c2.cnf")
circuit = QuantumCircuit(boolean_exp.num_qubits)
circuit.append(boolean_exp, range(boolean_exp.num_qubits))
circuit.draw('text')

     ┌───────────────────┐
q_0: ┤0                  ├
     │                   │
q_1: ┤1                  ├
     │  SIMPLE_V3_C2.CNF │
q_2: ┤2                  ├
     │                   │
q_3: ┤3                  ├
     └───────────────────┘

circuit.decompose().draw('text')

q_0: ──o────o────────────
       │    │
q_1: ──■────o────■───────
       │    │    │
q_2: ──■────┼────o────■──
     ┌─┴─┐┌─┴─┐┌─┴─┐┌─┴─┐
q_3: ┤ X ├┤ X ├┤ X ├┤ X ├
     └───┘└───┘└───┘└───┘

Ajout d'une nouvelle classe, PhaseOraclea été ajoutée au module qiskit.circuit.library module. Cette classe permet de construire des circuits d'oracle de phase à partir de Python expressions booléennes.

from qiskit.circuit.library.phase_oracle import PhaseOracle

oracle = PhaseOracle('x1 & x2 & (not x3)')
oracle.draw('mpl')

Ces oracles de phase peuvent être utilisés dans le cadre d'un algorithme plus large, par exemple avec qiskit.algorithms.AmplificationProblem:

from qiskit.algorithms import AmplificationProblem, Grover
from qiskit import BasicAer

backend = BasicAer.get_backend('qasm_simulator')

problem = AmplificationProblem(oracle, is_good_state=oracle.evaluate_bitstring)
grover = Grover(quantum_instance=backend)
result = grover.amplify(problem)
result.top_measurement

La classe PhaseOracle comprend également une méthode from_dimacs_file() qui permet de construire un oracle de phase à partir d'un fichier décrivant une formule au format DIMACS-CNF.

from qiskit.circuit.library.phase_oracle import PhaseOracle

oracle = PhaseOracle.from_dimacs_file("simple_v3_c2.cnf")
oracle.draw('text')

state_0: ─o───────o──────────────
          │ ┌───┐ │ ┌───┐
state_1: ─■─┤ X ├─■─┤ X ├─■──────
          │ └───┘   └───┘ │ ┌───┐
state_2: ─■───────────────o─┤ Z ├
                            └───┘

Toutes les passes de transpilation (c'est-à-dire toutes les instances de BasePass) sont désormais directement appelables. L'appel d'une passe fournit une interface pratique pour l'exécution de la passe sur un QuantumCircuit objet.

Par exemple, l'exécution d'une seule passe de transformation, telle que BasisTranslatorpeut se faire avec :

from qiskit import QuantumCircuit
from qiskit.transpiler.passes import BasisTranslator
from qiskit.circuit.equivalence_library import SessionEquivalenceLibrary as sel

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

pass_instance = BasisTranslator(sel, ['rx', 'rz', 'cx'])
result = pass_instance(circuit)
result.draw(output='mpl')

Lors de l'exécution d'un cycle d'analyse, un ensemble de propriétés (comme dict ou PropertySet) doit être ajouté en tant que paramètre et peut être modifié "sur place". Par exemple :

from qiskit import QuantumCircuit
from qiskit.transpiler.passes import Depth

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

property_set = {}
pass_instance = Depth()
pass_instance(circuit, property_set)
print(property_set)

La classe QasmQobjConfig dispose désormais d'un kwarg optionnel pour meas_level et meas_return. Ces champs peuvent être utilisés pour permettre de générer QasmQobj qui prennent en charge meas_level=1 (données kernellisées) pour les travaux sur les circuits (auparavant, cela n'était possible que pour les objets) PulseQobj ). La fonction assemble() a été mise à jour pour définir ce champ pour les objets QasmQobj objets qu'elle génère.
Une nouvelle méthode tensor() a été ajoutée à la classe QuantumCircuit a vu l'ajout d'une nouvelle méthode. Cette méthode permet d'associer un autre circuit à un circuit existant. Cette méthode fonctionne de manière analogue à qiskit.quantum_info.Operator.tensor() et est compatible avec la convention little-endian de Qiskit.

Par exemple :
```
from qiskit import QuantumCircuit
top = QuantumCircuit(1)
top.x(0);
bottom = QuantumCircuit(2)
bottom.cry(0.2, 0, 1);
bottom.tensor(top).draw(output='mpl')
```
La classe qiskit.circuit.QuantumCircuit prend désormais en charge les métadonnées arbitraires de forme libre avec l'attribut metadata attribut. Un utilisateur (ou un programme construit au-dessus de QuantumCircuit) peut attacher des métadonnées à un circuit afin de pouvoir le suivre. Par exemple :
```
from qiskit.circuit import QuantumCircuit

qc = QuantumCircuit(2, user_metadata_field_1='my_metadata',
                    user_metadata_field_2='my_other_value')
```
ou :
```
from qiskit.circuit import QuantumCircuit

qc = QuantumCircuit(2)
qc.metadata = {'user_metadata_field_1': 'my_metadata',
               'user_metadata_field_2': 'my_other_value'}
```
Ces métadonnées ne seront pas utilisées pour influencer l'exécution du circuit, mais simplement pour suivre le circuit pendant la durée de vie de l'objet. L'attribut metadata persistera entre toutes les transformations du circuit, y compris transpile() et assemble(). Il est prévu que les fournisseurs associent les métadonnées aux résultats qu'ils renvoient, de sorte que les utilisateurs puissent filtrer les résultats sur la base des métadonnées du circuit, de la même manière qu'ils peuvent actuellement le faire avec QuantumCircuit.name.
Ajouter une nouvelle classe d'opérateurs CNOTDihedral a été ajoutée au module qiskit.quantum_info module. Cette classe est utilisée pour représenter le groupe CNOT-Dihedral, qui est généré par les portes quantiques CXGate, TGateet XGate.
Ajoute un opérateur binaire & (__and__) aux sous-classes BaseOperator (ex qiskit.quantum_info.Operator) dans le module qiskit.quantum_info module. Il s'agit d'un raccourci pour appeler la méthode compose() (c'est-à-dire A & B == A.compose(B)).

Par exemple :
```
import qiskit.quantum_info as qi

qi.Pauli('X') & qi.Pauli('Y')
```
Ajoute un opérateur binaire & (__and__) à qiskit.quantum_info.Statevector et qiskit.quantum_info.DensityMatrix classes. Il s'agit d'un raccourci pour appeler la méthode evolve() (c'est-à-dire psi & U == psi.evolve(U)).

Par exemple :
```
import qiskit.quantum_info as qi

qi.Statevector.from_label('0') & qi.Pauli('X')
```
Une nouvelle porte à 2 qubits, ECRGatela résonance croisée d'écho (RCE), a été ajoutée au module qiskit.circuit.library ainsi qu'une méthode correspondante, ecr() pour la classe QuantumCircuit classe. La porte ECR est constituée de deux impulsions $CR(\frac{π}{4})$ , séparées par un XGate entre elles pour l'écho. Cette porte est localement équivalente à un CXGate (peut être convertie en CNOT avec une pré- ou post-rotation locale). C'est la porte native sur le matériel IBM actuel et compiler vers elle permet de fusionner les pré/post-rotations avec le reste du circuit.
Un nouveau kwarg approximation_degree a été ajouté à la fonction transpile() pour permettre une compilation approximative. Les valeurs valables sont comprises entre 0 et 1, une valeur plus élevée signifiant une approximation moindre. Il s'agit d'un cadran heuristique permettant d'expérimenter des approximations de circuits. L'interprétation concrète de ce nombre est laissée à chaque passe, qui peut l'utiliser pour effectuer une version approximative de la passe. Parmi les exemples spécifiques, on peut citer le UnitarySynthesis pass ou les traducteurs or vers des ensembles de portes discrètes. Si une passe ne prend pas en charge cette option, elle implique une transformation exacte.
Deux nouveaux passages de transpondeurs, GateDirection et qiskit.transpiler.passes.CheckGateDirectionont été ajoutés au module qiskit.transpiler.passes ont été ajoutés au module. Ces nouvelles passes sont censées être des remplacements plus généraux pour CXDirection et CheckCXDirection (qui sont tous deux maintenant dépréciés, voir les notes de dépréciation pour plus de détails) qui effectuent la même fonction mais fonctionnent avec d'autres portes que juste CXGate.
Sous Windows, l'exécution parallèle avec la fonction parallel_map() peut désormais être activée (elle est toujours désactivée par défaut). Pour ce faire, vous pouvez soit définir parallel = True dans un fichier de configuration utilisateur, soit remplacer la variable d'environnement QISKIT_PARALLEL par TRUE (ce qui aura également un effet sur transpile() et assemble() qui utilisent tous deux parallel_map() en interne). Il est important de noter qu'en activant le parallélisme sous Windows, il y a des limitations sur la façon dont Python lance les processus sous Windows, voir la section Problèmes connus ci-dessous pour plus de détails sur les limitations de l'exécution parallèle sous Windows.
Une nouvelle fonction, hellinger_distance()pour calculer la distance de Hellinger entre deux distributions de comptes a été ajoutée au module qiskit.quantum_info a été ajoutée au module.
La fonction decompose_clifford() du module qiskit.quantum_info (qui est utilisée en interne par la méthode qiskit.quantum_info.Clifford.to_circuit() ) dispose d'un nouveau kwarg method qui permet de sélectionner la méthode de synthèse utilisée en lui attribuant la valeur 'AG' ou 'greedy'. Par défaut, pour plus de trois qubits, il est fixé à 'greedy' qui utilise une routine de compilation non optimale pour la synthèse des éléments de Clifford, par Bravyi et. al, qui permet généralement d'obtenir un meilleur coût CX que la méthode Aaronson-Gottesman utilisée précédemment (pour plus de deux qubits). Vous pouvez utiliser le kwarg method pour revenir à la précédente méthode par défaut Aaronson-Gottesman en définissant method='AG'.
La classe Initialize du module qiskit.extensions peut maintenant être construite en utilisant un entier. Les bits "1" de l'entier insèrent un Reset et un XGate dans le circuit du qubit correspondant. Cela se fera en utilisant la convention standard little-endian de qiskit, c'est-à-dire que le bit le plus à droite de l'entier définira le qubit 0. Par exemple, si le paramètre Initialize est égal à 5 , les qubits 0 et 2 prendront la valeur 1.
```
from qiskit.extensions import Initialize

initialize = Initialize(13)
initialize.definition.draw('mpl')
```
La classe Initialize du module qiskit.extensions permet maintenant de construire directement à partir d'une étiquette de Pauli (analogue à la méthode qiskit.quantum_info.Statevector.from_label() ). Le label de Pauli fait référence aux états de base des états propres de Pauli Z, X, Y. Ces étiquettes utilisent la notation standard little-endian de Qiskit, par exemple une étiquette de '01' initialiserait le qubit 0 à $|1\rangle$ et le qubit 1 à $|0\rangle$ .
```
from qiskit.extensions import Initialize

initialize = Initialize("10+-lr")
initialize.definition.draw('mpl')
```
Le kwarg, template_list, pour le constructeur de la passe de qiskit.transpiler.passes.TemplateOptimization transpiler pass permet maintenant de prendre en compte une liste de QuantumCircuit et DAGDependency et d'objets. Auparavant, seuls les QuantumCircuit étaient acceptés (qui étaient convertis en interne en objets DAGDependency ) dans la liste d'entrée.
Un nouveau transpileur pass, qiskit.transpiler.passes.RZXCalibrationBuildercapable de générer des étalonnages et de les ajouter à un circuit quantique, a été introduite. Cette passe prend des objets calibrés CXGate et crée les calibrations pour les objets qiskit.circuit.library.RZXGate avec un angle de rotation arbitraire. Les horaires sont créés en étirant et en comprimant les impulsions GaussianSquare des portes de résonance écho-croisées.
De nouveaux circuits modèles pour l'utilisation de qiskit.circuit.library.RZXGate sont ajoutés au module qiskit.circuit.library (par exemple rzx_yz). Cela permet de jumeler le TemplateOptimization avec le laissez-passer qiskit.transpiler.passes.RZXCalibrationBuilder de trouver et de remplacer automatiquement les séquences de portes, telles que CNOT - P(theta) - CNOT, par des circuits plus efficaces basés sur les données de la base de données qiskit.circuit.library.RZXGate avec un étalonnage.
Le type de sortie matplotlib pour les champs circuit_drawer() et la méthode draw() pour la classe QuantumCircuit supporte désormais les fichiers de configuration pour définir le style de visualisation. Dans les versions précédentes, une fonctionnalité de base permettait aux utilisateurs de passer un kwarg style qui prenait en charge un kwarg dict pour personnaliser les couleurs et les autres caractéristiques d'affichage du tiroir mpl . Ces dictionnaires peuvent désormais être chargés directement à partir de fichiers JSON, sans qu'il soit nécessaire de transmettre un dictionnaire. Cela permet aux utilisateurs de créer de nouveaux fichiers de style et d'utiliser ce style pour les visualisations en transmettant le nom du fichier de style sous la forme d'une chaîne au kwarg style .

Pour tirer parti de cette fonctionnalité, vous devez définir l'option circuit_mpl_style_path dans un fichier de configuration utilisateur. Cette option doit être définie sur le chemin que qiskit doit rechercher pour les fichiers JSON de style. Si vous spécifiez plusieurs entrées de chemin, elles doivent être séparées par :. Par exemple, la définition de circuit_mpl_style_path = ~/.qiskit:~/user_styles dans un fichier de configuration utilisateur recherchera des fichiers JSON à la fois dans ~/.qiskit et ~/user_styles.

Un nouveau kwarg, format_marginal , a été ajouté à la fonction marginal_counts() qui, lorsqu'elle est définie sur True , formate la sortie des comptages en fonction de cregs dans le circuit et les indices manquants sont représentés par _. Par exemple :

from qiskit import QuantumCircuit, execute, BasicAer, result
from qiskit.result.utils import marginal_counts
qc = QuantumCircuit(5, 5)
qc.x(0)
qc.measure(0, 0)

result = execute(qc, BasicAer.get_backend('qasm_simulator')).result()
print(marginal_counts(result.get_counts(), [0, 2, 4], format_marginal=True))

Amélioration des performances des qiskit.quantum_info.Statevector.expectation_value() et qiskit.quantum_info.DensityMatrix.expectation_value() lorsque l'opérateur argument est un Pauli ou SparsePauliOp l'opérateur.
Le fichier de configuration utilisateur comporte deux nouvelles options de configuration, num_processes et parallel, qui sont utilisées pour contrôler le comportement par défaut de parallel_map(). L'option parallel est un booléen qui permet d'indiquer si parallel_map() s'exécutera dans plusieurs processus ou non. S'il est fixé à False , les appels à parallel_map() seront exécutés en série, tandis que s'il vaut True , ils seront exécutés en parallèle. L'option num_processes prend un entier qui définit le nombre de CPU à utiliser lors de l'exécution en parallèle. Par défaut, il utilise le nombre de cœurs de l'unité centrale d'un système.
Il existe deux nouvelles variables d'environnement, QISKIT_PARALLEL et QISKIT_NUM_PROCS, qui peuvent être utilisées pour contrôler le comportement par défaut de parallel_map(). L'option QISKIT_PARALLEL peut être définie à TRUE (toute majuscule) pour que le processus par défaut s'exécute dans plusieurs processus lors de l'appel de parallel_map() est appelé. S'il est défini à une autre valeur parallel_map() sera exécuté en série. QISKIT_NUM_PROCS prend un entier (par exemple QISKIT_NUM_PROCS=5) qui sera utilisé comme nombre de processus par défaut. Ces deux options ont la priorité sur l'option équivalente définie dans le fichier de configuration de l'utilisateur.
Une nouvelle méthode, gradient()a été ajoutée à la classe ParameterExpression classe. Cette méthode est utilisée pour évaluer le gradient d'un objet ParameterExpression objet.
La méthode __eq__ (c'est-à-dire ce qui est appelé lorsque l'opérateur == est utilisé) pour l'opérateur ParameterExpression permet désormais la comparaison avec une valeur numérique. Auparavant, il n'était possible de comparer que deux instances de ParameterExpression avec ==. Par exemple :
```
from qiskit.circuit import Parameter

x = Parameter("x")
y = x + 2
y = y.assign(x, -1)

assert y == 1
```
La classe PauliFeatureMap du module qiskit.circuit.library permet désormais d'ajuster le facteur de rotation, $\alpha$ , soit en utilisant le kwarg alpha dans le constructeur, soit en définissant l'attribut alpha après la création. Auparavant, cette valeur était fixée à 2.0. L'ajustement de cet attribut permet un meilleur contrôle des limites de décision et offre une flexibilité supplémentaire dans le traitement des caractéristiques d'entrée sans qu'il soit nécessaire de les mettre à l'échelle de manière explicite dans l'ensemble de données.
Une nouvelle Gate classe, PauliGatea été ajoutée au module qiskit.circuit.library et la méthode correspondante, pauli()a été ajoutée à la QuantumCircuit a été ajoutée à la classe. Cette nouvelle classe de portes permet d'appliquer simultanément plusieurs portes de Pauli à différents qubits. Ceci est principalement utile pour les simulateurs qui peuvent utiliser cette nouvelle porte pour implémenter plus efficacement plusieurs portes de Pauli simultanées.
Améliorer l'efficacité de l'opérateur qiskit.quantum_info.Pauli l'opérateur. Cette classe représente maintenant un élément du groupe de Pauli à N-qubits complet, y compris les coefficients complexes. Il prend désormais en charge les méthodes de l'API de l'opérateur, notamment compose(), dot(), tensor() etc, où compose et point sont définis par rapport au groupe de Pauli complet.

Cette classe permet également de convertir la représentation de Pauli en chaîne de caractères pour plus de commodité.

Par exemple
```
from qiskit.quantum_info import Pauli

P1 = Pauli('XYZ')
P2 = Pauli('YZX')
P1.dot(P2)
```
Les Pauli peuvent également être ajoutés directement aux QuantumCircuit objets
```
from qiskit import QuantumCircuit
from qiskit.quantum_info import Pauli

circ = QuantumCircuit(3)
circ.append(Pauli('XYZ'), [0, 1, 2])
circ.draw(output='mpl')
```
Des méthodes supplémentaires permettent de calculer quand deux Pauli se commutent (en utilisant la méthode commutes() ) ou anticommutent (à l'aide de la méthode anticommutes() et de calculer le Pauli résultant de la conjugaison de Clifford $P^\prime = C.P.C^\dagger$ en utilisant la méthode evolve() méthode.

Voir la documentation API de la classe Pauli pour plus d'informations.
Une nouvelle fonction, random_pauli()pour générer un élément aléatoire du groupe de Pauli de N-qubits a été ajoutée au module qiskit.quantum_info a été ajoutée au module.
Une nouvelle classe, PiecewisePolynomialPauliRotationsa été ajoutée au module qiskit.circuit.library module. Cet élément de la bibliothèque de circuits est utilisé pour mettre en correspondance une fonction polynomiale par morceaux, $f(x)$ , définie par des points de rupture et des coefficients, avec les amplitudes des qubits. Les points d'arrêt $(x_0, ..., x_J)$ sont un sous-ensemble de $[0, 2^n-1]$ , où $n$ est le nombre de qubits d'état. Les coefficients correspondants $[a_{j,1},...,a_{j,d}]$ , où $d$ est le degré le plus élevé de tous les polynômes. Le site $f(x)$ est alors défini comme suit :

\begin{split}f(x) = \begin{cases} 0, x < x_0 \\ \sum_{i=0}^{i=d}a_{j,i} x^i, x_j \leq x < x_{j+1} \end{cases}\end{split}

où nous supposons implicitement $x_{J+1} = 2^n$ . Et la cartographie appliquée aux amplitudes est donnée par

F|x\rangle |0\rangle = \cos(p_j(x))|x\rangle |0\rangle + \sin(p_j(x))|x\rangle |1\rangle

Cette cartographie est basée sur les rotations Y de Pauli contrôlées et construite à l'aide de l'algorithme PolynomialPauliRotations.

Un nouveau module qiskit.algorithms a été introduit. Ce module contient des fonctionnalités équivalentes à celles fournies précédemment par le module qiskit.aqua.algorithms (qui est désormais obsolète) et fournit les éléments de base pour la construction d'algorithmes quantiques. Pour plus de détails sur la migration de qiskit-aqua vers ce nouveau module, veuillez consulter le guide de migration.
Un nouveau module qiskit.opflow a été introduit. Ce module contient des fonctionnalités équivalentes à celles fournies précédemment par le module qiskit.aqua.operators (qui est désormais obsolète) et fournit les opérateurs et les fonctions d'état utilisés pour construire des algorithmes quantiques. Pour plus de détails sur la migration de qiskit-aqua vers ce nouveau module, veuillez consulter le guide de migration.
Il s'agit de la première version qui inclut des roues binaires précompilées pour les systèmes Linux aarch64. Si vous utilisez un système compatible avec manylinux2014 aarch64 Linux, des roues précompilées sont désormais disponibles sur PyPI,. Il n'est plus nécessaire de compiler à partir des sources pour installer qiskit-terra.
La fonction qiskit.quantum_info.process_fidelity() peut désormais être utilisée avec un canal cible non unitaire. Dans ce cas, la valeur renvoyée est équivalente à la valeur qiskit.quantum_info.state_fidelity() des matrices normalisées qiskit.quantum_info.Choi pour les canaux.

Il convient de noter que les qiskit.quantum_info.average_gate_fidelity() et qiskit.quantum_info.gate_error() exigent toujours que le canal cible soit unitaire et soulèvent une exception s'il ne l'est pas.

Ajout d'une nouvelle fonction de création d'impulsions, qiskit.pulse.macro(). Cela permet aux fonctions normales de Python d'être décorées comme des macros. Cela permet d'utiliser des fonctions de construction d'impulsions dans le cadre de la fonction décorée. La macro du constructeur peut ensuite être appelée à partir d'un contexte de construction d'impulsions, ce qui permet de réutiliser le code.

Par exemple :

from qiskit import pulse

@pulse.macro
def measure(qubit: int):
    pulse.play(pulse.GaussianSquare(16384, 256, 15872),
               pulse.MeasureChannel(qubit))
    mem_slot = pulse.MemorySlot(0)
    pulse.acquire(16384, pulse.AcquireChannel(0), mem_slot)
    return mem_slot

with pulse.build(backend=backend) as sched:
    mem_slot = measure(0)
    print(f"Qubit measured into {mem_slot}")

sched.draw()

Une nouvelle classe, PauliTwoDesigna été ajoutée à la classe qiskit.circuit.library qui met en œuvre une forme particulière d'un circuit à 2 conceptions à partir de https://arxiv.org/pdf/1803.11173.pdf Par exemple, ce circuit peut ressembler à
```
from qiskit.circuit.library import PauliTwoDesign
circuit = PauliTwoDesign(4, reps=2, seed=5, insert_barriers=True)
circuit.decompose().draw(output='mpl')
```
Un nouveau tiroir d'impulsion qiskit.visualization.pulse_v2.draw() (qui est alias qiskit.visualization.pulse_drawer_v2) est maintenant disponible. Ce nouveau tiroir à impulsions prend en charge plusieurs nouvelles fonctions qui n'étaient pas présentes dans le tiroir à impulsions original (pulse_drawer()).
- Troncature des instructions à impulsion longue.
- Visualisation des impulsions paramétriques.
- Nouvelles feuilles de style IQXStandard, IQXSimple, IQXDebugging.
- Visualisation des informations du système (fréquence du canal, etc...) en spécifiant des qiskit.providers.Backend des objets à visualiser.
- Spécification des objets axis pour le traçage afin de permettre l'extension des tracés générés, c'est-à-dire pour les manipulations de publication.
Les nouvelles feuilles de style peuvent contenir des fonctions de rappel qui modifient dynamiquement l'apparence de l'image de sortie, par exemple en réassemblant une collection de canaux, en affichant les détails des instructions, en mettant à jour l'apparence des enveloppes d'impulsion, etc. Vous pouvez créer des fonctions de rappel personnalisées et les introduire dans une instance de feuille de style pour modifier l'apparence de la figure sans modifier le code du tiroir. Voir la documentation du module tiroir à impulsion pour plus de détails.

Notez que l'enregistrement des fichiers est désormais délégué à Matplotlib. Pour enregistrer des fichiers images, vous devez appeler la méthode savefig et renvoyer l'objet Figure .
Ajoute une méthode reverse_qargs() à la méthode qiskit.quantum_info.Statevector et qiskit.quantum_info.DensityMatrix aux classes Cette méthode inverse l'ordre des sous-systèmes dans les états et est équivalente à la méthode pour les états à N qubits qiskit.circuit.QuantumCircuit.reverse_bits() pour les états à N qubits. Par exemple :
```
from qiskit.circuit.library import QFT
from qiskit.quantum_info import Statevector

circ = QFT(3)

state1 = Statevector.from_instruction(circ)
state2 = Statevector.from_instruction(circ.reverse_bits())

state1.reverse_qargs() == state2
```
Ajoute une méthode reverse_qargs() à la classe qiskit.quantum_info.Operator classe. Cette méthode inverse l'ordre des sous-systèmes dans l'opérateur et est équivalente à la méthode pour les opérateurs à N qubits qiskit.circuit.QuantumCircuit.reverse_bits() pour les opérateurs à N qubits. Par exemple :
```
from qiskit.circuit.library import QFT
from qiskit.quantum_info import Operator

circ = QFT(3)

op1 = Operator(circ)
op2 = Operator(circ.reverse_bits())

op1.reverse_qargs() == op2
```
La méthode de sortie latex pour la fonction qiskit.visualization.circuit_drawer() et la méthode draw() utilisent désormais une étiquette définie par l'utilisateur sur les portes dans la visualisation de sortie. Par exemple :
```
import math

from qiskit.circuit import QuantumCircuit

qc = QuantumCircuit(2)
qc.h(0)
qc.rx(math.pi/2, 0, label='My Special Rotation')

qc.draw(output='latex')
```
Le kwarg routing_method de la fonction transpile() accepte désormais une nouvelle option, 'none'. Sur routing_method='none' , aucune passe de routage ne sera exécutée dans le cadre de la transpilation. Si le circuit ne correspond pas à la carte de couplage, une TranspilerError exception sera levée.
Une nouvelle classe de porte, RVGatea été ajoutée au module qiskit.circuit.library ainsi que la méthode QuantumCircuit correspondante rv(). Le RVGate est une porte de rotation générale, similaire à la porte UGatemais au lieu de spécifier des angles d'Euler, on spécifie les trois composantes d'un vecteur de rotation où la direction du vecteur spécifie l'axe de rotation et la magnitude spécifie l'angle de rotation autour de l'axe en radians. Par exemple :
```
import math

import np

from qiskit.circuit import QuantumCircuit

qc = QuantumCircuit(1)
theta = math.pi / 5
phi = math.pi / 3
# RGate axis:
axis = np.array([math.cos(phi), math.sin(phi)])
rotation_vector = theta * axis
qc.rv(*rotation_vector, 0)
```
Non lié Parameter utilisés dans un objet QuantumCircuit seront désormais triés par nom. Cela prendra effet pour les paramètres renvoyés par l'attribut parameters . En outre, les qiskit.circuit.QuantumCircuit.bind_parameters() et qiskit.circuit.QuantumCircuit.assign_parameters() peuvent désormais prendre en compte une liste de valeurs a qui les lieront/assigneront aux paramètres dans l'ordre de leur nom. Auparavant, ces méthodes n'acceptaient qu'un dictionnaire de paramètres et de valeurs. Par exemple :
```
from qiskit.circuit import QuantumCircuit, Parameter

circuit = QuantumCircuit(1)
circuit.rx(Parameter('x'), 0)
circuit.ry(Parameter('y'), 0)

print(circuit.parameters)

bound = circuit.bind_parameters([1, 2])
bound.draw(output='mpl')
```
Les constructeurs pour les qiskit.quantum_info.Statevector et qiskit.quantum_info.DensityMatrix peuvent maintenant prendre un objet QuantumCircuit pour construire un objet Statevector et DensityMatrix à partir de ce circuit, en supposant que les qubits sont initialisés à $|0\rangle$ . Par exemple :
```
from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector

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

statevector = Statevector(qc)
statevector.draw(output='latex')
```
De nouvelles classes de faux backend sont disponibles à l'adresse qiskit.test.mock. Il s'agit de versions simulées de ibmq_casablanca, ibmq_sydney, ibmq_mumbai, ibmq_lima, ibmq_belem, ibmq_quito. Comme pour les autres backends fictifs, ceux-ci incluent des instantanés de 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.

Problèmes connus

Tentative d'ajout d'un objet qiskit.pulse.Instruction avec un objet paramétré duration (c'est-à-dire que la valeur de duration est un objet non lié Parameter ou ParameterExpression ) à un objet qiskit.pulse.Schedule n'est pas supportée. Toute tentative dans ce sens entraînera l'ouverture de UnassignedDurationError PulseError s'affichera. Il s'agit d'une limitation de la manière dont les contraintes de chevauchement de Instruction sont évaluées actuellement. Cela est possible grâce à ScheduleBlockdans lequel les contraintes de chevauchement sont évaluées juste avant l'exécution.

Sur les systèmes Windows, lorsque l'exécution parallèle est activée pour parallel_map() le parallélisme peut ne pas fonctionner lorsqu'il est appelé à partir d'un script s'exécutant en dehors d'un bloc if __name__ == '__main__': . Cela est dû à la façon dont Python lance des processus parallèles sous Windows. Si une erreur RuntimeError ou AttributeError est soulevée par des scripts qui appellent parallel_map() (y compris les fonctions qui utilisent parallel_map() en interne, comme transpile()) avec Windows et le parallélisme activé, vous pouvez essayer d'intégrer les appels de scripts dans if __name__ == '__main__': pour contourner le problème. Par exemple :

from qiskit import QuantumCircuit, QiskitError
from qiskit import execute, Aer

qc1 = QuantumCircuit(2, 2)
qc1.h(0)
qc1.cx(0, 1)
qc1.measure([0,1], [0,1])
# making another circuit: superpositions
qc2 = QuantumCircuit(2, 2)
qc2.h([0,1])
qc2.measure([0,1], [0,1])
execute([qc1, qc2], Aer.get_backend('qasm_simulator'))

Doit être remplacée par :

from qiskit import QuantumCircuit, QiskitError
from qiskit import execute, Aer

def main():
    qc1 = QuantumCircuit(2, 2)
    qc1.h(0)
    qc1.cx(0, 1)
    qc1.measure([0,1], [0,1])
    # making another circuit: superpositions
    qc2 = QuantumCircuit(2, 2)
    qc2.h([0,1])
    qc2.measure([0,1], [0,1])
    execute([qc1, qc2], Aer.get_backend('qasm_simulator'))

if __name__ == '__main__':
    main()

si des erreurs sont rencontrées avec le parallélisme sous Windows.

Mise à niveau

Les gestionnaires de passe prédéfinis level_1_pass_manager, level_2_pass_manageret level_3_pass_manager (qui sont utilisés pour les sites optimization_level 1, 2, et 3 dans les transpile() et execute() ) utilisent désormais inconditionnellement la passe Optimize1qGatesDecomposition pour l'optimisation de la porte à 1 qubit. Auparavant, ces gestionnaires de passes utilisaient la passe Optimize1qGates si les portes de base contenaient u1, u2, ou u3. Si vous souhaitez continuer à utiliser l'ancien Optimize1qGates vous devrez construire un PassManager avec le mot de passe.
Suite à la transpilation d'un QuantumCircuitparamétré, l'attribut global_phase du circuit de sortie ne peut plus être retourné sous une forme simplifiée, si la phase globale est un ParameterExpression.

Par exemple :
```
qc = QuantumCircuit(1)
theta = Parameter('theta')

qc.rz(theta, 0)
qc.rz(-theta, 0)

print(transpile(qc, basis_gates=['p']).global_phase)
```
renvoyait précédemment 0, mais renverra désormais -0.5*theta + 0.5*theta. Ce changement était nécessaire pour éviter une pénalité importante en termes de performances d'exécution, car la simplification des expressions symboliques peut être assez lente, en particulier s'il y a beaucoup d'objets dans un circuit ParameterExpression objets dans un circuit.
Les BasicAerJob renvoyés par les backends BasicAer sont désormais des instances synchrones de JobV1. Cela signifie que les appels à la fonction run() seront bloqués jusqu'à ce que la simulation ait fini de s'exécuter. Si vous voulez restaurer le comportement asynchrone précédent, vous devrez envelopper la fonction run() avec quelque chose qui s'exécutera dans un thread ou un processus séparé comme futures.ThreadPoolExecutor ou futures.ProcessPoolExecutor.
L'option allow_sample_measuring pour le simulateur BasicAer QasmSimulatorPy est passée d'une valeur par défaut de False à True. Cela a été fait pour mieux refléter le comportement par défaut du simulateur, qui utilise la mesure de l'échantillon si le circuit d'entrée le permet (même s'il n'est pas activé). Si vous utilisez un circuit qui ne supporte pas la mesure d'échantillon (c'est-à-dire qu'il a des opérations Reset ou s'il y a des opérations après une mesure sur un qubit), vous devez vous assurer de mettre explicitement cette option à False lorsque vous appelez run().
La passe de CommutativeCancellation est maintenant conscient des portes de la base cible, ce qui signifie qu'il n'utilisera que les portes de la base spécifiée. Auparavant, le laissez-passer remplaçait inconditionnellement les portes consécutives qui font la navette avec ZGate par les portes U1Gate. Cependant, maintenant que la passe est consciente de la base et dispose d'un kwarg, basis_gates, pour spécifier la base cible, il y a un changement potentiel de comportement si le kwarg n'est pas défini. Lorsque le kwarg basis_gates n'est pas utilisé et qu'il n'y a pas de portes à rotation z variable dans le circuit, il n'y a pas d'annulation commutative.
Register (qui est la classe mère de QuantumRegister et ClassicalRegister et Bit (qui est la classe parente de Qubit et Clbit) sont désormais immuables. Dans les versions précédentes, il était possible d'ajuster la valeur de a size ou name d'un objet Register et les attributs index ou register d'un objet Bit après sa création initiale. Cependant, cela conduirait à un comportement non sain qui corromprait les structures de conteneurs qui s'appuient sur un hachage (comme un dict) puisque ces attributs sont traités comme des propriétés immuables d'un registre ou d'un bit (voir #4705 pour plus de détails). Pour éviter ce comportement erroné, les attributs d'un Register et Bit ne sont plus paramétrables après la création initiale. Si vous ajustiez auparavant les objets au moment de l'exécution, vous devrez maintenant créer un nouvel objet Register ou Bit avec les nouvelles valeurs.
La méthode DAGCircuit.__eq__ (utilisée par l'opérateur == ), qui permet de vérifier l'égalité structurelle de DAGCircuit et QuantumCircuit inclura désormais la méthode global_phase et calibrations dans les champs dont l'égalité est vérifiée. Cela signifie que des circuits qui auraient été évalués comme égaux dans les versions précédentes peuvent ne plus l'être si les sites global_phase ou calibrations diffèrent entre les circuits. Par exemple, dans les versions précédentes, le résultat serait True:
```
import math

from qiskit import QuantumCircuit

qc1 = QuantumCircuit(1)
qc1.x(0)

qc2 = QuantumCircuit(1, global_phase=math.pi)
qc2.x(0)

print(qc2 == qc1)
```
Toutefois, étant donné que l'attribut global_phase des circuits diffère, le résultat sera désormais False.
Les méthodes qubits() et clbits() de la classe DAGCircuit qui étaient obsolètes dans la version 0.15.0 Terra, ont été supprimées. Vous devez plutôt utiliser les attributs qubits et clbits de la classe DAGCircuit de la classe. Par exemple, si vous étiez en train de courir :
```
from qiskit.dagcircuit import DAGCircuit

dag = DAGCircuit()
qubits = dag.qubits()
```
Il serait remplacé par :
```
from qiskit.dagcircuit import DAGCircuit

dag = DAGCircuit()
qubits = dag.qubits
```
Les PulseDefaults renvoyées par les backends de fausses impulsions qiskit.test.mock.FakeOpenPulse2Q et qiskit.test.mock.FakeOpenPulse3Q ont été mises à jour pour avoir des définitions de séquences d'impulsions plus réalistes. Si vous utilisez ces fausses classes backend, il se peut que vous deviez mettre à jour votre utilisation en raison de ces changements.
La méthode de synthèse par défaut utilisée par la fonction decompose_clifford() dans le module quantum_info (qui est utilisée en interne par la méthode qiskit.quantum_info.Clifford.to_circuit() ) pour plus de 3 qubits utilise maintenant une routine de compilation non optimale pour la synthèse des éléments de Clifford, par Bravyi et. al, qui permet généralement d'améliorer le coût de la CX par rapport à l'ancienne valeur par défaut. Si vous souhaitez revenir à la méthode Aaronson-Gottesman précédente, vous pouvez le faire en définissant method='AG'.

Le module qiskit.visualization.interactive, qui était obsolète dans la version 0.15.0, a été supprimé. Vous devriez plutôt utiliser les visualisations basées sur matplotlib :

Suppression de la fonction interactive	Fonction équivalente de matplotlib
`iplot_bloch_multivector`	`qiskit.visualization.plot_bloch_multivector()`
`iplot_state_city`	`qiskit.visualization.plot_state_city()`
`iplot_state_qsphere`	`qiskit.visualization.plot_state_qsphere()`
`iplot_state_hinton`	`qiskit.visualization.plot_state_hinton()`
`iplot_histogram`	`qiskit.visualization.plot_histogram()`
`iplot_state_paulivec`	`qiskit.visualization.plot_state_paulivec()`

Les attributs de premier niveau qiskit.Aer et qiskit.IBMQ sont désormais chargés paresseusement. Cela signifie que les objets existeront toujours et que des avertissements ne seront plus émis lors de l'importation si qiskit-aer ou qiskit-ibmq-provider ne sont pas installés (ou ne peuvent pas être trouvés par Python ). Si vous vérifiiez la présence de qiskit-aer ou qiskit-ibmq-provider en utilisant les attributs de ces modules et en les comparant explicitement à None ou en recherchant l'absence de l'attribut, cela ne fonctionnera plus car ils sont toujours définis en tant qu'objet. En d'autres termes, il s'agit de faire fonctionner quelque chose comme :
```
try:
    from qiskit import Aer
except ImportError:
    print("Aer not available")

or::

try:
    from qiskit import IBMQ
except ImportError:
    print("IBMQ not available")
```
ne fonctionnera plus. Pour déterminer si ces fournisseurs sont présents, vous pouvez soit utiliser explicitement qiskit.providers.aer.Aer et qiskit.providers.ibmq.IBMQ:
```
try:
    from qiskit.providers.aer import Aer
except ImportError:
    print("Aer not available")

try:
    from qiskit.providers.ibmq import IBMQ
except ImportError:
    print("IBMQ not available")
```
ou vérifiez plutôt bool(qiskit.Aer) et bool(qiskit.IBMQ) , par exemple :
```
import qiskit

if not qiskit.Aer:
    print("Aer not available")
if not qiskit.IBMQ:
    print("IBMQ not available")
```
Cette modification était nécessaire pour éviter les problèmes potentiels de cycle d'importation entre les paquets qiskit et pour améliorer le temps d'importation lorsque Aer ou IBMQ ne sont pas utilisés.
L'option suppress_packaging_warnings du fichier de configuration utilisateur et la variable d'environnement QISKIT_SUPPRESS_PACKAGING_WARNINGS n'ont plus d'effet et seront ignorées silencieusement. Les avertissements que cette option contrôlait ont été supprimés et ne seront plus émis lors de l'importation du module qiskit .
Le kwarg condition précédemment déprécié pour qiskit.dagcircuit.DAGNode a été supprimé. Elle a été supprimée dans la version 0.15.0. Au lieu de cela, vous devez maintenant définir la condition classique sur l'objet Instruction passé dans le constructeur DAGNode lors de la création d'un nouveau nœud op .
Lors de la création d'une nouvelle classe Register (qui est la classe parente de QuantumRegister et ClassicalRegister) ou QuantumCircuit avec un nombre de bits (par exemple QuantumCircuit(2)), il est désormais nécessaire que le nombre de bits soit spécifié sous la forme d'un entier ou d'un autre type pouvant être converti en entiers non ambigus (par exemple 2.0). Les valeurs non entières soulèveront désormais une erreur car l'intention dans ces cas n'était pas claire (vous ne pouvez pas avoir de bits fractionnaires). Pour plus d'informations sur les raisons de ce changement, voir : #4855
networkx n'est plus nécessaire pour qiskit-terra. Toute l'utilisation de networkx dans qiskit-terra a été supprimée à l'exception de 3 méthodes :
- qiskit.dagcircuit.DAGCircuit.to_networkx
- qiskit.dagcircuit.DAGCircuit.from_networkx
- qiskit.dagcircuit.DAGDependency.to_networkx
Si vous utilisez l'une de ces méthodes, vous devrez installer manuellement networkx dans votre environnement pour continuer à les utiliser.
Par défaut, sur macOS avec Python >= 3.8 parallel_map() ne s'exécutera plus dans plusieurs processus. Il s'agit d'un changement par rapport aux versions précédentes où le comportement par défaut était de lancer plusieurs processus parallel_map() lançait plusieurs processus. Cette modification a été apportée parce qu'avec les versions plus récentes de macOS avec Python 3.8 et 3.9, le multitraitement n'est pas fiable ou ajoute une surcharge significative en raison du changement dans Python 3.8 pour lancer de nouveaux processus avec spawn au lieu de fork. Pour réactiver l'exécution parallèle sur macOS avec Python >= 3.8, vous pouvez utiliser l'option parallel du fichier de configuration utilisateur ou définir la variable d'environnement QISKIT_PARALLEL sur True.

Le kwarg callback sur le constructeur de la classe PassManager a été supprimé. Ce kwarg est obsolète depuis la version 0.13.0 (9 avril 2020). Au lieu de cela, vous pouvez transmettre directement le kwarg callback à la méthode qiskit.transpiler.PassManager.run() directement. Par exemple, si vous utilisez :

from qiskit.circuit.random import random_circuit
from qiskit.transpiler import PassManager

qc = random_circuit(2, 2)

def callback(**kwargs)
  print(kwargs['pass_'])

pm = PassManager(callback=callback)
pm.run(qc)

peut être remplacé par :

from qiskit.circuit.random import random_circuit
from qiskit.transpiler import PassManager

qc = random_circuit(2, 2)

def callback(**kwargs)
  print(kwargs['pass_'])

pm = PassManager()
pm.run(qc, callback=callback)

Il n'est désormais plus possible d'instancier un canal de base sans préfixe, tel que qiskit.pulse.Channel ou qiskit.pulse.PulseChannel. Ces classes sont conçues pour classer les différents types de canaux orientés vers l'utilisateur, tels que qiskit.pulse.DriveChannel, mais n'ont pas de définition en tant que ressource cible. Si vous instanciez auparavant directement qiskit.pulse.Channel ou qiskit.pulse.PulseChannel, cela n'est plus autorisé. Veuillez utiliser la sous-classe appropriée.
Lorsque les kwargs require_cp et/ou require_tp de qiskit.quantum_info.process_fidelity(), qiskit.quantum_info.average_gate_fidelity(), qiskit.quantum_info.gate_error() sont True, ils n'affichent plus qu'un avertissement au lieu de lever une exception si le canal d'entrée est non-CP ou non-PT QiskitError si le canal d'entrée est non-CP ou nonTP respectivement.
La classe QFT dans le module qiskit.circuit.library calcule maintenant la transformée de Fourier en utilisant une représentation little-endian des tenseurs, c'est-à-dire que l'état $|1\rangle$ se traduit par $|0\rangle - |1\rangle + |2\rangle - ..$ en supposant que la base de calcul corresponde à l'ordre des bits little-endian des entiers. $|0\rangle = |000\rangle, |1\rangle = |001\rangle$ etc. Cela a été fait pour le rendre plus cohérent avec le reste de Qiskit, qui utilise une convention little-endian pour l'ordre des bits. Si vous dépendiez de l'ordre des bits précédent, vous pouvez utiliser la méthode reverse_bits() pour revenir au comportement précédent. Par exemple :
```
from qiskit.circuit.library import QFT

qft = QFT(5).reverse_bits()
```
L'attribut du module qiskit.__qiskit_version__ , qui était auparavant un dict , renverra désormais un objet Mapping personnalisé en lecture seule qui vérifie la version des éléments qiskit au moment de l'exécution plutôt qu'au moment de l'importation. Cela a été fait pour accélérer le chemin d'importation de qiskit et éliminer un cycle d'importation possible en n'important les paquets d'éléments au moment de l'exécution que si la version est nécessaire à partir du paquet. Il devrait être entièrement compatible avec le retour précédent de dict et, dans la plupart des cas d'utilisation normale, il n'y aura pas de différence. Toutefois, si certaines applications reposaient sur la mutation du contenu ou la vérification explicite du type, des mises à jour pourraient s'avérer nécessaires pour s'adapter à ce changement.
Le module qiskit.execute a été renommé en qiskit.execute_function. Ceci était nécessaire pour éviter un conflit de nom potentiel entre la fonction execute() qui est réexportée en tant que qiskit.execute. qiskit.execute la fonction dans certaines situations pourrait entrer en conflit avec qiskit.execute le module, ce qui entraînerait une erreur cryptique parce que Python considérait qiskit.execute comme le module alors que l'intention était la fonction ou vice versa. Le renommage du module était nécessaire pour éviter ce conflit. Si vous importez qiskit.execute pour obtenir le module (l'utilisation typique était from qiskit.execute import execute), vous devrez mettre à jour ceci pour utiliser qiskit.execute_function à la place. qiskit.execute se résoudra désormais toujours à la fonction.
Les modules qiskit.compiler.transpile, qiskit.compiler.assemble, qiskit.compiler.schedule, et qiskit.compiler.sequence ont été renommés en qiskit.compiler.transpiler, qiskit.compiler.assembler, qiskit.compiler.scheduler, et qiskit.compiler.sequence respectivement. Cela était nécessaire pour éviter un conflit de nom potentiel entre les modules et les chemins de la fonction réexportée qiskit.compiler.transpile(), qiskit.compiler.assemble(), qiskit.compiler.schedule(), et qiskit.compiler.sequence(). Dans certaines situations, ce conflit de nom entre le chemin du module et le chemin de la fonction réexportée peut conduire à une erreur énigmatique parce que Python considère une importation comme un module alors que l'intention était d'utiliser la fonction ou vice versa. Le renommage du module était nécessaire pour éviter ce conflit. Si vous utilisiez les importations pour obtenir les modules auparavant (l'utilisation typique serait like\Nfrom qiskit.compiler.transpile import transpile\Nfrom import transpile\Nfrom import transpile\Nfrom transpile\Nfrom), vous devrez mettre à jour ceci pour utiliser les nouveaux chemins des modules. qiskit.compiler.transpile(), qiskit.compiler.assemble(), qiskit.compiler.schedule(),, et qiskit.compiler.sequence() renverront toujours aux fonctions.
La classe qiskit.quantum_info.Quaternion a été déplacée du sous-module qiskit.quantum_info.operator au sous-module qiskit.quantum_info.synthesis pour mieux refléter son objectif. Aucune modification n'est nécessaire si vous l'importez depuis le module racine qiskit.quantum_info mais si vous l'importez depuis qiskit.quantum_info.operator , vous devrez mettre à jour votre chemin d'importation.
Suppression de la méthode QuantumCircuit.mcmt , qui est obsolète depuis la publication de Qiskit Terra 0.14.0 en avril 2020. Au lieu d'utiliser la méthode, veuillez utiliser la classe MCMT pour construire une porte multi-contrôle multi-cible et utiliser la méthode qiskit.circuit.QuantumCircuit.append() ou qiskit.circuit.QuantumCircuit.compose() pour l'ajouter à un circuit.

Par exemple, vous pouvez remplacer :
```
circuit.mcmt(ZGate(), [0, 1, 2], [3, 4])
```
avec :
```
from qiskit.circuit.library import MCMT
mcmt = MCMT(ZGate(), 3, 2)
circuit.compose(mcmt, range(5))
```
Suppression de la méthode QuantumCircuit.diag_gate qui est obsolète depuis la sortie de Qiskit Terra 0.14.0 en avril 2020. Au lieu de cela, utilisez la méthode diagonal() méthode de QuantumCircuit.
Suppression de la méthode QuantumCircuit.ucy qui est obsolète depuis la sortie de Qiskit Terra 0.14.0 en avril 2020. Au lieu de cela, utilisez la méthode ucry() méthode de QuantumCircuit.
La méthode mirror() pour qiskit.circuit.QuantumCircuit a été supprimée. Elle a été supprimée dans la version 0.15.0. La méthode qiskit.circuit.QuantumCircuit.reverse_ops() doit être utilisée à la place, car l'effet miroir pourrait être confondu avec l'échange des qubits de sortie du circuit. La méthode reverse_ops() ne fait qu'inverser l'ordre des portes appliquées au lieu de les inverser.
Le support précédemment déprécié du passage d'un float (pour le kwarg scale ) en tant que premier argument positionnel de la fonction qiskit.circuit.QuantumCircuit.draw() a été supprimée. Elle a été supprimée dans la version 0.12.0. Le premier argument positionnel de la méthode qiskit.circuit.QuantumCircuit.draw() est maintenant le kwarg output qui n'accepte pas les flottants. Vous devriez plutôt utiliser scale comme un kwarg nommé au lieu de l'utiliser de manière positionnelle.

Par exemple, si vous appeliez auparavant draw avec :
```
from qiskit import QuantumCircuit

qc = QuantumCircuit(2)
qc.draw(0.75, output='mpl')
```
il faudrait maintenant que ce soit le cas :
```
from qiskit import QuantumCircuit

qc = QuantumCircuit(2)
qc.draw(output='mpl', scale=0.75)
```
ou :
```
qc.draw('mpl', scale=0.75)
```

Les fonctionnalités de Qiskit Pulse (qiskit.pulse) qui étaient obsolètes dans la version 0.15.0 (août 2020) ont été supprimées. L'ensemble des changements sont les suivants :

Module	Ancien	Nouveau
`qiskit.pulse.library`	`SamplePulse`	`Waveform`
`qiskit.pulse.library`	`ConstantPulse`	`Constant`
(module rename)	`pulse.pulse_lib` Module	`qiskit.pulse.library`

Classe	Ancienne méthode	Nouvelle méthode
`ParametricPulse`	`get_sample_pulse`	`get_waveform`
`Instruction`	`command`	N/A. Les commandes et les instructions ont été unifiées. Utilisez `operands()` pour obtenir des informations sur les données d'instruction.
`Acquire`	`acquires`, `mem_slots`, `reg_slots`	`acquire()`, `mem_slot()`, `reg_slot()`. (L'instruction `Acquire` n'est plus diffusée sur plusieurs qubits)

Le dictionnaire précédemment tenu sur les DAGCircuit a été supprimé. Au lieu de cela, les bords contiennent maintenant l'instance Bit qui avait été précédemment incluse dans le dictionnaire comme champ 'wire' . Notez que le graphe NetworkX renvoyé par to_networkx() aura toujours un dictionnaire pour ses attributs d'arêtes, mais le champ 'name' ne sera plus rempli.
L'attribut parameters de la classe QuantumCircuit ne renvoie plus la valeur set. Au lieu de cela, il renvoie un objet ParameterView qui met en œuvre toutes les méthodes offertes par set (bien que dépréciées). Cela a été fait pour soutenir un modèle qui préserve les paramètres triés par nom. Elle doit être entièrement compatible avec toute utilisation antérieure de l'adresse set renvoyée par l'attribut parameters à l'exception des cas où une vérification explicite du type d'un ensemble a été effectuée.
Lorsque l'on travaille transpile() sur un QuantumCircuit avec delay() les unités seront converties en dt si la valeur de dt (temps d'échantillonnage) est connue de transpile()soit explicitement via le kwarg dt , soit via le kwarg BackendConfiguration pour un objet Backend transmis via le kwarg backend .
L'interprétation de meas_map (qui est un attribut d'un objet ou le kwarg correspondant sur le site ) peut être faite en fonction de la nature de l'objet PulseBackendConfiguration ou comme le kwarg meas_map correspondant sur l'objet schedule(), assemble(), sequence(), ou execute() ) a été mise à jour pour mieux correspondre aux contraintes réelles du matériel. Le format de ces données est une liste de listes, où les éléments de la liste intérieure sont des nombres entiers spécifiant les étiquettes des qubits. Par exemple :
```
[[A, B, C], [D, E, F, G]]
```
Auparavant, la contrainte meas_map était interprétée de telle sorte que si un qubit était acquis (par exemple A), tous les autres qubits partageant un sous-groupe avec ce qubit (B et C) devaient être acquis au même moment et pour la même durée. Cette contrainte a été assouplie. Une acquisition ne nécessite pas d'autres acquisitions. (Si A est acquis, B et C n'ont pas besoin d'être acquis) En revanche, les qubits d'un même groupe de mesure ne peuvent pas être acquis de manière à se chevaucher partiellement - considérez le site meas_map comme spécifiant une ressource d'acquisition partagée (si nous acquérons A de t=1000 à t=2000, nous ne pouvons pas acquérir B à partir de 1000<t<2000). Par exemple :
```
# Good
meas_map = [[0, 1]]
# Acquire a subset of [0, 1]
sched = pulse.Schedule()
sched = sched.append(pulse.Acquire(10, acq_q0))

# Acquire 0 and 1 together (same start time, same duration)
sched = pulse.Schedule()
sched = sched.append(pulse.Acquire(10, acq_q0))
sched = sched.append(pulse.Acquire(10, acq_q1))

# Acquire 0 and 1 disjointly
sched = pulse.Schedule()
sched = sched.append(pulse.Acquire(10, acq_q0))
sched = sched.append(pulse.Acquire(10, acq_q1)) << 10

# Acquisitions overlap, but 0 and 1 aren't in the same measurement
# grouping
meas_map = [[0], [1]]
sched = pulse.Schedule()
sched = sched.append(pulse.Acquire(10, acq_q0))
sched = sched.append(pulse.Acquire(10, acq_q1)) << 1

# Bad: 0 and 1 are in the same grouping, but acquisitions
# partially overlap
meas_map = [[0, 1]]
sched = pulse.Schedule()
sched = sched.append(pulse.Acquire(10, acq_q0))
sched = sched.append(pulse.Acquire(10, acq_q1)) << 1
```

Remarques concernant la dépréciation

Deux nouveaux arguments ont été ajoutés à qiskit.dagcircuit.DAGNode.semantic_eq()bit_indices1 et bit_indices2, qui sont censés cartographier les instances de Bit dans chaque DAGNode à leur index dans la liste qubits ou clbits de leur fichier DAGCircuit. Pendant la période de dépréciation, ces arguments sont facultatifs et s'ils ne sont pas spécifiés, les correspondances seront automatiquement construites sur la base des propriétés register et index de chaque instance Bit instance. Cependant, dans une prochaine version, ils seront des arguments obligatoires et la correspondance devra être fournie par l'utilisateur.
Les pulse fonctions du constructeur :
- qiskit.pulse.call_circuit()
- qiskit.pulse.call_schedule()
sont obsolètes et seront supprimées dans une prochaine version. Ces fonctions sont regroupées sur le site qiskit.pulse.call() , qu'il convient d'utiliser à la place.
La méthode qiskit.pulse.Scheduleqiskit.pulse.Schedule.flatten() est obsolète et sera supprimée dans une prochaine version. À la place, vous pouvez utiliser la fonction qiskit.pulse.transforms.flatten() qui effectuera la même opération.
Le site assign_parameters() pour les classes suivantes :
- qiskit.pulse.channels.Channel,
- qiskit.pulse.library.Pulse,
- qiskit.pulse.instructions.Instruction,
et toutes ses sous-classes sont désormais obsolètes et seront supprimées dans une prochaine version. Cette fonctionnalité a été reprise ScheduleBlock ce qui constitue l'orientation future de la construction de programmes d'impulsions paramétrés.
L'attribut parameters pour les classes suivantes :
- Channel
- Instruction.
est obsolète et sera supprimée dans une prochaine version. Cette fonctionnalité a été reprise ScheduleBlock ce qui constitue l'orientation future de la construction de programmes d'impulsions paramétrés.
Python 3.6 est obsolète et sera supprimée dans une prochaine version. Lorsque le support sera supprimé, vous devrez mettre à jour la version de Python que vous utilisez vers Python 3.7 ou une version supérieure.

Deux méthodes QuantumCircuitcombine() et extend() ainsi que les opérateurs Python, + et += correspondants sont obsolètes et seront supprimés dans une prochaine version. Au lieu de cela, la méthode QuantumCircuit méthode compose() doit être utilisée. La méthode compose() permet une plus grande flexibilité dans la composition de deux circuits qui n'ont pas de registres correspondants. Elle n'ajoute cependant pas automatiquement les qubits/clbits, contrairement aux méthodes dépréciées. Pour ajouter un circuit sur de nouveaux qubits/clbits, la méthode qiskit.circuit.QuantumCircuit.tensor() peut être utilisée. Par exemple :

from qiskit.circuit import QuantumRegister, QuantumCircuit

a = QuantumRegister(2, 'a')
circuit_a = QuantumCircuit(a)
circuit_a.cx(0, 1)

b = QuantumRegister(2, 'b')
circuit_b = QuantumCircuit(b)
circuit_b.cz(0, 1)

# same as circuit_a + circuit_b (or combine)
added_with_different_regs = circuit_b.tensor(circuit_a)

# same as circuit_a + circuit_a (or combine)
added_with_same_regs = circuit_a.compose(circuit_a)

# same as circuit_a += circuit_b (or extend)
circuit_a = circuit_b.tensor(circuit_a)

# same as circuit_a += circuit_a (or extend)
circuit_a.compose(circuit_a, inplace=True)

Prise en charge du passage des instances Qubit au kwarg qubits de la méthode qiskit.transpiler.InstructionDurations.get() est obsolète et sera supprimée dans une prochaine version. Au lieu de cela, vous devez appeler la méthode get() avec les indices entiers des qubits souhaités.
L'utilisation de @ (__matmul__) pour invoquer la méthode compose des sous-classes de BaseOperator (par ex Operator) est dépréciée et sera supprimée dans une prochaine version. La méthode qiskit.quantum_info.Operator.compose() peut être utilisée directement ou invoquée à l'aide de l'opérateur & (__and__).
Utiliser * (__mul__) pour appeler la méthode dot() des sous-classes de BaseOperator (par exemple qiskit.quantum_info.Operator) est dépréciée et sera supprimée dans une prochaine version. Au lieu de cela, vous pouvez appeler directement le dot() directement.
Utiliser @ (__matmul__) pour invoquer la méthode de la evolve() de la méthode qiskit.quantum_info.Statevector et qiskit.quantum_info.DensityMatrix est dépréciée et sera supprimée dans une prochaine version... La méthode evolve peut être utilisée directement ou invoquée à l'aide de l'opérateur & (__and__).

La classe qiskit.pulse.schedule.ParameterizedSchedule est obsolète et sera supprimée dans une prochaine version. Au lieu de cela, vous pouvez paramétrer directement les objets pulse Schedule avec un objet Parameter par exemple :

from qiskit.circuit import Parameter
from qiskit.pulse import Schedule
from qiskit.pulse import ShiftPhase, DriveChannel

theta = Parameter('theta')
target_schedule = Schedule()
target_schedule.insert(0, ShiftPhase(theta, DriveChannel(0)), inplace=True)

La classe qiskit.pulse.ScheduleComponent du module qiskit.pulse est obsolète et sera supprimée dans une prochaine version. Son utilisation doit être remplacée soit par un qiskit.pulse.Schedule soit en utilisant directement qiskit.pulse.Instruction . De plus, l'objectif premier de la classe ScheduleComponent était de servir de classe de base commune pour les deux types d'objets Schedule et Instruction pour tout endroit qui vérifiait explicitement le type ou documentait l'acceptation d'une entrée ScheduleComponent devrait être mis à jour pour accepter Instruction ou Schedule.
Les fichiers JSON Schema et leur utilisation pour les charges utiles de l'API IBMQ sont obsolètes et seront supprimés dans une prochaine version. Cela inclut tout ce qui se trouve sous le module qiskit.schemas et le module qiskit.validation . Cela inclut également les kwargs de validate pour qiskit.qobj.QasmQobj.to_dict() et qiskit.qobj.QasmQobj.to_dict() ainsi que les validateurs fastjsonschema au niveau du module dans qiskit.qobj (qui ne lèvent pas d'avertissement de dépréciation). Les fichiers de schémas ont été déplacés vers le dépôt Qiskit/ibmq-schemas et ceux-ci doivent être traités comme les versions canoniques des schémas de l'API. À l'avenir, seuls ces schémas recevront des mises à jour et seront utilisés comme source de vérité pour les schémas. Si vous utilisiez les schémas intégrés dans qiskit-terra, vous devriez mettre à jour pour utiliser ce dépôt à la place.
Le module qiskit.util est obsolète et sera supprimé dans une prochaine version. Il a été remplacé par qiskit.utils qui offre les mêmes fonctionnalités et sera étendu à l'avenir. Notez qu'aucun DeprecationWarning ne sera émis concernant cette dépréciation puisqu'elle n'était pas réalisable sur Python 3.6.
La passe de transposition CXDirection dans le module qiskit.transpiler.passes est obsolète et sera supprimée dans une prochaine version. Il convient d'utiliser plutôt le site GateDirection . Il se comporte de la même manière que le site CXDirection , sauf qu'il permet désormais de transformer un circuit avec des ECRGate portes en plus de CXGate portes.
La passe de transposition CheckCXDirection dans le module qiskit.transpiler.passes est obsolète et sera supprimée dans une prochaine version. Au lieu de cela, il convient d'utiliser le laissez-passer CheckGateDirection . Son comportement est identique à celui de CheckCXDirection , mais il permet désormais de vérifier la direction de toutes les portes à 2 qubits, et non plus seulement des portes à CXGate portes.
La méthode WeightedAddernum_ancilla_qubits() est obsolète et sera supprimée dans une prochaine version. Il a été remplacé par l'attribut qiskit.circuit.library.WeightedAdder.num_ancillas qui est cohérent avec les API des autres bibliothèques de circuits.
Les méthodes suivantes de la classe qiskit.quantum_info.Pauli ont été supprimées. Voir la documentation de la méthode pour l'utilisation de remplacement dans la classe Pauli mise à jour.
- from_label()
- sgn_prod()
- to_spmatrix()
- kron()
- update_z()
- update_x()
- insert_paulis()
- append_paulis()
- delete_qubits()
- pauli_single()
- random()
L'utilisation d'un list ou d'un numpy.ndarray comme argument channel ou target pour la commande qiskit.quantum_info.process_fidelity(), qiskit.quantum_info.average_gate_fidelity(), qiskit.quantum_info.gate_error(), et qiskit.quantum_info.diamond_norm() a été dépréciée et ne sera plus prise en charge dans les versions ultérieures. Les entrées doivent plutôt être un objet Gate ou un objet de la sous-classe BaseOperator (ex. Operator, Choi, etc.)
L'accès aux références de Qubit et Clbit aux registres qu'elles contiennent par l'intermédiaire de la méthode register ou index est obsolète et sera supprimé dans une prochaine version. Au lieu de cela, Register peuvent être interrogés pour trouver les objets Bit qu'ils contiennent.
La fonctionnalité actuelle de la fonction qiskit.visualization.pulse_drawer() est obsolète et sera remplacée par qiskit.visualization.pulse_drawer_v2() (qui n'est pas rétrocompatible) dans une prochaine version.
L'utilisation de méthodes héritées du type set sur la sortie de l'attribut parameters (qui était auparavant un set) de la classe QuantumCircuit est dépréciée et sera supprimée dans une prochaine version. Cela inclut les méthodes des sites add(), difference(), difference_update(), discard(), intersection(), intersection_update(), issubset(), issuperset(), symmetric_difference(), symmetric_difference_update(), union(), update(), __isub__() (qui est l'opérateur -= ), et __ixor__() (qui est l'opérateur ^= ).
Le nom du premier (et unique) argument positionnel de la méthode qiskit.circuit.QuantumCircuit.bind_parameters() est passé de value_dict à values. Le passage d'un argument avec le nom values_dict est obsolète et sera supprimé dans les prochaines versions. Par exemple, si vous appeliez auparavant bind_parameters() avec un appel comme : bind_parameters(values_dict={}) ceci est déprécié et doit être remplacé par bind_parameters(values={}) ou mieux encore, passez simplement l'argument en position bind_parameters({}).
Le nom du premier (et unique) argument positionnel de la méthode qiskit.circuit.QuantumCircuit.assign_parameters() est passé de param_dict à parameters. Le fait de passer un argument avec le nom param_dict est obsolète et sera supprimé dans les prochaines versions. Par exemple, si vous appeliez auparavant assign_parameters() avec un appel comme : assign_parameters(param_dict={}) ceci est déprécié et doit être remplacé par assign_parameters(values={}) ou mieux encore, passez simplement l'argument en position assign_parameters({}).

Corrections des erreurs

Correction d'un problème où la fonction execute() soulevait une exception QiskitError lorsqu'un objet ParameterVector était fourni pour le kwarg parameter_bind . paramètre. Par exemple, il est désormais possible d'appeler quelque chose comme :
```
execute(circuit, backend, parameter_binds=[{pv1: [...], pv2: [...]}])
```
où pv1 et pv2 sont des ParameterVector objets. Corrigé #5467
Correction d'un problème avec les étiquettes des impulsions paramétriques dans la classe PulseQobjInstruction n'étaient pas correctement définies, comme c'est le cas pour les impulsions échantillonnées. Cela signifie également que les noms d'impulsions importés de la base de données PulseDefaults renvoyés par un Backendtels que x90, x90m, etc, seront correctement définis. Corrigé #5363
Correction d'un problème où les paramètres non liés ne se produisaient que dans l'attribut global_phase d'un objet QuantumCircuit n'apparaissaient pas dans l'attribut parameters et ne pouvaient pas être liés. Corrigé #5806
L'attribut calibrations des objets QuantumCircuit sont désormais préservés lorsque les méthodes += (c'est-à-dire la méthode extend() ) et + (c'est-à-dire la méthode combine() ) sont utilisées. Corrigé #5930 et #5908
La méthode name de la classe Register (qui est la classe mère de QuantumRegister et ClassicalRegister) ne vérifiait pas auparavant si la chaîne attribuée était un nom de registre valide, conformément à la spécification OpenQASM. Cette vérification n'était auparavant effectuée que lorsque le nom était spécifié dans le constructeur, ce qui a été corrigé de sorte que la définition directe de l'attribut name avec une valeur invalide soulèvera également une exception. Corrigé #5461
Correction d'un problème avec la fonction qiskit.visualization.circuit_drawer() fonction et qiskit.circuit.QuantumCircuit.draw() lors de la visualisation d'un QuantumCircuit avec un Gate qui a une condition classique après une Measure qui a utilisé le même ClassicalRegisteril était possible que le conditionnel Gate soit affiché à gauche du Measure. Corrigé #5387
Dans le passage du transpondeur qiskit.transpiler.passes.CSPLayout un biais en faveur des qubits les moins nombreux a pu être observé. Ce biais indésirable a été corrigé en mélangeant les candidats afin de rendre les résultats aléatoires. En outre, l'utilisation du CSPLayout dans le preset_passmanagers (pour les niveaux 2 et 3) a été ajustée afin d'utiliser une graine configurée si le kwarg seed_transpiler est défini lors de l'appel de transpile() est appelé. Corrigé #5990
Correction d'un bogue à cause duquel le champ channels d'un objet PulseBackendConfiguration n'était pas inclus dans le résultat de la méthode qiskit.providers.models.PulseBackendConfiguration.to_dict méthode. Corrigé #5579
Correction de l'enchevêtrement 'circular' dans la classe de circuit qiskit.circuit.library.NLocal pour le cas particulier où le circuit a la même taille que le bloc d'intrication (par exemple, un circuit à deux qubits et des portes d'intrication CZ). Dans ce cas, il ne devrait y avoir qu'une seule porte d'intrication, mais une deuxième porte a été ajoutée accidentellement dans la direction inverse de la première. Fixe qiskit-community/qiskit-aqua#1452
Correction de la gestion des points d'arrêt dans la classe PiecewisePolynomialPauliRotations dans la classe qiskit.circuit.library. Maintenant, pour les intervalles n , les points d'arrêt n+1 sont autorisés. Cela permet de spécifier un autre intervalle final que $2^\text{num qubits}$ , ce qui est important car, de la fin du dernier intervalle à $2^\text{num qubits}$ , la fonction est l'identité.
Correction d'un problème dans la classe qiskit.circuit.library.Permutation où certaines permutations n'étaient pas correctement générées. Ce problème pourrait également affecter qiskit.circuit.library.QuantumVolume s'il était appelé avec classical_permutation=False`. Corrigé #5812
Correction d'un problème où la génération d'une sortie QASM avec la méthode qasm() pour un objet QuantumCircuit qui possède un ControlledGate avec une commande ouverte, la sortie se faisait comme si toutes les commandes étaient fermées, indépendamment de l'état de la commande spécifiée. Il en résulterait qu'un circuit différent serait créé à partir de from_qasm_str() si l'on analyse le MAQS généré.

Ce problème a été résolu en mettant à jour la sortie QASM de qasm() en définissant une porte composite qui utilise XGate pour mettre en œuvre les commandes d'ouverture. La porte composite est nommée <original_gate_name>_o<ctrl_state> , où o représente la commande ouverte et ctrl_state la valeur entière de l'état de la commande. Corrigé #5443
Correction d'un problème où la liaison des objets Parameter dans un QuantumCircuit avec l'adresse parameter_binds dans la fonction execute entraînait le fait que tous les objets QuantumCircuit avaient le même name, ce qui signifiait que les noms des résultats n'étaient pas non plus uniques. Ce correctif fait que les bind_parameters() et assign_parameters() d'attribuer un nom de circuit unique lorsqu'il est utilisé à l'adresse inplace=False :
```
<base name>-<class instance no.>[-<pid name>]
```
où <base name> est le nom fourni par le kwarg "name", sinon il prend par défaut la valeur "circuit". Le numéro d'instance de la classe est incrémenté chaque fois qu'une instance de la classe est générée. <pid name> est ajouté s'il est appelé en dehors du processus principal. Corrigé #5185
Correction d'un problème avec la fonction scheduler() qui soulevait une exception si un circuit d'entrée contenait un objet non lié QuantumCircuit non lié. Corrigé #5304
Correction d'un problème dans les passes de qiskit.transpiler.passes.TemplateOptimization où les circuits de modèles contenant des objets non liés Parameter se plantaient dans certains scénarios si les paramètres ne pouvaient pas être liés lors de la mise en correspondance des modèles. Maintenant, si les Parameter ne peuvent pas être liés, les modèles avec unbound Parameter sont rejetés et ignorés par le TemplateOptimization pass. Corrigé #5533
Correction d'un problème avec la fonction qiskit.visualization.timeline_drawer() où les bits classiques étaient mal gérés. Corrigé #5361
Correction d'un problème dans la fonction qiskit.visualization.circuit_drawer() et la méthode qiskit.circuit.QuantumCircuit.draw() où les instructions Delay instructions dans un objet QuantumCircuit n'étaient pas correctement traitées comme des temps morts. Ainsi, lorsque le kwarg de idle_wires est réglé sur False , les fils avec les objets sont toujours affichés Delay seraient toujours affichés. Ce problème a été corrigé afin que les fils inactifs soient supprimés de la visualisation s'il n'y a que des objets sur un fil Delay objets sur un fil.
Auparavant, lorsque l'option layout_method kwarg était fournie à la fonction transpile() et que l'option optimization_level kwarg était fixée à >= 2 pour que la passe s'exécute, si l'option kwarg était définie à >= 2, la passe s'exécutait qiskit.transpiler.passes.CSPLayout s'exécute, si CSPLayout trouvait une solution, la méthode de layout_method n'était pas exécutée. Ce point a été corrigé de sorte que, si elle est spécifiée, l'adresse layout_method est toujours respectée. Corrigé #5409
Lorsque l'argument coupling_map=None (qu'il soit défini explicitement, implicitement comme valeur par défaut ou via le kwarg backend ), le processus de transposition n'a pas "intégré" le circuit. En d'autres termes, même lorsqu'une adresse initial_layout a été spécifiée, les qubits virtuels n'ont pas été affectés à des qubits physiques. Ce problème a été corrigé de sorte que la fonction qiskit.compiler.transpile() honore l'argument initial_layout en intégrant le circuit :
```
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.compiler import transpile

qr = QuantumRegister(2, name='qr')
circ = QuantumCircuit(qr)
circ.h(qr[0])
circ.cx(qr[0], qr[1])

transpile(circ, initial_layout=[1, 0]).draw(output='mpl')
```
Si le site initial_layout fait référence à plus de qubits que le circuit, le processus de transposition élargira le circuit avec des ancillas.
```
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.compiler import transpile

qr = QuantumRegister(2, name='qr')
circ = QuantumCircuit(qr)
circ.h(qr[0])
circ.cx(qr[0], qr[1])

transpile(circ, initial_layout=[4, 2], coupling_map=None).draw()
```
Corrigé #5345
Un nouveau kwarg, user_cost_dict , a été ajouté au constructeur de la passe de qiskit.transpiler.passes.TemplateOptimization transpiler pass. Cela permet aux utilisateurs de fournir un dictionnaire de coûts personnalisé pour les portes de l'algorithme de mise en correspondance des modèles sous-jacents. Par exemple :
```
from qiskit.transpiler.passes import TemplateOptimization

cost_dict = {'id': 0, 'x': 1, 'y': 1, 'z': 1, 'h': 1, 't': 1}
pass = TemplateOptimization(user_cost_dict=cost_dict)
```
Un problème survient lorsque l'on passe l'objet Counts renvoyé par get_counts() à marginal_counts() produisait un objet Counts avec certaines entrées a été corrigé. Corrige #5424
Amélioration de l'allocation des qubits d'aide en PolynomialPauliRotations et PiecewiseLinearPauliRotations ce qui rend la mise en œuvre de ces circuits plus efficace. Corrigé #5320 et #5322
Fixer l'utilisation des qubits d'aide alloués dans le système de gestion de l'information MCXGate dans la classe WeightedAdder classe. Ceux-ci étaient précédemment alloués mais non utilisés avant cette correction. Corrigé #5321
Dans un certain nombre de cas, la méthode de sortie latex pour la fonction qiskit.visualization.circuit_drawer() et la méthode draw() n'affichait pas correctement le nom de la porte et, dans d'autres cas, n'incluait pas les paramètres de la porte là où ils devraient l'être. Les noms des portes s'affichent maintenant de la même manière qu'avec la méthode de sortie mpl , et les paramètres s'affichent pour toutes les portes qui en sont dotées. En outre, certaines portes ne s'affichaient pas sous la forme correcte, ce qui a été corrigé. Corrections #5605, #4938, et #3765
Correction d'un problème où, si la méthode qiskit.circuit.Instruction.to_instruction() était utilisée sur un sous-circuit contenant des registres classiques et que cet objet était ensuite ajouté à un sous-circuit contenant des registres classiques, la méthode était utilisée sur un sous-circuit contenant des registres classiques Instruction était ensuite ajouté à un objet QuantumCircuit la sortie de la fonction qiskit.visualization.circuit_drawer() et de la méthode qiskit.circuit.QuantumCircuit.draw() affichait dans certains cas le sous-circuit à gauche d'une mesure alors qu'il aurait dû être affiché à droite. Corrigé #5947
Correction d'un problème avec Delay dans un QuantumCircuit où qiskit.compiler.transpile() ne convertissaient pas les unités de l'objet Delay en unités de Backendsi le kwarg de backend est défini sur transpile(). Cela peut entraîner un comportement erroné en raison d'une inadéquation des unités, par exemple en cours d'exécution :
```
from qiskit import transpile, execute
from qiskit.circuit import QuantumCircuit

qc = QuantumCircuit(1)
qc.delay(100, [0], unit='us')

qc = transpile(qc, backend)
job = execute(qc, backend)
```
aurait auparavant entraîné un retard du backend de 100 pas de temps (chacun d'une durée dt) au lieu des pas de temps prévus ( 100e-6 / dt). Cette erreur a été corrigée afin que la fonction qiskit.compiler.transpile() convertisse correctement les unités.

Autres remarques

Les snapshots de tous les backends fake/mock de qiskit.test.mock ont été mis à jour pour refléter les récents changements d'appareils. Il s'agit notamment d'une modification de l'attribut basis_gates pour l'attribut BackendConfiguration à ['cx', 'rz', 'sx', 'x', 'id'], l'ajout d'une propriété readout_length aux propriétés des qubits dans la base de données BackendPropertieset la mise à jour de l'attribut PulseDefaults afin que tous les backends simulés supportent les instances paramétriques basées sur les impulsions InstructionScheduleMap paramétriques.

Aer 0.8.0

Prélude

La version 0.8 comprend plusieurs nouvelles fonctionnalités et corrections de bogues. Les points forts de cette version sont : l'introduction d'un backend unifié AerSimulator pour exécuter des simulations de circuits à l'aide de n'importe quelle méthode de simulation prise en charge; une bibliothèque d'instructions de simulateur (qiskit.providers.aer.library) qui comprend des instructions personnalisées pour enregistrer divers types de données de simulateur; le support MPI pour exécuter des simulations de grande envergure dans un environnement informatique distribué.

Nouvelles fonctions

Python 3.9 a été ajouté dans cette version. Vous pouvez maintenant exécuter Qiskit Aer en utilisant Python 3.9 sans construire à partir des sources.
Ajoutez le drapeau CMake DISABLE_CONAN (default=`OFF\``)s. Lors de l'installation à partir des sources, la valeur ONpermet de contourner le gestionnaire de paquets Conan pour trouver les bibliothèques qui sont déjà installées sur votre système. Cette option est également disponible sous la forme d'une variable d'environnementDISABLE_CONAN`, qui a la priorité sur l'option CMake. Il ne s'agit pas de la procédure officielle pour construire l'ARE. Il incombe donc à l'utilisateur de fournir toutes les bibliothèques nécessaires et les fichiers correspondants pour que CMake puisse les trouver.
Cette version inclut le support pour la construction de qiskit-aer avec le support MPI pour exécuter de grandes simulations sur un environnement informatique distribué. Voir le guide de contribution pour les instructions sur la construction et l'exécution dans un environnement MPI.
Il est maintenant possible de construire qiskit-aer avec CUDA activé dans Windows. Voir le guide de contribution pour les instructions sur la construction à partir des sources avec le support du GPU.
Lors de la construction de l'extension qiskit-aer Python à partir des sources, plusieurs dépendances doivent être préinstallées pour permettre la compilation C++. Pour le confort de l'utilisateur, lors de la construction de l'extension, toutes les dépendances manquantes sont automatiquement installées à l'aide de pip avant les étapes d'installation normales de setuptools . Cependant, il n'était pas possible auparavant d'éviter cette installation automatique. Pour résoudre ce problème, une nouvelle variable d'environnement DISABLE_DEPENDENCY_INSTALL a été ajoutée. S'il est défini à 1 ou ON lors de la construction de l'extension python à partir des sources, cela désactivera l'installation automatique de ces dépendances manquantes.
Ajout de la prise en charge de la porte de Pauli optimisée pour les N-qubits ( qiskit.circuit.library.PauliGate) à StatevectorSimulator, UnitarySimulator, et aux méthodes de vecteurs d'état et de matrices de densité de QasmSimulator et AerSimulator.
La méthode run() pour les backends AerSimulator, QasmSimulator, StatevectorSimulator, et UnitarySimulator prend maintenant un paramètre QuantumCircuit (ou une liste d'objets QuantumCircuit comme entrée. L'objet précédent QasmQobj est encore pris en charge pour l'instant, mais il sera supprimé dans une version ultérieure.

Pour un exemple d'utilisation, voir :
```
from qiskit import transpile, QuantumCircuit

from qiskit.providers.aer import Aer

backend = Aer.get_backend('aer_simulator')

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

tqc = transpile(circuit, backend)
result = backend.run(tqc, shots=4096).result()
```
La méthode run() pour le backend PulseSimulator prend désormais en compte un élément Schedule (ou une liste d'objets Schedule comme entrée. L'objet précédent PulseQobj est encore pris en charge pour l'instant, mais il sera supprimé dans une version ultérieure.
Ajoute le nouveau backend du simulateur AerSimulator qui prend en charge les méthodes de simulation suivantes
- automatic
- statevector
- stabilizer
- density_matrix
- matrix_product_state
- unitary
- superop
La méthode automatique par défaut choisira automatiquement une méthode de simulation séparément pour chaque circuit d'exécution sur la base des instructions du circuit et du modèle de bruit (le cas échéant). L'initialisation d'un simulateur avec une méthode spécifique peut être effectuée en utilisant l'option méthode.

La simulation GPU pour le vecteur d'état, la matrice de densité et les méthodes unitaires peut être activée en définissant l'option device='GPU' backend.

Notez que les méthodes unitary et superop ne prennent pas en charge les mesures car elles simulent la matrice unitaire ou la matrice des superopérateurs du circuit d'exécution. L'une des nouvelles instructions save_unitary(), save_superop() ou save_state() doit donc être utilisée pour enregistrer l'état du simulateur dans les résultats renvoyés. De même, l'état des autres méthodes de simulation peut être sauvegardé en utilisant les instructions appropriées. Voir les documents de l'API qiskit.providers.aer.library pour plus de détails.

Notez que le simulateur AerSimulator remplace les backends QasmSimulator, StatevectorSimulator, et UnitarySimulator qui seront obsolètes dans une prochaine version.
Mise à jour de la classe AerProvider afin d'inclure plusieurs backends AerSimulator préconfigurés pour toutes les méthodes de simulation et tous les dispositifs de simulation disponibles. Les nouveaux backends sont accessibles via l'interface du fournisseur en utilisant les noms suivants
- "aer_simulator"
- "aer_simulator_statevector"
- "aer_simulator_stabilizer"
- "aer_simulator_density_matrix"
- "aer_simulator_matrix_product_state"
- "aer_simulator_extended_stabilizer"
- "aer_simulator_unitary"
- "aer_simulator_superop"
De plus, si Aer a été installé avec le support GPU sur un système compatible, les backends GPU suivants seront également disponibles
- "aer_simulator_statevector_gpu"
- "aer_simulator_density_matrix_gpu"
- "aer_simulator_unitary_gpu"
Par exemple :
```
from qiskit import Aer

# Get the GPU statevector simulator backend
backend = Aer.get_backend('aer_simulator_statevector_gpu')
```
Ajout d'une nouvelle méthode norm estimation pour effectuer des mesures lors de l'utilisation de la méthode de simulation "extended_stabilizer" . Cette méthode d'estimation de la norme peut être utilisée en passant les options suivantes aux backends AerSimulator et QasmSimulator
```
simulator = QasmSimulator(
    method='extended_stabilizer',
    extended_stabilizer_sampling_method='norm_estimation')
```
La méthode d'estimation de la norme est plus lente que les options alternatives metropolis ou resampled_metropolis , mais donne de meilleures performances sur les circuits avec des distributions de sortie éparses. Voir la documentation du site QasmSimulator pour plus d'informations.
Ajoute des instructions pour sauvegarder l'état du simulateur dans différents formats. Ces instructions sont
- qiskit.providers.aer.library.SaveDensityMatrix
- qiskit.providers.aer.library.SaveMatrixProductState
- qiskit.providers.aer.library.SaveStabilizer
- qiskit.providers.aer.library.SaveState
- qiskit.providers.aer.library.SaveStatevector
- qiskit.providers.aer.library.SaveStatevectorDict
- qiskit.providers.aer.library.SaveUnitary
Ces instructions peuvent être ajoutées à un circuit quantique en utilisant les méthodes de circuit save_density_matrix, save_matrix_product_state, save_stabilizer, save_state, save_statevector, save_statevector_dict, save_unitary qui sont ajoutées à QuantumCircuit lors de l'importation d'Aer.

Voir la documentation de l'API qiskit.providers.aer.library pour plus de détails sur la compatibilité des méthodes pour chaque instruction.

Notez que les instructions d'instantané SnapshotStatevector, SnapshotDensityMatrix, SnapshotStabilizer sont toujours prises en charge, mais qu'elles seront supprimées dans une prochaine version.
Ajoute les instructions des circuits quantiques qiskit.providers.aer.library.SaveExpectationValue et qiskit.providers.aer.library.SaveExpectationValueVariance pour enregistrer la valeur de l'espérance $\langle H\rangle = Tr[H\rho]$ , ou la valeur de l'espérance et la variance $Var(H) = \langle H^2\rangle - \langle H\rangle^2$ , d'un opérateur hermitien $H$ pour l'état du simulateur $\rho$ . Ces instructions peuvent être ajoutées à un circuit quantique en utilisant les méthodes de circuit save_expectation_value et save_expectation_value_variance qui sont ajoutées à QuantumCircuit lors de l'importation d'Aer.

Notez que l'instruction d'instantané SnapshotExpectationValue, est toujours prise en charge, mais qu'elle sera supprimée dans une prochaine version.
Ajoute qiskit.providers.aer.library.SaveProbabilities et qiskit.providers.aer.library.SaveProbabilitiesDict instruction de circuit quantique pour sauvegarder toutes les probabilités de résultat de mesure pour les mesures de base Z de l'état du simulateur. Ces instructions peuvent être ajoutées à un circuit quantique en utilisant les méthodes de circuit save_probabilities et save_probabilities_dict qui est ajouté à QuantumCircuit lors de l'importation d'Aer.

Notez que l'instruction d'instantané SnapshotProbabilities, est toujours prise en charge, mais qu'elle sera supprimée dans une prochaine version.
Ajoute les instructions de circuit qiskit.providers.aer.library.SaveAmplitudes et qiskit.providers.aer.library.SaveAmplitudesSquared pour sauvegarder les amplitudes complexes des vecteurs d'état sélectionnés ou les probabilités sélectionnées (amplitudes au carré) pour les méthodes de simulation prises en charge. Ces instructions peuvent être ajoutées à un circuit quantique en utilisant les méthodes de circuit save_amplitudes et save_amplitudes_squared qui est ajouté à QuantumCircuit lors de l'importation d'Aer.
Ajoute des instructions pour définir l'état des simulateurs. Ces instructions doivent être définies sur l'ensemble des qubits du circuit. Ils peuvent être appliqués à n'importe quel point d'un circuit et remplaceront l'état du simulateur par celui spécifié. Les instructions ajoutées sont les suivantes
- qiskit.providers.aer.library.SetDensityMatrix
- qiskit.providers.aer.library.SetStabilizer
- qiskit.providers.aer.library.SetStatevector
- qiskit.providers.aer.library.SetUnitary
Ces instructions peuvent être ajoutées à un circuit quantique en utilisant les méthodes de circuit set_density_matrix, set_stabilizer, set_statevector, set_unitary qui sont ajoutées à QuantumCircuit lors de l'importation d'Aer.

Voir la documentation de l'API qiskit.providers.aer.library pour plus de détails sur la compatibilité des méthodes pour chaque instruction.
Ajout de la prise en charge des portes diagonales dans la méthode de simulation "matrix_product_state" .
Ajout de la prise en charge de l'instruction initialize à la méthode de simulation "matrix_product_state" .

Problèmes connus

Il existe un problème connu où la simulation de certains circuits avec un modèle de bruit Kraus en utilisant la méthode de simulation "matrix_product_state" peut provoquer un plantage du simulateur. Pour plus d'informations, reportez-vous au point 306.

Mise à niveau

La version minimale de Conan a été augmentée à 1.31.2. Cette modification était nécessaire pour résoudre un problème de compatibilité avec les versions plus récentes de l'application urllib3 (qui est une dépendance de Conan). Il ajoute également la prise en charge native de AppleClang 12, ce qui est utile pour les utilisateurs de nouveaux ordinateurs Apple.
pybind11 la version minimale requise est 2.6 au lieu de 2.4. Cela est nécessaire pour prendre en charge la compilation CUDA sous Windows.
Cython a été supprimé en tant que dépendance de construction.
Suppression de la décomposition en portes de x90 des modèles de bruit qui était obsolète dans qiskit-aer 0.7. Cette décomposition est maintenant effectuée en utilisant les portes de base du modèle de bruit régulier et le transpileur qiskit.
Les options suivantes de la méthode de simulation "extended_stabilizer" ont été modifiées.
- extended_stabilizer_measure_sampling: Cette option a été remplacée par l'option extended_stabilizer_sampling_method, qui contrôle la manière dont nous simulons la mesure des qubits.
- extended_stabilizer_mixing_time: Cette option a été renommée extended_stabilizer_metropolis_mixing_time pour préciser qu'elle ne s'applique qu'aux méthodes d'échantillonnage metropolis et resampled_metropolis .
- extended_stabilizer_norm_estimation_samples: Cette option a été renommée extended_stabilizer_norm_estimation_default_samples.
Une option supplémentaire, extended_stabilizer_norm_estimation_repetitions , a été ajoutée, qui contrôle une partie du comportement de la méthode d'échantillonnage de l'estimation de la norme.

Remarques concernant la dépréciation

Python 3.6 est obsolète et sera supprimée dans une prochaine version. Lorsque le support sera supprimé, vous devrez mettre à jour la version de Python que vous utilisez vers Python 3.7 ou une version supérieure.

Corrections des erreurs

Correction d'un bogue avec AerProvider où les options définies sur les backends retournés en utilisant set_options() étaient stockées dans le fournisseur et persistaient pour les appels ultérieurs à get_backend() pour le même backend nommé. Désormais, chaque appel à et backends() renvoie une nouvelle instance du backend du simulateur qui peut être configuré.
Correction d'un bogue dans le message d'erreur renvoyé lorsqu'un circuit contient des instructions de simulateur non prises en charge. Auparavant, certaines instructions prises en charge figuraient également dans le message d'erreur avec les instructions non prises en charge.
Correction d'un problème lié à la définition des portes de base de QasmSimulator lors de l'utilisation conjointe des options "method" et "noise_model" , et lors de leur utilisation avec un simulateur construit à l'aide de from_backend(). Désormais, les portes de base énumérées seront l'intersection des portes prises en charge par la configuration du backend, la méthode de simulation et les portes de base du modèle de bruit. Si l'intersection des portes de base du modèle de bruit et des portes de base du simulateur est vide, un avertissement sera enregistré.
Correction d'un bug où la porte "sx"` SXGate n'était pas listée comme une porte supportée dans le code C++, dans StateOpSet de matrix_product_state.hp.
Correction d'un bug où "csx", "cu2", "cu3" étaient incorrectement listés comme portes de base supportées pour la méthode "density_matrix" de la méthode QasmSimulator.
Correction d'un bogue où les paramètres étaient transmis de manière incorrecte entre les fonctions dans matrix_product_state_internal.cpp, ce qui entraînait une simulation erronée, ainsi que l'atteinte d'états non valides, ce qui provoquait à son tour une boucle infinie.
Correction d'un bogue qui faisait que c_if ne fonctionnait pas lorsque la largeur du registre conditionnel était supérieure à 64. Voir #1077.
Correction d'un bogue (#1153 ) où le bruit sur les portes conditionnelles était toujours appliqué sans tenir compte du fait que la porte conditionnelle était effectivement appliquée sur la base de la valeur du registre classique. Désormais, le bruit d'une porte conditionnelle ne sera appliqué que dans le cas où la porte conditionnelle est appliquée.
Correction d'un bogue avec les OpenMP imbriqués dont le drapeau était positionné à true alors qu'il ne devait pas l'être.
Correction d'un bogue lors de l'application de la troncature dans la méthode d'état du produit matriciel de QasmSimulator.
Correction du problème #1126 : bug dans le rapport de mesure d'un seul qubit. Le bogue s'est produit lors de la copie de la valeur mesurée dans la structure de données de sortie.
Dans MPS, apply_kraus opérait directement sur les bits d'entrée des qubits de paramètres, au lieu des qubits internes. Dans l'algorithme MPS, les qubits sont constamment en mouvement et toutes les opérations doivent donc être appliquées aux qubits internes.
Lorsque nous invoquons MPS::sample_measure, nous devons d'abord trier les qubits selon l'ordre par défaut, car c'est l'hypothèse de qasm_controller.This, en invoquant la méthode move_all_qubits_to_sorted_ordering. Elle était correcte dans l'échantillon "mesure" utilisant "application" de la mesure, mais manquait dans l'échantillon "mesure" utilisant "probabilité".
Correction d'un bogue avec la méthode from_backend() de QasmSimulator qui fixait l'attribut local de la configuration à la valeur du backend au lieu d'être toujours fixé à True.
Correction d'un bogue dans from_backend() et from_backend() où basis_gates était défini de manière incorrecte pour les appareils IBMQ dont la porte de base était définie sur ['id', 'rz', 'sx', 'x', 'cx']. Désormais, le modèle de bruit aura toujours les mêmes portes de base que les portes de base du backend, que ces instructions comportent ou non des erreurs dans le modèle de bruit.
Corrige un problème où la méthode de simulation "extended_stabilizer" donnait des résultats incorrects sur les circuits quantiques avec des distributions de sortie éparses. Pour plus d'informations et d'exemples, voir le numéro 306.

Ignis 0.6.0

Nouvelles fonctions

La fonction qiskit.ignis.mitigation.expval_meas_mitigator_circuits() a été améliorée de sorte que le nombre de circuits générés par la fonction utilisée pour l'étalonnage par la méthode CTMP est réduit de $O(n)$ à $O(\log{n})$ (où $n$ est le nombre de qubits).

Mise à niveau

La fonction qiskit.ignis.verification.randomized_benchmarking_seq() utilise désormais la classe CNOTDihedral améliorée, qiskit.ignis.verification.CNOTDihedral, qui permet d'effectuer une analyse comparative aléatoire CNOT-Dihedral sur plus de deux qubits.
Le paquet python retworkx est maintenant nécessaire pour installer qiskit-ignis. Il remplace l'utilisation précédente de networkx (qui n'est plus nécessaire) pour obtenir de meilleures performances.
La dépendance scikit-learn n'est plus requise et est désormais facultative. Si vous utilisez les discriminateurs de mesure IQ (IQDiscriminationFitter, LinearIQDiscriminationFitter, QuadraticIQDiscriminationFitter, ou SklearnIQDiscriminator) vous devrez maintenant installer manuellement scikit-learn, soit en exécutant pip install scikit-learn ou lorsque vous installez également qiskit-ignis avec pip install qiskit-ignis[iq].

Corrections des erreurs

Correction d'un problème dans la méthode de la valeur d'espérance expectation_value(), pour les classes d'atténuation des erreurs TensoredExpvalMeasMitigator et CTMPExpvalMeasMitigator si le kwarg qubits n'était pas spécifié, il utilisait incorrectement le nombre total de qubits de l'atténuateur, plutôt que le nombre de bits classiques dans le dictionnaire de comptage, ce qui entraînait une réduction considérable des performances. Corrigé #561
Corriger la méthode "auto" de TomographyFitter, StateTomographyFitter, et ProcessTomographyFitter pour n'utiliser "cvx" que si CVXPY est installé et qu' un solveur SDP tiers autre que SCS est disponible. En effet, le solveur SCS est moins précis que les autres méthodes de résolution et renvoie souvent une matrice de densité ou une matrice de Choi qui n'est pas complètement positive et qui échoue à la validation lorsqu'elle est utilisée avec la méthode qiskit.quantum_info.state_fidelity() ou qiskit.quantum_info.process_fidelity() et échoue à la validation.

Aqua 0.9.0

Cette version rend officiellement obsolète le projet Qiskit Aqua, dans le futur (au plus tôt 3 mois après cette version) le projet Aqua aura sa version finale et sera archivé. Toutes les fonctionnalités fournies par qiskit-aqua ont été migrées vers de nouveaux paquets ou vers d'autres paquets qiskit. Les modules d'application fournis par qiskit-aqua ont été divisés en plusieurs nouveaux paquets : qiskit-optimization, qiskit-nature, qiskit-machine-learning, et qiskit-finance. Ces paquets peuvent être installés seuls (via la commande pip install standard, c'est-à-dire pip install qiskit-nature) ou avec le reste du métapaquet Qiskit en tant qu'extras optionnels (c'est-à-dire pip install 'qiskit[finance,optimization]' ou pip install 'qiskit[all]'. Les éléments de base des algorithmes et du flux d'opérateurs font désormais partie intégrante de qiskit-terra à l'adresse qiskit.algorithms et qiskit.opflow. En fonction de votre utilisation actuelle d'Aqua, vous devriez utiliser soit les paquets d'application, soit les nouveaux modules de Qiskit Terra.

Pour plus de détails sur la façon de migrer à partir de Qiskit Aqua, vous pouvez vous référer au guide de migration.

IBM 0.12.2 du fournisseur Q

Pas de modification

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

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