Skip to main content
IBM Quantum Platform

OpenQASM 3

qiskit.qasm3

Qiskit fournit quelques outils pour convertir les représentations OpenQASM 3 des programmes quantiques, et la classe QuantumCircuit classe. Celles-ci continueront d'évoluer au fur et à mesure que le support de Qiskit pour les capacités de circuit dynamique exprimées par OpenQASM 3 augmentera.

Exportation vers OpenQASM 3

Les fonctions de haut niveau sont simplement dump() et dumps()qui exportent respectivement vers un fichier (donné comme nom de fichier) et vers une chaîne Python.

dump

qiskit.qasm3.dump(circuit, stream, **kwargs)

GitHub

Sérialiser un objet QuantumCircuit un objet sous forme de flux OpenQASM 3 vers un objet de type fichier.

Paramètres

  • circuit (QuantumCircuit) – Circuit à sérialiser.
  • stream (TextIOBase) – objet de type flux pour déverser la sérialisation de OpenQASM 3
  • **kwargs - Arguments pour le constructeur Exporter constructeur.

Type de retour

Aucun

dumps

qiskit.qasm3.dumps(circuit, **kwargs)

GitHub

Sérialiser un objet QuantumCircuit objet dans une chaîne de caractères OpenQASM 3.

Paramètres

  • circuit (QuantumCircuit) – Circuit à sérialiser.
  • **kwargs - Arguments pour le constructeur Exporter constructeur.

Retours

La sérialisation de OpenQASM 3

Type de retour

str

Ces deux fonctions d'exportation sont des enveloppes à usage unique autour de la classe principale Exporter à usage unique. Pour des besoins d'exportation plus complexes, y compris le dumping de plusieurs circuits en une seule session, il peut être plus pratique ou plus rapide d'utiliser l'interface complète.

Exportateur

class qiskit.qasm3.Exporter(includes=('stdgates.inc', ), basis_gates=('U', ), disable_constants=False, alias_classical_registers=None, allow_aliasing=None, indent='  ', experimental=<ExperimentalFeatures: 0>, annotation_handlers=None, implicit_defcals=None)

GitHub

Bases : object

QASM3 classe principale de l'exportateur.

Paramètres

  • includes (Sequence[str]) –

    les noms de fichiers qui doivent être émis en tant qu'inclusions.

    Remarque

    Actuellement, seul le fichier de la bibliothèque standard stdgates.inc est correctement compris par l'exportateur, en ce sens qu'il connaît les portes qu'il définit. Vous pouvez spécifier d'autres inclusions, mais vous devrez transmettre les noms des portes qu'elles définissent dans l'argument basis_gates pour éviter que l'exportateur ne produise une définition distincte de gate .

  • basis_gates (Sequence[str]) – l'ensemble de portes défini de base du backend.

  • disable_constants (bool) – si True, émet toujours des constantes en virgule flottante pour les valeurs numériques des paramètres. Si False (valeur par défaut), les valeurs proches des multiples de OpenQASM 3 constantes (pi, euler, et tau) seront émises en termes de ces constantes à la place, ce qui peut améliorer la précision de la sortie.

  • alias_classical_registers (bool | None) –

    Si True, les bits peuvent être contenus dans plus d'un registre. Si c'est le cas, les registres seront émis en utilisant des définitions "alias", qui pourraient ne pas être bien supportées par les utilisateurs de OpenQASM 3.

    Voir aussi

    Paramètres allow_aliasing

    Une valeur pour allow_aliasing remplace toute valeur donnée ici et annule ce paramètre.

  • allow_aliasing (bool | None) –

    Si True, les bits peuvent être contenus dans plus d'un registre. Si c'est le cas, les registres seront émis en utilisant des définitions "alias", qui pourraient ne pas être bien supportées par les utilisateurs de OpenQASM 3. La valeur par défaut est False ou la valeur de alias_classical_registers.

    Ajouté dans la version 0.25.0.

  • indent (str) – la chaîne d'indentation à utiliser pour chaque niveau d'un bloc indenté. Peut être défini comme une chaîne vide pour désactiver l'indentation.

  • experimental (ExperimentalFeatures) – les éventuelles fonctionnalités expérimentales à activer lors de l'exportation. Voir ExperimentalFeatures pour plus de détails.

  • annotation_handlers (dict[str, OpenQASM3Serializer] | None) – une mise en correspondance entre les espaces de noms et les sérialiseurs d'annotations. Lorsqu'un Annotation objet est détecté, l'espace de noms le plus spécifique de ce mappage qui correspond à l'attribut de namespace l'annotation sera utilisé pour le sérialiser.

  • implicit_defcals (dict[str, DefcalInstruction] | None) – mise en correspondance de Instruction.names avec un objet associé DefcalInstruction . Toutes les instructions dont le nom de clé figure dans le circuit d'entrée doivent être traitées comme s'il existait une defcal instruction correspondant à la clé donnée DefcalInstruction . Il n'est pas nécessaire que le nom de la clé et le DefcalInstruction.name correspondent. Le defcal nom ne doit pas entrer en conflit avec un mot-clé de l' OpenQASM e 3.

dump

dump(circuit, stream)

GitHub

Convertissez le circuit en OpenQASM 3, en envoyant le résultat dans un fichier ou un flux de texte.

dumps

dumps(circuit)

GitHub

Convertit le circuit en OpenQASM 3, en renvoyant le résultat sous forme de chaîne de caractères.

Toutes ces interfaces relèveront QASM3ExporterError en cas d'échec.

QASM3ExporterError

exception qiskit.qasm3.QASM3ExporterError(*message)

GitHub

Bases : QASM3Error

Une erreur s'est produite lors de l'exécution de l'exportateur OpenQASM 3.

Définir le message d'erreur.

Fonctions expérimentales

Le langage OpenQASM 3 continue d'évoluer au fur et à mesure que les capacités matérielles s'améliorent, de sorte qu'il n'existe pas de syntaxe définitive que Qiskit puisse cibler de manière fiable. Afin de représenter l'évolution du langage, nous publierons parfois des fonctionnalités avant la normalisation formelle, qui pourraient devoir être modifiées au fur et à mesure de l'avancement du processus de révision au sein des comités de conception de OpenQASM 3. Par défaut, les exportateurs ne prennent en charge que les fonctionnalités standardisées de la langue. Pour activer ces fonctionnalités, utilisez le mot-clé experimental de la commande dump() et dumps(). Les indicateurs de caractéristiques disponibles sont les suivants :

ExperimentalFeatures

class qiskit.qasm3.ExperimentalFeatures(*values)

GitHub

Bases : Flag

Indicateurs de fonctionnalités expérimentales prises en charge par l'exportateur OpenQASM 3.

Ils sont expérimentaux et sont plus susceptibles de changer, car la spécification OpenQASM 3 ne les a pas encore formellement acceptés, de sorte que la syntaxe peut ne pas être finalisée.

SWITCH_CASE_V1

Valeur par défaut : 1

Prise en charge de l'exportation des déclarations switch-case comme proposé par https://github.com/openqasm/openqasm/pull/463 au commit bfa787aa3078.

Ceux-ci ont le format de sortie :

switch (i) {
    case 0:
    case 1:
        x $0;
    break;

    case 2: {
        z $0;
    }
    break;

    default: {
        cx $0, $1;
    }
    break;
}

Cela diffère de la syntaxe de la déclaration switch telle qu'elle a été stabilisée. Si ce drapeau n'est pas passé, l'analyseur syntaxique utilisera à la place la syntaxe stabilisée, ce qui rendrait le même exemple ci-dessus comme :

switch (i) {
    case 0, 1 {
        x $0;
    }
    case 2 {
        z $0;
    }
    default {
        cx $0, $1;
    }
}

Si vous souhaitez activer plusieurs fonctions expérimentales, vous devez combiner les drapeaux à l'aide de l'opérateur | , par exemple flag1 | flag2.

Par exemple, pour effectuer une exportation en utilisant la première sémantique du support switch :

from qiskit import qasm3, QuantumCircuit, QuantumRegister, ClassicalRegister

# Build the circuit
qreg = QuantumRegister(3)
creg = ClassicalRegister(3)
qc = QuantumCircuit(qreg, creg)
with qc.switch(creg) as case:
    with case(0):
        qc.x(0)
    with case(1, 2):
        qc.x(1)
    with case(case.DEFAULT):
        qc.x(2)

# Export to an OpenQASM 3 string.
qasm_string = qasm3.dumps(qc, experimental=qasm3.ExperimentalFeatures.SWITCH_CASE_V1)
Remarque

Toutes les fonctions activées par les drapeaux expérimentaux sont naturellement transitoires. S'il s'avère nécessaire de supprimer les drapeaux, ils seront soumis à la politique de dépréciation standard de Qiskit. Nous laisserons ces drapeaux expérimentaux en place aussi longtemps qu'il sera raisonnable de le faire.

Cependant, nous ne pouvons garantir aucune fenêtre de support pour les consommateurs de code OpenQASM 3 généré à l'aide de ces drapeaux expérimentaux, si la spécification du langage OpenQASM 3 modifie la proposition sur laquelle le drapeau est basé. Il est possible que tout outil que vous utilisez pour consommer du code OpenQASM 3 créé à l'aide de ces drapeaux mette à jour ou supprime leur support alors que Qiskit continue à offrir le drapeau. Vous ne devez pas vous fier au code expérimental OpenQASM 3 résultant pour le stockage à long terme des programmes.

Importation depuis OpenQASM 3

Actuellement, seules deux fonctions de haut niveau sont proposées, car la prise en charge par Qiskit de l'importation à partir de OpenQASM 3 n'en est qu'à ses balbutiements, et la mise en œuvre devrait changer de manière significative. Les deux fonctions sont load() et loads()qui sont les contreparties directes de dump() et dumps()qui chargent respectivement un programme indirectement à partir d'un fichier nommé et directement à partir d'une chaîne de caractères donnée.

Remarque

Bien que nous soyons encore dans la période exploratoire, pour utiliser l'une ou l'autre de ces fonctions, le paquet qiskit_qasm3_import doit être installé. Ceci peut être fait en installant Qiskit avec l'extra qasm3-import , comme par exemple :

pip install qiskit[qasm3-import]

Nous espérons que cette fonctionnalité sera finalement intégrée à Qiskit et ne nécessitera plus d'importation facultative, mais nous ne disposons pas encore d'un calendrier à cet égard.

load

qiskit.qasm3.load(filename, *, num_qubits=None, annotation_handlers=None)

GitHub

Charger un programme OpenQASM 3 à partir du fichier filename.

Paramètres

  • filename (str) – le nom du fichier à partir duquel le programme doit être chargé.
  • num_qubits (int | None) – qui fournit le nombre de qubits physiques/virtuels.
  • annotation_handlers (dict[str, annotation.OpenQASM3Serializer] | None) – un mappage dont les clés sont des espaces de noms (parents) et dont les valeurs sont des sérialiseurs capables de gérer les éléments enfants de ces espaces de noms. Nécessite qiskit_qasm3_import>=0.6.0.

Retours

une représentation du circuit du programme OpenQASM 3.

Type de retour

QuantumCircuit

Augmentations

QASM3ImporterError - si le fichier OpenQASM 3 n'est pas valide ou ne peut être représenté par un fichier QuantumCircuit.

Ajouté dans la version 2.1

L'argument annotation_handlers . Pour ce faire, il faut se rendre sur le site qiskit_qasm3_import>=0.6.0.

loads

qiskit.qasm3.loads(program, *, num_qubits=None, annotation_handlers=None)

GitHub

Charge un programme OpenQASM 3 à partir de la chaîne donnée.

Exemples

Chargement d'une chaîne OpenQASM3 dans un circuit quantique avec/sans l'argument num_qubits.

from qiskit import qasm3

# An OpenQASM 3 program that only uses 2 physical qubits.
prog = '''
    OPENQASM 3.0;
    include "stdgates.inc";
    h $0;
    cx $0, $1;
'''
# The importer can be supplied with the number of qubits in the target backend.
# so the result is full width.
qc = qasm3.loads(prog, num_qubits=5)
assert qc.num_qubits == 5

Paramètres

  • program (str) – le programme OpenQASM 3.
  • num_qubits (int | None) – fournit le nombre de qubits physiques/virtuels.
  • annotation_handlers (dict[str, annotation.OpenQASM3Serializer] | None) – un mappage dont les clés sont des espaces de noms (parents) et dont les valeurs sont des sérialiseurs capables de gérer les éléments enfants de ces espaces de noms. Nécessite qiskit_qasm3_import>=0.6.0.

Retours

une représentation du circuit du programme OpenQASM 3.

Type de retour

QuantumCircuit

Augmentations

Ajouté dans la version 2.1

L'argument annotation_handlers . Pour ce faire, il faut se rendre sur le site qiskit_qasm3_import>=0.6.0.

Ces deux fonctions soulèvent QASM3ImporterError en cas d'échec.

QASM3ImporterError

exception qiskit.qasm3.QASM3ImporterError(*message)

GitHub

Bases : QASM3Error

Une erreur s'est produite pendant l'importateur OpenQASM 3.

Définir le message d'erreur.

Par exemple, nous pouvons définir un programme quantique en utilisant OpenQASM 3, et utiliser loads() pour le convertir directement en un programme QuantumCircuit:

import qiskit.qasm3

program = """
    OPENQASM 3.0;
    include "stdgates.inc";

    input float[64] a;
    qubit[3] q;
    bit[2] mid;
    bit[3] out;

    let aliased = q[0:1];

    gate my_gate(a) c, t {
      gphase(a / 2);
      ry(a) c;
      cx c, t;
    }
    gate my_phase(a) c {
      ctrl @ inv @ gphase(a) c;
    }

    my_gate(a * 2) aliased[0], q[{1, 2}][0];
    measure q[0] -> mid[0];
    measure q[1] -> mid[1];

    while (mid == "00") {
      reset q[0];
      reset q[1];
      my_gate(a) q[0], q[1];
      my_phase(a - pi/2) q[1];
      mid[0] = measure q[0];
      mid[1] = measure q[1];
    }

    if (mid[0]) {
      let inner_alias = q[{0, 1}];
      reset inner_alias;
    }

    out = measure q;
"""
circuit = qiskit.qasm3.loads(program)
circuit.draw("mpl")
Schéma de circuit produit par le code précédent.

Interface d'importation expérimentale

Les fonctions d'importation présentées ci-dessus s'appuient sur l'analyseur de référence ANTLR du projet OpenQASM lui-même, qui est davantage conçu comme une référence linguistique que comme un analyseur performant. Vous devez avoir installé l'extension qiskit-qasm3-import pour l'utiliser.

Qiskit développe un analyseur natif, écrit en Rust, qui est disponible dans le paquetage de base de Qiskit. Cet analyseur en est encore à ses premiers stades expérimentaux, il lui manque donc des fonctionnalités et son interface est en train de changer et de s'étendre, mais il est généralement plus performant de plusieurs ordres de grandeur pour le sous-ensemble de OpenQASM 3 qu'il supporte actuellement, et ses internes produisent de meilleurs diagnostics d'erreur en cas d'échec de l'analyse.

Vous pouvez utiliser l'interface expérimentale immédiatement, avec des fonctions similaires à celles de l'interface principale ci-dessus :

load_experimental

qiskit.qasm3.load_experimental(pathlike_or_filelike, /, *, custom_gates=None, include_path=None)

Charger un programme OpenQASM 3 à partir d'un fichier source dans un fichier QuantumCircuit.

Avertissement

Cette version native de l'importateur OpenQASM 3 est actuellement expérimentale. Il est généralement beaucoup plus rapide que load()mais dispose d'un ensemble réduit de fonctionnalités prises en charge, qui s'étoffera au fil du temps.

Paramètres

  • pathlike_or_filelike (str |os.PathLike |io.TextIOBase) – la source du programme. Il peut s'agir d'un chemin d'accès à un fichier ou d'un objet de flux de texte ouvert. Si le flux est déjà ouvert, il est consommé dans l'espace Python, alors que les noms de fichiers sont ouverts et consommés dans l'espace Rust; les performances peuvent être légèrement différentes selon votre système et la manière dont les flux sont mis en mémoire tampon par défaut.
  • custom_gates (Iterable[CustomGate]) – Python les constructeurs à utiliser pour des portes nommées particulières. S'il n'est pas fourni, Qiskit utilisera ses propres constructeurs de bibliothèque standard pour les portes définies dans le fichier de bibliothèque standard OpenQASM 3.0 stdgates.inc.
  • include_path (Iterable[str]) – le chemin à rechercher lors de la résolution des déclarations include . S'il n'est pas indiqué, Qiskit s'arrangera pour qu'il pointe vers un emplacement contenant uniquement stdgates.inc . Les chemins sont essayés dans l'ordre de la séquence.

Retours

l'objet circuit construit.

Type de retour

QuantumCircuit

Augmentations

.QASM3ImporterError - si une erreur s'est produite lors de l'analyse syntaxique ou sémantique. Dans le cas d'une erreur d'analyse, la plupart des messages d'erreur sont imprimés sur le terminal et formatés, pour une meilleure lisibilité.

loads_experimental

qiskit.qasm3.loads_experimental(source, /, *, custom_gates=None, include_path=None)

Charger un programme OpenQASM 3 à partir d'une chaîne de caractères dans un fichier QuantumCircuit.

Avertissement

Cette version native de l'importateur OpenQASM 3 est actuellement expérimentale. Il est généralement beaucoup plus rapide que loads()mais dispose d'un ensemble réduit de fonctionnalités prises en charge, qui s'étoffera au fil du temps.

Paramètres

  • source (str) – la source du programme dans une chaîne Python.
  • custom_gates (Iterable[CustomGate]) – Python les constructeurs à utiliser pour des portes nommées particulières. S'il n'est pas fourni, Qiskit utilisera ses propres constructeurs de bibliothèque standard pour les portes définies dans le fichier de bibliothèque standard OpenQASM 3.0 stdgates.inc.
  • include_path (Iterable[str]) – le chemin à rechercher lors de la résolution des déclarations include . S'il n'est pas indiqué, Qiskit s'arrangera pour qu'il pointe vers un emplacement contenant uniquement stdgates.inc . Les chemins sont essayés dans l'ordre de la séquence.

Retours

l'objet circuit construit.

Type de retour

QuantumCircuit

Augmentations

.QASM3ImporterError - si une erreur s'est produite lors de l'analyse syntaxique ou sémantique. Dans le cas d'une erreur d'analyse, la plupart des messages d'erreur sont imprimés sur le terminal et formatés, pour une meilleure lisibilité.

Ces deux fonctions sont expérimentales, ce qui signifie qu'elles émettent un ExperimentalWarning sur l'utilisation, et leurs interfaces peuvent être modifiées dans la série de versions de Qiskit 1.x. En particulier, l'analyseur natif peut être promu au rang de version par défaut de load() et loads(). Si vous acceptez les risques liés à l'utilisation de l'interface expérimentale, vous pouvez désactiver l'avertissement en procédant comme suit :

import warnings
from qiskit.exceptions import ExperimentalWarning

warnings.filterwarnings("ignore", category=ExperimentalWarning, module="qiskit.qasm3")

Ces deux fonctions permettent de spécifier des chemins d'inclusion sous la forme d'une table itérative de chemins et de spécifier des constructeurs Python personnalisés à utiliser pour des portes particulières. Ces constructeurs personnalisés sont spécifiés à l'aide de l'option CustomGate de l'objet :

CustomGate

class qiskit.qasm3.CustomGate(constructor, name, num_params, num_qubits)

Bases : object

Informations reçues de Python space sur la manière de construire un objet Python -space pour représenter une porte donnée qui pourrait être déclarée.

constructor

Un objet Python appelable qui prend num_params des angles comme arguments de position et renvoie un Gate objet représentant la porte.

name

Le nom de la porte tel qu'il apparaît dans le programme OpenQASM 3. Ce nom n'est pas nécessairement identique à celui que Qiskit donne à la porte.

num_params

Nombre de paramètres de type angle requis par la porte.

num_qubits

Le nombre de qubits sur lesquels la porte agit.

Si custom_gates n'est pas spécifié, Qiskit tentera d'utiliser les objets de porte de sa bibliothèque standard pour les portes définies dans le fichier de la bibliothèque standard « stdgates.incOpenQASM 3 ». Cette séquence de portes est disponible sur ce module, si vous souhaitez vous en servir comme base :

qiskit.qasm3.STDGATES_INC_GATES

Un tuple d'objets CustomGate spécifiant les constructeurs Qiskit à utiliser pour le fichier d'inclusion stdgates.inc .

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