Qiskit SDK 2.0 notes de mise à jour

---

2.0.3

Prélude

Qiskit v2.0.3 est une version de correction de bogues pour la série de versions mineures v2.0.

Corrections des erreurs

• ApplyLayout traitera désormais correctement le cas de l'application d'un qubit zéro Layout. Auparavant, il affirmait qu'aucune disposition n'avait été définie, même si le champ "layout" du fichier PropertySet était égal à Layout().

• Correction d'un problème dans la passe ElidePermutations où la permutation de sortie n'était pas mise à jour correctement en présence d'opérations PermutationGate opérations. Il en résulterait un circuit de sortie incorrect et une propriété virtual_permutation_layout incorrecte sur le site property_set . Lorsqu'il est exécuté dans le cadre d'un PassManager il en résulterait également un TranspileLayout dans le circuit de sortie QuantumCircuit.layout dans le circuit de sortie.

• Correction d'un bug dans la fonction HighLevelSynthesis lors du déroulement d'objets imbriqués/personnalisés Instruction imbriqués. Si le QuantumCircuit renvoyée par Instruction.definition d'un objet personnalisé contenait des objets Clbit ces bits classiques utiliseraient à tort l'index interne de l'objet personnalisé Instruction.definition QuantumCircuit au lieu de les faire correspondre à l'index correspondant dans l'objet externe QuantumCircuit.

• Correction d'un bogue dans les PauliEvolutionSynthesisDefault et PauliEvolutionSynthesisRustiq qui modifiait l'attribut.synthesis du circuit original lors du réglage de preserve_order=False. Le comportement des plugins a été rétabli et le circuit d'origine est désormais préservé tout au long du pipeline de transpilation.

• Correction d'un problème de compatibilité avec la version minimale supportée de rustworkx, 0.15. Pour certaines entrées, les boutons VF2Layout et VF2PostLayout utilisaient auparavant une méthode rustworkx qui avait été ajoutée dans rustworkx 0.16.0 et qui provoquait une erreur lors de l'utilisation d'une version plus ancienne de rustworkx qui est listée comme étant supportée.

• SabreLayout et SabreSwap ne paniquera plus lorsqu'il appliquera le résultat du routage à un circuit qui utilise expr.Var ou Stretch dans une portée de flux de contrôle imbriquée.

• qiskit.circuit.library.quantum_volume() a été mis à jour pour gérer un numpy.random.Generator comme entrée de son argument seed . Auparavant, un tel argument relatif au générateur entraînait l'envoi de TypeError.

---

2.0.2

Prélude

Qiskit v2.0.2 est une version de correction de bogues pour la série de versions mineures v2.0.

Corrections des erreurs

• Fixe l'attribut name de la classe OrGate pour qu'il soit désormais défini sur "or" afin d'identifier cette porte de manière unique. Il était auparavant incorrectement réglé sur "and" , ce qui ne permettait pas de le distinguer de AndGate ou d'avoir des plugins de synthèse pour synthétiser un OrGate.

• Correction d'un problème dans la passe de ConsolidateBlocks où la consolidation de certains blocs échouait si la porte KAK sélectionnée (directement ou par l'intermédiaire de la cible) était supercontrôlée et non CXGate. Corrigé #14413

• Correction d'un bug dans les fonctions du circuit evolved_operator_ansatz(), qaoa_ansatz() et hamiltonian_variational_ansatz()où les paramètres avaient une composante complexe nulle. Cela ne pose normalement pas de problème, sauf si le paramètre est traduit en SymPy à l'aide de la méthode ParameterExpression.sympify() ce qui provoquerait une erreur.

---

2.0.1

Prélude

Qiskit v2.0.1 est une version mineure de correction de bogues pour la série de versions v2.0.x.

Corrections des erreurs

• Correction d'un bug de visualisation dans le tiroir du circuit de texte où les opérations de flux de contrôle post-transpilation pouvaient avoir leur "crochet" de fermeture rendu verticalement dans le désordre. Voir #14271 pour plus de détails.

• Correction d'un bug dans la passe de UnitarySynthesis qui ignorait le paramètre synth_gates et ne synthétisait que les portes unitary . La passe synthétise maintenant correctement toutes les portes spécifiées dans le paramètre synth_gates . Correction #14343.

• Ajout de la prise en charge manquante de repr pour Duration.

• Ajout d'un support manquant pour le décapage Python de Duration. Cela empêchait la transpilation parallèle de circuits avec des instructions utilisant des expressions de durée delay() qui utilisent des expressions de durée.

• Correction d'un problème dans la passe de HighLevelSynthesis qui l'amenait à se terminer prématurément sur certains circuits avec des opérations de flux de contrôle. Corrigé #14338

• Fixer la construction de circuits en temps polynomial quantique instantané (IQP) en IQP et par iqp(). L'implémentation précédente utilisait incorrectement les puissances de la porte $\sqrt{T}$ au lieu des puissances de la porte $T$.

• SabreLayout propage désormais correctement les éléments suivants d'un circuit name et metadata d'un circuit lorsqu'il est exécuté en tant que passe conjointe de mise en page et de routage.

• Correction d'un problème dans le plugin de synthèse unitaire SolovayKitaevSynthesis où l'exécution répétée du plugin avec différentes portes de base réutilisait incorrectement les portes de base de la première exécution seulement. Ce problème était dû au fait que les portes de base étaient ignorées lors de la mise en cache des approximations de base.

• Correction d'un problème dans la passe SolovayKitaev où la passe pouvait se bloquer en raison d'une rotation de 180 degrés dans la récursion interne, qui n'était pas gérée correctement.

• Correction d'un problème dans la passe de SolovayKitaev où l'approximation générée pouvait avoir une phase qui différait de $\pi$ de la valeur correcte. Cela est dû à la représentation interne $SO(3)$, qui nécessite une manipulation supplémentaire pour obtenir le signe correct de la matrice de la porte du qubit. Corrigé #9552

• Les circuits contenant des retards avec des étirements (voir QuantumCircuit.add_stretch()) peuvent maintenant être compilés avec succès en utilisant les gestionnaires de passage prédéfinis (transpile() et generate_preset_pass_manager()) lorsqu'ils visent un backend qui a des contraintes d'alignement, par exemple IBM Quantum Eagle devices like ibm_sherbrooke.

• L'heuristique de l'erreur de repli dans VF2Layout et VF2PostLayoututilisée lorsqu'il n'y avait pas de taux d'erreur signalés, pouvait précédemment attribuer des erreurs supérieures à un et avoir des effets imprévisibles sur les scores de présentation obtenus.

---

2.0.0

Prélude

Nous sommes heureux de publier Qiskit v2.0.0, avec de nouvelles fonctionnalités qui améliorent ses performances et ses capacités. Les caractéristiques principales de Qiskit v2.0.0 sont les suivantes :

• L'introduction d'une API C pour construire des objets et interagir avec eux SparseObservable et d'interagir avec eux. Cette première interface en langage compilé représente une étape importante dans l'évolution de Qiskit et son champ d'application s'étendra tout au long de la série de versions v2.x. L'itération initiale de l'API C est une fonctionnalité expérimentale, et il est possible que des changements radicaux soient apportés à l'API dans les versions mineures, conformément à notre stratégie de version.
• L'ajout d'un nouvel BoxOp control-flow op qui correspond au concept de boîte de OpenQASM 3 et permet de regrouper des séries d'instructions en vue d'un traitement ultérieur et d'une programmation personnalisée. Cet opérateur est utile pour des applications telles que le tournoiement, l'apprentissage du bruit et l'ordonnancement basé sur l'étirement, entre autres.
• La possibilité de créer des durées stretch pour les instructions, ce qui permet d'exprimer les relations entre les instructions sensibles au temps Delay qui permettent d'exprimer les relations entre les instructions sensibles au temps. Le nouveau type Stretch étend le système d'expression classique existant, ce qui permet de saisir l'intention de conception au moment de la construction du circuit et de la résoudre au moment de la compilation. Voir la documentation de OpenQASM pour plus de détails.
• Synthèse améliorée lorsqu'un Target contient des portes de base fractionnaires à deux qubits avec prise en charge d'angles arbitraires tels que RZXGate ou RZZGatece qui réduit considérablement le nombre de portes dans les circuits synthétisés.
• Amélioration des performances d'exécution, en particulier lors de l'étape de construction du circuit, où le benchmarking benchpress montre une accélération de 2x par rapport à Qiskit v1.3. Cette amélioration est obtenue grâce à une combinaison de contributions, notamment l'exploitation de représentations natives supplémentaires de la porte Rust, telles que UnitaryGateet la suppression d'éléments de modèles de données hérités.

Conformément à notre politique de versionnement sémantique, documentée à l'époque de la version v1.0.0, cette version majeure comprend également des modifications de l'API qui ne sont pas rétrocompatibles avec la série de versions v1.x. En particulier, plusieurs composants obsolètes du modèle de données Qiskit ont été supprimés, tels que la méthode .c_if() , le module qobj , BackendV1 et qiskit.pulse, ainsi que les implémentations de référence primitives obsolètes V1. Vous pouvez vous référer aux notes de mise à jour pour plus de détails sur toutes ces suppressions et modifications de l'API. Les API supprimées sont toujours prises en charge dans la version de Qiskit v1.4.x qui recevra des corrections de bogues pendant encore six mois et des mises à jour de sécurité pendant un an.

Nouvelles fonctions

• Le support de la plateforme Linux aarch64 a été promu au niveau 1 comme indiqué dans le document :

  /guides/install-qiskit#operating-system-support

  de son niveau de soutien précédent, le niveau 2, dans la série de publications v1.x.

• Introduction d'une nouvelle API en C pour construire et interagir avec des observables éparses. Bien que la surface de l'API dans cette version soit relativement petite - couvrant seulement la classe SparseObservable elle représente une étape importante dans l'évolution de Qiskit, car c'est la première fois que le SDK expose une interface publique en C et elle jette les bases de futures extensions de l'interface C de Qiskit. Comme il s'agit de la première interface publique en C, il s'agit d'une fonctionnalité expérimentale et, si nécessaire, l'API peut être modifiée dans une version mineure.

  Une syntaxe détaillée et des informations supplémentaires sont disponibles dans la documentation de l'API C. Un exemple minimal pour construire l'observable de 100 qubits 2 X0 Y1 Z2 est le suivant :

  #include <complex.h>
  #include <qiskit.h>
  #include <stdint.h>
  #include <stdio.h>
  
  int main(int argc, char *argv[]) {
      // build a 100-qubit empty observable
      uint32_t num_qubits = 100;
      QkObs *obs = qk_obs_zero(num_qubits);
  
      // add the term 2 * (X0 Y1 Z2) to the observable
      complex double coeff = 2;
      QkBitTerm bit_terms[3] = {QkBitTerm_X, QkBitTerm_Y, QkBitTerm_Z};
      uint32_t indices[3] = {0, 1, 2};
      QkObsTerm term = {coeff, 3, bit_terms, indices, num_qubits};
      qk_obs_add_term(obs, &term);
  
      // print some properties
      printf("num_qubits: %u\n", qk_obs_num_qubits(obs));
      printf("num_terms: %lu\n", qk_obs_num_terms(obs));
  
      // free the memory allocated for the observable
      qk_obs_free(obs);
  
      return 0;
  }

Caractéristiques des circuits

• Ajout d'une nouvelle fonction de commodité get_control_flow_name_mapping() qui renvoie une correspondance entre les noms des opérations du flux de contrôle Qiskit et les classes correspondantes.

  Exemple d'utilisation :

  from qiskit.circuit import get_control_flow_name_mapping
  
  ctrl_flow_name_map = get_control_flow_name_mapping()
  if_else_object = ctrl_flow_name_map["if_else"]
  
  print(if_else_object)

  <class 'qiskit.circuit.controlflow.if_else.IfElseOp'>

• Ajout d'une nouvelle méthode de circuit, QuantumCircuit.estimate_duration()pour estimer la durée d'un circuit programmé après transpilation. La durée du circuit est estimée en trouvant le chemin le plus long sur un circuit programmé sur la base des durées fournies par un circuit donné Target. Cette méthode ne fonctionne que pour les circuits simples qui ne contiennent pas de flux de contrôle ou d'autres opérations classiques en amont.

  Utilisez cette méthode au lieu de l'attribut QuantumCircuit.duration si vous avez besoin d'une estimation de la durée totale du circuit.

  Exemple d'utilisation :

  from qiskit import QuantumCircuit, transpile
  from qiskit.providers.fake_provider import GenericBackendV2
  
  backend = GenericBackendV2(num_qubits=3, seed=42)
  
  circ = QuantumCircuit(3)
  circ.cx(0, 1)
  circ.measure_all()
  circ.delay(1e15, 2)
  
  circuit_dt = transpile(circ, backend, scheduling_method="asap")
  duration = circuit_dt.estimate_duration(backend.target, unit="s")
  print("Estimated duration: ", duration)

• Ajout de deux nouvelles classes : BitFlipOracleGate et PhaseOracleGate. BitFlipOracleGate a été introduit comme alternative à la synthèse directe de BooleanExpression, qui a été supprimée dans Qiskit v2.0. PhaseOracleGate a été ajouté comme alternative à PhaseOraclecar cette dernière sera dépréciée au fil des versions de v2.x. Les deux classes partagent l'interface de PhaseOracleà l'exception de la méthode evaluate_bitstring , qui n'existe plus.

  BitFlipOracleGate synthétise un oracle à retournement de bit au lieu d'un oracle à retournement de phase, ce qui signifie qu'il agit sur un qubit supplémentaire et peut être considéré comme appliquant une opération X contrôlée, où le contrôle est déterminé par la valeur de l'expression codée par l'oracle.

  from qiskit import QuantumCircuit
  from qiskit.circuit.library.bit_flip_oracle import BitFlipOracleGate
  qc = QuantumCircuit(5)
  bool_expr = "(x0 & x1 | ~x2) & x4"
  oracle = BitFlipOracleGate(bool_expr)
  qc.compose(oracle, inplace=True)
  qc.draw('mpl')
  qc.decompose().draw('mpl')

  
  from qiskit import QuantumCircuit
  from qiskit.circuit.library.phase_oracle import PhaseOracleGate
  qc = QuantumCircuit(5)
  bool_expr = "(x0 & x1 | ~x2) & x4"
  oracle = PhaseOracleGate(bool_expr)
  qc.compose(oracle, inplace=True)
  qc.draw('mpl')
  qc.decompose().draw('mpl')

  

• Un nouveau flux de contrôle op, BoxOpla méthode et le gestionnaire de contexte qui lui sont associés sont désormais disponibles QuantumCircuit.box() et son gestionnaire de contexte sont maintenant disponibles à partir de qiskit.circuit.

  La façon normale de construire une boîte est d'utiliser le QuantumCircuit.box() gestionnaire de contexte :

  from qiskit.circuit import QuantumCircuit
  
  qc = QuantumCircuit(5)
  
  with qc.box():
    # This box "uses" qubits 0 and 1.
    qc.x(0)
    qc.z(1)
  
  # Boxes can be assigned a duration.
  with qc.box(duration=100, unit="ms"):
    # This box "uses" qubits 2, 3 and 4.
    # Qubit 4 undergoes no operations.
    qc.cx(2, 3)
    qc.noop(4)

  La "boîte" Qiskit correspond presque directement au concept de boîte de OpenQASM 3.

  Tous les qubits "utilisés" par la boîte sont synchronisés au début et à la fin de la boîte. En d'autres termes, la boîte a la même "durée" pour chaque qubit qu'elle utilise, et les points de départ sont synchronisés. Les autres opérations ayant la même portée que l'opération BoxOp elle-même considèrent la boîte comme atomique; il est possible de faire passer une opération devant une boîte entière si l'opération commute avec l'action de la boîte entière, mais il n'est généralement pas possible de déplacer une opération à l'intérieur ou à l'extérieur d'une boîte.

  Les principales utilisations d'une boîte sont le regroupement d'une série d'instructions en vue d'un traitement ultérieur (comme le regroupement d'une couche partielle de portes à deux qubits) et l'ordonnancement d'un bloc composé à une portée tout en utilisant un ordonnancement relatif au sein du bloc (comme le découplage dynamique de plusieurs qubits au sein d'un groupe). Le compilateur de Qiskit ne dispose pas encore de passes intégrées permettant de grouper les instructions ou d'ordonnancer les instructions avec une fonction BoxOp.

  Le transpileur prend en charge le routage et la mise en page en présence de boîtes, et optimisera à l'intérieur de la boîte (jusqu'au paramètre optimization_level ), mais n'effectue pas encore d'optimisations autour de la structure atomique des boîtes. La boîte de support des tiroirs de circuits basés sur le texte et Matplotlib. L'exportation vers QPY et vers OpenQASM 3 est prise en charge, bien que OpenQASM 3 n'ait actuellement aucun moyen de désigner les qubits inactifs à l'intérieur d'une boîte (il est prévu qu'un changement de spécification ajoute cela dans un avenir proche : voir la proposition de fonctionnalité correspondante ).

• Ajout d'un nouvel argument approximation_degree à CommutationChecker.commute() et CommutationChecker.commute_nodes(). Cet argument vous permet de définir le seuil d'approximation à partir duquel les portes sont évaluées comme faisant la navette. Voir la docstring de CommutationChecker pour plus d'informations.

• Ajout d'une nouvelle méthode de circuit, QuantumCircuit.noop()qui permet aux qubits d'être explicitement marqués comme étant utilisés dans le cadre d'un constructeur de flux de contrôle sans leur ajouter d'opération correspondante.

• Le module classique d'expressions en temps réel qiskit.circuit.classical peut désormais représenter des expressions constantes. La classe Expr possède désormais un attribut booléen const qui indique la constance de l'expression. Cela nous permet d'imposer que les expressions dans certains contextes doivent pouvoir être évaluées au moment de la compilation.

  Toutes les expressions Var sont considérées comme non-const, tandis que toutes les expressions Value sont constantes.

  Une expression composée uniquement d'autres expressions const est également const :

  from qiskit.circuit.classical import expr
  
  assert expr.bit_and(5, 6).const

  Une expression qui contient une expression non-const est non-const :

  from qiskit.circuit.classical import expr, types
  
  assert not expr.bit_and(5, expr.Var.new("a", types.Uint(5)).const

• Le module classique d'expressions en temps réel qiskit.circuit.classical peut maintenant représenter des durées en utilisant le nouveau type Duration.

  Le module qiskit.circuit dispose également d'une nouvelle classe Duration qui peut être utilisée comme valeur littérale dans les expressions classiques.

  La fonction lift() peut être utilisée pour créer une expression de valeur à partir d'une Duration d'une instance :

  from qiskit.circuit import Duration
  from qiskit.circuit.classical import expr
  
  expr.lift(Duration.dt(1000))
  # Value(Duration.dt(1000), Duration())

• Le module classique d'expressions en temps réel qiskit.circuit.classical peut maintenant représenter IEEE-754 des valeurs en virgule flottante à double précision en utilisant le nouveau type Float.

  La fonction lift() peut être utilisée pour créer une expression de valeur à partir d'un flotteur Python :

  from qiskit.circuit.classical import expr
  
  expr.lift(5.0)
  # >>> Value(5.0, Float())

  Ce type est principalement destiné à être utilisé dans les expressions liées au temps (duration et stretch). Elle n'est pas compatible avec les opérations logiques ou par bit, bien qu'elle puisse être utilisée avec ces dernières si elles sont d'abord explicitement transformées en quelque chose d'autre.

• Réduction du nombre de portes à deux qubits lors de la décomposition de portes unitaires à un qubit multicontrôlées. Par exemple :

  • Pour le multi-contrôle YGate sur 10 qubits, le CXGate a été réduit de 56%.
  • Pour le multi-contrôle HGate sur 10 qubits, le CXGate a été réduit de 56%.
  • Pour les systèmes multicontrôlés SXGate et SXdgGate sur 10 qubits, le CXGate a été réduit de 80%.
  • Pour le multi-contrôle UGate sur 10 qubits, le CXGate a été réduit de 31%.

• Le module classique d'expressions en temps réel qiskit.circuit.classical peut maintenant représenter des opérations arithmétiques add(), sub(), mul(), et div() sur des opérandes numériques et temporels.

  Par exemple :

  from qiskit.circuit import QuantumCircuit, ClassicalRegister, Duration
  from qiskit.circuit.classical import expr
  
  # Subtract two integers
  cr = ClassicalRegister(4, "cr")
  qc = QuantumCircuit(cr)
  with qc.if_test(expr.equal(expr.sub(cr, 2), 3)):
      pass
  
  # Multiply a Duration by a Float
  with qc.if_test(expr.less(expr.mul(Duration.dt(200), 2.0), Duration.ns(500))):
      pass
  
  # Divide a Duration by a Duration to get a Float
  with qc.if_test(expr.greater(expr.div(Duration.dt(200), Duration.dt(400)), 0.5)):
      pass

  Pour d'autres exemples, voir la documentation au niveau du module dont le lien figure ci-dessus.

• Le constructeur de UCGate possède désormais un nouvel argument facultatif, mux_simp, qui prend une valeur booléenne permettant la recherche des simplifications de Carvalho et al. Cette optimisation, activée par défaut, identifie et supprime les contrôles inutiles du multiplexeur, réduisant ainsi le nombre de portes CX et la profondeur du circuit, en particulier dans la préparation d'états séparables avec des Initialize.

• Les PauliEvolutionGate supporte désormais nativement les SparseObservablecomme entrée. Cela permet de traiter efficacement l'évolution sous les projecteurs, qui sont mis en œuvre comme des contrôles d'une rotation de phase et nécessitent moins de portes que l'expansion explicite du projecteur en termes de Paulis. Par exemple :

  from qiskit.circuit.library import PauliEvolutionGate
  from qiskit.quantum_info import SparseObservable
  
  obs = SparseObservable("001")
  evo_proj = PauliEvolutionGate(obs, time=1)
  print(evo_proj.definition.draw())

• Un nouveau nœud d'expression Stretch a été ajouté au système d'expression classique pour représenter les variables stretch . Pour créer une nouvelle variable stretch , vous pouvez utiliser QuantumCircuit.add_stretch(). L'expression résultante est une expression constante de type Durationqui peut être utilisée comme argument duration d'une expression de type delay().

  Par exemple, pour garantir qu'une séquence de portes entre deux barrières sera alignée à gauche, quelle que soit leur durée réelle, vous pouvez procéder comme suit :

  from qiskit import QuantumCircuit
  from numpy import pi
  
  qc = QuantumCircuit(5)
  qc.barrier()
  qc.cx(0, 1)
  qc.u(pi/4, 0, pi/2, 2)
  qc.cx(3, 4)
  
  a = qc.add_stretch("a")
  b = qc.add_stretch("b")
  c = qc.add_stretch("c")
  
  # Use the stretches as Delay duration.
  qc.delay(a, [0, 1])
  qc.delay(b, 2)
  qc.delay(c, [3, 4])
  qc.barrier()

  L'expression Stretch est très similaire à l'expression Var existante utilisée pour représenter les variables classiques dans un circuit, sauf qu'elle est constante et qu'elle est toujours de type Duration. Il peut être utilisé dans d'autres expressions (par exemple, vous pouvez le multiplier par une constante numérique) QuantumCircuit fournit une prise en charge complète de la portée (par exemple, elle peut être capturée par ou déclarée dans une portée de flux de contrôle).

  Pour plus de contexte et d'exemples, voir la spécification du langage OpenQASM 3.

• Ajouté Gate des versions des portes arithmétiques à registre unique qui permettent au transpileur d'effectuer des optimisations de haut niveau par rapport à leurs variantes QuantumCircuit variantes. Il s'agit de :

  • ExactReciprocalGate (en remplaçant ExactReciprocal)
  • IntegerComparatorGate (en remplaçant IntegerComparator)
  • LinearPauliRotationsGate (en remplaçant LinearPauliRotations)
  • PiecewiseLinearPauliRotationsGate (en remplaçant PiecewiseLinearPauliRotations)
  • PiecewiseChebyshevGate (en remplaçant PiecewiseChebyshev)
  • PiecewisePolynomialPauliRotationsGate (en remplaçant PiecewisePolynomialPauliRotations)
  • PolynomialPauliRotationsGate (en remplaçant PolynomialPauliRotations)
  • LinearAmplitudeFunctionGate (en remplaçant LinearAmplitudeFunction)
  • QuadraticFormGate (en remplaçant QuadraticForm)
  • WeightedSumGate (en remplaçant WeightedAdder)

Fonctionnalités primitives

• Ajout d'une nouvelle méthode to_bool_array() à la classe BitArray qui renvoie le tableau de bits sous la forme d'un tableau booléen NumPy. L'argument order peut être utilisé pour spécifier l'endianness du tableau de sortie.

Fonctionnalités des fournisseurs

• Ajout de la possibilité de définir la propriété dt de GenericBackendV2 dans l'initialisateur de la classe avec un nouvel argument dt . Exemple d'utilisation :

  from qiskit.providers.fake_provider import GenericBackendV2
  
  backend = GenericBackendV2(
    num_qubits = 5,
    basis_gates = ["cx", "id", "rz", "sx", "x"],
    dt = 2.22*e-10,
    seed = 42
  )

Caractéristiques de l'information quantique

• Ajout d'une nouvelle méthode SparseObservable.to_sparse_list() pour obtenir une représentation sous forme de liste éparse d'un fichier SparseObservable. Par exemple :

  from qiskit.quantum_info import SparseObservable
  
  obs = SparseObservable.from_list([("+II", 1), ("-II", 1)])
  print(obs.to_sparse_list())  # [("+", [2], 1), ("-", [2], 1)]

• Ajout d'une nouvelle SparseObservable.as_paulis() pour exprimer une observable éparse en termes de Paulis uniquement, en développant tous les projecteurs. Par exemple :

  from qiskit.quantum_info import SparseObservable
  
  obs = SparseObservable("+-")
  obs_paulis = obs.as_paulis()  # 1/4 ( II + XI - IX - XX )

• Qiskit v2.0.0 permet de construire un SparsePauliOp à partir d'un SparseObservable en utilisant la nouvelle méthode SparsePauliOp.from_sparse_observable(). Il est important de se rappeler que SparseObservable peuvent représenter efficacement les projecteurs, qui nécessitent un nombre exponentiel de termes dans l'équation SparsePauliOp.

• SparseObservable prend désormais en charge la composition d'opérateurs à l'aide de la méthode compose() à l'instar des autres classes quantum_info classes. Il s'agit d'une méthode analogue à la multiplication matricielle, bien qu'elle soit entièrement exempte de matrice.

• SparseObservable.BitTerm possède un nouvel attribut, labelqui contient la chaîne à un seul caractère Python utilisée pour représenter le terme dans les étiquettes de chaîne.

• La méthode StabilizerState.expectation_value() peut maintenant accepter un opérateur de type SparsePauliOp.

Caractéristiques de la synthèse

• Ajout d'une nouvelle classe TwoQubitControlledUDecomposer qui décompose tout unitaire à deux qubits en termes de portes fractionnaires à deux qubits de base, telles que RZZGate (ou des portes à deux qubits qui sont localement équivalentes à RZZGatejusqu'aux portes à un qubit).

  Par exemple :

  from qiskit.circuit.library import RZZGate
  from qiskit.synthesis import TwoQubitControlledUDecomposer
  from qiskit.quantum_info import random_unitary
  
  unitary = random_unitary(4, seed=1)
  decomposer = TwoQubitControlledUDecomposer(RZZGate, euler_basis="ZXZ")
  circ = decomposer(unitary)
  circ.draw(output='mpl')

• La passe synth_cnot_depth_line_kms() a été porté en Rust, avec des benchmarks préliminaires indiquant un facteur d'accélération de 20x.

• La passe synth_cx_cz_depth_line_my() a été porté en Rust, avec des benchmarks préliminaires indiquant un facteur d'accélération de 70x.

• Ajout de fonctions de synthèse synth_integer_comparator_2s() et synth_integer_comparator_greedy() pour compiler des portes qui implémentent une comparaison d'entiers, telles que IntegerComparatorGate. Les plugins de synthèse de haut niveau correspondants sont IntComparatorSynthesis2s et IntComparatorSynthesisNoAux. Pour permettre au compilateur de sélectionner la décomposition optimale en fonction des qubits auxiliaires disponibles, utiliser IntComparatorSynthesisDefault.

• Ajouté synth_weighted_sum_carry() pour synthétiser les objets WeightedSumGate objets. C'est actuellement la seule méthode de synthèse disponible pour WeightedSumGateavec le plugin de synthèse de haut niveau correspondant WeightedSumSynthesisDefault.

Fonctionnalités du transpilateur

• Ajout d'un support pour travailler avec des objets Target qui contiennent des portes de base à deux qubits contenant des angles arbitraires, tels que RZZGateà la passe de ConsolidateBlocks transpiler pass. La passe précédente n'estimait pas correctement le nombre de portes nécessaires pour une décomposition, ce qui faisait que les blocs n'étaient pas consolidés là où l'on pouvait potentiellement optimiser le bloc UnitarySynthesis pourrait potentiellement optimiser le bloc. En interne, l'estimation du nombre de portes est réalisée à l'aide de la classe TwoQubitControlledUDecomposer classe.

  Par exemple :

  from qiskit import QuantumCircuit
  from qiskit.transpiler import generate_preset_pass_manager
  from qiskit.transpiler.passes import ConsolidateBlocks
  
  qc = QuantumCircuit(2)
  qc.rzz(0.1, 0, 1)
  qc.rzz(0.2, 0, 1)
  # basis_gates contains fractional gate (rzz)
  consolidate_pass = ConsolidateBlocks(basis_gates=["rz", "rzz", "sx", "x", "rx"])
  block = consolidate_pass(qc)  # consolidate the circuit into a single unitary block
  block.draw(output='mpl')
  
  pm = generate_preset_pass_manager(
      optimization_level=2, basis_gates=["rz", "rzz", "sx", "x", "rx"]
  )
  tqc = pm.run(qc)  # synthesizing the circuit into basis gates
  tqc.draw(output='mpl')

• Ajout de la prise en charge des portes de base fractionnaires à deux qubits, telles que RZZGateà la passe de UnitarySynthesis transpiler pass. La décomposition est effectuée à l'aide de la fonction TwoQubitControlledUDecomposeret prend en charge les portes de base standard et personnalisées.

  Par exemple :

  from qiskit import QuantumCircuit
  from qiskit.quantum_info import random_unitary
  from qiskit.transpiler.passes import UnitarySynthesis
  from qiskit.converters import circuit_to_dag, dag_to_circuit
  
  unitary = random_unitary(4, seed=1)
  qc = QuantumCircuit(2)
  qc.append(unitary, [0, 1])
  dag = circuit_to_dag(qc)
  
  # basis_gates contains fractional gate (rzz)
  circ = UnitarySynthesis(basis_gates=['rzz', 'rx', 'rz']).run(dag)
  dag_to_circuit(circ).draw(output='mpl')

• Ajout d'une nouvelle passe de transposition, LightConequi renvoie le cône de lumière d'un circuit lors de la mesure d'un sous-ensemble de qubits ou d'une chaîne de Pauli spécifique.

  Par exemple, pour le circuit suivant :

  

  l'exécution du laissez-passer permettrait d'éliminer les portes qui n'ont pas d'incidence sur le résultat :

  from qiskit.transpiler.passes.optimization.light_cone import LightCone
  from qiskit.transpiler.passmanager import PassManager
  from qiskit.circuit import QuantumCircuit
  
  qc = QuantumCircuit(3,1)
  qc.h(range(3))
  qc.cx(0,1)
  qc.cx(2,1)
  qc.h(range(3))
  qc.measure(0,0)
  
  pm = PassManager([LightCone()])
  new_circuit = pm.run(qc)
  new_circuit.draw("mpl")

  

• Ajout d'un nouvel argument max_block_width à la classe BlockCollector et à la classe CollectLinearFunctions et CollectCliffords pour le transpileur. Cet argument permet de limiter le nombre maximal de qubits sur lequel un bloc de nœuds est défini.

  Par exemple :

  from qiskit.circuit import QuantumCircuit
  from qiskit.transpiler.passes import CollectLinearFunctions
  
  qc = QuantumCircuit(5)
  qc.h(0)
  qc.cx(0, 1)
  qc.cx(1, 2)
  qc.cx(2, 3)
  qc.cx(3, 4)
  
  # Collects all CX-gates into a single block 
  qc1 = CollectLinearFunctions()(qc)
  qc1.draw(output='mpl')
  
  # Collects CX-gates into two blocks of width 3 
  qc2 = CollectLinearFunctions(max_block_width=3)(qc)
  qc2.draw(output='mpl')

• Ajout d'une nouvelle option, collect_from_back, à la passe de CollectMultiQBlocks transpiler. Lorsqu'il est réglé sur True, les blocs sont collectés dans le sens inverse, des sorties vers les entrées du circuit. Les blocs sont toujours signalés selon l'ordre topologique normal. Il en résulte une flexibilité supplémentaire offerte par la passe et des possibilités d'optimisation supplémentaires lorsqu'elle est combinée à une méthode de resynthèse des circuits.

• Ajout d'un nouvel argument approximation_degree à CommutationAnalysis. Cet argument permet de définir le seuil d'approximation à partir duquel les portes sont évaluées en fonction de la commutation. Voir la docstring de la classe pour plus d'informations.

• Un nouveau laissez-passer pour transpondeurs, ContractIdleWiresInControlFlowest disponible dans qiskit.transpiler.passes. Ce passage supprime les qubits des blocs de flux de contrôle si la sémantique le permet et si le qubit reste inactif tout au long de l'opération de flux de contrôle. Auparavant, l'étape de routage des gestionnaires de passes prédéfinies pouvait supprimer des qubits inactifs, ce qui était un effet secondaire involontaire du fonctionnement des passes. Désormais, ce comportement est correctement géré dans le cadre d'une passe d'optimisation.

• Un nouvel étage de plugin de routage "default" a été ajouté. Dans Qiskit v2.0.0, il s'agit simplement d'un alias de l'ancienne valeur par défaut "sabre". L'algorithme par défaut sous-jacent peut changer au cours de la série de versions de Qiskit v2.x pour certaines ou toutes les cibles, mais vous pouvez toujours définir explicitement routing_method="sabre" pour maintenir le comportement actuel.

• Ajout d'une nouvelle étape du plugin de traduction "default" . Dans Qiskit v2.0.0, il s'agit d'un alias de l'ancienne valeur par défaut "translator". L'algorithme par défaut sous-jacent peut changer au cours de la série Qiskit 2.x pour certaines ou toutes les cibles, mais vous pouvez toujours définir translation_method="translator" explicitement pour conserver le comportement actuel.

• La passe de HighLevelSynthesis synthétise désormais des objets de type AnnotatedOperation à travers l'interface du plugin.

• PassManager.run() accepte désormais un argument property_set , qui peut être défini comme un objet Mapping-pour fournir les valeurs initiales des objets PropertySet. Cela peut être utilisé pour recommencer une compilation partiellement appliquée, ou pour réutiliser certaines analyses d'une compilation antérieure à un nouvel endroit.

• La programmation passe PadDelay et PadDynamicalDecoupling ont maintenant de nouveaux arguments sur leurs constructeurs : target et durations. Ceux-ci sont utilisés pour spécifier l'option Target ou InstructionDurations respectivement. Pour accéder aux durées d'instruction lors de l'exécution de la passe, l'un des arguments est nécessaire.

• Ajout d'une nouvelle méthode seconds_to_dt() à la classe Target classe. Il est utilisé pour traduire une durée en secondes en un nombre de pas de temps discrétisés de la résolution temporelle du système spécifiée dans l'attribut Target.dt attribut. Ceci est typiquement utile pour convertir la valeur InstructionProperties.duration en unités de dt.

• La passe de Split2QUnitaries la passe de transpilation a été améliorée pour traiter le cas où l'unité considérée peut être écrite sous la forme d'une SwapGate et deux portes à un qubit. Dans ce cas, il divise l'unité et applique également une permutation virtuelle, similaire à ce qui est fait dans la méthode ElidePermutations. Cette fonctionnalité peut être contrôlée à l'aide d'un nouvel argument, split_swap, dans le constructeur de :class`.Split2QUnitaries`, qui peut être utilisé pour désactiver le fractionnement des portes équivalentes de permutation.

Divers. Fonctions

• qiskit.utils contient désormais des utilitaires permettant un meilleur contrôle et une meilleure inspection des paramètres de parallélisation de Qiskit multiprocessing de Qiskit. En particulier, on peut maintenant utiliser should_run_in_parallel() pour demander si parallel_map() (et les gestionnaires de passe) lancera des sous-processus pour des entrées appropriées, et utiliser le gestionnaire de contexte should_run_in_parallel.override() pour remplacer temporairement la plupart des configurations du système et de l'utilisateur autour de cette décision.

  Une fonction supplémentaire, default_num_processes()lit le nombre maximal par défaut de sous-processus que Qiskit utilisera pour le parallélisme basé sur les processus.

• Une nouvelle variable d'environnement, QISKIT_IGNORE_USER_SETTINGS, permet désormais de déterminer s'il faut lire le fichier des paramètres de l'utilisateur sur import qiskit. S'il s'agit de la chaîne true, le fichier de configuration ne sera pas lu. Ceci est utile pour isoler certaines instances de Qiskit de l'environnement du système, par exemple pour des tests.

Mise à niveau

• Qiskit v2.0 a abandonné la prise en charge de Linux i686 et de Windows 32 bits. À partir de Qiskit v2.0.0, une plate-forme 64 bits est nécessaire pour faire fonctionner Qiskit. Cela correspond à la tendance de la communauté scientifique Python et permet à Qiskit de se concentrer sur l'amélioration des performances du matériel informatique quantique de plus en plus complexe.

  Qiskit v1.4 continuera à supporter les plateformes 32-bit jusqu'à la fin de vie (septembre 2025), mais à partir de cette version 2.0.0, Qiskit ne publiera plus de binaires pré-compilés pour ces plateformes, et n'offre aucune garantie de succès des compilations de sources sur les plateformes 32-bit.

• La version minimale de Rust supportée pour construire Qiskit à partir des sources est maintenant v1.79. Cette version a été augmentée par rapport à v1.70, la version Rust minimale supportée précédente dans la série de versions de Qiskit v1.x.

• Qiskit Pulse a été complètement supprimé dans cette version, suite à sa dépréciation dans Qiskit v1.3. Cela comprend tous les fichiers du module d'impulsion, la fonctionnalité de visualisation des impulsions, la prise en charge de la sérialisation et de la désérialisation de ScheduleBlock et de la porte d'impulsion dans QPY, la gestion des étalonnages dans le module d'impulsion QuantumCircuit, Target et DAGCircuitet de faux backends basés sur les impulsions. Pour plus de détails sur les composants retirés liés à l'impulsion, voir les sections correspondantes ci-dessous.

  Notez que la migration de Pulse vers Qiskit Dynamics, telle qu'elle était initialement prévue suite à la dépréciation de Pulse, a été suspendue en raison des priorités de développement de Qiskit Dynamics. Les utilisateurs souhaitant utiliser Qiskit Pulse en tant qu'interface avec les backends ou dans d'autres cas d'utilisation peuvent toujours l'utiliser dans les versions de Qiskit antérieures à v2.0.0, qui incluent la fonctionnalité Pulse.

• Les fonctions sequence et schedule du module compiler ont été supprimées suite à leur dépréciation dans Qiskit v1.3. Ils s'appuyaient sur la possibilité de traduire les circuits en composants d'impulsion à l'aide de définitions de backend, une capacité qui n'existe plus aujourd'hui. C'est pourquoi elles ont été supprimées sans qu'aucune alternative ne soit proposée. Notez que ces suppressions concernent le paquet Pulse, qui est également supprimé dans Qiskit 2.0.

Notes sur la mise à niveau des circuits

• Bit et Register ainsi que leurs sous-classes ne sont plus garanties comparables par les contrôles effectués sur is , en raison des conversions vers et depuis Python qui peuvent réallouer chaque instance exposée à Python.

• Bit et Register (et leurs sous-classes) ne peuvent plus être sous-classés. Il n'a jamais été prévu que ce comportement soit pris en charge, et cela entraînerait un comportement non spécifié dans Qiskit. Il n'est plus possible de le faire en tant que détail d'implémentation des classes.

• Il n'est plus possible de créer des instances de la base Bit et Register et de la classe L'instanciation directe de ces classes a été clairement documentée comme n'étant pas prise en charge, et la possibilité de le faire n'était qu'un artefact d'implémentation de la hiérarchie des classes dans les versions précédentes. À partir de Qiskit v2.0.0, il n'est plus possible de le faire.

• Le module qiskit.circuit.classicalfunction a été supprimé suite à sa dépréciation dans Qiskit v1.4. Il s'agit de la classe ClassicalFunction , de la fonction connexe classical_function et de la classe BooleanExpression . Ce changement a été effectué pour supprimer la dépendance de la bibliothèque tweedledum , qui n'est plus compatible avec toutes les plateformes supportées par Qiskit et les versions de Python. ClassicalFunction était exclusivement utilisé dans PhaseOraclequi a été mis à jour pour n'accepter que les expressions au format string (voir la note de mise à jour suivante). BooleanExpression a été remplacée par la nouvelle classe BitFlipOracleGate classe.

• La classe PhaseOracle ne dépend plus de la bibliothèque tweedledum , car cette dépendance n'est pas activement maintenue. L'interface a été simplifiée : elle n'accepte plus de paramètre synthesizer et le paramètre expression ne peut être qu'une chaîne de caractères. Le type ClassicalFunction précédemment accepté, déprécié dans Qiskit v1.4, a été supprimé dans Qiskit v2.0.

  Malgré ces améliorations, l'utilisation standard de la classe PhaseOracle reste inchangée :

  from qiskit.circuit.library.phase_oracle import PhaseOracle
  bool_expr = "(x0 & x1 | ~x2) & x4"
  oracle = PhaseOracle(bool_expr)
  oracle.draw('mpl')

  

  Notez que ce changement peut affecter l'efficacité de la synthèse, mais qu'il était nécessaire pour assurer la compatibilité avec toutes les plateformes supportées par Qiskit et les versions de Python.

• Mise à jour de la métrique utilisée pour vérifier les commutations dans CommutationChecker. Deux portes sont supposées commuter si la fidélité moyenne de la commutation est supérieure à (1 - 1e-12). Cette valeur est choisie pour tenir compte des erreurs d'arrondi dans le calcul de la fidélité et pour des raisons de cohérence avec RemoveIdentityEquivalent et TwoQubitWeylDecomposition. Voir la docstring de la classe pour plus d'informations.

• La méthode QuantumCircuit.measure_active() a changé le nom du registre classique qu'elle crée, car le nom précédent entrait en conflit avec un mot réservé de OpenQASM . Au lieu de measure, il s'appelle désormais meas, ce qui correspond au nom du registre utilisé par le measure_all().

• La méthode DAGCircuit.control_flow_op_nodes() a été mise à jour afin de toujours renvoyer une liste, même si elle est vide. Auparavant, il renvoyait None s'il était vide, et ne renvoyait jamais une liste vide, ce qui nécessitait un traitement spécial. Si vous avez besoin de tester explicitement la vacuité à la fois dans Qiskit v1.x et v2.x, vous pouvez le faire :

  control_flow_nodes = dag.control_flow_op_nodes()
  if not control_flow_nodes:
      # There are no control-flow nodes.
      pass

• BlueprintCircuit.copy_empty_like() renvoie désormais un QuantumCircuit avec le même nombre de qubits et de clbits, et les mêmes métadonnées que le circuit original, au lieu d'un BlueprintCircuit. Cette modification permet de remédier à un comportement inattendu où le traitement d'une copie "vide" d'un circuit de schéma directeur entraînait la reconstruction des données du circuit. Notez que BlueprintCircuit.copy() renvoie toujours un BlueprintCircuit. Bien que BlueprintCircuit ne soit pas une classe publique puisqu'il s'agit d'un type interne utilisé pour la construction d'entrées patrimoniales en qiskit.circuit.library cela a un impact sur ses sous-classes telles que NLocal et ZZFeatureMap. Se référer au qiskit.circuit.library pour obtenir la liste complète des classes concernées par ce changement. Corrigé #13535

• La fonction interne qiskit.circuit.add_control.add_control a été supprimée. Cette fonction ne faisait pas partie de l'API publique, elle avait des conditions préalables fragiles à respecter et était une source fréquente de bogues. Les utilisations de add_control(SomeGate(...), ...) doivent être remplacées par SomeGate(...).control(...) en utilisant Gate.control() à la place, ce qui est bien plus sûr.

• La méthode ParameterExpression.sympify() peut désormais lever une exception MissingOptionalLibrary si sympy n'est pas installé. Dans les versions de Qiskit v1.x, l'installation de sympy était toujours garantie, mais à partir de v2.0.0, ce n'est plus une condition sine qua non et vous n'en aurez besoin que si vous utilisez cette méthode. Comme cette fonctionnalité nécessite explicitement sympy , vous devez vous assurer que sympy est installé pour utiliser cette méthode.

• L'argument DAGNode dag a été supprimé de la classe DAGNode et de ses sous-classes : DAGOpNode, DAGOutNodeet DAGInNode.

  Le paramètre dag était un argument facultatif lors de la construction de ces objets, mais il est inutilisé et ignoré depuis la version v1.3, et déprécié depuis la version v1.4.

• Les méthodes suivantes QuantumCircuit méthodes :

  • cast
  • cbit_argument_conversion
  • cls_instances
  • cls_prefix
  • qbit_argument_conversion

  ont été supprimés, suite à leur dépréciation dans Qiskit 1.2. Ces méthodes étaient des fonctions d'aide internes et n'ont jamais été destinées à devenir des API publiques. Aucun remplacement n'est prévu.

• Les attributs dépréciés pour Instruction et Gateduration et unit ont été supprimés, de sorte que vous ne pouvez plus définir les arguments unit ou duration pour n'importe quelle classe ou sous-classe de qiskit.circuit.Instruction ou de la sous-classe. Ces attributs ont été supprimés dans Qiskit v1.3.0 et ont été utilisés pour attacher une durée d'exécution personnalisée et une unité pour cette durée à une instruction individuelle. Cependant, la source de vérité de la durée d'une porte est le BackendV2 Targetqui contient la durée de chaque instruction prise en charge par le backend. La durée d'une instruction n'est généralement pas réglable par l'utilisateur et est une propriété immuable du backend. Si vous avez déjà utilisé cette fonction pour expérimenter différentes durées de porte, vous pouvez modifier le champ InstructionProperties.duration dans un champ Target pour définir une durée personnalisée pour une instruction sur un backend. (L'unité est toujours en secondes dans le Target.)

• L'attribut déprécié pour qiskit.circuit.Instruction et Gate: condition a été supprimé. Cette fonctionnalité a été remplacée par la classe IfElseOp qui peut être utilisée pour décrire une condition classique dans un circuit. Cet attribut a été supprimé dans la version v1.3.0.

• Les méthodes obsolètes pour Instruction et Gate: c_if et condition_bits ont été supprimées. Ces méthodes ont été supprimées dans la version v1.3.0. Cette fonctionnalité a été remplacée par la classe IfElseOp qui peut être utilisée pour décrire une condition classique dans un circuit. Par exemple, un circuit utilisant précédemment Instruction.c_if() comme :

  from qiskit.circuit import QuantumCircuit
  
  qc = QuantumCircuit(2, 2)
  qc.h(0)
  qc.x(0).c_if(0, 1)
  qc.z(1.c_if(1, 0)
  qc.measure(0, 0)
  qc.measure(1, 1)

  peut être réécrit ainsi :

  qc = QuantumCircuit(2, 2)
  qc.h(0)
  with expected.if_test((expected.clbits[0], True)):
      qc.x(0)
  with expected.if_test((expected.clbits[1], False)):
      qc.z(1)
  qc.measure(0, 0)
  qc.measure(1, 1)

• La méthode obsolète InstructionSet.c_if a été supprimée. Cette méthode a été supprimée dans la version 1.3.0. Cette fonctionnalité a été remplacée par la classe IfElseOp qui peut être utilisée pour décrire une condition classique dans un circuit.

• Dans le cadre de la suppression de Pulse à Qiskit v2.0.0, la propriété calibrations a été supprimée de la base de données QuantumCircuit, DAGCircuit et DAGDependency ont été supprimées. En outre, la méthode has_calibration_for a été supprimée de l'interface de l'application QuantumCircuit et DAGCircuit et add_calibration a été supprimée des classes QuantumCircuit.

• Le module qiskit.circuit.classicalfunction a été retiré. Ce module dépendait de la bibliothèque tweedledum qui n'est pas compatible avec les nouvelles versions de Python. En guise d'alternative, les boutons PhaseOracleGate et BitFlipOracleGate peuvent être utilisées pour générer des circuits à partir d'expressions booléennes.

• La représentation interne de UnitaryGate lorsqu'il est ajouté à un QuantumCircuit a changé. L'objet stocké dans le circuit ne partagera plus nécessairement une référence commune avec l'objet ajouté au circuit. Ce comportement n'était jamais garanti, et la mutation de l'objet UnitaryGate directement ou par référence était toujours bancale et susceptible de corrompre le circuit, en particulier lors de la modification de la matrice. Si vous avez besoin de muter un élément du circuit (ce qui n'est pas recommandé car c'est inefficace et source d'erreurs), faites quelque chose comme :

  from qiskit.circuit import QuantumCircuit
  from qiskit.quantum_info import random_unitary
  from qiskit.circuit.library import UnitaryGate
  import numpy as np
  
  qc = QuantumCircuit(2)
  qc.unitary(np.eye(2, dtype=complex))
  
  new_op = UnitaryGate(random_unitary(2))
  qc.data[0] = qc.data[0].replace(operation=new_op)

  Ceci s'applique également à DAGCircuitmais vous pouvez utiliser DAGCircuit.substitute_node() à la place.

• L'attribut CircuitInstruction.params pour un CircuitInstruction qui contient un UnitaryGate pour son operation ne contiendra plus la matrice unitaire sous-jacente de la porte. En effet, la représentation interne de la porte ne traite plus l'objet matrice comme un paramètre. Si vous devez accéder à la matrice du portail, vous pouvez le faire soit par l'intermédiaire de l'interface de gestion du portail, soit par l'intermédiaire de l'interface de gestion du portail CircuitInstruction.matrix soit par le champ UnitaryGate.params du champ CircuitInstruction.operation.

Notes de mise à niveau des primitives

• À la suite de la suppression du modèle BackendV1 , les BackendSamplerV2 et BackendEstimatorV2 n'acceptent plus les entrées de type BackendV1 dans leur argument d'entrée backend .

• Les implémentations primitives de V1 et les alias de type non-versionnés de V1-exclusive, dépréciés dans Qiskit v1.2, ont été supprimés. Ces interfaces ont été remplacées par leurs équivalents sur V2. La suppression comprend les classes suivantes qui mettent en œuvre les interfaces V1 :

  • Estimatoren faveur de l'équivalent V2, StatevectorEstimator
  • Sampleren faveur de l'équivalent V2, StatevectorSampler
  • BackendEstimatoren faveur de l'équivalent V2, BackendEstimatorV2
  • BackendSampleren faveur de l'équivalent V2, BackendSamplerV2

  Ainsi que les alias de type non versionnés suivants :

  • BaseEstimator, alias de BaseEstimatorV1
  • BaseSampler, alias de BaseSamplerV1

  Cette suppression n'affecte PAS les définitions des interfaces abstraites BaseEstimatorV1 et BaseSamplerV1 qui ont fait l'objet d'une version explicite, ni les classes de résultats et de tâches correspondantes, qui ont été conservées pour des raisons de compatibilité ascendante. Si vous utilisez un alias V1-type non versionné tel que BaseEstimator, vous pouvez le remplacer directement par le type versionné (BaseEstimatorV1).

  En outre, les fonctions d'utilité suivantes ont été supprimées. Ces fonctions n'ont été utilisées que dans les implémentations primitives de V1 :

  • init_circuitpour initialiser un circuit à partir d'un Statevectorutiliser QuantumCircuit.initialize() à la place.
  • init_observable: utiliser le constructeur de SparsePauliOp à la place.
  • final_measurement_mapping: utiliser QuantumCircuit.layout() et SparsePauliOp.apply_layout() pour ajuster un opérateur à une mise en page. Sinon, utilisez mthree.utils.final_measurement_mapping. Voir les fonctions utilitaires de Mthree pour plus de détails.

Notes de mise à niveau des fournisseurs

• La méthode configuration de BasicSimulator a été supprimée suite à sa dépréciation dans Qiskit v1.3. Cette méthode renvoie une instance de BackendConfiguration , une classe qui faisait partie du flux de travail BackendV1 abandonné et qui est également supprimée dans Qiskit v2.0.0. Les différents éléments de configuration peuvent désormais être récupérés directement à partir du backend ou de l'instance de Target contenue (backend.target).

• La méthode run_experiment de BasicSimulator a été supprimée. Cette méthode prend une instance de la classe QasmQobjExperiment comme argument d'entrée, une classe qui a été dépréciée depuis Qiskit v1.2 et qui a été supprimée avec le flux de travail Qobj dans Qiskit v2.0.0.

• Le modèle BackendV1 a été supprimé suite à sa dépréciation dans Qiskit 1.2.0. Cela inclut la classe BackendV1 ainsi que les modules et utilitaires associés, car ils ont été remplacés par le BackendV2 modèle. La liste des objets retirés comprend

  • BackendV1 classe : le cœur du modèle retiré

  • Tous les éléments de qiskit/providers/models, car ils ont été utilisés pour représenter les composants du modèle BackendV1 :

    • BackendConfiguration
    • BackendProperties
    • BackendStatus
    • QasmBackendConfiguration
    • PulseBackendConfiguration
    • UchannelLO
    • GateConfig
    • PulseDefaults
    • PulseQobjDef
    • Command
    • GateProperties
    • Nduv
    • JobStatus: Cette classe a été remplacée par celle, plus répandue, de JobStatus
    • PulseDefaults

  • BackendV2Converter classe : utilisée pour convertir BackendV1 en BackendV2

  • convert_to_target fonction : utilisée pour construire une instance Target instance à partir des anciens composants de BackendV1 (tels que BackendConfiguration ou BackendProperties)

  • BackendPropertyError et BackendConfigurationError: exceptions liées aux classes supprimées

• Le BasicSimulator ne peut plus simuler un flux de contrôle classique. Il ne permettait que l'utilisation de .c_if()/.condition pour modéliser le flux de contrôle, mais cette construction a maintenant été supprimée du modèle de données Qiskit.

• Toutes les fausses classes de backend basées sur la version dépréciée de BackendV1 ont été supprimées du module providers.fake_provider module. Ces classes sont obsolètes depuis Qiskit 1.2 et faisaient partie du flux de travail obsolète BackendV1 . Leur utilisation dans les tests a été remplacée par la classe GenericBackendV2 qui permet de créer des instances personnalisées de BackendV2 qui mettent en œuvre un BackendV2.run(). Le retrait affecte :

  • Classes de base :

    • FakeBackend
    • FakePulseBackend
    • FakeQasmBackend

  • Faux backends à des fins de tests spécifiques :

    • Fake1Q
    • FakeOpenPulse2Q
    • FakeOpenPulse3Q

  • Faux backends hérités :

    • Fake5QV1
    • Fake20QV1
    • Fake7QPulseV1
    • Fake27QPulseV1
    • Fake127QPulseV1

• Dans le cadre de la suppression des impulsions dans Qiskit v2.0.0, les méthodes suivantes ont été supprimées :

  • qiskit.providers.BackendV2.instruction_schedule_map
  • qiskit.providers.BackendV2.drive_channel
  • qiskit.providers.BackendV2.measure_channel
  • qiskit.providers.BackendV2.acquire_channel
  • qiskit.providers.BackendV2.control_channel

• Dans le cadre de la suppression de l'impulsion dans Qiskit v2.0.0, la prise en charge de l'impulsion a été supprimée de GenericBackendV2. Cela inclut la possibilité d'initialiser le backend avec des calibrations personnalisées (argumentcalibrate_instructions ) et des attributs de canaux d'impulsion (drive_channel, measure_channel, acquire_channel, control_channel).

• Suppression des classes de base abstraites Provider et ProviderV1, qui sont obsolètes depuis Qiskit v1.1.0. L'abstraction fournie par ces définitions d'interface n'offrait pas de valeur significative, ne comprenant que les attributs name, backends, et une méthode get_backend() .

  Un fournisseur, en tant que concept, continuera d'exister en tant que collection de backends. Si vous mettez actuellement en œuvre un fournisseur, vous pouvez adapter votre code en supprimant simplement ProviderV1 en tant que classe parente de votre mise en œuvre.

  Dans le cadre de ce changement, vous voudrez probablement ajouter une implémentation de get_backend pour assurer la compatibilité ascendante. Par exemple :

  def get_backend(self, name=None, **kwargs):
    backend = self.backends(name, **kwargs)
    if len(backends) > 1:
      raise QiskitBackendNotFoundError("More than one backend matches the criteria")
    if not backends:
      raise QiskitBackendNotFoundError("No backend matches the criteria")
    return backends[0]

Notes de mise à niveau QPY

• La fonction qpy.load() peut maintenant lever une exception MissingOptionalLibrary si une charge utile QPY v10, v11, ou v12 est transmise qui utilise des expressions symboliques symengine et que symengine n'est pas installé. L'exception est également levée si sympy n'est pas installé pour une autre charge utile QPY avant v13. Dans les versions de Qiskit v1.x, l'installation de symengine et sympy était toujours garantie. Cependant, à partir de v2.x, ce n'est plus une exigence absolue et cela ne sera peut-être nécessaire que si vous désérialisez un fichier QPY qui a été généré à l'aide de symengine. L'analyse de ces données utiles QPY nécessite symengine car son utilisation fait partie de la spécification du format pour QPY v10, v11, et v12. Si la charge utile l'exige, l'installation d'une version compatible de symengine (0.11.0 ou 0.13.0) est la seule option possible. De même, sympy a été utilisé pour ParameterExpression l'encodage de toutes les versions 1 à 12 de QPY.

• La version minimale de compatibilité QPY, QPY_COMPATIBILITY_VERSIONa été portée de 10 (la version requise pour v1.x ) à 13. Cette version contrôle la version minimale de QPY qui peut être émise par la fonction qpy.dump() par la fonction Cela signifie que qpy.dump() ne peut émettre que des QPY v13 et v14 dans cette version. QPY v13 est toujours compatible avec Qiskit v1.3.x et v1.4.x, ce qui signifie que les charges utiles générées dans Qiskit v2.x avec QPY v13 peuvent toujours être chargées avec la série de versions Qiskit v1.x.

  Ce changement était nécessaire parce que les versions 10 à 12 de QPY nécessitent les bibliothèques sympy ou symengine pour générer une sérialisation pour les objets, mais dans Qiskit, aucune bibliothèque n'est nécessaire pour les objets ParameterExpression mais dans Qiskit 2.x aucune bibliothèque n'est requise pour l'objet ParameterExpression objet.

• Avec la suppression de pulse dans Qiskit v2.0.0, le support pour la sérialisation des programmes ScheduleBlock à travers la fonction qiskit.qpy.dump() a été supprimée. Les utilisateurs peuvent toujours charger des charges utiles contenant des portes d'impulsion en utilisant la fonction qiskit.qpy.load() mais elles seront traitées comme des instructions personnalisées opaques. Le chargement de ScheduleBlock payloads n'est plus supporté et provoquera une QpyError exception.

Notes de mise à niveau de Synthesis

• L'argument appelable atomic_evolution de ProductFormula (et ses sous-classes QDrift, LieTrotter, et SuzukiTrotter ) a une nouvelle signature de fonction. L'ancienne signature prenait un opérateur de Pauli et un coefficient de temps et renvoyait le circuit d'évolution :

  def atomic_evolution(pauli_op: SparsePauliOp, time: float) -> QuantumCircuit:
    evol_circuit = QuantumCircuit(pauli_op.num_qubits)
    # append operators to circuit
    return evol_circuit

  La nouvelle signature prend directement en compte un circuit existant et doit ajouter à ce circuit l'évolution du temps de Pauli fourni :

  def atomic_evolution(evol_circuit: QuantumCircuit, pauli_op: SparsePauliOp, time: float):
    # append operators to circuit, in-place modification

  Cette nouvelle mise en œuvre est nettement plus performante.

Notes de mise à niveau du transpilateur

• Augmentation du seuil minimum à partir duquel les portes sont supposées être l'identité en RemoveIdentityEquivalent de epsilon machine à 1e-12 pour tenir compte des erreurs d'arrondi dans le calcul de la fidélité et par souci de cohérence avec les autres classes, telles que CommutationAnalysis et TwoQubitWeylDecomposition.

• Le nom de scène du plugin de routage default est désormais réservé au plugin intégré Qiskit du même nom.

• L' étape du plugin de routage par défaut est désormais "default". Dans Qiskit v2.0.0, il s'agit simplement d'un alias de l'ancienne valeur par défaut "sabre". L'algorithme par défaut sous-jacent peut changer au cours de la série de versions de Qiskit v2.x pour certaines ou toutes les cibles, mais vous pouvez toujours définir explicitement routing_method="sabre" pour conserver le comportement actuel.

• Le nom de scène du plugin de traduction default est désormais réservé au plugin intégré Qiskit du même nom.

• L' étape du plugin de traduction par défaut est désormais "default". Dans Qiskit 2.0, il s'agit simplement d'un alias de l'ancienne valeur par défaut "translator". L'algorithme par défaut sous-jacent peut changer au cours de la série Qiskit 2.x pour certaines ou toutes les cibles, mais vous pouvez toujours définir translation_method="translator" explicitement pour conserver le comportement actuel.

• Les anciennes passes d'ordonnancement ASAPSchedule, ALAPSchedule, DynamicalDecoupling, et AlignMeasures ont été supprimées en faveur des alternatives mises à jour ALAPScheduleAnalysis, ASAPScheduleAnalysis, PadDynamicalDecoupling, et ConstrainedReschedule respectivement. Ils ont été supprimés dans Qiskit v1.1 après que le nouveau workflow de planification ait remplacé l'ancien.

• Dans le cas où ni target ni un ensemble de basis_gates ne sont spécifiés, la passe de HighLevelSynthesis synthétise des circuits avec des opérations annotées avec moins de couches d'enveloppes qu'auparavant (c'est le cas, par exemple, pour le circuit produit par multiplier_cumulative_h18()).

• L'argument mot-clé property_set est désormais réservé dans BasePassManager.run()et ne peut pas être utilisé comme kwarg qui sera transmis à la conversion de la sous-classe de la représentation frontale à la représentation interne.

• Les utilisations dépréciées suivantes de l'objet BackendProperties dans le pipeline de transpilation ont été supprimées dans Qiskit 2.0:

  • backend_properties l'argument d'entrée dans transpile()
  • backend_properties l'argument d'entrée dans PassManagerConfig
  • backend_properties l'argument d'entrée dans generate_preset_pass_manager()
  • backend_properties l'argument d'entrée dans generate_routing_passmanager()
  • backend_properties l'argument d'entrée dans generate_translation_passmanager()
  • backend_properties argument d'entrée Target.from_configuration()

  Les passes suivantes ont également été mises à jour pour n'accepter que target au lieu de :

  • backend_prop l'argument d'entrée dans DenseLayout
  • properties l'argument d'entrée dans VF2Layout
  • properties et coupling_map les arguments d'entrée dans VF2PostLayout
  • backend_props l'argument d'entrée dans UnitarySynthesis

  La classe BackendProperties est obsolète depuis Qiskit v1.2, car elle faisait partie du flux de travail BackendV1 . Des propriétés d'instruction spécifiques, telles que les erreurs de porte ou les durées, peuvent être ajoutées à une instruction lors de sa construction Target lors de sa construction par le biais de la méthode Target.add_instruction() et communiquées aux passes de transposition concernées par l'intermédiaire de l'argument d'entrée target .

• Suite à la suppression du modèle BackendV1 , les types d'entrée acceptés des objets transpileurs suivants ont été mis à jour :

  • Les generate_preset_pass_manager() et transpile() n'acceptent plus les entrées de type BackendV1 dans leur argument d'entrée backend .
  • La méthode Target.from_configuration() n'accepte plus l'argument backend_properties
  • La méthode Target.target_to_backend_properties() a été supprimée

• La passe de ResetAfterMeasureSimplification utilise maintenant un IfElseOp pour conditionner l'exécution du XGate au lieu de définir un attribut condition sur la porte. En effet, l'attribut condition a été supprimé du modèle de données Qiskit.

• La passe de transpilation ConvertConditionsToIfOps , obsolète, a été supprimée. L'attribut condition sous-jacent de Instruction a été supprimé, de sorte que cette passe de transposition n'a plus rien à convertir. Au lieu de cela, vous devez utiliser directement IfElseOp pour conditionner classiquement l'exécution d'une opération.

• Les PadDelay et PadDynamicalDecoupling requièrent désormais un nouvel argument lors de leur construction. Les adresses target et durations doivent être spécifiées à l'aide d'un astérisque Target ou InstructionDurations respectivement. Sans cela, les passes ne peuvent pas déterminer la durée des instructions dans le circuit et commettent des erreurs. Auparavant, ces passes déterminaient ces valeurs à partir de l'attribut duration des objets, qui a été supprimé Instruction objets.

• La passe de transpilation AlignMeasures , précédemment dépréciée, a été supprimée. Cette passe a été supprimée dans Qiskit v1.1.0. Au lieu de cela, il convient d'utiliser le ConstrainedReschedule doit être utilisé. ConstrainedReschedule remplit la même fonction et permet également de s'aligner sur des contraintes de temps supplémentaires.

• Lors de la programmation à l'aide de generate_preset_pass_manager() ou transpile()si l'argument instruction_durations est spécifié, les durées sont formatées sous forme de list et sont exprimées en unités de dt. Vous devez également définir l'argument d'entrée dt de la fonction de transpilation.

• Suppression de l'attribut " DAGNode.sort_key ", qui était obsolète. Cet attribut a été supprimé dans la version de Qiskit v1.4.0. Le tri topologique lexicographique étant effectué en interne dans Rust et l'attribut sort key étant inutilisé, cet attribut a été supprimé afin d'éviter la surcharge liée à la création de nœuds DAG. Si vous vous êtes appuyé sur la clé de tri, vous pouvez la reproduire à partir d'un nœud donné en utilisant quelque chose comme :

  def get_sort_key(node: DAGNode):
      if isinstance(node, (DAGInNode, DAGOutNode)):
          return str(node.wire)
      return ",".join(
          f"{dag.find_bit(q).index:04d}" for q in itertools.chain(node.qargs, node.cargs)
      )

• Les éléments suivants transpile() et generate_preset_pass_manager() qui sont obsolètes depuis Qiskit 1.3, ont été supprimés de l'API :

  • instruction_durations
  • timing_constraints

  En outre, la spécification de portes de base personnalisées par l'intermédiaire de l'argument de porte basis de transpile() et generate_preset_pass_manager()également déprécié dans Qiskit 1.3, n'est plus autorisée, et un message ValueError sera émis dans ce cas.

  Les informations précédemment fournies par ces derniers peuvent toujours être spécifiées via les arguments backend ou target . Vous pouvez construire une instance Target avec des durées d'instruction définies en faisant :

  Target.from_configuration(..., instruction_durations=...)

  Pour des contraintes de temps spécifiques :

  Target.from_configuration(..., timing_constraints=...)

  Et pour les portes de base personnalisées, vous pouvez les ajouter manuellement à la cible ou utiliser .from_configuration avec un mappage de nom personnalisé, par exemple :

  from qiskit.circuit.library import XGate
  from qiskit.transpiler.target import Target
  
  basis_gates = ["my_x", "cx"]
  custom_name_mapping = {"my_x": XGate()}
  target = Target.from_configuration(
      basis_gates=basis_gates, num_qubits=2, custom_name_mapping=custom_name_mapping
  )

• Les transpile() et generate_preset_pass_manager() soulèvent maintenant un UserWarning lorsqu'elles fournissent un coupling_map et/ou un basis_gates en même temps qu'un backend. Dans ces cas, les sources de vérité sont multiples, les intentions de l'utilisateur ne sont pas toujours claires et il peut y avoir des conflits que l'on ne sait pas comment résoudre generate_preset_pass_manager() peuvent ne pas savoir comment les résoudre. L'alternative proposée consiste à définir un objectif personnalisé qui combine les contraintes choisies.

  L'une de ces situations est la spécification d'une porte avec 3 qubits ou plus dans backend ou basis_gates avec un coupling_map personnalisé. La carte de couplage ne fournit pas les détails de connectivité nécessaires pour déterminer l'action de la porte. Dans ces cas-là, transpile() et generate_preset_pass_manager() soulèvent maintenant un ValueError.

• Dans le cadre de la suppression de Pulse dans Qiskit 2.0, toutes les fonctionnalités liées à l'impulsion et à la calibration dans le transpiler ont été supprimées.

  Les passes et fonctions suivantes ont été supprimées :

  • qiskit.transpiler.passes.PulseGates réussite
  • qiskit.transpiler.passes.ValidatePulseGates réussite
  • qiskit.transpiler.passes.RXCalibrationBuilder réussite
  • qiskit.transpiler.passes.RZXCalibrationBuilder réussite
  • qiskit.transpiler.passes.RZXCalibrationBuilderNoEcho réussite
  • qiskit.transpiler.passes.EchoRZXWeylDecomposition réussite
  • qiskit.transpiler.passes.NoramlizeRXAngle réussite
  • qiskit.transpiler.passes.rzx_templates() fonction

  L'argument inst_map a été supprimé des éléments suivants :

  • Les generate_preset_pass_manager() et transpile() fonctions
  • La Target.from_configuration() méthode
  • Le constructeur de la PassManagerConfig classe

  Le support d'étalonnage a été supprimé :

  • calibration a été supprimée du constructeur InstructionProperties et n'est plus une propriété de cette classe.
  • Les méthodes has_calibration, get_calibration, instruction_schedule_map et update_from_instruction_schedule_map ont été supprimées de la classe Target classe.

• La passe de transpilation StochasticSwap , obsolète, et son plugin d'étape de routage intégré "stochastic", ont été supprimés. Ils ont été marqués comme obsolètes dans la version de Qiskit v1.3.0. La passe a été remplacée par la classe SabreSwap qui devrait être utilisée à la place, car elle offre de meilleures performances et une meilleure qualité de sortie. Par exemple, si la passe a été invoquée précédemment par le biais de la fonction transpile, comme par exemple :

  from qiskit import transpile
  from qiskit.circuit import QuantumCircuit
  from qiskit.transpiler import CouplingMap
  from qiskit.providers.fake_provider import GenericBackendV2
  
  
  qc = QuantumCircuit(4)
  qc.h(0)
  qc.cx(0, range(1, 4))
  qc.measure_all()
  
  cmap = CouplingMap.from_heavy_hex(3)
  backend = GenericBackendV2(num_qubits=cmap.size(), coupling_map=cmap)
  
  tqc = transpile(
      qc,
      routing_method="stochastic",
      layout_method="dense",
      seed_transpiler=12342,
      target=backend.target
  )

  à remplacer par :

  tqc = transpile(
      qc,
      routing_method="sabre",
      layout_method="dense",
      seed_transpiler=12342,
      target=backend.target
  )

• Le laissez-passer qiskit.transpiler.passes.CXCancellation a été supprimé. Il a été abandonné au profit de class:.InverseCancellation, qui est plus générique. CXCancellation() est pleinement équivalent sémantiquement à InverseCancellation([CXGate()]).

• La passe de SolovayKitaev ne soulève plus d'exception sur les circuits qui contiennent des opérations sur un seul qubit sans méthode to_matrix (comme les mesures, les barrières et les opérations sur le flux de contrôle) ou des opérations sur un seul qubit paramétrées, mais les laissera inchangées.

• Les plugins pour l' étape de traduction des gestionnaires de passages prédéfinis doivent désormais respecter la directionnalité des portes dans leur sortie Target dans leur sortie. Précédemment, transpile() et generate_preset_pass_manager() générerait un PassManager qui contiendrait des laissez-passer de réparation si nécessaire. Vous devez maintenant les inclure dans votre propre scène personnalisée, si votre scène ne garantit pas qu'elle respecte la directionnalité.

  Vous pouvez utiliser le GateDirection pour effectuer les mêmes réparations que Qiskit. Par exemple :

  from qiskit.transpiler import PassManager
  from qiskit.transpiler.passes import GateDirection
  from qiskit.transpiler.preset_passmanagers.plugin import PassManagerStagePlugin
  
  class YourTranslationPlugin(PassManagerStagePlugin):
      def pass_manager(self, pass_manager_config, optimization_level):
          pm = PassManager([
              # ... whatever your current setup is ...
          ])
          # Add the two-qubit directionality-fixing pass.
          pm.append(GateDirection(
              pass_manager_config.coupling_map,
              pass_manager_config.target,
          ))
          return pm

• Les gestionnaires de passe prédéfinis ne remplissent plus l'étape implicite pre_optimization de leur sortie StagedPassManager. Vous pouvez maintenant attribuer en toute sécurité votre propre PassManager à ce champ. Auparavant, vous ne pouviez qu'ajouter au fichier PassManager.

• La valeur par défaut de l'argument generate_routing_passmanager()seed_transpiler est passée de None à -1. Cette modification a été apportée parce que cet indicateur n'était utilisé que pour configurer la passe de transpilation VF2PostLayout et pour cette passe, la randomisation dégrade généralement les performances et n'est pas souhaitable. Si vous vous êtes fié à la valeur par défaut précédente, vous pouvez rétablir ce comportement en définissant explicitement l'argument seed_transpiler=None. Si vous définissez explicitement une valeur d'amorçage pour ce paramètre, il n'y a pas de changement de comportement.

Notes de mise à niveau de la visualisation

• Le paramètre idle_wires de tous les tiroirs de circuits a été complété par une nouvelle option, "auto", qui est désormais le comportement par défaut. Si vous souhaitez toujours afficher les fils sans instructions, définissez explicitement idle_wires=True.

  Lorsqu'il est réglé sur "auto", le comportement est le suivant :

  • Si le circuit a un attribut .layout défini, idle_wires est automatiquement mis à False (dissimulation des fils inactifs)
  • Sinon, idle_wires reste True (montrant tous les fils, comme c'était le cas par défaut auparavant)

  L'exemple suivant montre un circuit sans schéma affiché à l'aide de idle_wires="auto":

  qr_0: ────────
        ┌───┐┌─┐
  qr_1: ┤ H ├┤M├
        └───┘└╥┘
  cr_0: ══════╬═
              ║
  cr_1: ══════╩═

  Une fois la disposition appliquée, idle_wires="auto" relie idle_wires à False, cachant ainsi les fils inutilisés :

            ┌───┐┌─┐
  qr_1 -> 1 ┤ H ├┤M├
            └───┘└╥┘
      cr_1: ══════╩═

  Si vous souhaitez afficher tous les fils d'un circuit, définissez explicitement idle_wires=True :

       qr_0 -> 0 ────────
                 ┌───┐┌─┐
       qr_1 -> 1 ┤ H ├┤M├
                 └───┘└╥┘
  ancilla_0 -> 2 ──────╫─
                       ║
           cr_0: ══════╬═
                       ║
           cr_1: ══════╩═

  Au fur et à mesure que les ordinateurs quantiques s'étendent à un plus grand nombre de qubits, même les petits circuits peuvent produire de grandes représentations de circuits après transpilation. Le paramètre "auto" permet d'améliorer la lisibilité en masquant les fils inutiles dans la mesure du possible.

• La fonction array_to_latex() la fonction et la méthode Operator.draw() peut désormais lever une exception MissingOptionalLibrary si la bibliothèque sympy n'est pas installée. Dans les versions de Qiskit v1.x, symengine et sympy étaient toujours garantis d'être installés, mais à partir de v2.0.0, ce n'est plus une exigence absolue. La visualisation d'une matrice à l'aide de LaTeX repose sur la bibliothèque sympy . Si vous utilisez cette fonctionnalité, assurez-vous que sympy est installé.

• En raison de la suppression du modèle BackendV1 , le modèle plot_gate_map(), plot_error_map() et plot_circuit_layout() n'acceptent plus les entrées de type BackendV1 dans leur argument d'entrée backend .

• Le tiroir de la ligne du temps exige désormais que l'argument target soit spécifié lors de l'appel. Comme les instructions ne contiennent plus d'attributs de durée, cet argument supplémentaire est nécessaire pour spécifier les durées pour toutes les instructions prises en charge. Sans l'argument, le tiroir chronologique n'a pas accès à ces informations.

• Dans le cadre de la suppression de Pulse dans Qiskit 2.0, la prise en charge du dessin des impulsions via qiskit.visualization.pulse_drawer a été supprimée.

Divers. Mise à niveau

• Les décorateurs deprecate_function et deprecate_arguments , dépréciés depuis Qiskit v0.24 (mai 2023), ont été supprimés dans Qiskit v2.0.0. L'actuel deprecate_func() remplace @deprecate_function et le courant deprecate_arg() remplace @deprecate_arguments.

• La fonction assemble et les capacités associées (contenues dans le module assembler ) ont été supprimées de la base de code suite à leur dépréciation dans Qiskit v1.2. assemble a été utilisé pour générer un Qobj dans le contexte du flux de travail BackendV1 , qui est obsolète. La conversion n'est plus nécessaire, car le pipeline de transpilation et de primitives traite directement les circuits quantiques, ce qui rend le site Qobj obsolète.

  La suppression comprend les composants API publics suivants :

  • qiskit.compiler.assemble fonction
  • qiskit.assembler.assemble_circuits fonction
  • qiskit.assembler.assemble_schedules fonction
  • qiskit.assembler.disassemble fonction
  • qiskit.assembler.RunConfig Classe
  • qiskit.circuit.Instruction.assembleméthode

• La structure Qobj et les classes associées, obsolètes dans Qiskit v1.2.0, ont été supprimées. Ils ont été introduits dans le cadre du flux de travail BackendV1 et ne sont plus nécessaires pour interagir avec les BackendV2 . Ils ne sont plus nécessaires pour interagir avec les backends. Cette suppression concerne les classes suivantes :

  • QobjExperimentHeader
  • QobjHeader
  • QasmQobj
  • QasmQobjInstruction
  • QasmQobjExperimentConfig
  • QasmQobjExperiment
  • QasmQobjConfig
  • QasmExperimentCalibrations
  • GateCalibration
  • PulseQobj
  • PulseQobjInstruction
  • PulseQobjExperimentConfig
  • PulseQobjExperiment
  • PulseQobjConfig
  • QobjMeasurementOption
  • PulseLibraryItem

• Les classes MeasLevel et MeasReturnType , précédemment définies dans qobj/utils.py, ont été transférées dans result/models.py suite à la suppression du module qobj . Ces classes ne faisaient pas partie de l'API publique. Le chemin d'importation a été mis à jour de : from qiskit.qobj.utils import MeasLevel, MeasReturnType à : from qiskit.result import MeasLevel, MeasReturnType.

• L'utilisation d'arguments positionnels dans le constructeur de Result a été désactivée. Veuillez définir tous les arguments en utilisant la syntaxe kwarg, c'est-à-dire : Result(backend_name="name", ....). En outre, l'argument qobj_id ne sera plus utilisé dans la construction des Result internes. Il est toujours possible de définir qobj_id comme un kwarg générique, qui se retrouvera dans le champ des métadonnées avec les autres kwargs génériques.

• Dans le cadre de la suppression des impulsions dans Qiskit 2.0.0, les fonctions sequence et schedule_circuit de qiskit.scheduler ainsi que la classe ScheduleConfig ont été supprimées.

• Le module qiskit.result.mitigation a été supprimé suite à sa dépréciation dans Qiskit v1.3. La suppression comprend les classes LocalReadoutMitigator et CorrelatedReadoutMitigator ainsi que les utilitaires associés. Il n'y a pas de chemin alternatif dans Qiskit, car leur fonctionnalité a été remplacée par l'addon `mthree . <https://github.com/Qiskit/qiskit-addon-mthree> `__

Circuits obsolètes

• L'attribut QuantumCircuit.duration n'a pas été supprimé dans cette version comme prévu initialement. Il sera supprimé dans le cadre de la version de Qiskit v3.0.0. Cette fonctionnalité a été remplacée par la méthode QuantumCircuit.estimate_duration() qui doit être utilisée à la place.

• L'interface de type tuple pour CircuitInstruction n'a pas été supprimée dans cette version comme prévu initialement. Il sera supprimé dans Qiskit v3.0.0 à la place. Au lieu de cela, utilisez l'option operation, qubits, et clbits les attributs nommés.

• La classe de circuit "Multiple-Control-Multiple-Target" MCMT est désormais obsolète et a été remplacée par MCMTGatequi est une sous-classe Gate sous-classe. L'utilisation d'une porte au lieu d'un circuit permet au compilateur de raisonner sur l'objet à un niveau d'abstraction plus élevé et permet d'appliquer plusieurs modules de synthèse.

Dépréciations du transcompilateur

• L'attribut DAGCircuit.duration n'a pas été supprimé dans cette version comme prévu initialement. Il sera supprimé dans le cadre de la version de Qiskit v3.0.0. Cette fonctionnalité a été remplacée par la méthode QuantumCircuit.estimate_duration() qui doit être utilisée à la place.

• L'argument propagate_condition de DAGCircuit.substitute_node() et DAGCircuit.substitute_node_with_dag() a été déprécié. Avec la suppression de Instruction.condition du modèle de données Qiskit, cette option n'a plus de raison d'être. S'il est activé, il n'a plus d'effet. Il n'est pas supprimé de la signature afin de maintenir la compatibilité lors de la migration de Qiskit 1.x -> 2.0. Cette option sera supprimée dans Qiskit 3.0.

• La fonction generate_pre_op_passmanager() est obsolète. Il n'est plus utilisé dans les gestionnaires de presets de Qiskit, et sa fonction est obsolète; il générait à l'origine une étape de correction pour les plugins de traduction qui ne respectaient pas la directionnalité de l'ISA. Les étapes de traduction sont désormais tenues de respecter la directionnalité, de sorte que la fonctionnalité n'est pas nécessaire et que, très probablement, aucun remplacement n'est requis.

Problèmes de sécurité

• Correction d'une faille de sécurité dans qpy.load() lors du chargement de charges utiles qui utilisent sympy pour sérialiser des objets et autres expressions symboliques ParameterExpression des objets et d'autres expressions symboliques. Cela inclut potentiellement toute charge utile QPY utilisant la version QPY < 10, et éventuellement 10, 11 et 12 en fonction de l'encodage symbolique utilisé dans l'étape de sérialisation (qpy.dump()).

Corrections des erreurs

• Correction d'une incohérence dans le processus de transpilation lors de la manipulation de portes proches de l'identité, où ces portes étaient évaluées pour commuer avec tout par CommutationAnalysismais non supprimées par RemoveIdentityEquivalent. Le problème sous-jacent a été causé par RemoveIdentityEquivalent et CommutationAnalysis (et, par extension, CommutativeInverseCancellation) utilisant des métriques différentes. Tous deux utilisent désormais la fidélité moyenne des portes et le même seuil pour déterminer si une porte doit être traitée comme une identité (par exemple, une porte de rotation avec un angle très faible). Voir la documentation de ces classes pour plus d'informations. Correction #13547.

• Correction d'un bogue dans QuantumCircuit.assign_parameters()qui survenait lors de l'affectation de paramètres à des portes standard dont la définition avait déjà été déclenchée. Dans ce cas, les nouvelles valeurs n'ont pas été correctement propagées dans les instances de la porte. Alors que le circuit lui-même était toujours compilé comme prévu, l'inspection des opérations individuelles montrait toujours l'ancien paramètre.

  Par exemple :

  from qiskit.circuit.library import EfficientSU2
  
  circuit = EfficientSU2(2, flatten=True)
  circuit.assign_parameters([1.25] * circuit.num_parameters, inplace=True)
  print(circuit.data[0].operation.params)  # would print θ[0] instead of 1.25

  Correction #13478.

• Correction d'un bug dans DAGCircuit qui faisait que les nœuds de sortie Var devenaient des nœuds d'entrée pendant deepcopy et le décapage.

• Correction d'un oubli dans la classe Target où la définition d'une nouvelle valeur pour l'attribut dt et l'appel ultérieur à target.durations() n'affichaient pas la valeur mise à jour de dt dans l'objet retourné InstructionDurations retourné. Ce problème est désormais corrigé par l'invalidation du cache interne des durées d'instruction cible dans l'outil de configuration dt .

• Correction d'un problème dans la passe de BasisTranslator où la phase globale du DAG n'était pas mise à jour correctement. Correction #14074.

• Correction d'un bug dans la passe HighLevelSynthesis qui synthétisait toute instruction pour laquelle un greffon de synthèse est disponible, que l'instruction soit déjà supportée par la cible ou qu'elle fasse partie de l'instruction explicitement passée basis_gates. Ce comportement est désormais corrigé, de sorte que ces instructions déjà prises en charge ne sont plus synthétisées.

• La passe de transpilation InverseCancellation s'exécute désormais à l'intérieur de blocs de flux de contrôle. Auparavant, il ignorait les paires de portes qui pouvaient être annulées lorsqu'elles étaient définies dans des blocs classiques. Voir #13437 pour plus de détails.

• Correction d'un bug avec les rotations multi-contrôlées où l'angle de rotation était un ParameterExpression. Une tentative de synthèse dans ce cas entraînerait une erreur indiquant que la porte ne peut pas être synthétisée avec un paramètre non lié. Ce bogue affectait les méthodes de circuits de rotation multicontrôlés QuantumCircuit.mcrx(), :meth:.QuantumCircuit.mcry, et QuantumCircuit.mcrz()ainsi que lors de l'appel de RXGate.control(), RYGate.control()ou RZGate.control() lorsque l'angle de rotation était un ParameterExpression. Désormais, ces circuits de rotation multicontrôlés peuvent être synthétisés sans soulever d'erreur.

• Correction d'un bogue dans QPY (qiskit.qpy) où les circuits contenant des portes de classe MCMTGate ne parvenaient pas à se sérialiser. Voir #13965.

• Correction d'un bogue qui faisait que Statevector.expectation_value() de produire des résultats incorrects pour l'opérateur d'identité lorsque le vecteur d'état n'était pas normalisé. Corrigé #13029

• La conversion d'un circuit quantique en une porte avec converters.circuit_to_instruction() échoue désormais correctement lorsque le circuit donné contient des instructions de flux de contrôle.

• Appeler un AnalysisPass ou un TransformationPass comme une fonction (comme dans pass_ = MyPass(); pass_(qc)) respectera désormais toutes les exigences que la passe pourrait avoir. Par exemple, les passes de programmation telles que ALAPScheduleAnalysis exige que TimeUnitConversion s'exécute avant elles. L'exécution de la passe à l'aide d'un PassManager a toujours respecté cette exigence, mais jusqu'à présent, elle n'était pas respectée lors de l'appel direct de la passe.

• Lorsqu'une TranspilerError est levée par une passe à l'intérieur d'un appel à PassManger.run(), l'exception sera désormais propagée sans perte, plutôt que de devenir une exception chaînée avec un type effacé.

• SabreSwap ne contractera plus les fils de qubits inactifs hors des blocs de flux de contrôle pendant le routage. Il s'agit généralement d'une optimisation valable, mais qui n'est pas un effet secondaire attendu d'une passe de routage. Vous pouvez maintenant utiliser la passe ContractIdleWiresInControlFlow pour effectuer cette contraction.

• Correction d'un non-déterminisme basé sur un processus dans SparsePauliOp.to_matrix. L'ordre exact des opérations en virgule flottante dans la sommation variait auparavant en fonction du processus, mais il sera désormais identique entre les différentes invocations du même script. Voir #13413.