Skip to main content
IBM Quantum Platform

Notes de publication de Qiskit 1.0

1.0.2

Prélude

Qiskit 1.0.2 est une version mineure de correction de bugs pour la série 1.0.

Corrections des erreurs

  • Correction d'un problème avec convert_to_target() où le convertisseur ignorait à tort les instructions de flux de contrôle si elles étaient spécifiées dans l'attribut BackendConfiguration.supported_instructions , qui est l'endroit typique où les instructions de flux de contrôle sont spécifiées dans un objet BackendConfiguration objet. Correction #11872.

  • L'appel à EquivalenceLibrary.set_entry() mettra désormais correctement à jour l'objet graphique interne de la bibliothèque. Auparavant, les métadonnées étaient mises à jour, mais la structure du graphe restait inchangée, ce qui signifiait que des utilisateurs tels que BasisTranslator continueraient à utiliser les anciennes règles. Correction #11958.

  • La fonction EvolvedOperatorAnsatz gère désormais correctement le cas où l'argument operators est une liste vide. Auparavant, cela entraînait une erreur.

  • Correction d'un problème de cohérence avec les instances EvolvedOperatorAnsatz avec des qubits nuls. Auparavant, ces instances contenaient un seul QuantumRegister in qregs avec zéro qubit, mais maintenant aucun registre n'est créé. Ce comportement est plus cohérent avec celui de la superclasse QuantumCircuit.

  • Correction d'un crash dans convert_to_target() qui se produisait lorsque les propriétés d'un qubit (soit T1, T2 ou la fréquence) étaient manquantes. Les valeurs manquantes dans QubitProperties sont maintenant remplies avec None.

  • Correction d'un problème de performance dans la fonction qpy.load() lors de la désérialisation de charges utiles QPY avec un grand nombre de qubits ou de clbits dans un circuit.

  • Correction d'un bogue dans lequel EstimatorPub.coerce() et SamplerPub.coerce() géraient de manière incorrecte un paramètre de type BindingsArray. Auparavant, une exception ValueError était levée à tort.

  • Les gestionnaires de passage prédéfinis utilisés par transpile() n'échoueront plus sur les circuits avec flux de contrôle lorsqu'aucune cible matérielle ou aucun jeu de portes de base n'est spécifié. Ils traiteront désormais ces cibles abstraites comme autorisant toutes les opérations de flux de contrôle. Correction #11906.

  • Correction de coerce() pour qu'il renvoie un tableau de 0-d lorsque l'entrée est un seul observable non noué. Auparavant, il est passé par erreur à une dimension unique, avec la forme (1,).

  • Parameter a été mis à jour de manière à ce que les instances qui se comparent entre elles aient toujours le même hachage. Auparavant, seul le Parameter.uuid était comparée, de sorte que les instances Parameter ayant des noms différents pouvaient être comparées entre elles si elles avaient été construites en utilisant une valeur commune pour le paramètre uuid (qui n'est généralement pas transmis explicitement).

  • Correction d'un bogue dans QuantumCircuit.draw() qui entraînait la modification des dictionnaires de styles personnalisés pour le tiroir Matplotlib lors de l'exécution.

1.0.1

Prélude

Qiskit 1.0.1 est une version corrective qui corrige un petit nombre de bogues identifiés dans la version Qiskit 1.0.0.

Corrections des erreurs

  • Correction d'un bogue dans la conversion des instructions d'impulsion personnalisées au format legacy qiskit.qobj ancien. Le bogue a été introduit dans Qiskit 1.0.0 et provoquait une erreur lors de la conversion d'instructions avec des formes d'impulsion personnalisées. Après la correction, la conversion s'effectue correctement et l'impulsion personnalisée est convertie en pulse.Waveform comme il se doit. Correction #11828.

  • Correction d'un problème dans la passe InverseCancellation qui, dans certains cas, annulait incorrectement une porte paramétrée auto-inverse même si la valeur du paramètre ne correspondait pas. Correction #11815.

  • BasePassManager.run() ne laissera plus échapper l'ancien PropertySet dans les nouveaux flux de travail lorsqu'elle est appelée plusieurs fois. Auparavant, les mêmes PropertySet que précédemment était utilisée pour initialiser les exécutions suivantes, ce qui pouvait signifier que des informations non valides sur les propriétés étaient communiquées aux tâches. Le comportement correspond désormais à celui de Qiskit 0.44. Correction #11784.

  • Un bogue a été corrigé dans convert_durations_to_dt() : la fonction supposait que ses entrées étaient toutes exprimées en secondes, au lieu de lire l'unité réelle. Cela pourrait conduire à des ordres de grandeur erronés dans les durées de circuit rapportées.

1.0.0

Prélude

Nous sommes très heureux de publier Qiskit 1.0.0. Cette version est l'aboutissement de 7 années de développement pour faire de Qiskit un SDK stable et performant pour l'informatique quantique, et marque le début d'une nouvelle ère pour le projet Qiskit et sa communauté. Outre les améliorations générales des performances et de la stabilité, les changements les plus importants de la version 1.0.0 concernent la politique de stabilité, les cycles de publication et les versions. Qiskit utilise désormais officiellement le versionnage sémantique, ce qui signifie que, pour l'ensemble du cycle de vie de la série de versions 1.x, le projet s'engage à maintenir la compatibilité ascendante dans ses API publiques documentées. Nous commençons également à proposer une assistance pour les corrections de bogues pour les versions majeures, de sorte que vous continuiez à disposer d'une branche assistée pendant 6 mois après la sortie de la prochaine version majeure. Cela commence maintenant avec les séries majeures 1.x et 0.x : la version 0.46.x continuera à être prise en charge, avec des versions de correctifs périodiques qui contiennent des corrections de bogues, pendant 6 mois après la sortie de 1.0. En d'autres termes, le site 0.46.x sera soutenu jusqu'en 2024-08. Vous pouvez consulter tous les détails de la nouvelle politique ici :

start/install#qiskit-versioning

Le changement d'emballage est également d'une importance capitale pour cette version. Depuis la version de Qiskit 0.7 en 2018-12, lorsque Qiskit a introduit son modèle d' éléments, le paquet qiskit que vous installez est un méta-paquet (ou paquet de paquets) qui installe les éléments combinés qui composent Qiskit. Comme annoncé dans les versions précédentes (pour plus de détails, voir la section 0.44.0, 0.45.3, et 0.46.0 ainsi que ce billet de blog ), avec la version 1.0, nous achevons la transition vers un paquetage unique qiskit exposant uniquement le SDK de base (ce qui était auparavant qiskit-terra). Cela signifie que pour les versions >= 1.0.0, nous avons cessé d'utiliser le paquet qiskit-terra et ne publierons plus que qiskit. Comme ce changement dans la structure de l'emballage n'est pas entièrement pris en charge par l'installateur de paquets Python pip, il n'est pas possible d'utiliser pip install -U qiskit pour mettre à niveau qiskit 0.46.0 vers 1.0.0. Il est fortement recommandé de créer un environnement virtuel séparé pour isoler l'installation lors de la mise à jour vers Qiskit 1.0.0. Il existe un guide de migration détaillé qui explique les changements de packaging et la façon d'installer Qiskit 1.0.0 dans différents scénarios, qui peut être trouvé ici :

https://qisk.it/1-0-packaging-migration

Comme toutes nos versions majeures, Qiskit 1.0.0 a également une pléthore de nouvelles fonctionnalités, les points forts de cette version sont les suivants :

  • La classe QuantumCircuit la structure interne de la classe data a été réécrite en Rust afin d'améliorer considérablement l'efficacité de la mémoire des objets en mettant en cache les arguments des instructions QuantumCircuit en mettant en cache les arguments des instructions.
  • Une nouvelle version de la définition de l'interface des primitives en qiskit.primitives avec les éléments BaseSamplerV2 et BaseEstimatorV2 et les classes abstraites. Cette nouvelle version de l'interface permet d'effectuer des appels vectorisés à la primitive afin de spécifier efficacement les balayages sur les ensembles de valeurs des paramètres et les observables.
  • Un nouveau parseur expérimental natif OpenQASM 3 qiskit.qasm3.loads_experimental() et qiskit.qasm3.load_experimental(). Ce nouvel analyseur est encore en cours de développement et présente encore plusieurs limitations. Cependant, là où il est utilisable, le nouvel analyseur est nettement plus rapide et dispose d'un meilleur message d'erreur de diagnostic qui permet de déboguer les cas où un programme OpenQASM 3 n'est pas valide. Ce nouvel analyseur est écrit en Rust et basé sur une bibliothèque Rust nouvellement développée pour l'analyse de OpenQASM3 qui peut être trouvée ici : https://github.com/Qiskit/openqasm3_parser

Enfin, la version de Qiskit 1.0.0 a été l'occasion de nettoyer une partie de la dette technique accumulée au cours des 7 dernières années de développement. Vous remarquerez que la version de Qiskit 1.0.0 est pratiquement exempte d'émissions de DeprecationWarninget que, dans le même temps, la section relative à la mise à niveau des notes de version de 1.0.0 est plus longue que d'habitude. Il s'agit là de conséquences directes de l'assainissement de la dette technique. Pour faciliter la migration de 0.46.x vers 1.0.0, outre les notes de version, nous avons également publié un guide de migration spécifique qui peut être consulté ici :

Qiskit 1.0 : changements de fonctionnalités

Ce guide a pour but de compléter les notes de version et de donner des conseils ciblés sur la manière de migrer les modifications de l'API après la suppression des fonctionnalités obsolètes de la version 0.46.0.

Caractéristiques des circuits

  • Ajout d'un nouvel argument, annotated, aux méthodes QuantumCircuit.inverse(), circuit.Instruction.inverse() et .inverse() des méthodes de Instruction (telles que SwapGate ou SGate) pour qu'elles renvoient éventuellement un argument AnnotatedOperation. La valeur par défaut de annotated est False et correspond au comportement préexistant de la méthode. En outre, pour les portes standard dont la méthode inverse est explicitement définie, l'argument annotated n'a aucun effet, par exemple, les deux :

    SwapGate().inverse(annotated=False)
SwapGate().inverse(annotated=True)

    retourner a SwapGateet les deux :

    SGate().inverse(annotated=False)
SGate().inverse(annotated=True)

    renvoyer un SdgGate. La différence se manifeste pour les instructions personnalisées sans inverse explicitement défini. Avec annotated=False, la méthode renvoie une nouvelle instruction avec la définition inversée récursivement, comme précédemment. Tandis que annotated=True renvoie un AnnotatedOperation qui représente l'instruction modifiée avec le InverseModifier.

  • Ajout d'une bibliothèque de commutation à la CommutationChecker. Cette bibliothèque stocke toutes les relations de commutation des portes standard non paramétrables dans un dictionnaire qui permet une recherche efficace au moment de l'exécution. Cela accélère l'exécution de la classe CommutationChecker et, par extension, de la passe CommutationAnalysis car au lieu de calculer si deux portes standard non paramétrables commutent, il suffit de le chercher dans la bibliothèque.

    En outre, l'outil CommutationChecker a été remanié et dispose désormais d'une limite supérieure pour le nombre de relations de commutation mises en cache qui ne se trouvent pas dans la bibliothèque de commutation. Cette question a été abordée : #8020 et #7101

  • QuantumCircuit.assign_parameters() accepte désormais les clés de type chaîne de caractères dans la forme de mappage de l'entrée. Ces noms sont utilisés pour rechercher l'instance correspondante Parameter correspondante en utilisant get_parameter(). Cela vous permet de faire :

    from qiskit.circuit import QuantumCircuit, Parameter

a = Parameter("a")
qc = QuantumCircuit(1)
qc.rx(a, 0)

qc.assign_parameters({"a": 1}) == qc.assign_parameters({a: 1})

  • QuantumCircuit a deux nouvelles méthodes, get_parameter() et has_parameter()qui permettent respectivement de récupérer une instance de Parameter utilisée dans le circuit par son nom, et renvoient un booléen indiquant si un paramètre portant le même nom (ou l'instance exacte donnée) est utilisé dans le circuit.

  • A uuid a été ajoutée à la classe qiskit.circuit.Parameter classe. Dans les cas d'utilisation avancée, cette propriété peut être utilisée pour créer des instances qui se comparent l'une à l'autre qiskit.circuit.Parameter qui se comparent l'une à l'autre.

  • Ajout d'une nouvelle méthode, ParameterExpression.numeric()qui convertit une expression de paramètre entièrement liée dans le type numérique intégré Python le plus restrictif qui décrit précisément le résultat de l'évaluation symbolique. Par exemple, un entier symbolique deviendra un inttandis qu'un nombre réel symbolique deviendra un float et un nombre complexe deviendra a complex. Cette méthode comprend plusieurs solutions de contournement pour les particularités des contextes d'évaluation de symengine, qui peuvent parfois conduire à des résultats erronés lors de l'appel de complex ou float sur une expression directement.

Fonctionnalités primitives

  • La version 2 des primitives est introduite par le biais d'une nouvelle classe de base pour l'échantillonneur et l'estimateur, ainsi que de nouveaux types pour leurs entrées et sorties. Cette nouvelle version met l'accent sur l'exécution d'appels vectorisés aux méthodes primitives run() , de sorte que les balayages sur les ensembles de valeurs des paramètres et les observables puissent être spécifiés efficacement. Voir StatevectorSampler et StatevectorEstimator pour les implémentations de référence des primitives V2.

    En outre, l'estimateur a gagné un argument precision dans la méthode run() qui spécifie la précision ciblée des estimations de la valeur de l'espérance. De la même manière, l'échantillonneur a déplacé shots des options vers les arguments de la méthode run() méthode. L'échantillonneur a également été modifié pour renvoyer les sorties (par exemple des chaînes de bits) de chaque prise, plutôt que de fournir un retour de type Counts-et également pour stocker les données de plusieurs ClassicalRegisters. Cela permet aux classes dérivées de mettre en œuvre la prise en charge de l'échantillonneur pour les circuits avec un flux de contrôle classique.

    Les classes de base primitives de V2 sont les suivantes

    Les nouveaux types utilisés pour les entrées et les sorties sont les suivants :

    • SamplerPubLikebloc primitif unifié ( PUB ) des entrées de l'échantillonneur; type d'union des entrées autorisées pour un échantillonneur
    • EstimatorPubLike: Bloc primitif unifié ( PUB ) des entrées de l'estimateur; type d'union des entrées autorisées d'un estimateur
    • PubResultles données et métadonnées résultant de l'exécution d'un seul site PUB
    • DataBin: Un espace de noms pour contenir les données de l'exécution d'un seul PUB
    • BitArrayune collection de valeurs de bits sous forme de tableau dans un format dense
    • PrimitiveResult: un itérable de PubResultavec des métadonnées

  • La mise en œuvre de référence StatevectorEstimator de BaseEstimatorV2 a été ajoutée. Comme le montre l'exemple ci-dessous, cet estimateur (et tous les estimateurs V2 ) permet de fournir des tableaux d'observables et/ou des tableaux d'ensembles de valeurs de paramètres attachés à des circuits particuliers.

    Chaque tuple de (circuit, observables, <optional> parameter values, <optional> precision), appelé bloc unifié primitif d'estimateur ( PUB ), produit son propre résultat sous forme de tableau. La méthode run() peut être appliquée à plusieurs pubs à la fois.

    from qiskit.circuit import Parameter, QuantumCircuit
from qiskit.primitives import StatevectorEstimator
from qiskit.quantum_info import Pauli, SparsePauliOp

import matplotlib.pyplot as plt
import numpy as np

# Define a circuit with two parameters.
circuit = QuantumCircuit(2)
circuit.h(0)
circuit.cx(0, 1)
circuit.ry(Parameter("a"), 0)
circuit.rz(Parameter("b"), 0)
circuit.cx(0, 1)
circuit.h(0)

# Define a sweep over parameter values, where the second axis is over
# the two parameters in the circuit.
params = np.vstack([
    np.linspace(-np.pi, np.pi, 100),
    np.linspace(-4 * np.pi, 4 * np.pi, 100)
]).T

# Define three observables. Many formats are supported here including
# classes such as qiskit.quantum_info.SparsePauliOp. The inner length-1
# lists cause this array of observables to have shape (3, 1), rather
# than shape (3,) if they were omitted.
observables = [
    [SparsePauliOp(["XX", "IY"], [0.5, 0.5])],
    [Pauli("XX")],
    [Pauli("IY")]
]

# Instantiate a new statevector simulation based estimator object.
estimator = StatevectorEstimator()

# Estimate the expectation value for all 300 combinations of
# observables and parameter values, where the pub result will have
# shape (3, 100). This shape is due to our array of parameter
# bindings having shape (100,), combined with our array of observables
# having shape (3, 1)
pub = (circuit, observables, params)
job = estimator.run([pub])

# Extract the result for the 0th pub (this example only has one pub).
result = job.result()[0]

# Error-bar information is also available, but the error is 0
# for this StatevectorEstimator.
result.data.stds

# Pull out the array-based expectation value estimate data from the
# result and plot a trace for each observable.
for idx, pauli in enumerate(observables):
    plt.plot(result.data.evs[idx], label=pauli)
plt.legend()

  • La mise en œuvre de référence StatevectorSampler de BaseSamplerV2 a été ajoutée. Comme le montre l'exemple ci-dessous, cet échantillonneur (et tous les échantillonneurs V2 ) permet de fournir des tableaux d'ensembles de valeurs de paramètres à lier à un seul circuit.

    Chaque tuple de (circuit, <optional> parameter values, <optional> shots), appelé bloc unifié primitif de l'échantillonneur ( PUB ), produit son propre résultat sous forme de tableau. La méthode run() peut être appliquée à plusieurs pubs à la fois.

    from qiskit.circuit import (
    Parameter, QuantumCircuit, ClassicalRegister, QuantumRegister
)
from qiskit.primitives import StatevectorSampler

import matplotlib.pyplot as plt
import numpy as np

# Define our circuit registers, including classical registers
# called 'alpha' and 'beta'.
qreg = QuantumRegister(3)
alpha = ClassicalRegister(2, "alpha")
beta = ClassicalRegister(1, "beta")

# Define a quantum circuit with two parameters.
circuit = QuantumCircuit(qreg, alpha, beta)
circuit.h(0)
circuit.cx(0, 1)
circuit.cx(1, 2)
circuit.ry(Parameter("a"), 0)
circuit.rz(Parameter("b"), 0)
circuit.cx(1, 2)
circuit.cx(0, 1)
circuit.h(0)
circuit.measure([0, 1], alpha)
circuit.measure([2], beta)

# Define a sweep over parameter values, where the second axis is over.
# the two parameters in the circuit.
params = np.vstack([
    np.linspace(-np.pi, np.pi, 100),
    np.linspace(-4 * np.pi, 4 * np.pi, 100)
]).T

# Instantiate a new statevector simulation based sampler object.
sampler = StatevectorSampler()

# Start a job that will return shots for all 100 parameter value sets.
pub = (circuit, params)
job = sampler.run([pub], shots=256)

# Extract the result for the 0th pub (this example only has one pub).
result = job.result()[0]

# There is one BitArray object for each ClassicalRegister in the
# circuit. Here, we can see that the BitArray for alpha contains data
# for all 100 sweep points, and that it is indeed storing data for 2
# bits over 256 shots.
assert result.data.alpha.shape == (100,)
assert result.data.alpha.num_bits == 2
assert result.data.alpha.num_shots == 256

# We can work directly with a binary array in performant applications.
raw = result.data.alpha.array

# For small registers where it is anticipated to have many counts
# associated with the same bitstrings, we can turn the data from,
# for example, the 22nd sweep index into a dictionary of counts.
counts = result.data.alpha.get_counts(22)

# Or, convert into a list of bitstrings that preserve shot order.
bitstrings = result.data.alpha.get_bitstrings(22)
print(bitstrings)

Fonctionnalités des fournisseurs

  • Ajout d'une nouvelle classe, GenericBackendV2au module qiskit.providers.fake_provider module. Cette classe est configurable et construit une instance de BackendV2 qui peut être exécutée localement (dans l'esprit des faux backends). Les utilisateurs peuvent configurer le nombre de qubits, les portes de base, la carte de couplage, la capacité à exécuter des circuits dynamiques (instructions de flux de contrôle), les calibrations d'instructions et le pas de temps de mesure du backend sans avoir à s'occuper de la construction manuelle de la cible. Les propriétés du Qubit et de la porte (durée, erreur) sont générées par un échantillonnage aléatoire à partir des plages par défaut. La graine de cette génération aléatoire peut être fixée pour garantir la reproductibilité de la sortie du backend. Il est important de noter que ce backend ne prend en charge que les portes de la bibliothèque standard. Si vous avez besoin d'un backend plus flexible, vous avez toujours la possibilité d'instancier directement un objet Target à utiliser pour la transpilation.

    Exemple d'utilisation 1 :

    from qiskit import QuantumCircuit, transpile
from qiskit.providers.fake_provider import GenericBackendV2

# Create a simple circuit
circuit = QuantumCircuit(3)
circuit.h(0)
circuit.cx(0,1)
circuit.cx(0,2)
circuit.measure_all()
circuit.draw('mpl')

# Define backend with 3 qubits
backend = GenericBackendV2(num_qubits=3)

# Transpile and run
transpiled_circuit = transpile(circuit, backend)
result = backend.run(transpiled_circuit).result()

    Exemple d'utilisation 2 :

    from qiskit import QuantumCircuit, ClassicalRegister, transpile
from qiskit.providers.fake_provider import GenericBackendV2

# Create a circuit with classical control
creg = ClassicalRegister(19)
qc = QuantumCircuit(25)
qc.add_register(creg)
qc.h(0)
for i in range(18):
    qc.cx(0, i + 1)
for i in range(18):
    qc.measure(i, creg[i])
with qc.if_test((creg, 0)):
    qc.ecr(20, 21)

# Define backend with custom basis gates and control flow instructions
backend = GenericBackendV2(
    num_qubits=25,
    basis_gates=["ecr", "id", "rz", "sx", "x"],
    control_flow=True,
  )

#Transpile
transpiled_qc = transpile(qc, backend)
    Remarque

    Les propriétés du bruit généré par cette classe n'imitent aucun dispositif quantique concret et ne doivent pas être utilisées pour mesurer des comportements concrets. Il s'agit de "valeurs par défaut raisonnables" qui peuvent être utilisées pour tester la fonctionnalité de l'interface backend et non de valeurs de bruit spécifiques liées à des systèmes quantiques réels. Pour une simulation plus précise des dispositifs existants, vous pouvez construire manuellement un modèle de bruit à partir du backend réel à l'aide de la fonctionnalité offerte dans le fichier qiskit_aer.

  • Le module qiskit.providers.fake_provider comprend désormais une série de faux backends génériques suivant l'interface BackendV1 l'interface. Ils ont été introduits comme une alternative aux faux backends basés sur des instantanés, exposés dans la version obsolète de FakeProvider (FakeVigo, FakeTokyo, etc). La liste des nouveaux faux backends comprend

    Ils peuvent être importés en suivant le modèle suivant : from qiskit.providers.fake_provider import Fake5QV1. Vous trouverez plus de détails sur les propriétés du backend dans la documentation de l'API de chaque backend.

OpenQASM Caractéristiques

  • Le paquet qiskit.qasm3 contient maintenant un analyseur intégré, basé sur Rust, pour lire les programmes OpenQASM 3 dans QuantumCircuitque l'on trouve à l'adresse qiskit.qasm3.load_experimental() et loads_experimental(). Ils sont généralement plusieurs fois plus rapides que les systèmes existants, purement Python load() et loads() qui nécessitent l'installation de qiskit-qasm3-import .

    Par exemple, nous pouvons créer un enchevêtrement de 20 000 instructions QuantumCircuit:

    import numpy as np
import qiskit.qasm3
from qiskit.circuit.library import RealAmplitudes

qc = RealAmplitudes(100, reps=100, flatten=True)
qc = qc.assign_parameters(np.random.rand(qc.num_parameters))
oq3 = qiskit.qasm3.dumps(qc)

    L'ancien programme qasm3.loads() prenait environ 7.3s pour charger le programme OpenQASM 3 résultant, alors que qasm3.loads_experimental() a pris moins de 300ms sur un Macbook Pro grand public ( i7, 2020)-une accélération de 25x!

    L'ensemble des fonctionnalités supportées par l'analyseur expérimental est très limité dans cette version de prévisualisation, mais il s'étendra au fur et à mesure que le côté Qiskit et l' analyseur natif basé sur Rust s 'amélioreront.

    L'un de nos principaux objectifs avec ce nouvel analyseur, outre les énormes améliorations en termes de vitesse, est de fournir des diagnostics d'erreur de grande qualité. Comme pour les autres parties de l'analyseur, il s'agit d'un travail en cours, mais vous commencerez à voir des messages d'erreur de bien meilleure qualité s'afficher lorsque vous analyserez des programmes OpenQASM 3 invalides avec l'analyseur expérimental.

  • L'exportateur OpenQASM 3 (voir dump() et dumps() dans qiskit.qasm3) supporte désormais par défaut la syntaxe stabilisée de la déclaration switch dans OpenQASM 3. La syntaxe de pré-certification de la déclaration switch est toujours disponible en utilisant l'indicateur ExperimentalFeatures.SWITCH_CASE_V1 dans l'argument experimental de l'exportateur. Aucun indicateur de fonctionnalité n'est requis pour la syntaxe stabilisée, mais si vous êtes en interface avec d'autres outils qui n'ont pas encore été mis à jour, vous devrez peut-être passer l'indicateur expérimental.

    La syntaxe de la forme stabilisée est légèrement différente en ce qui concerne la terminaison des instructions break (qui n'est plus requise ni autorisée), et les cas multiples sont désormais combinés en une seule ligne case , plutôt que d'utiliser les retombées à la manière du langage C. Pour plus de détails, voir la documentation de OpenQASM 3 sur la construction switch-case.

Caractéristiques du QPY

  • Ajout d'une nouvelle classe d'avertissement, QPYLoadingDeprecatedFeatureWarningau module QPY. Cette classe permet de faire apparaître les avertissements de dépréciation même si la fonction dépréciée est accessible à un point variable de la pile d'appels, comme c'est le cas pour de nombreuses fonctions de chargement QPY qui sont appelées de manière récursive.

  • Ajout d'un nouvel indicateur, version, à la fonction qpy.dump() fonction. Cela permet qpy.dump() de prendre optionnellement une valeur entière pour la version du format QPY à émettre. Ceci est utile si vous devez générer un fichier QPY qui sera chargé par une ancienne version de Qiskit. Cependant, les versions supportées pour l'émission sont limitées, seules les versions entre la dernière version de QPY (qui est la version par défaut), et la version de compatibilité de QPY qui est la version 10 (qui a été introduite dans Qiskit 0.45.0 ) peuvent être utilisées. La version de compatibilité restera fixe pendant toute la série de versions majeures de 1.x.y. Cela ne modifie pas les garanties de rétrocompatibilité du format QPY lors de l'appel de qpy.load()cela permet simplement aux utilisateurs d'émettre une version plus ancienne de QPY afin de maintenir la compatibilité et l'interopérabilité entre les séries de versions 0.x et 1.x.

Caractéristiques de l'information quantique

  • Ajout d'une méthode qiskit.quantum_info.StabilizerState.from_stabilizer_list() qui génère un état de stabilisation à partir d'une liste de stabilisateurs :

    from qiskit.quantum_info import StabilizerState

stabilizer_list = ["ZXX", "-XYX", "+ZYY"]
stab = StabilizerState.from_stabilizer_list(stabilizer_list)

  • SparsePauliOp.from_operator() utilise maintenant une implémentation de "l'algorithme de décomposition de Pauli tensorisé" présenté dans Hatznko, Binkowski et Gupta (2023). La méthode est désormais plus rapide de plusieurs ordres de grandeur; par exemple, il est possible de décomposer un opérateur aléatoire de 10 qubits en environ 250ms sur un Macbook Pro grand public (Intel i7, 2020).

Caractéristiques de la synthèse

  • Ajout d'une qiskit.synthesis.synth_circuit_from_stabilizers() qui renvoie un circuit qui produit l'état stabilisé par une série de stabilisateurs donnés.

  • La méthode du plugin de synthèse unitaire de l'AQC utilise désormais par défaut une évaluation plus rapide de la fonction objective, ce qui se traduit par une amélioration substantielle du temps de synthèse.

  • Ajouter une nouvelle méthode de synthèse synth_qft_line() d'un circuit QFT pour la connectivité linéaire du plus proche voisin, qui réduit considérablement le nombre de SWAP pour un grand nombre de qubits par rapport à SABRE.

  • La classe TwoQubitWeylDecomposition a été ajoutée à l'API publique dans qiskit.synthesis. Cette classe permet d'appliquer la décomposition de Weyl aux unitaires à deux qubits. Si vous avez importé cette classe alors qu'il s'agissait d'une classe non publique dans le module qiskit.quantum_info.synthesis , désormais supprimé, vous devez mettre à jour vos chemins d'importation.

Fonctionnalités du transpilateur

  • Ajout d'une nouvelle classe d'exception : InvalidLayoutError. Il s'agit d'une sous-classe de TranspilerError qui apparaît lorsqu'une disposition fournie par l'utilisateur n'est pas valide (taille inadaptée, qubits en double, etc.).

  • Ajout d'un nouveau mot-clé, num_processes, à transpile() et à la méthode PassManager.run() méthode. Cela permet de remplacer à la fois QISKIT_NUM_PROCS et le champ num_processes dans les fichiers de configuration de l'utilisateur pour chaque transpile. Par exemple :

    from qiskit import transpile, QuantumCircuit

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

transpile([qc]*10, basis_gates=['u', 'cz'], num_processes=2)

    exécutera le transpile sur les 10 circuits d'entrée en utilisant seulement 2 processus et remplacera la valeur par défaut du système, la variable d'environnement ou le fichier de configuration de l'utilisateur pour ce transpile() appel.

  • Ajout d'une nouvelle passe de transposition, OptimizeAnnotatedqui optimise les opérations annotées sur un circuit quantique.

    Prenons l'exemple suivant :

    from qiskit.circuit import QuantumCircuit
from qiskit.circuit.annotated_operation import (
    AnnotatedOperation,
    InverseModifier,
    ControlModifier,
)
from qiskit.circuit.library import CXGate, SwapGate
from qiskit.transpiler.passes import OptimizeAnnotated

# Create a quantum circuit with multiple annotated gates
gate1 = AnnotatedOperation(
    SwapGate(),
    [InverseModifier(), ControlModifier(2), InverseModifier(), ControlModifier(1)],
)
gate2 = AnnotatedOperation(
    SwapGate(),
    [InverseModifier(), InverseModifier()]
)
gate3 = AnnotatedOperation(
    AnnotatedOperation(CXGate(), ControlModifier(2)),
    ControlModifier(1)
)
qc = QuantumCircuit(6)
qc.append(gate1, [3, 2, 4, 0, 5])
qc.append(gate2, [1, 5])
qc.append(gate3, [5, 4, 3, 2, 1])

# Optimize the circuit using OptimizeAnnotated transpiler pass
qc_optimized = OptimizeAnnotated()(qc)

# This is how the optimized circuit should look like
gate1_expected = AnnotatedOperation(SwapGate(), ControlModifier(3))
gate2_expected = SwapGate()
gate3_expected = AnnotatedOperation(CXGate(), ControlModifier(3))
qc_expected = QuantumCircuit(6)
qc_expected.append(gate1_expected, [3, 2, 4, 0, 5])
qc_expected.append(gate2_expected, [1, 5])
qc_expected.append(gate3_expected, [5, 4, 3, 2, 1])

assert qc_optimized == qc_expected

    Dans le cas de gate1, les modificateurs de la porte de swap annotée sont ramenés à la forme canonique : les deux s s'annulent et les deux s s'annulent InverseModifiers'annulent et les deux ControlModifiersont combinés. Dans le cas de gate2, tous les modificateurs sont supprimés et l'opération annotée est remplacée par son opération de base. Dans le cas de gate3, plusieurs couches d'annotations sont combinées en une seule.

    Le constructeur du OptimizeAnnotated accepte les arguments optionnels target, equivalence_library, basis_gates et recurse. Lorsque recurse est True (valeur par défaut) et que target ou basis_gates sont spécifiés, la passe descend récursivement dans les circuits definition de la porte, à l'exception des portes qui sont déjà supportées par la cible ou qui appartiennent à la bibliothèque d'équivalence. En revanche, lorsque ni target ni basis_gates ne sont spécifiés, ou lorsque recurse est défini comme False, la passe ne synthétise que les opérations annotées de "niveau supérieur", c'est-à-dire qu'elle ne descend pas récursivement dans les circuits definition . Ce comportement est cohérent avec celui de la passe HighLevelSynthesis qui doit être appelée pour "dérouler" les opérations annotées en portes à 1 et 2 qubits.

  • Ajout d'un nouveau HighLevelSynthesisPlugin pour PermutationGate basé sur l'algorithme d'échange de jetons de Qiskit. Pour utiliser ce plugin, spécifiez token_swapper lors de la définition de la configuration de la synthèse à haut niveau.

    Ce plugin de synthèse peut être exécuté avant ou après la définition de la mise en page. Lorsque la synthèse réussit, le plugin produit un circuit quantique composé uniquement de portes de permutation. Lorsque la synthèse n'aboutit pas, le plugin émet None.

    Le code suivant illustre la manière dont le nouveau plugin peut être exécuté :

    from qiskit.circuit import QuantumCircuit
from qiskit.circuit.library import PermutationGate
from qiskit.transpiler import PassManager, CouplingMap
from qiskit.transpiler.passes.synthesis.high_level_synthesis import HighLevelSynthesis, HLSConfig

# This creates a circuit with a permutation gate.
qc = QuantumCircuit(8)
perm_gate = PermutationGate([0, 1, 4, 3, 2])
qc.append(perm_gate, [3, 4, 5, 6, 7])

# This defines the coupling map.
coupling_map = CouplingMap.from_ring(8)

# This high-level-synthesis config specifies that we want to use
# the "token_swapper" plugin for synthesizing permutation gates,
# with the option to use 10 trials.
synthesis_config = HLSConfig(permutation=[("token_swapper", {"trials": 10})])

# This creates the pass manager that runs high-level-synthesis on our circuit.
# The option use_qubit_indices=True indicates that synthesis is run after the layout is set,
# and hence should preserve the specified coupling map.
pm = PassManager(
    HighLevelSynthesis(
        synthesis_config, coupling_map=coupling_map, target=None, use_qubit_indices=True
    )
)

qc_transpiled = pm.run(qc)

  • Ajout de deux nouveaux arguments, matrix_based et max_qubits, au constructeur de la passe de CommutativeInverseCancellation transpiler pass. Lorsque matrix_based est True, la passe utilise des représentations matricielles pour vérifier si deux opérations sont l'inverse l'une de l'autre. Cela rend les vérifications plus puissantes et permet en outre d'annuler des paires d'opérations inverses jusqu'à une phase, tout en mettant à jour la phase globale du circuit en conséquence. Cela permet généralement d'obtenir davantage de réductions au prix d'une augmentation de la durée d'exécution. L'argument max_qubits limite le nombre de qubits dans les vérifications de commutativité et d'inversion basées sur les matrices. Par exemple :

    import numpy as np
from qiskit.circuit import QuantumCircuit
from qiskit.transpiler import PassManager
from qiskit.transpiler.passes import CommutativeInverseCancellation

circuit = QuantumCircuit(1)
circuit.rz(np.pi / 4, 0)
circuit.p(-np.pi / 4, 0)

passmanager = PassManager(CommutativeInverseCancellation(matrix_based=True))
new_circuit = passmanager.run(circuit)

    La passe est capable d'annuler les portes RZ et P , tout en ajustant la phase globale du circuit à 15π8\frac{15 \pi}{8}.

  • Ajout d'une nouvelle fonction, high_level_synthesis_plugin_names()qui peut être utilisée pour obtenir la liste des plugins de synthèse de haut niveau installés pour un nom d'opération donné.

Fonctionnalités de visualisation

  • Les sorties text et mpl pour le QuantumCircuit.draw() et circuit_drawer() affichent désormais des informations détaillées pour les opérations de AnnotatedOperation. Si le site AnnotatedOperation.modifiers contient un ControlModifierl'opération sera affichée de la même manière que les portes contrôlées. Si le InverseModifier ou PowerModifier sont utilisés, ils seront indiqués avec le nom de l'opération de base. Par exemple :

    from qiskit.circuit import (
    AnnotatedOperation,
    ControlModifier,
    PowerModifier,
    InverseModifier,
    QuantumCircuit
)
from qiskit.circuit.library import SGate

annotated_op = AnnotatedOperation(SGate(), [PowerModifier(3.4), ControlModifier(3), InverseModifier()])
qc = QuantumCircuit(4)
qc.append(annotated_op, range(4))
qc.draw("mpl")
    _images/release_notes-1.png

Divers. Fonctions

  • Ajout d'une nouvelle classe de base d'avertissement, QiskitWarning. Qiskit continuera d'utiliser les avertissements intégrés de Python (tels que DeprecationWarning) lorsque ceux-ci sont les plus appropriés, pour les cas plus spécifiques à Qiskit, les avertissements seront des sous-classes de QiskitWarning.

  • Les testeurs de fonctionnalités optionnelles (qiskit.utils.optionals) distingueront désormais une dépendance optionnelle totalement introuvable (situation normale) d'une dépendance qui a été trouvée, mais qui a déclenché des erreurs lors de son importation. Dans ce dernier cas, ils émettront maintenant un OptionalDependencyImportWarning pour vous expliquer ce qui s'est passé, car cela peut indiquer un échec de l'installation ou une version incompatible.

Mise à niveau

  • Qiskit 1.0 nécessite désormais la version 0.14.0 de rustworkx. La version minimale requise a été augmentée pour prendre en charge le nouveau plugin de synthèse token_swapper PermutationGate pour le plugin de synthèse HighLevelSynthesisPlugin.

  • La version minimale de Rust supportée pour construire Qiskit à partir des sources est maintenant 1.70. Cette version a été augmentée par rapport à la version Rust minimale supportée de 1.64 dans les séries de versions de Qiskit 0.45.x et 0.46.0.

  • La dépendance à l'égard de psutil a été supprimée. La bibliothèque psutil n'était auparavant utilisée que pour détecter le nombre de CPU physiques et la mémoire totale du système. Cependant, cette information fournie n'apporte pas une valeur ajoutée suffisante pour justifier les dépendances et les frais généraux supplémentaires, et elle a donc été supprimée. Cela signifie que le nombre par défaut de processus utilisés par parallel_map() et les fonctions qui peuvent être utilisées en interne parallel_map() comme transpile() et PassManager.run() peuvent utiliser plus ou moins de processus parallèles que dans les versions précédentes. Si vous souhaitez ajuster le nombre de processus utilisés, vous pouvez utiliser le nouvel argument num_processes pour ces fonctions, ou la variable d'environnement QISKIT_NUM_PROCS ou le champ num_processes dans un fichier de configuration utilisateur (voir le guide de configuration locale pour plus de détails) si vous avez besoin d'ajuster le nombre de processus que Qiskit utilise potentiellement.

  • Les méthodes scoped_parameters et search_parameters ont été supprimées de la classe ScheduleBlock de la classe. Ces méthodes renvoient Parameter qui sont partiellement liés aux paramètres de l'instance ScheduleBlock mais l'attribution de valeurs à l'aide de ces objets ne fonctionnait pas correctement. Les utilisateurs doivent utiliser ScheduleBlock.parameters à la place et itérer à travers ScheduleBlock.references et les comparer aux attributs Schedule.parameters des sous-références lorsqu'il s'agit de déterminer dans quelle sous-routine un paramètre est utilisé. Voir #11654 pour plus d'informations.

  • Suppression de la logique d'injection de QuantumCircuit et Gate dans le contexte de l'impulsion (comme dans pulse.builder.call()), qui était un comportement hérité et déprécié dans Qiskit 0.46. Les programmes d'impulsions doivent être élaborés dans le contexte d'un programme complet; les circuits et les portes constituent un niveau d'abstraction plus élevé.

    Cela inclut la suppression des fonctions correspondantes :

    • pulse.builder.call_gate
    • pulse.builder.cx
    • pulse.builder.u1
    • pulse.builder.u2
    • pulse.builder.u3
    • pulse.builder.x
    • pulse.builder.active_transpiler_settings
    • pulse.builder.active_circuit_scheduler_settings
    • pulse.builder.transpiler_settings
    • pulse.builder.circuit_scheduler_settings

    Les arguments default_transpiler_settings et default_circuit_scheduler_settings de pulse.builder.build() sont également supprimés.

    from qiskit import transpile, schedule, QuantumCircuit, pulse
from qiskit.providers.fake_provider import Fake7QPulseV1

backend = Fake7QPulseV1()

# Create a schedule from a hardware-based circuit.
qc = QuantumCircuit(2)
qc.cx(0, 1)
qc = transpile(qc, backend)
sched = schedule(qc, backend)

# These pulse schedules can still be called in builder contexts.
with pulse.build(backend) as qc_sched:
  pulse.call(sched)

# Schedules for certain operations can also be directly retrieved
# from BackendV1 instances:
sched = backend.defaults().instruction_schedule_map.get('x', (0,))

# ... and from BackendV2 instances:
sched = backend.target['x'][(0,)].calibration

  • La version minimale requise pour symengine a été portée à >= 0.11.

Notes sur la mise à niveau des circuits

  • Suppression de la méthode Instruction.qasm , qui était obsolète dans Qiskit 0.45.0. Utiliser qiskit.qasm2.dump() avec un QuantumCircuit à la place.

  • Les propriétés Bit.register et Bit.index sont supprimées. Ils ont été supprimés dans Qiskit 0.25 (publié en 2021-04). Les qubits et les bits ne vivent plus que dans le contexte d'une QuantumCircuit. L'alternative aux propriétés est d'utiliser QuantumCircuit.find_bit() pour trouver tous les registres contenant un circuit et l'index du bit dans le circuit.

  • La méthode QuantumCircuit.bind_parameters a été supprimée, suite à sa dépréciation dans Qiskit 0.45. Vous pouvez utiliser QuantumCircuit.assign_parameters() comme un remplacement direct avec toutes ses valeurs par défaut, et il expose également des fonctionnalités supplémentaires par rapport à l'ancienne méthode.

  • L'importation de Int1, Int2, BooleanFunction, classical_function() à partir de qiskit.circuit est désormais désactivée. Au lieu de cela, importez les objets du sous-module qiskit.circuit.classicalfunction qui nécessite le paquetage tweedledum .

  • Les attributs header et extension_lib réservés aux données de QuantumCircuit sont supprimés suite à leur dépréciation dans Qiskit 0.45. Il s'agissait de détails internes de l'exportateur OpenQASM 2 qui ne sont plus utilisés.

  • Suppression du module qiskit.extensions , qui était en attente de dépréciation depuis la version 0.45 et a été complètement déprécié dans la version 0.46. Les opérations suivantes de ce module sont disponibles dans qiskit.circuit.library:

    Les objets suivants ont été supprimés :

    • SingleQubitUnitary (utilisez plutôt library.UnitaryGate),
    • Snapshot (remplacé par les instructions Aer's save),
    • ExtensionError,

    ainsi que les méthodes de circuit suivantes :

    • QuantumCircuit.snapshot,
    • QuantumCircuit.squ,
    • QuantumCircuit.diagonal,
    • QuantumCircuit.hamiltonian,
    • QuantumCircuit.isometry et QuantumCircuit.iso,
    • QuantumCircuit.uc,
    • QuantumCircuit.ucrx,
    • QuantumCircuit.ucry,
    • QuantumCircuit.ucrz.

    Ces opérations peuvent toujours être effectuées en ajoutant l'instruction appropriée à un circuit quantique.

  • Suppression des méthodes QuantumCircuit méthodes. Exemples :

  • Vous ne pouvez plus définir QuantumCircuit.metadata à None, suite à la dépréciation de Qiskit 0.43.0. Son type est dictpour l'effacer, il faut donc lui attribuer la valeur {}.

  • L'attribut .Register.name_format a été supprimé suite à sa dépréciation dans Qiskit 0.40.0. Il n'y a plus de restriction sur les noms de registre, et l'expression régulière était simplement [a-z][a-zA-Z0-9_]*.

Notes de mise à niveau des primitives

Notes de mise à niveau des fournisseurs

  • Modification de la valeur par défaut de deux arguments (add_delay et filter_faulty) dans la fonction convert_to_target() fonction. Cette fonction de conversion ajoute désormais des instructions de retard et supprime les instructions défectueuses par défaut.

  • Les BackendProperties et PulseDefaults utilisés par le FakeOpenPulse2Q ont été mis à jour pour assurer la cohérence interne et ajouter les instructions manquantes. Si vous utilisiez les objets du modèle précédent comme cible de compilation, vous pouvez utiliser le backend avec Qiskit 0.46 et exporter un fichier QuantumCircuit généré avec transpile() et le sérialiser en utilisant qpy.dump pour y accéder dans cette version.

  • Le module qiskit.providers.basicaer , exposé en tant que qiskit.BasicAer, a été supprimé suite à sa dépréciation dans la version 0.46. Sa fonctionnalité a été remplacée par le module qiskit.quantum_info et le nouveau module qiskit.providers.basic_provider module.

    La migration de l'utilisation de qiskit.providers.basicaer (qiskit.BasicAer) vers qiskit.providers.basic_provider peut être effectuée comme suit :

    Migration à partir de :
    Remplacer par
    qiskit.BasicAerLe nouveau fournisseur n'a pas d'instance globale, les importations doivent provenir de qiskit.providers.basic_provider
    qiskit.providers.basicaerbasic_provider
    BasicAerProviderBasicProvider
    BasicAerJobBasicProviderJob
    QasmSimulatorPyBasicSimulator
    UnitarySimulatorPyutiliser Operator
    StatevectorSimulatorPyutiliser Statevector

    Une différence notable est que le nouveau fournisseur n'est plus exposé par le biais d'une instance globale (comme BasicAer), de sorte qu'il ne sera pas possible de faire from qiskit import BasicProvider. Au lieu de cela, la classe du fournisseur doit être importée de son sous-module et instanciée manuellement :

    from qiskit.providers.basic_provider import BasicProvider

provider = BasicProvider()
backend = provider.get_backend("basic_simulator")

    Les exemples suivants montrent les chemins de migration des trois simulateurs dans BasicAer.

    1. Simulateur de vecteur d'état :

      from qiskit import QuantumCircuit
qc = QuantumCircuit(3)
qc.h(0)
qc.h(1)
qc.cx(1,2)

# Former path
from qiskit import BasicAer
backend = BasicAer.get_backend("statevector_simulator")
statevector = backend.run(qc).result().get_statevector()

# New path
from qiskit.quantum_info import Statevector
statevector = Statevector(qc)

    2. Simulateur unitaire :

      from qiskit import QuantumCircuit
qc = QuantumCircuit(3)
qc.h(0)
qc.h(1)
qc.cx(1,2)

# Former path
from qiskit import BasicAer
backend = BasicAer.get_backend("unitary_simulator")
result = backend.run(qc).result()

# New path
from qiskit.quantum_info import Operator
result = Operator(qc).data

    3. Simulateur Qasm :

      from qiskit import QuantumCircuit
qc = QuantumCircuit(3)
qc.h(0)
qc.h(1)
qc.cx(1,2)
qc.measure_all()

# Former path
from qiskit import BasicAer
backend = BasicAer.get_backend("qasm_simulator")
result = backend.run(qc).result()

# New path
from qiskit.providers.basic_provider import BasicProvider
backend = BasicProvider().get_backend("basic_simulator")
result = backend.run(qc).result()
# or, directly
from qiskit.providers.basic_provider import BasicSimulator
backend = BasicSimulator()
result = backend.run(qc).result()

  • Suppression de la classe ConfigurableFakeBackend , obsolète dans Qiskit 0.46.0. Au lieu de cela, on peut utiliser un FakeBackend peut être utilisé.

  • Le module qiskit.providers.fake_provider a été migré vers le paquet qiskit-ibm-runtime Python. Pour cette raison, les éléments suivants de la section qiskit.providers.fake_provider ont été supprimés à la suite de leur dépréciation dans Qiskit 0.46:

    • qiskit.providers.fake_provider.FakeProvider
    • qiskit.providers.fake_provider.FakeProviderForBackendV2
    • qiskit.providers.fake_provider.FakeProviderFactory
    • qiskit.providers.fake_provider.fake_backends.FakeBackendV2
    • tout faux backend contenu dans qiskit.providers.fake_provider.backends (accessible via le fournisseur)
    • qiskit.providers.fake_provider.FakeQasmSimulator
    • qiskit.providers.fake_provider.FakeJob
    • qiskit.providers.fake_provider.FakeQobj

    Pour utiliser le nouveau module "fake provider", vous pouvez lancer pip install qiskit-ibm-runtime et remplacer le chemin d'importation de qiskit (qiskit.providers.fake_provider) par le nouveau chemin d'importation (qiskit_ibm_runtime.fake_provider). Exemple de migration :

    # Legacy path
from qiskit.providers.fake_provider import FakeProvider, FakeSherbrooke
backend1 = FakeProvider().get_backend("fake_ourense")
backend2 = FakeSherbrooke()

# New path
# run "pip install qiskit-ibm-runtime"
from qiskit_ibm_runtime.fake_provider import FakeProvider, FakeSherbrooke
backend1 = FakeProvider().get_backend("fake_ourense")
backend2 = FakeSherbrooke()

    En outre, les faux backends suivants, conçus à des fins de test spéciales, ont été remplacés par la nouvelle classe GenericBackendV2 et sont également supprimés suite à leur dépréciation dans Qiskit 0.46:

    • qiskit.providers.fake_provider.fake_backend_v2.FakeBackendV2
    • `qiskit.providers.fake_provider.fake_backend_v2.FakeBackendV2LegacyQubitProps
    • qiskit.providers.fake_provider.fake_backend_v2.FakeBackend5QV2
    • qiskit.providers.fake_provider.fake_backend_v2.FakeBackendSimple

    Exemple de migration vers la nouvelle GenericBackendV2 classe :

    # Legacy path
from qiskit.providers.fake_provider import FakeBackend5QV2
backend = FakeBackend5QV2()

# New path
from qiskit.providers.fake_provider import GenericBackendV2
backend = GenericBackendV2(num_qubits=5)
# note that this class will generate 5q backend with generic
# properties that serves the same purpose as FakeBackend5QV2
# but will generate different results

Notes de mise à jour Pulse

  • Suppression de la classe dépréciée qiskit.pulse.instructions.Call Aucune autre instruction d'impulsion n'est fournie.

  • Suppression des méthodes obsolètes dans InstructionToQobjConverter et QobjToInstructionConverter. Cela inclut :

    • InstructionToQobjConverter.convert_acquire()
    • InstructionToQobjConverter.convert_bundled_acquires()
    • InstructionToQobjConverter.convert_set_frequency()
    • InstructionToQobjConverter.convert_shift_frequency()
    • InstructionToQobjConverter.convert_set_phase()
    • InstructionToQobjConverter.convert_shift_phase()
    • InstructionToQobjConverter.convert_delay()
    • InstructionToQobjConverter.convert_play()
    • InstructionToQobjConverter.convert_snapshot()
    • QobjToInstructionConverter.convert_acquire()
    • QobjToInstructionConverter.convert_set_phase()
    • QobjToInstructionConverter.convert_shift_phase()
    • QobjToInstructionConverter.convert_set_frequency()
    • QobjToInstructionConverter.convert_shift_frequency()
    • QobjToInstructionConverter.convert_delay()
    • QobjToInstructionConverter.bind_pulse()
    • QobjToInstructionConverter.convert_parametric()
    • QobjToInstructionConverter.convert_snapshot()

    Ces méthodes publiques sont toutes remplacées par des méthodes protégées qui sont implicitement appelées à partir du point d'entrée unique, c'est-à-dire en appelant la classe comme une fonction.

  • La classe qiskit.pulse.library.ParametricPulse et toutes les sous-classes sont supprimées. Ils sont dépréciés depuis Qiskit 0.39 (avec qiskit-terra 0.22 ), publié en 2022-10. Utilisez plutôt SymbolicPulse et consultez sa documentation pour plus de détails.

OpenQASM Notes de mise à jour

  • Les méthodes qasm() des classes QuantumRegister et ClassicalRegister ont été supprimées. Aucun remplacement n'est nécessaire; il s'agissait d'un détail interne d'une ancienne implémentation de l'exportateur OpenQASM 2. Pour exporter un programme vers OpenQASM 2, utilisez qasm2.dump() ou qasm2.dumps().

Notes de mise à niveau QPY

  • La dernière version du format de QPY est maintenant la version 11 et c'est ce qui est émis par défaut lorsque l'on exécute qpy.dump().

  • Le chemin du module qiskit.circuit.qpy_serialization a été supprimé, suite à sa dépréciation dans Qiskit 0.40.0. Pour la sérialisation QPY, utilisez qiskit.qpyqui est le nouvel emplacement.

Notes de mise à jour sur les informations quantiques

  • Suppression des méthodes magiques __getitem__/__setitem__ de Clifford. Ces méthodes sont obsolètes depuis Qiskit 0.44, publié en 2023-07. Au lieu de cela, il faut indexer ou itérer à travers l'attribut Clifford.tableau .

  • Suppression du module qiskit.quantum_info.synthesis , qui est obsolète depuis la version 0.46. Les objets suivants ont été déplacés vers qiskit.synthesis:

    Cette fonction a été supprimée, car elle a déjà été mise au rancart dans la version 0.46 : * cnot_rxx_decompose

    Ces fonctions ont été supprimées, car elles ont déjà été mises au rancart dans une version précédente : * decompose_clifford (utiliser synth_clifford_full() à la place) * decompose_cnotdihedral (utiliser synth_cnotdihedral_full() à la place)

  • Les fonctions process_fidelity(), average_gate_fidelity(), gate_error() et diamond_norm() n'essaieront plus de contraindre des entrées arbitraires à leurs types attendus marqués, suite à la dépréciation dans Qiskit 0.25.0. Passer les entrées des types marqués à chaque argument directement.

Notes de mise à niveau de Synthesis

Notes de mise à niveau du transpilateur

  • La méthode Target.aquire_alignment , obsolète, a été supprimée. Il a été marqué comme obsolète dans Qiskit 0.43 (version 2023-05). La méthode Target.acquire_alignment() doit être utilisée à la place.

  • Suppression de la fonction obsolète qiskit.transpiler.preset_passmanagers.common.get_vf2_call_limit. Utilisez plutôt get_vf2_limits().

  • L'utilisation implicite de approximation_degree!=1.0 par défaut dans la fonction generate_preset_pass_manager() a été désactivée. L'ancienne valeur par défaut pouvait entraîner des approximations excessives et inattendues, en particulier dans les charges de travail impliquant la trotterisation ou des séries d'opérations similaires qui sont proches de l'identité, mais pas du tout égales.

    Cette modification permet d'aligner les valeurs par défaut de la génération du gestionnaire de passe interne sur celles de transpile()ce qui a toujours été l'intention. Voir #8595 pour plus de détails.

  • Suppression de la classe dépréciée Unroller dans qiskit.transpiler.passes.basis. Cette classe a été supprimée dans Qiskit 0.45 et son utilisation peut être remplacée par l'utilisation combinée de BasisTranslator et UnrollCustomDefinitions.

    Il convient de noter que BasisTranslator et UnrollCustomDefinitions prennent des arguments différents de Unroller, car ils nécessitent la transmission d'un objet EquivalenceLibrary .

    Là où l'on pouvait auparavant utiliser Unroller(basis_gates) , on peut désormais utiliser :

    from qiskit.circuit.library.standard_gates.equivalence_library import (
    StandardEquivalenceLibrary as std_eqlib,
)
pm = PassManager([
    UnrollCustomDefinitions(std_eqlib, basis_gates)
    BasisTranslator(std_eqlib, basis_gates),
])
translated = pm.run(circuit)

  • La passe de transpilation NoiseAdaptiveLayout , obsolète, a été supprimée. Il a été marqué comme obsolète dans Qiskit 0.46.0. Ce laissez-passer a été largement remplacé par VF2Layout et VF2PostLayout qui définira une disposition basée sur les caractéristiques de bruit rapportées d'un backend. En même temps que le laissez-passer, le plugin layout_method "noise_adaptive" a été supprimé.

  • La passe de transpilation CrosstalkAdaptiveSchedule , obsolète, a été supprimée. Il a été marqué comme obsolète dans Qiskit 0.46.0. Cette passe n'était plus utilisable car son fonctionnement interne dépendait de la définition de propriétés personnalisées dans la charge utile d'un BackendProperties d'une BackendV1 instance. Comme aucun backend ne définit ces champs, la passe a été supprimée. Si vous dépendez de la passe pour un flux de travail personnalisé, vous pouvez utiliser la version de Qiskit 0.46.x.

  • Suppression du module qiskit.transpiler.synthesis , qui est obsolète depuis la version 0.46. Les objets suivants ont été déplacés :

  • L'alias du mot-clé target lors de l'appel d'instances en tant que fonctions a été supprimé suite à sa suppression dans Qiskit TwoQubitBasisDecomposer en tant que fonctions a été supprimé suite à sa dépréciation dans Qiskit 0.40.0. Vous devez passer l'argument positionnellement comme premier argument, ou utiliser le nouveau nom unitary.

  • La passe de transpilation spécialisée LinearFunctionsSynthesis a été supprimée suite à sa dépréciation dans Qiskit 0.40.0. Depuis sa dépréciation, il s'agit simplement d'une enveloppe très fine autour de HighLevelSynthesisque vous devriez utiliser à la place.

  • Le chemin d'importation qiskit.transpiler.passes.scheduling.calibration_creators est supprimé. Le transpondeur le passe logé, RZXCalibrationBuilder et RZXCalibrationBuilderNoEcho peut être importé directement depuis qiskit.transpiler.passes.

  • Le chemin d'importation qiskit.transpiler.passes.scheduling.rzx_templates est supprimé. Vous devez importer rzx_templates() de qiskit.transpiler.passes directement.

  • Un modèle pour la construction de la ligne de passage a été mis à jour. Le sucre syntaxique illustré ci-dessous pour l'instanciation du contrôleur de flux a été supprimé.

    from qiskit.transpiler import PassManager

pm = PassManager()
pm.append(my_pass, condition=condition_callable, do_while=do_while_callable)

    Au lieu d'utiliser ce modèle d'argument de mot-clé, vous devriez instancier explicitement le contrôleur de flux.

    from qiskit.passmanager import ConditionalController, DoWhileController
from qiskit.transpiler import PassManager

pm = PassManager()
pm.append(
  ConditionalController(
    DoWhileController(my_pass, do_while=do_while_callable),
    condition=condition_callable,
  )
)

    Notez que vous pouvez gérer l'ordre des contrôleurs lorsque vous souhaitez les imbriquer, ce qui n'était pas possible avec les arguments de type mot-clé. Vous pouvez également construire le pipeline avec le constructeur du gestionnaire de passe comme ci-dessous car il n'y a pas de raison d'appeler la méthode append maintenant.

    pm = PassManager(
  ConditionalController(
    DoWhileController(my_pass, do_while=do_while_callable),
    condition=condition_callable,
  )
)

  • La méthode append des contrôleurs de flux intégrés a été supprimée. Cela inclut :

    • ConditionalController.append
    • DoWhileController.append
    • FlowControllerLinear.append

    Le pipeline de tâches d'un contrôleur de flux est gelé et doit être transmis lors de la création de l'instance du contrôleur.

  • Suppression des méthodes passess de PassManager et StagedPassManager qui renvoyaient une représentation des passes incluses sous la forme d'une liste de dictionnaires. Toutefois, ce format ne permet pas de représenter efficacement des circuits de passage plus complexes, qui peuvent inclure des branchements conditionnels et des conditions imbriquées. Au lieu d'utiliser cette représentation, veuillez utiliser le modèle suivant

    pm = PassManager(...)
pm.to_flow_controller().tasks

    Cette fonction renvoie directement une base linéarisée d'instances de tâches au format tuple.

  • L'argument max_iteration a été supprimé de PassManager.append() et PassManager.replace().

  • Les classes héritées suivantes ont été supprimées des modules de gestion des passes et de transposition à la suite de leur dépréciation dans Qiskit 0.46:

    • qiskit.passmanager.flow_controllers.FlowController
    • qiskit.transpiler.fencedobjs.FencedObject
    • qiskit.transpiler.fencedobjs.FencedPropertySet
    • qiskit.transpiler.fencedobjs.FencedDAGCircuit
    • qiskit.transpiler.runningpassmanager.RunningPassManager

Notes de mise à niveau de la visualisation

  • Le style par défaut pour la visualisation des circuits utilisant Matplotlib a été modifié en "iqp", correspondant à la plate-forme Quantum IBM.

  • Le module obsolète qiskit.visualization.qcstyle a été supprimé. Ce module a été marqué comme obsolète depuis Qiskit 0.39.0. Au lieu de cela, vous devez utiliser le site qiskit.visualization.circuit.qcstyle.

  • La prise en charge obsolète du passage d'un QuasiDistribution, ProbDistributionou un dictionnaire de distribution à l'argument data de la visualisation plot_histogram() a été supprimé. Cette fonctionnalité a été marquée comme obsolète dans la version de Qiskit 0.39.0 (2022-10). Au lieu de cela, si vous souhaitez tracer un histogramme à partir de a QuasiDistribution, ProbDistributionou d'un dictionnaire de distribution, vous devriez plutôt utiliser la fonction plot_distribution() à la place.

  • La clé link_interval_dt de QiskitTimelineStyle a été supprimée. Vous devez utiliser le nouveau nom link_interval_percent.

Divers. Mise à niveau

  • L'objet qiskit.Aer a été supprimé suite à sa dépréciation dans Qiskit 0.46. Vous pouvez utiliser qiskit_aer.Aer, qui est un remplacement direct.

  • L'importation à partir de qiskit.providers.aer ne fonctionnera plus, suite à sa dépréciation dans Qiskit 0.46. Vous devriez plutôt importer de qiskit_aer, qui est un remplacement direct.

  • Les travaux Pulse ne sont plus pris en charge dans les faux backends, suite à la dépréciation et à la suppression de la fonctionnalité de simulation sous-jacente dans Aer. Pour la simulation au niveau des impulsions, en dehors du contexte des objets de circuit, il convient d'envisager l'utilisation d'une bibliothèque spécialisée telle que Qiskit Dynamics.

  • La fonction execute() de Qiskit est supprimée. Cette fonction sert d'enveloppe de haut niveau pour la transposition d'un circuit à l'aide de certaines options de transposition et son exécution sur un backend à l'aide de certaines options d'exécution. Pour faire la même chose, vous pouvez utiliser explicitement la fonction transpile() (avec les options de transposition appropriées) suivie de backend.run() (avec les options d'exécution appropriées).

    Par exemple, au lieu de courir :

    from qiskit import execute
job = execute(circuit, backend)

    vous pouvez courir :

    from qiskit import transpile
new_circuit = transpile(circuit, backend)
job = backend.run(new_circuit)

    Alternativement, la primitive Sampler est sémantiquement équivalente à la fonction dépréciée execute() . La classe BackendSampler est une enveloppe générique pour les backends qui ne supportent pas les primitives :

    from qiskit.primitives import BackendSampler
sampler = BackendSampler(backend)
job = sampler.run(circuit)

  • L'objet qiskit.IBMQ , obsolète, a été supprimé. Cet objet alias a été marqué comme obsolète dans la version de Qiskit 0.40.0. Cet objet alias redirigeait paresseusement l'accès aux attributs vers qiskit.providers.ibmq.IBMQ. Comme le paquet qiskit-ibmq-provider a été retiré et remplacé par le paquet qiskit-ibm-provider qui a son propre espace de noms, le maintien de cet alias n'est plus pertinent. Si vous utilisiez l'alias qiskit.IBMQ , vous devez migrer votre utilisation vers le paquet qiskit-ibm-provider , voir le guide de migration pour plus de détails.

  • Suppression du module obsolète qiskit.tools.jupyter qui incluait auparavant des magiques Jupyter et des widgets pour visualiser interactivement certaines données de Qiskit. Ce module a été supprimé dans Qiskit 0.46.0. La plupart de ces fonctionnalités étaient directement liées à l'ancien paquetage qiskit-ibmq-provider et n'étaient plus valables; le module a donc été supprimé. Une fonctionnalité similaire est disponible dans le module qiskit_ibm_provider.jupyter du paquet qiskit-ibm-provider.

  • Suppression du module obsolète qiskit.tools.monitor qui incluait auparavant des outils pour suivre les instances de travail, principalement à partir de l'ancien paquetage JobV1 principalement à partir de l'ancien paquetage qiskit-ibm-provider . Ce module a été marqué comme obsolète dans Qiskit 0.46.0. Il est supprimé parce qu'il était directement lié à l'ancien paquet qiskit-ibm-provider .

  • Suppression du chemin d'importation obsolète qiskit.test.mock qui était utilisé pour rediriger les importations pour les backends fictifs vers leur nouvel emplacement dans le fichier qiskit.providers.fake_provider. Ce module a été marqué comme obsolète dans Qiskit 0.37.0. Si vous utilisiez ce module, vous devriez mettre à jour vos importations de qiskit.test.mock vers qiskit.providers.fake_provider à la place.

  • Le module qiskit.test n'est plus un module public. Il n'a jamais été destiné à être public, ni à être utilisé en dehors de la suite de tests de Qiskit. Toutes les fonctionnalités étaient spécifiques à Qiskit et aucune alternative n'est fournie; si vous aviez besoin de fonctionnalités similaires, vous devriez les inclure dans vos propres harnais de test.

  • Le module qiskit.tools.visualization , obsolète, a été supprimé. Ce module a été supprimé dans la version de Qiskit 0.46.0. Ce module était une redirection héritée de l'emplacement original du module de visualisation de Qiskit et a été déplacé vers qiskit.visualization dans Qiskit 0.8.0. Si vous utilisez toujours ce chemin, vous pouvez simplement mettre à jour vos importations de qiskit.tools.visualization à qiskit.visualization.

  • Le module qiskit.tools.events et l'utilitaire qiskit.tools.progressbar qu'il exposait ont été supprimés. Il a été supprimé dans la version de Qiskit 0.46.0. Les fonctionnalités de ce module n'ont pas été largement utilisées et ont été mieux couvertes par des logiciels spécialisés tels que tqdm.

  • Le module qiskit.tools a été retiré. Ce module a été supprimé dans Qiskit 0.46.0. Tout le contenu de ce module a été supprimé, à l'exception de la fonction qiskit.tools.parallel_map qui peut désormais être utilisée à partir de qiskit.utils.parallel_map() à la place.

Primitives obsolètes

  • Les méthodes PrimitiveJob.submit() et PrimitiveJob.wait_for_final_state() ont été supprimées suite à leur dépréciation dans Qiskit 0.46. Ces méthodes n'étaient pas censées être publiques, mais étaient le résultat d'une structure d'héritage incorrecte.

Corrections des erreurs

  • Correction du retour de programmes de mesure incorrects lorsque seul un sous-ensemble de qubits était demandé. Auparavant, un programme de mesures pour tous les qubits était renvoyé.

  • Correction d'un problème dans le tiroir du circuit text lors de l'affichage d'opérations qui n'étaient pas de type circuit.instruction.Instruction classe. Ces opérations entraîneraient la défaillance du tiroir. Voici quelques exemples Clifford et AnnotatedOperation.

  • Correction d'un problème avec la passe SetLayout où une entrée de liste d'entiers invalide qui contenait des entrées dupliquées entraînait la génération d'un Layout était généré et les passes de transposition suivantes échouaient avec une erreur cryptique. Ce problème est désormais résolu lorsque SetLayout.run() est appelé, une erreur InvalidLayoutError une erreur sera soulevée indiquant qu'il y a des entrées en double dans la liste des entiers.

  • QPY (en utilisant qpy.dump() et qpy.load()) sérialisera et désérialisera désormais correctement les circuits quantiques avec des opérations annotées (AnnotatedOperation).

  • Appel copy() ou copy_empty_like() sur un site BlueprintCircuit propage désormais correctement la mention global_phase à la copie. Auparavant, la phase globale était toujours nulle après la copie.

  • QuantumCircuit.compose() lèvera désormais correctement un CircuitError lorsqu'il y a des doublons dans les arguments qubits ou clbits .

  • QPY (en utilisant qpy.dump() et qpy.load()) sérialisera et désérialisera désormais correctement les circuits quantiques avec des opérateurs de Clifford (Clifford).

  • Correction d'un problème dans le tiroir du circuit mpl où le texte s'imprimait au-delà de la fin de la case pour un SwitchCaseOp si la case par défaut était vide.

  • La diffusion de l'argument qubit de QuantumCircuit.delay() produit maintenant correctement des instructions individuelles Delay pour chaque qubit, comme prévu. Auparavant, lorsqu'on lui donnait certains itérables (tels que sets), il produisait silencieusement un circuit invalide qui pouvait échouer à des endroits inhabituels.

  • Correction d'un problème lors de l'utilisation transpile() ou lors de l'exécution d'un gestionnaire de passe prédéfini (tel que généré par generate_preset_pass_manager()) en ciblant un backend qui a une connectivité disjointe ajoutant des barrières supplémentaires à la sortie QuantumCircuit. Dans certains cas, plusieurs directives Barrier seraient incluses dans le circuit de sortie juste avant les mesures finales dans le circuit. Il s'agissait d'un état interne généré par le traitement interne de la connectivité disjointe qui était incorrectement ajoutée dans le circuit de sortie. Corrigé #11649

  • Correction d'une erreur lorsqu'un utilisateur tente de charger les données d'étalonnage d'une porte à partir d'un fichier de données Target dans une situation particulière. Cela se produit lorsque le backend ne communique que des données d'étalonnage partielles, par exemple en faisant référence à une impulsion de forme d'onde dans une définition de commande mais sans inclure cette impulsion de forme d'onde dans la bibliothèque d'impulsions. Dans cette situation, l'objet d'impulsion Qiskit n'a pas pu être construit, ce qui a entraîné l'échec de la construction de l'horaire d'impulsion pour l'étalonnage. Désormais, lorsque les données d'étalonnage sont incomplètes, le Target traite cette situation comme si aucun étalonnage n'était signalé et ne soulève pas d'exception.

  • La méthode Operator.power() fonctionne désormais avec des exposants en virgule flottante, ce qui correspond à la description documentée.

  • Correction d'un problème avec la passe OptimizeSwapBeforeMeasure qui optimisait de manière incorrecte les circuits impliquant des instructions d'échange et de mesure. Par exemple :

    from qiskit import QuantumCircuit
from qiskit.transpiler.passes import OptimizeSwapBeforeMeasure
pass_ = OptimizeSwapBeforeMeasure()
qc = QuantumCircuit(2, 1)
qc.swap(0, 1)
qc.measure(0, 0)
qc.measure(0, 0)
print(qc.draw())
print(pass_(qc).draw())

    s'imprimerait auparavant :

            ┌─┐┌─┐
q_0: ─X─┤M├┤M├
      │ └╥┘└╥┘
q_1: ─X──╫──╫─
         ║  ║
c: 1/════╩══╩═
         0  0
     ┌─┐
q_0: ┤M├───
     └╥┘┌─┐
q_1: ─╫─┤M├
      ║ └╥┘
c: 1/═╩══╩═
      0  0

    et maintenant le deuxième circuit est correctement optimisé pour :

    q_0: ──────
     ┌─┐┌─┐
q_1: ┤M├┤M├
     └╥┘└╥┘
c: 1/═╩══╩═
      0  0

  • Correction d'un problème avec la sérialisation QPY lorsqu'un fichier QuantumCircuit contenait plusieurs instances d'instructions personnalisées ayant le même attribut name attribut. Dans les versions du format QPY antérieures à la version 11, la charge utile QPY ne faisait pas de différence entre ces instances et ne sérialisait que les propriétés de la première instance d'un circuit. Cela pourrait potentiellement entraîner une désérialisation incorrecte si les autres propriétés de l'instruction personnalisée étaient différentes mais que les noms étaient les mêmes. Ce problème a été corrigé dans la version 11 de QPY afin que chaque instance d'une instruction personnalisée soit sérialisée individuellement et qu'il n'y ait plus de conflit potentiel avec des noms qui se chevauchent. Corrige #8941.

  • Correction d'un problème avec la fonction qpy.dump() où, lorsque l'indicateur use_symengine était défini sur un objet véridique évalué à True mais qui n'était pas en fait le booléen True, la charge utile QPY générée était corrompue. Par exemple, si vous attribuez à use_symengine la valeur HAS_SYMENGINEcet objet est évalué à True lorsqu'il est converti en bool, mais n'est pas réellement True.

  • Correction d'un bug dans la représentation des StabilizerState dans la représentation des chaînes de caractères.

  • Un bogue où convert_to_target() et BackendV2Converter provoquaient une erreur inattendue a été résolu. Le bogue se produisait lorsque le backend à convertir incluait des calibrations pour une porte qui n'avait pas de définition dans les propriétés du backend. Cette porte est désormais diffusée à tous les qubits en tant qu'instruction idéale sans erreur, même lorsque des calibrations pour un ensemble fini de qubits sont rapportées.

  • Correction d'un problème avec la fonction circuit_drawer() fonction et QuantumCircuit.draw() lors du chargement d'un style matplotlib via le fichier de configuration utilisateur.

  • InstructionDurations.from_backend() renvoie désormais une instance de n'importe quelle sous-classe de InstructionDurations au lieu de la classe de base.

  • La passe UnitarySynthesis génère désormais une erreur à l'initialisation lorsqu'un greffon de synthèse inexistant est spécifié, au lieu d'attendre l'exécution pour le signaler. Correction #11355.

  • Le site OpenQASM 3 exportateurs qasm3.dump() et dumps() produiront désormais correctement des fichiers revendiquant la version 3.0 plutôt que la version non qualifiée 3, puisque le projet OpenQASM 3 a maintenant normalisé la gestion des versions.

  • La forme paramétrique de XXPlusYYGate et XXMinusYYGate renvoyée par get_standard_gate_name_mapping() inclut désormais correctement le paramètre β\beta ainsi que la rotation initiale θ\theta.

  • La passe TemplateOptimization renvoie désormais les expressions paramétriques en utilisant le format d'expression symbolique natif de ParameterExpressionau lieu de toujours utiliser Sympy. Pour la plupart des plates-formes prises en charge, cela signifie que les expressions seront des objets Symengine. Auparavant, la passe pouvait renvoyer des objets non concordants, ce qui pouvait entraîner des échecs ultérieurs dans le code de traitement des paramètres.

Cette page a-t-elle été utile ?
Signaler un bogue, une coquille ou proposer du contenu sur GitHub.