Notes de publication de Qiskit 0.44

---

Historique des versions

Il s'agit de la dernière version dans laquelle qiskit était un "méta-paquet", qui contenait plusieurs "éléments" différents. Ce qui est appelé "Qiskit Terra" dans cette note de mise à jour (et dans les précédentes) est principalement ce qui est maintenant appelé "Qiskit".

Ce tableau indique les versions des méta-paquets et la version de chaque élément Qiskit installé :

---

0.44.1

Terra 0.25.1

Prélude

Qiskit Terra 0.25.1 est une version de correction de bogues, abordant certains problèmes identifiés depuis la version 0.25.1.

Corrections des erreurs

• Correction d'un bogue dans la sérialisation QPY (qiskit.qpy) où plusieurs portes personnalisées contrôlées dans un circuit pouvaient donner lieu à un fichier QPY invalide qui ne pouvait pas être analysé. Correction #9746.

• Correction de #9363. en étiquetant les synthèses sans registre dans l'ordre de retour de Tweedledum. Par exemple, comparez cet exemple avant et après la correction :

  from qiskit.circuit import QuantumCircuit
  from qiskit.circuit.classicalfunction import BooleanExpression
  
  boolean_exp = BooleanExpression.from_dimacs_file("simple_v3_c2.cnf")
  circuit = QuantumCircuit(boolean_exp.num_qubits)
  circuit.append(boolean_exp, range(boolean_exp.num_qubits))
  circuit.draw("text")
  
  from qiskit.circuit.classicalfunction import classical_function
  from qiskit.circuit.classicalfunction.types import Int1
  
  @classical_function
  def grover_oracle(a: Int1, b: Int1, c: Int1) -> Int1:
      return (a and b and not c)
  
  quantum_circuit = grover_oracle.synth(registerless=False)
  print(quantum_circuit.draw())

  Ce qui imprimerait

       Before             After
  
       c: ──■──           a: ──■──
            │                  │
       b: ──■──           b: ──■──
            │                  │
       a: ──o──           c: ──o──
          ┌─┴─┐              ┌─┴─┐
  return: ┤ X ├      return: ┤ X ├
          └───┘              └───┘

• Correction de plot_state_paulivec(), qui amortissait auparavant les coefficients d'état par un facteur de $2^n$, où $n$ est le nombre de qubits. Le graphique à barres affiche maintenant correctement les coefficients sous la forme $\mathrm{Tr}(\sigma\rho)$, où $\rho$ est l'état à représenter et $\sigma$ itère sur tous les produits tensoriels possibles de Paulis à un seul qubit.

• Les angles dans l'exportateur OpenQASM 2 (QuantumCircuit.qasm()) incluront désormais toujours un point décimal, par exemple dans le cas de 1.e-5. C'est ce qu'exige une interprétation stricte de la spécification de la virgule flottante littérale dans OpenQASM 2. L'analyseur de OpenQASM 2 de Qiskit (qasm2.load() et loads()) est plus permissif par défaut et autorise 1e-5 sans le point décimal, sauf en mode strict .

• Le setter de SparsePauliOp.paulis rejette désormais correctement les tentatives de définition de l'attribut avec des données de forme incorrecte, au lieu d'autoriser silencieusement la création d'un objet invalide. Voir #10384.

• Correction d'une régression de performance dans les SabreLayout et SabreSwap dans les passes du transpileur. Corrigé #10650

---

0.44.0

Cette version marque officiellement la fin du support du package Qiskit IBMQ Provider et le retrait de Qiskit Aer du métapackage Qiskit. Après cette version, le métapackage ne contient plus que Qiskit Terra, c'est donc la dernière version pour laquelle nous ferons référence au métapackage Qiskit et à Qiskit Terra en tant qu'éléments distincts. A partir de la prochaine version de Qiskit 0.45.0, le paquet Qiskit sera simplement ce qui était auparavant Qiskit Terra et il n'y aura plus de séparation entre les deux.

Si vous utilisez encore le paquet qiskit-ibmq-provider , il a été retiré et n'est plus pris en charge. Vous devez suivre les liens vers les guides de migration dans le README du paquet pour savoir comment passer aux nouveaux paquets de remplacement qiskit-ibm-provider, qiskit-ibm-runtime, et qiskit-ibm-experiment:

https://github.com/Qiskit/qiskit-ibmq-provider#migration-guides

Le projet Qiskit Aer est toujours actif et maintenu, mais il n'est plus inclus dans le paquet qiskit . Pour continuer à utiliser qiskit-aer , vous devrez installer explicitement qiskit-aer et importer le paquet de qiskit_aer.

Comme il s'agit de la version finale du métapackage Qiskit, les extras setuptools suivants utilisés pour installer les dépendances optionnelles ne fonctionneront plus dans la prochaine version de Qiskit 0.45.0:

• nature
• machine-learning
• finance
• optimization
• experiments

Si vous utilisez les extras pour installer des paquets, vous devriez migrer vers l'utilisation directe des paquets au lieu des extras. Par exemple, si vous utilisiez pip install qiskit[experiments] auparavant, vous devez passer à pip install qiskit qiskit-experiments pour installer les deux paquets. De même, l'extra all (qui est installé via pip install "qiskit[all]") n'inclura plus ces paquets dans Qiskit 0.45.0.

Terra 0.25.0

Prélude

Les points forts de la version Qiskit Terra 0.25.0 sont les suivants :

• Les opérations de flux de contrôle sont désormais prises en charge par le transpileur à tous les niveaux d'optimisation, y compris les niveaux 2 et 3 (par exemple, l'appel à transpile() ou generate_preset_pass_manager() avec le mot-clé optimization_level spécifié comme étant 2 ou 3 est maintenant pris en charge).

• Les champs IfElseOp.condition, WhileLoopOp.condition et SwitchCaseOp.target peuvent désormais être des instances du nouveau type d'expression classique d'exécution expr.Expr. Il se distingue de ParameterExpression car elle est évaluée au moment de l'exécution pour les backends qui prennent en charge de telles opérations.

  Ces nouvelles expressions sont beaucoup plus puissantes que l'ancienne forme à deux couples de conditions classiques. Par exemple, il est désormais possible de représenter les contraintes d'égalité entre deux registres classiques différents, ou le "ou" logique de deux bits classiques. Ces deux exemples se présentent comme suit :

  from qiskit.circuit import QuantumCircuit, ClassicalRegister, QuantumRegister
  from qiskit.circuit.classical import expr
  
  qr = QuantumRegister(4)
  cr1 = ClassicalRegister(2)
  cr2 = ClassicalRegister(2)
  qc = QuantumCircuit(qr, cr1, cr2)
  qc.h(0)
  qc.cx(0, 1)
  qc.h(2)
  qc.cx(2, 3)
  qc.measure([0, 1, 2, 3], [0, 1, 2, 3])
  
  # If the two registers are equal to each other.
  with qc.if_test(expr.equal(cr1, cr2)):
    qc.x(0)
  
  # While either of two bits are set.
  with qc.while_loop(expr.logic_or(cr1[0], cr1[1])):
    qc.reset(0)
    qc.reset(1)
    qc.measure([0, 1], cr1)

  Pour plus d'exemples, voir la documentation de qiskit.circuit.classical.

  Cette fonctionnalité est nouvelle à la fois pour Qiskit et pour le matériel quantique disponible avec lequel Qiskit fonctionne. Comme les fonctionnalités sont encore en cours de développement, il est probable qu'il y ait des cas limites inattendus qui nécessiteront un certain temps pour être résolus. Si vous rencontrez un problème concernant le support ou l'utilisation de l'expression classique, veuillez ouvrir un dossier auprès de Qiskit ou de votre fournisseur de matériel.

  Dans cette première version, Qiskit a ajouté les opérations :

  • bit_not()
  • logic_not()
  • bit_and()
  • bit_or()
  • bit_xor()
  • logic_and()
  • logic_or()
  • equal()
  • not_equal()
  • less()
  • less_equal()
  • greater()
  • greater_equal()

  Elles peuvent agir sur Python, sur les entiers et les booléens, ou sur ClassicalRegister et Clbit instances.

  Toutes ces expressions classiques sont entièrement prises en charge par la pile de transposition Qiskit, par la sérialisation QPY (qiskit.qpy) et pour l'exportation vers OpenQASM 3 (qiskit.qasm3). L'importation depuis OpenQASM 3 est actuellement gérée par un paquetage séparé (qui est réexposé via qiskit.qasm3), qui, nous l'espérons, sera étendu pour correspondre aux nouvelles fonctionnalités de Qiskit.

• Le module qiskit.algorithms est obsolète et sera supprimé dans une prochaine version. Elle a été remplacée par une nouvelle bibliothèque autonome qiskit-algorithms qui peut être trouvée sur PyPi ou sur Github ici :

  https://github.com/qiskit-community/qiskit-algorithms

  Le module qiskit.algorithms continuera à fonctionner comme avant et des corrections de bogues y seront apportées jusqu'à son retrait futur, mais le développement actif de nouvelles fonctionnalités a été déplacé vers le nouveau paquet. Si vous vous appuyez sur qiskit.algorithms vous devez mettre à jour vos exigences pour Python afin d'inclure également qiskit-algorithms et mettre à jour les importations de qiskit.algorithms vers qiskit_algorithms. Veuillez noter que ce nouveau paquet n'inclut pas le code des algorithmes déjà obsolètes, y compris les algorithmes basés sur opflow et QuantumInstance. Si vous n'avez pas encore migré des algorithmes basés sur QuantumInstance aux algorithmes basés sur les primitives, vous devez suivre les directives de migration dans https://qisk.it/algo _migration. La décision de migrer le module algorithms dans un paquet séparé a été prise afin de clarifier l'objectif de Qiskit et de faire une distinction entre les outils et les bibliothèques construits au-dessus de lui.

Qiskit Terra 0.25 a abandonné la prise en charge de Python 3.7 suite aux avertissements de dépréciation lancés dans Qiskit Terra 0.23. Ceci est cohérent avec la fin de vie de Python 3.7’s le 27 juin 2023. Pour continuer à utiliser Qiskit, vous devez passer à une version plus récente de Python.

Nouvelles fonctions

• Les fonctionnalités suivantes ont été ajoutées dans cette version.

Fonctionnalités du transpilateur

• Deux nouvelles options ont été ajoutées à BlockCollector.

  La première nouvelle option split_layers permet de diviser les blocs collectés en sous-blocs sur des sous-ensembles de qubits disjoints, c'est-à-dire en sous-blocs depth-1.

  La deuxième nouvelle option collect_from_back permet de collecter des blocs avec avidité à partir des sorties du circuit. Ceci est important en combinaison avec les passes de programmation ALAP où l'on peut préférer placer les portes dans les blocs les plus tardifs plutôt que les plus précoces.

• Ajout de nouvelles options split_layers et collect_from_back à CollectLinearFunctions et CollectCliffords transpiler passes.

  Lorsque split_layers est vrai, les blocs collectés sont divisés en sous-blocs sur des sous-ensembles de qubits disjoints, c'est-à-dire en sous-blocs depth-1. Prenons l'exemple suivant :

  from qiskit.circuit import QuantumCircuit
  from qiskit.transpiler.passes import CollectLinearFunctions
  
  circuit = QuantumCircuit(5)
  circuit.cx(0, 2)
  circuit.cx(1, 4)
  circuit.cx(2, 0)
  circuit.cx(0, 3)
  circuit.swap(3, 2)
  circuit.swap(4, 1)
  
  # Collect all linear gates, without splitting into layers
  qct = CollectLinearFunctions(split_blocks=False, min_block_size=1, split_layers=False)(circuit)
  assert qct.count_ops()["linear_function"] == 1
  
  # Collect all linear gates, with splitting into layers
  qct = CollectLinearFunctions(split_blocks=False, min_block_size=1, split_layers=True)(circuit)
  assert qct.count_ops()["linear_function"] == 4

  Le circuit original est linéaire. Lorsque l'on rassemble des portes linéaires sans les diviser en couches, on devrait obtenir une seule fonction linéaire. Cependant, en rassemblant les portes linéaires et en les divisant en couches, nous devrions obtenir 4 fonctions linéaires.

  Lorsque collect_from_back est vrai, les blocs sont collectés avec avidité des sorties vers les entrées du circuit. Prenons l'exemple suivant :

  from qiskit.circuit import QuantumCircuit
  from qiskit.transpiler.passes import CollectLinearFunctions
  
  circuit = QuantumCircuit(3)
  circuit.cx(1, 2)
  circuit.cx(1, 0)
  circuit.h(2)
  circuit.swap(1, 2)
  
  # This combines the CX(1, 2) and CX(1, 0) gates into a single linear function
  qct = CollectLinearFunctions(collect_from_back=False)(circuit)
  
  # This combines the CX(1, 0) and SWAP(1, 2) gates into a single linear function
  qct = CollectLinearFunctions(collect_from_back=True)(circuit)

  Le circuit original contient une porte de Hadamard, de sorte que la porte CX(1, 0) peut être combinée soit avec CX(1, 2), soit avec SWAP(1, 2), mais pas avec les deux. Lorsque collect_from_back est Faux, les blocs linéaires sont collectés avec avidité depuis le début du circuit, et donc CX(1, 0) est combiné avec CX(1, 2). Lorsque collect_from_back est vrai, les blocs linéaires sont collectés avec avidité à l'extrémité du circuit, et donc CX(1, 0) est combiné avec SWAP(1, 2).

• Ajouté DAGCircuit.classical_predecessors() et DAGCircuit.classical_successors()une alternative à la sélection des fils classiques qui ne nécessite pas d'accéder directement au graphe interne d'un nœud du DAG. L'exemple suivant illustre la nouvelle fonctionnalité :

  from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
  from qiskit.converters import circuit_to_dag
  from qiskit.circuit.library import RZGate
  
  q = QuantumRegister(3, 'q')
  c = ClassicalRegister(3, 'c')
  circ = QuantumCircuit(q, c)
  circ.h(q[0])
  circ.cx(q[0], q[1])
  circ.measure(q[0], c[0])
  circ.rz(0.5, q[1]).c_if(c, 2)
  circ.measure(q[1], c[0])
  dag = circuit_to_dag(circ)
  
  rz_node = dag.op_nodes(RZGate)[0]
  # Contains the "measure" on clbit 0, and the "wire start" nodes for clbits 1 and 2.
  classical_predecessors = list(dag.classical_predecessors(rz_node))
  # Contains the "measure" on clbit 0, and the "wire end" nodes for clbits 1 and 2.
  classical_successors = list(dag.classical_successors(rz_node))

• A permis de soutenir ControlFlowOp dans la passe CommutativeCancellation passer. Auparavant, les blocs dans les opérations de flux de contrôle étaient ignorés par cette passe.

• A permis de soutenir ControlFlowOp dans la passe ConsolidateBlocks passer.

• Ajouté DAGCircuit.quantum_causal_cone() pour obtenir le cône de causalité d'un qubit dans un espace de travail DAGCircuit. L'exemple suivant montre son utilisation correcte :

  from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
  from qiskit.circuit.library import CXGate, CZGate
  from qiskit.dagcircuit import DAGCircuit
  
  # Build a DAGCircuit
  dag = DAGCircuit()
  qreg = QuantumRegister(5)
  creg = ClassicalRegister(5)
  dag.add_qreg(qreg)
  dag.add_creg(creg)
  dag.apply_operation_back(CXGate(), qreg[[1, 2]], [])
  dag.apply_operation_back(CXGate(), qreg[[0, 3]], [])
  dag.apply_operation_back(CZGate(), qreg[[1, 4]], [])
  dag.apply_operation_back(CZGate(), qreg[[2, 4]], [])
  dag.apply_operation_back(CXGate(), qreg[[3, 4]], [])
  
  # Get the causal cone of qubit at index 0
  result = dag.quantum_causal_cone(qreg[0])

• Une nouvelle méthode find_bit() a été ajoutée à la classe DAGCircuit qui renvoie l'emplacement des bits de l'élément Qubit ou Clbit sous la forme d'un tuple comprenant l'indice de position du bit dans le circuit et une liste de tuples qui localisent le bit dans les registres du circuit.

• La fonction intégrée du transpondeur EquivalenceLibrary (qiskit.circuit.equivalence_library.SessionEquivalenceLibrary) a appris les relations de Pauli circulaires $X = iYZ$, $Y = iZX$ et $Z = iXY$. Cela devrait rendre plus fiable la transposition vers des ensembles de bases contraints et potentiellement incomplets. Voir #10293 pour plus de détails.

• Les opérations de flux de contrôle sont désormais prises en charge par le transpileur à tous les niveaux d'optimisation, y compris les niveaux 2 et 3 (par exemple, l'appel à transpile() ou generate_preset_pass_manager() avec le mot-clé optimization_level=3).

• DAGCircuit.substitute_node() a gagné un argument de mot-clé propagate_condition qui est analogue au même argument dans substitute_node_with_dag(). En définissant cette valeur sur False , on renonce à l'ancien comportement qui consiste à copier une condition de node sur le nouveau op qui le remplace.

  Cette option est ignorée pour les opérations générales de flux de contrôle, qui ne propageront jamais leur condition, ni n'accepteront de condition de la part d'un autre nœud.

• Introduction d'une nouvelle méthode, DAGCircuit.separable_circuits()qui renvoie une liste d'objets DAGCircuit un pour chaque ensemble de qubits connectés qui n'ont pas de portes les reliant à un autre ensemble.

  Chaque instance DAGCircuit renvoyée par cette méthode contiendra le même nombre de clbits que self. Cette méthode ne renvoie pas DAGCircuit constituées uniquement de clbits.

• Ajout de l'attribut Target.concurrent_measurements qui représente une contrainte matérielle de qubits mesurés simultanément. Cette contrainte est fournie sous la forme d'une liste imbriquée, dans laquelle chaque élément représente un groupe de qubits à mesurer ensemble. Dans l'exemple ci-dessous :

  [[0, 1], [2, 3, 4]]

  les qubits 0 et 1, et 2, 3 et 4 sont mesurés ensemble sur l'appareil. Cette contrainte ne bloque pas la mesure d'un qubit individuel, mais vous devrez peut-être prendre en compte l'alignement des opérations de mesure pour ces qubits lorsque vous travaillez avec l' ordonnanceur Qiskit Pulse et lorsque vous créez de nouvelles passes de transpilation qui tiennent compte du temps (c'est-à-dire des passes qui effectuent l'ordonnancement).

• La passe de transposition SetLayout peut maintenant être construit avec une liste d'entiers qui représentent les qubits physiques sur lesquels le circuit quantique sera mappé. En d'autres termes, le premier qubit du circuit sera attribué au qubit physique en position zéro de la liste, et ainsi de suite.

• La fonction intégrée du transpileur EquivalenceLibrary a été enseigné plus d'équivalences de rotation de Paul entre les portes à un qubit $R_X$, $R_Y$ et $R_Z$, et entre les portes à deux qubits $R_{XX}$, $R_{YY}$ et $R_{ZZ}$. Cela devrait rendre les traductions de bases simples plus fiables, en particulier les circuits qui utilisent les rotations $Y$. Voir #7332.

• Les opérations de flux de contrôle sont désormais prises en charge par les passes de transposition de la famille Sabre, à savoir la passe de mise en page SabreLayout et la passe de routage SabreSwap. Fonction transpile() les arguments du mot-clé layout_method et routing_method acceptent désormais l'option "sabre" pour les circuits avec flux de contrôle, ce qui n'était pas le cas auparavant.

Caractéristiques des circuits

• Les champs IfElseOp.condition, WhileLoopOp.condition et SwitchCaseOp.target peuvent désormais être des instances du nouveau type d'expression classique d'exécution expr.Expr. Il se distingue de ParameterExpression car elle est évaluée au moment de l'exécution pour les backends qui prennent en charge de telles opérations.

  Ces nouvelles expressions sont beaucoup plus puissantes que l'ancienne forme à deux couples de conditions classiques. Par exemple, il est désormais possible de représenter les contraintes d'égalité entre deux registres classiques différents, ou le "ou" logique de deux bits classiques. Ces deux exemples se présentent comme suit :

  from qiskit.circuit import QuantumCircuit, ClassicalRegister, QuantumRegister
  from qiskit.circuit.classical import expr
  
  qr = QuantumRegister(4)
  cr1 = ClassicalRegister(2)
  cr2 = ClassicalRegister(2)
  qc = QuantumCircuit(qr, cr1, cr2)
  qc.h(0)
  qc.cx(0, 1)
  qc.h(2)
  qc.cx(2, 3)
  qc.measure([0, 1, 2, 3], [0, 1, 2, 3])
  
  # If the two registers are equal to each other.
  with qc.if_test(expr.equal(cr1, cr2)):
    qc.x(0)
  
  # While either of two bits are set.
  with qc.while_loop(expr.logic_or(cr1[0], cr1[1])):
    qc.reset(0)
    qc.reset(1)
    qc.measure([0, 1], cr1)

  Pour plus d'exemples, voir la documentation de qiskit.circuit.classical.

  Cette fonctionnalité est nouvelle à la fois pour Qiskit et pour le matériel quantique disponible avec lequel Qiskit fonctionne. Comme les fonctionnalités sont encore en cours de développement, il est probable qu'il y ait des cas limites inattendus qui nécessiteront un certain temps pour être résolus. Si vous rencontrez un problème concernant le support ou l'utilisation de l'expression classique, veuillez ouvrir un dossier auprès de Qiskit ou de votre fournisseur de matériel.

  Dans cette première version, Qiskit a ajouté les opérations :

  • bit_not()
  • logic_not()
  • bit_and()
  • bit_or()
  • bit_xor()
  • logic_and()
  • logic_or()
  • equal()
  • not_equal()
  • less()
  • less_equal()
  • greater()
  • greater_equal()

  Elles peuvent agir sur Python, sur les entiers et les booléens, ou sur ClassicalRegister et Clbit instances.

  Toutes ces expressions classiques sont entièrement prises en charge par la pile de transposition Qiskit, par la sérialisation QPY (qiskit.qpy) et pour l'exportation vers OpenQASM 3 (qiskit.qasm3). L'importation depuis OpenQASM 3 est actuellement gérée par un paquetage séparé (qui est réexposé via qiskit.qasm3), qui, nous l'espérons, sera étendu pour correspondre aux nouvelles fonctionnalités de Qiskit.

• Des outils permettant de travailler avec les nouvelles représentations des expressions d'exécution classiques ont été ajoutés. Une sous-classe générale ExprVisitor est fournie pour que les consommateurs de ces expressions puissent les sous-classer. Deux services publics basés sur cette structure, iter_vars() et structurally_equivalent()sont également fournis, qui produisent respectivement un itérateur à travers les nœuds Var et vérifient si deux instances de Expr sont structurellement identiques, jusqu'à une certaine mise en correspondance des Var contenus.

• Fonction ajoutée lift_legacy_condition() qui peut être utilisée pour convertir des conditions de l'ancien style en nœuds du nouveau style Expr nouveaux. Notez que ces nœuds d'expression ne sont pas autorisés dans les champs de type ancien Instruction.condition qui doivent être remplacés par des traitements classiques plus avancés tels que IfElseOp.

• Ajout de la prise en charge des valeurs absolues de ParameterExpressions. Par exemple, il est désormais possible de faire ce qui suit :

  from qiskit.circuit import QuantumCircuit, Parameter
  
  x = Parameter("x")
  circuit = QuantumCircuit(1)
  circuit.rx(abs(x), 0)
  
  bound = circuit.bind_parameters({x: -1})

• Les performances de QuantumCircuit.assign_parameters() et bind_parameters() ont augmenté de manière significative pour les grands circuits avec des structures typiques des applications utilisées. Cela inclut la plupart des circuits basés sur la NLocal structure, tels que EfficientSU2. Voir #10282 pour plus de détails.

• La méthode QuantumCircuit.assign_parameters() a gagné deux nouveaux mots-clés : flat_input et strict. Il s'agit d'options avancées qui peuvent être utilisées pour accélérer la méthode lorsque les liaisons de paramètres sont transmises sous forme de dictionnaire; flat_input=True garantit que les clés du dictionnaire ne contiennent que des instances de Parameter (et non des ParameterVector), et strict=False permet au dictionnaire de contenir des paramètres qui ne sont pas présents dans le circuit. L'utilisation de ces deux options permet de réduire la charge de travail liée à la normalisation des entrées dans cette fonction.

• Ajout d'un nouveau mot-clé flatten dans le constructeur des classes suivantes :

  • EfficientSU2
  • ExcitationPreserving
  • NLocal
  • RealAmplitudes
  • TwoLocal
  • EvolvedOperatorAnsatz
  • QAOAAnsatz

  Si cet argument est défini à True , la sous-classe QuantumCircuit générée n'enveloppera pas l'implémentation en Gate ou Instruction dans des objets de type "ou". Bien que cela ne soit pas optimal pour la visualisation, il en résulte généralement de bien meilleures performances d'exécution, en particulier avec QuantumCircuit.bind_parameters() et QuantumCircuit.assign_parameters() qui peut voir une amélioration substantielle de la durée d'exécution avec une sortie aplatie par rapport à la sortie par défaut imbriquée et enveloppée.

• Ajout d'un support pour la construction de LinearFunctionà partir de circuits quantiques plus généraux, qui peuvent contenir :

  • Obstacles (de type Barrier) et les retards (Delay), qui sont simplement ignorés
  • Permutations (de type PermutationGate)
  • Autres fonctions linéaires
  • Cliffords (de type Clifford), lorsque le Clifford représente une fonction linéaire (et une exception CircuitError est levée si ce n'est pas le cas)
  • Circuits quantiques imbriqués de cette forme

• Ajout de la méthode LinearFunction.__eq__() . Deux objets de type LinearFunction sont considérés comme égaux lorsque leurs représentations sous forme de matrices inversibles binaires sont égales.

• Méthode ajoutée LinearFunction.extend_with_identity() qui permet d'étendre une fonction linéaire sur k qubits à une fonction linéaire sur n >= k qubits, en spécifiant les nouvelles positions des qubits originaux et en complétant avec des identités sur les qubits restants.

• Ajout de deux méthodes pour l'impression d'objets LinearFunction qui renvoie la représentation sous forme de chaîne de la fonction linéaire vue comme une matrice avec des entrées 0/1, et LinearFunction.mat_str()qui renvoie la représentation sous forme de chaîne de caractères de la fonction linéaire vue comme une matrice avec des entrées 0/1, et LinearFunction.function_str()qui renvoie la représentation sous forme de chaîne de caractères de la fonction linéaire considérée comme une transformation linéaire.

• Les instructions StatePreparation et Initialize, ainsi que les méthodes de circuit qui leur sont associées QuantumCircuit.prepare_state() et initialize()ont obtenu un argument de mot-clé normalize, qui peut être défini à True pour normaliser automatiquement une cible de tableau. Par défaut, il s'agit de False, ce qui conserve le comportement actuel qui consiste à lever une exception lorsque l'entrée n'est pas normalisée.

Caractéristiques des algorithmes

• Ajout de l'option permettant de passer un callback à l'optimiseur UMDA qui permet de suivre le nombre d'évaluations de la fonction, les paramètres actuels et la meilleure valeur de la fonction obtenue.

OpenQASM Caractéristiques

• Le site OpenQASM 3 exportateurs (qasm3.dump(), dumps() et Exporter) ont un nouvel argument allow_aliasing , qui remplacera éventuellement l'argument alias_classical_registers . Cela permet de contrôler si l'aliasing est autorisé pour les bits classiques ou les qubits, au lieu que l'option ne soit disponible que pour les bits classiques.

Caractéristiques de l'information quantique

• Ajout d'une nouvelle fonction negativity() qui calcule la mesure d'intrication de la négativité d'un état quantique. Un exemple d'utilisation de la fonction ci-dessus est donné ci-dessous :

  from qiskit.quantum_info.states.densitymatrix import DensityMatrix
  from qiskit.quantum_info.states.statevector import Statevector
  from qiskit.quantum_info import negativity
  import numpy as np
  
  # Constructing a two-qubit bell state vector
  state = np.array([0, 1/np.sqrt(2), -1/np.sqrt(2), 0])
  # Calculating negativity of statevector
  negv = negativity(Statevector(state), [1])
  
  # Creating the Density Matrix (DM)
  rho = DensityMatrix.from_label("10+")
  # Calculating negativity of DM
  negv2 = negativity(rho, [0, 1])

• Ajout de la fonction schmidt_decomposition(). Cette fonction fonctionne avec les Statevector et DensityMatrix pour les états purs bipartites.

• Prise en charge de la multiplication d'objets SparsePauliOp objets avec Parameter en utilisant l'opérateur *, par exemple :

  from qiskit.circuit import Parameter
  from qiskit.quantum_info import SparsePauliOp
  
  param = Parameter("a")
  op = SparsePauliOp("X")
  param * op

Fonctionnalités Pulse

• La SymbolicPulse la bibliothèque a été agrandie. Les nouvelles fonctions d'impulsion de la bibliothèque sont les suivantes

  • GaussianDeriv()
  • Sech()
  • SechDeriv()
  • Square()

  Les nouvelles fonctions renvoient une instance ScalableSymbolicPulse et correspondent aux fonctions correspondantes de la bibliothèque des impulsions discrètes, à l'exception de Square() pour laquelle une phase de $2\pi$ se décale d'un cycle complet (contrairement à la fonction discrète square() où un tel décalage était induit par une phase de $\pi$ ).

• La méthode filter() est activée dans la ScheduleBlock classe. Cette méthode permet aux utilisateurs de ne conserver que les Instruction les objets qui passent à travers tous les filtres fournis. En tant que conditions de filtrage intégrées, l'instance de sous-classe pulse Channel et le type de sous-classe Instruction peuvent être spécifiées. Des rappels définis par l'utilisateur, prenant l'exemple de Instruction peuvent également être ajoutés aux filtres.

• La méthode exclude() est activée dans la ScheduleBlock classe. Cette méthode permet aux utilisateurs de ne conserver que Instruction les objets qui ne satisfont pas à au moins un des filtres fournis. En tant que conditions de filtrage intégrées, l'instance de sous-classe pulse Channel et le type de sous-classe Instruction peuvent être spécifiées. Des rappels définis par l'utilisateur, prenant l'exemple de Instruction peuvent également être ajoutés aux filtres. Cette méthode est le complément de filter(), de sorte que la condition suivante est toujours satisfaite : block.filter(*filters) + block.exclude(*filters) == block en termes d'instructions incluses, où block est une ScheduleBlock exemple.

• Ajout d'une nouvelle fonction gaussian_square_echo() à la bibliothèque d'impulsions. L'impulsion renvoyée est composée de trois GaussianSquare impulsions. Les deux premières sont des impulsions d'écho d'une durée égale à la moitié de la durée totale et mettent en œuvre des tonalités rotatives. La troisième impulsion est une tonalité d'annulation qui dure toute la durée de l'impulsion et qui corrige les rotations d'un qubit unique.

• QPY prend en charge les objets Discriminator et Kernel . Cette fonction permet aux utilisateurs de sérialiser et de désérialiser les instructions avec ces objets à l'aide de QPY Acquire instructions avec ces objets en utilisant QPY.

Caractéristiques de la synthèse

• Ajout d'une nouvelle fonction de synthèse synth_cx_cz_depth_line_my() qui produit la forme d'un circuit CX suivi d'un circuit CZ pour la connectivité linéaire du plus proche voisin (LNN) dans une profondeur de 2 qubits d'au plus 5n, en utilisant CX et des portes de phase (S, Sdg ou Z). L'algorithme de synthèse est basé sur l'article de Maslov et Yang, arXiv:2210.16195.

  L'algorithme accepte une matrice inversible binaire mat_x représentant le circuit CX, une matrice symétrique binaire mat_z représentant le circuit CZ, et renvoie un circuit quantique avec une profondeur de 2 qubits d'au plus 5n calculant la composition des circuits CX et CZ. L'exemple suivant illustre la nouvelle fonctionnalité :

  import numpy as np
  from qiskit.synthesis.linear_phase import synth_cx_cz_depth_line_my
  mat_x = np.array([[0, 1], [1, 1]])
  mat_z = np.array([[0, 1], [1, 0]])
  qc = synth_cx_cz_depth_line_my(mat_x, mat_z)

  Cette fonction est désormais utilisée par défaut dans l'algorithme de synthèse Clifford synth_clifford_depth_lnn() qui optimise la profondeur de 2 qubits pour la connectivité LNN, en améliorant la profondeur de 2 qubits de 9n+4 à 7n+2. L'algorithme de synthèse de Clifford peut être utilisé comme suit :

  from qiskit.quantum_info import random_clifford
  from qiskit.synthesis import synth_clifford_depth_lnn
  
  cliff = random_clifford(3)
  qc = synth_clifford_depth_lnn(cliff)

  La synthèse ci-dessus peut être encore améliorée comme décrit dans l'article de Maslov et Yang, en utilisant l'optimisation locale entre les couches de 2 qubits. Cette amélioration fera l'objet d'un travail ultérieur.

Fonctionnalités de visualisation

• QuantumCircuit.draw() et la fonction circuit_drawer() lors de l'utilisation de l'option output='mpl' permet désormais de dessiner les blocs de circuits imbriqués de ControlFlowOp y compris if, else, while, for, et switch/case. Les blocs de circuits sont entourés de boîtes pour délimiter les circuits.

• Certaines restrictions concernant l'utilisation de wire_order dans les tiroirs de circuits ont été assouplies. Maintenant, wire_order peut répertorier uniquement des qubits et, dans ce cas, il peut être utilisé avec cregbundle=True, puisqu'il n'affectera pas les bits classiques.

  from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
  
  qr = QuantumRegister(4, "q")
  cr = ClassicalRegister(4, "c")
  cr2 = ClassicalRegister(2, "ca")
  circuit = QuantumCircuit(qr, cr, cr2)
  circuit.h(0)
  circuit.h(3)
  circuit.x(1)
  circuit.x(3).c_if(cr, 10)
  circuit.draw('text', wire_order=[2, 3, 0, 1], cregbundle=True)

   q_2: ────────────
        ┌───┐ ┌───┐
   q_3: ┤ H ├─┤ X ├─
        ├───┤ └─╥─┘
   q_0: ┤ H ├───╫───
        ├───┤   ║
   q_1: ┤ X ├───╫───
        └───┘┌──╨──┐
   c: 4/═════╡ 0xa ╞
             └─────┘
  ca: 2/════════════

Divers. Fonctions

• Un nouveau testeur d'importation paresseuse, HAS_PYGMENTSest disponible pour tester la présence de la bibliothèque de coloration syntaxique Pygments.

• La magie %qiskit_version_table de qiskit.tools.jupyter inclut désormais tous les modules importés dont le nom contient qiskit .

Mise à niveau

• Qiskit Terra 0.25 a abandonné la prise en charge de Python 3.7 suite aux avertissements de dépréciation lancés dans Qiskit Terra 0.23. Ceci est cohérent avec la fin de vie de Python 3.7’s le 27 juin 2023. Pour continuer à utiliser Qiskit, vous devez passer à une version plus récente de Python.

• Qiskit Terra 0.25 nécessite désormais la version 0.13.0 de rustworkx.

• Par défaut, Qiskit construit ses extensions compilées en utilisant l' ABI Python Stable avec un support remontant à la plus ancienne version de Python supportée par Qiskit (actuellement 3.8 ). Cela signifie qu'à l'avenir, il y aura une seule roue précompilée qui sera livrée à la sortie et qui fonctionnera avec toutes les versions de Qiskit supportées par Python. Il n'y a pas de différence de performance d'exécution attendue en utilisant l'API limitée, c'est pourquoi elle est activée par défaut pour toutes les versions. Auparavant, les extensions compilées étaient construites à l'aide de l'API spécifique à la version et ne fonctionnaient qu'avec une seule version de Python. Ce changement a été effectué pour réduire le nombre de fichiers de paquets que nous devons construire et publier dans chaque version. Lors de la construction de Qiskit à partir des sources, aucune modification ne devrait être apportée au processus de construction, si ce n'est que les balises par défaut dans les noms de fichiers de sortie seront différentes afin de refléter l'utilisation de l'API limitée.

Notes de mise à niveau du transpilateur

• La prise en charge du passage de listes de valeurs d'arguments à la fonction transpile() est supprimée. Cette fonctionnalité a été supprimée dans le cadre de la version 0.23.0. Vous pouvez toujours transmettre une liste d'objets QuantumCircuit pour le premier argument de position. Ce qui a été supprimé, c'est la diffusion de la liste des autres arguments de chaque circuit dans cette liste d'entrée. La suppression de cette fonctionnalité était nécessaire pour réduire considérablement les frais généraux liés à l'exécution parallèle de la transposition de plusieurs circuits à la fois. Si vous utilisez cette fonctionnalité actuellement, vous pouvez appeler transpile() plusieurs fois à la place. Par exemple, si vous faisiez auparavant quelque chose comme.. :

  from qiskit.transpiler import CouplingMap
  from qiskit import QuantumCircuit
  from qiskit import transpile
  
  qc = QuantumCircuit(2)
  qc.h(0)
  qc.cx(0, 1)
  qc.measure_all()
  
  cmaps = [CouplingMap.from_heavy_hex(d) for d in range(3, 15, 2)]
  results = transpile([qc] * 6, coupling_map=cmaps)

  au lieu de cela, vous devriez maintenant exécuter quelque chose comme :

  from qiskit.transpiler import CouplingMap
  from qiskit import QuantumCircuit
  from qiskit import transpile
  
  qc = QuantumCircuit(2)
  qc.h(0)
  qc.cx(0, 1)
  qc.measure_all()
  
  cmaps = [CouplingMap.from_heavy_hex(d) for d in range(3, 15, 2)]
  results = [transpile(qc, coupling_map=cm) for cm in cmap]

  Vous pouvez également utiliser parallel_map() ou multiprocessing de la bibliothèque standard Python si vous souhaitez exécuter cette opération en parallèle.

• La famille des transpileurs Sabre (à savoir SabreLayout et SabreSwap) sont désormais utilisées par défaut pour tous les circuits lors de l'invocation du transpilateur au niveau d'optimisation 1 (par exemple en appelant transpile() ou generate_preset_pass_manager() avec le mot-clé optimization_level=1). Auparavant, les circuits avec des opérations de flux de contrôle utilisaient DenseLayout et StochasticSwap avec ce profil.

Notes sur la mise à niveau des circuits

• Les méthodes de construction de OpenQASM 2 sur QuantumCircuit (from_qasm_str() et from_qasm_file()) ont été modifiées pour utiliser l'analyseur syntaxique basé sur Rust ajouté dans Qiskit Terra 0.24. Il devrait en résulter des temps d'analyse nettement plus rapides (il n'est pas rare qu'ils soient multipliés par 10 ou plus) et une réduction considérable de l'utilisation de la mémoire intermédiaire.

  Les méthodes QuantumCircuit sont conservées avec la même interface pour des raisons de continuité; la façon préférée d'accéder à l'importateur OpenQASM 2 est d'utiliser qasm2.load() et qasm2.loads()qui offrent une interface élargie pour contrôler l'analyse et la construction.

• L'argument circuit_cregs du constructeur de la classe InstructionSet a été supprimé. Elle a été supprimée dans la version 0.19.0. Si vous utilisez cet argument et construisez manuellement un objet InstructionSet (ce qui devrait être assez rare car il est principalement utilisé en interne), vous devriez passer un appelable à l'argument du mot-clé resource_requester à la place. Par exemple :

  from qiskit.circuit import Clbit, ClassicalRegister, InstructionSet
  from qiskit.circuit.exceptions import CircuitError
  
  def my_requester(bits, registers):
      bits_set = set(bits)
      bits_flat = tuple(bits)
      registers_set = set(registers)
  
      def requester(specifier):
          if isinstance(specifer, Clbit) and specifier in bits_set:
              return specifier
          if isinstance(specifer, ClassicalRegster) and specifier in register_set:
              return specifier
          if isinstance(specifier, int) and 0 <= specifier < len(bits_flat):
              return bits_flat[specifier]
          raise CircuitError(f"Unknown resource: {specifier}")
  
      return requester
  
  my_bits = [Clbit() for _ in [None]*5]
  my_registers = [ClassicalRegister(n) for n in range(3)]
  
  InstructionSet(resource_requester=my_requester(my_bits, my_registers))

OpenQASM Notes de mise à jour

• Les méthodes de construction de OpenQASM 2 sur QuantumCircuit (from_qasm_str() et from_qasm_file()) ont été modifiées pour utiliser l'analyseur syntaxique basé sur Rust ajouté dans Qiskit Terra 0.24. Il devrait en résulter des temps d'analyse nettement plus rapides (il n'est pas rare qu'ils soient multipliés par 10 ou plus) et une réduction considérable de l'utilisation de la mémoire intermédiaire.

  Les méthodes QuantumCircuit sont conservées avec la même interface pour des raisons de continuité; la façon préférée d'accéder à l'importateur OpenQASM 2 est d'utiliser qasm2.load() et qasm2.loads()qui offrent une interface élargie pour contrôler l'analyse et la construction.

• Le site OpenQASM 3 exportateurs (qasm3.dump(), dumps() et Exporter) utiliseront désormais moins de définitions d'"alias de registre" dans leur sortie. Le circuit décrit ne changera pas, mais il exportera désormais de préférence en termes de types directs bit, qubit et qubit[n] plutôt que de produire un registre _loose_bits et d'aliéner d'autres registres à partir de celui-ci. Cela permet de minimiser le nombre de fonctions avancées de OpenQASM 3 utilisées et d'éviter d'introduire une structure de tableau inutile dans des programmes qui n'en ont pas besoin.

Notes de mise à jour sur les informations quantiques

• Clifford.from_circuit() ne tentera plus de résoudre les instructions dont les champs definition sont mutuellement récursifs avec un autre objet. De telles définitions récursives constituent déjà une violation de l'ordre strictement hiérarchique exigé par le domaine definition et le code ne doit pas compter sur cette possibilité. Si vous souhaitez définir des équivalences autorisées à avoir des cycles (mutuels), utilisez un élément EquivalenceLibrary.

Notes de mise à niveau de la visualisation

• Dans l'objet interne ~qiskit.visualization.circuit.matplotlib.MatplotlibDrawer , les arguments layout, global_phase, qregs et cregs ont été supprimés. Ils étaient à l'origine obsolètes dans Qiskit Terra 0.20. Ces objets sont simplement déduits de l'adresse circuit .

  Il s'agit d'une classe de travail interne aux routines de visualisation. Il est peu probable que vous ayez à modifier votre code.

Divers. Mise à niveau

• L'emplacement d'importation qiskit.util a été supprimé, car il était obsolète depuis Qiskit Terra 0.17. Les utilisateurs doivent utiliser le nouvel emplacement d'importation, qiskit.utils.

Remarques concernant la dépréciation

• Les extensions des espaces de noms qiskit et qiskit.providers par des paquets externes sont désormais obsolètes et les points d'ancrage qui les permettent seront supprimés dans une prochaine version. Dans le passé, le projet Qiskit était composé d'éléments qui étendaient un espace de noms partagé et ces points d'accroche permettaient de le faire. Toutefois, il n'était pas prévu que ces interfaces soient utilisées par d'autres paquets. Maintenant que l'ensemble du paquetage Qiskit n'utilise plus ce modèle d'empaquetage, laisser la possibilité de ces extensions comporte plus de risques que d'avantages et est donc déprécié en vue d'une suppression future. Si vous maintenez un paquet qui étend l'espace de noms Qiskit (c'est-à-dire que vos utilisateurs importent à partir de qiskit.x ou qiskit.providers.y), vous devez passer à l'utilisation d'un espace de noms Python autonome pour votre paquet. Aucun avertissement ne sera émis dans ce cadre car il n'existe pas de méthode pour injecter un avertissement au niveau de l'emballage, ce qui serait nécessaire pour avertir les emballages externes de ce changement.

• Le dictionnaire qiskit.__qiskit_version__ est obsolète, car Qiskit est défini avec un seul paquet (qiskit-terra). À l'avenir, qiskit.__version__ sera le seul point d'interrogation de la version de Qiskit, sous la forme d'une chaîne de caractères standard.

Dépréciations du transcompilateur

• La fonction get_vf2_call_limit disponible via le module qiskit.transpiler.preset_passmanagers.common est obsolète. Cela n'affectera probablement que très peu d'utilisateurs puisque cette fonction n'a pas été explicitement exportée ni documentée. Sa fonctionnalité a été remplacée et étendue par une fonction du même module.

Circuits obsolètes

• La méthode qasm() et toutes les méthodes de surcharge des sous-classes de :class:~qiskit.circuit.Instruction sont obsolètes. La génération d'une chaîne OpenQASM2 pour une instruction isolée n'est pas remplacée, car un objet d'instruction unique ne dispose généralement pas d'un contexte suffisant pour générer complètement une chaîne OpenQASM2 valide. Si vous utilisez cette méthode actuellement, vous devrez plutôt utiliser l'exportateur OpenQASM2 : QuantumCircuit.qasm() pour générer le site OpenQASM2 pour un objet circuit entier.

Algorithmes obsolètes

• Le module qiskit.algorithms est obsolète et sera supprimé dans une prochaine version. Elle a été remplacée par une nouvelle bibliothèque autonome qiskit-algorithms qui peut être trouvée sur PyPi ou sur Github ici :

  https://github.com/qiskit-community/qiskit-algorithms

  Le module qiskit.algorithms continuera à fonctionner comme avant et des corrections de bogues y seront apportées jusqu'à son retrait futur, mais le développement actif de nouvelles fonctionnalités a été déplacé vers le nouveau paquet. Si vous vous appuyez sur qiskit.algorithms vous devez mettre à jour vos exigences pour Python afin d'inclure également qiskit-algorithms et mettre à jour les importations de qiskit.algorithms vers qiskit_algorithms. Veuillez noter que ce nouveau paquet n'inclut pas le code des algorithmes déjà obsolètes, y compris les algorithmes basés sur opflow et QuantumInstance. Si vous n'avez pas encore migré des algorithmes basés sur QuantumInstance aux algorithmes basés sur les primitives, vous devez suivre les directives de migration dans https://qisk.it/algo _migration. La décision de migrer le module algorithms dans un paquet séparé a été prise afin de clarifier l'objectif de Qiskit et de faire une distinction entre les outils et les bibliothèques construits au-dessus de lui.

Dépréciations des impulsions

• Initialisation de ScalableSymbolicPulse avec une valeur complexe pour amp. Cette modification concerne également les impulsions de bibliothèque suivantes :

  • Gaussian
  • GaussianSquare
  • Drag
  • Constant

  L'initialisation de amp avec une valeur complexe est également obsolète.

  Au lieu de cela, utilisez deux valeurs flottantes lorsque vous spécifiez les paramètres amp et angle , où amp représente la magnitude de l'amplitude complexe et angle représente l'angle de l'amplitude complexe. c'est-à-dire que l'amplitude complexe est donnée par $\texttt{amp} \times \exp(i \times \texttt{angle})$.

• L'instruction Call est obsolète et sera supprimée dans une prochaine version. Au lieu de cela, utilisez la fonction call() du module qiskit.pulse.builder dans le contexte d'un bâtiment actif.

Divers. Dépréciations

• La magie Jupyter %circuit_library_info et les objets de qiskit.tools.jupyter.library qu'elle appelle à leur tour :

  • circuit_data_table
  • properties_widget
  • qasm_widget
  • circuit_digram_widget
  • circuit_library_widget

  sont obsolètes et seront supprimées dans une prochaine version. Ces objets étaient uniquement destinés à être utilisés dans la documentation. Ils n'y sont plus utilisés et ne sont donc plus soutenus ou maintenus.

Problèmes connus

• Les circuits contenant des expressions classiques réalisées avec le module expr ne sont pas encore pris en charge par les visualisateurs de circuits.

Corrections des erreurs

• Correction d'un bogue dans Channel où la validation de l'index n'était pas effectuée correctement et ne générait une erreur que lorsque l'index était à la fois non entier et négatif, au lieu de l'un ou l'autre.

• Correction d'un problème avec la fonction transpile() et tous les gestionnaires de passe prédéfinis générés par la fonction generate_preset_pass_manager() où l'objet de sortie QuantumCircuit de l'objet layout de l'objet de sortie avait un attribut TranspileLayout.final_layout invalide. Cela se produirait dans des scénarios où la passe s'exécuterait et trouverait une autre disposition initiale ayant des taux d'erreur signalés plus faibles VF2PostLayout s'exécute et trouve une autre disposition initiale dont les taux d'erreur signalés sont inférieurs. Lors de la modification de la présentation initiale, l'attribut final_layout n'a jamais été mis à jour pour refléter ce changement. Ce problème a été corrigé de sorte que le site final_layout reflète toujours correctement la permutation de sortie causée par l'étape de routage. Corrigé #10457

• L'analyseur OpenQASM 2 (qasm2.load() et loads()) fonctionnant en mode strict émettra désormais correctement une erreur si une déclaration barrier n'a pas d'arguments. En mode plus permissif (par défaut), une instruction barrier sans argument continuera à provoquer une barrière sur tous les qubits actuellement dans le champ d'application (les qubits affectés par une définition de porte, ou tous les qubits définis par un programme, si l'instruction est dans le corps d'une porte ou dans le champ d'application global, respectivement).

• L'exportateur OpenQASM 2 (QuantumCircuit.qasm()) n'essaiera plus de produire les instructions barrier qui n'agissent sur aucun qubit. Une telle déclaration de barrière n'a pas d'effet non plus dans Qiskit, mais elle est invalide OpenQASM 2.

• Qiskit peut représenter des instructions personnalisées qui agissent sur zéro qubit ou sur un nombre non nul de bits classiques. Ceux-ci ne peuvent pas être exportés vers OpenQASM 2, mais auparavant QuantumCircuit.qasm() essayait, et produisait un résultat invalide OpenQASM 2. Au lieu de cela, un QASM2ExportError sera désormais correctement soulevée. Voir #7351 et #10435.

• Correction d'un problème lié à l'utilisation de Targetsans coupler les cartes avec la passe FullAncillaAllocation transpiler pass. Dans ce cas, FullAncillaAllocation ajoutera maintenant des qubits ancillaires pour que le nombre de qubits dans le DAGCircuit corresponde à celui de Target.num_qubits.

• DAGCircuit.substitute_node() n'écrasera plus silencieusement une condition existante sur le remplacement donné op. Si propagate_condition est défini sur True (par défaut), un DAGCircuitError sera affiché à la place.

• Un circuit paramétré contenant une porte personnalisée dont la définition comporte une phase globale paramétrée peut désormais lier avec succès le paramètre dans la phase globale interne. Voir #10283 pour plus de détails.

• Construction d'un Statevector à partir d'un QuantumCircuit contenant des opérations à zéro qubit ne soulèvera plus d'erreur. Ces opérations confèrent une phase globale au vecteur d'état résultant.

• L'interface du constructeur de flux de contrôle inclut désormais correctement les ressources des instructions de commutation imbriquées dans les champs d'application des circuits qu'elles contiennent ClassicalRegister des ressources provenant d'instructions de commutation imbriquées dans les champs d'application des circuits qu'elles contiennent. Voir #10398.

• Correction d'un problème dans QuantumCircuit.decompose() où le fait de passer un nom de circuit à la fonction correspondant à un nom de porte composite ne décomposait pas la porte si une étiquette lui était également attribuée. Corrigé #9136

• Correction d'un problème avec qiskit.visualization.plot_histogram() où la légende relative n'apparaissait pas lorsque l'ensemble de données donné avait une valeur nulle en première position. Voir #10158 pour plus de détails.

• Correction d'un échec avec la méthode Target.update_from_instruction_schedule_map() déclenchée par le site inst_map contenant un Schedule avec des durées non assignées.

• Lorsque le paramètre conditional=True est spécifié dans random_circuit()les opérations conditionnelles dans le circuit résultant seront désormais précédées d'une mesure complète à mi-circuit. Corrections #9016

• Amélioration des annotations de type sur la méthode QuantumCircuit.assign_parameters() pour refléter le changement de type de retour en fonction de l'argument inplace .

• Les méthodes de construction de circuits OpenQASM 2 (QuantumCircuit.from_qasm_str() et from_qasm_file()) ne provoquent plus d'erreur lorsqu'elles rencontrent une définition gate contenant des instructions U ou CX . Voir #5536.

• Réduction du surcoût de la passe ConsolidateBlocks en effectuant des opérations matricielles sur tous les blocs de deux qubits au lieu de créer une instance de QuantumCircuit et de la passer à un Operator. L'accélération ne sera applicable que lors de la consolidation de blocs de deux qubits. Tout ce qui est supérieur à cela sera toujours géré par la Operator classe. Consultez le numéro 8779 pour plus de détails.

• L'exportateur OpenQASM 3 (qiskit.qasm3) ne produira plus de OpenQASM 3 invalide pour les instances non unitaires Instruction mais lèvera à la place un QASM3ExporterError expliquant que ces instances ne sont pas encore prises en charge. Cette fonctionnalité est prévue pour une version ultérieure de Qiskit, lorsqu'il y aura plus de possibilités de traitement classique dans la bibliothèque.

• Corrige le problème #10185.

• Correction d'un problème avec la fonction state_to_latex(). Auparavant, il produisait des LaTeX invalides avec des coefficients arrondis de manière involontaire, ce qui entraînait des erreurs lors de l'appel à state_drawer(). Correction #9297.