OpenQASM 2 și Qiskit SDK

Versiuni de pachete

Codul de pe această pagină a fost dezvoltat folosind următoarele cerințe. Recomandăm utilizarea acestor versiuni sau a unora mai noi.

qiskit[all]~=2.3.0

# Added by doQumentation — required packages for this notebook
!pip install -q qiskit

Qiskit SDK oferă câteva instrumente pentru a converti între reprezentările OpenQASM ale programelor cuantice și clasa QuantumCircuit.

Importă un program OpenQASM 2 în Qiskit

Există două funcții pentru a importa programe OpenQASM 2 în Qiskit. Acestea sunt qasm2.load(), care primește un nume de fișier, și qasm2.loads(), care primește programul OpenQASM 2 ca șir de caractere.

import qiskit.qasm2

qiskit.qasm2.load(filename, include_path=('.',), include_input_directory='append', custom_instructions=(), custom_classical=(), strict=False)
qiskit.qasm2.loads(program, include_path=('.',), custom_instructions=(), custom_classical=(), strict=False)

Consultă API-ul OpenQASM 2 din Qiskit pentru mai multe informații.

Importă programe simple

Pentru majoritatea programelor OpenQASM 2, poți folosi qasm2.load și qasm2.loads cu un singur argument.

Exemplu: importă un program OpenQASM 2 ca șir de caractere

Folosește qasm2.loads() pentru a importa un program OpenQASM 2 ca șir de caractere într-un QuantumCircuit:

import qiskit.qasm2

program = """
    OPENQASM 2.0;
    include "qelib1.inc";
    qreg q[2];
    creg c[2];

    h q[0];
    cx q[0], q[1];

    measure q -> c;
"""
circuit = qiskit.qasm2.loads(program)
circuit.draw()

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

Exemplu: importă un program OpenQASM 2 dintr-un fișier

Folosește load() pentru a importa un program OpenQASM 2 dintr-un fișier într-un QuantumCircuit:

import qiskit.qasm2
circuit = qiskit.qasm2.load("myfile.qasm")

Asociază Gate-uri OpenQASM 2 cu Gate-uri Qiskit

În mod implicit, importatorul OpenQASM 2 din Qiskit tratează fișierul include "qelib1.inc" ca pe o bibliotecă standard de facto. Importatorul tratează acest fișier ca și cum ar conține exact Gate-urile descrise în lucrarea originală care definește OpenQASM 2. Qiskit va folosi Gate-urile integrate din biblioteca de Circuit-uri pentru a reprezenta Gate-urile din "qelib1.inc". Gate-urile definite în program prin instrucțiuni manuale gate în OpenQASM 2 vor fi, în mod implicit, construite ca subclase personalizate Qiskit Gate.

Poți indica importatorului să folosească anumite clase Gate pentru instrucțiunile gate întâlnite. De asemenea, poți utiliza acest mecanism pentru a trata nume suplimentare de Gate-uri ca „integrate", adică fără a necesita o definiție explicită. Dacă specifici ce clase Gate să folosești pentru instrucțiunile gate din afara "qelib1.inc", Circuit-ul rezultat va fi în general mai eficient de utilizat.

avertizare

Începând cu Qiskit SDK v1.0, exportatorul OpenQASM 2 din Qiskit (vezi Exportă un Circuit Qiskit în OpenQASM 2) se comportă în continuare ca și cum "qelib1.inc" ar avea mai multe Gate-uri decât are în realitate. Aceasta înseamnă că setările implicite ale importatorului s-ar putea să nu poată importa un program exportat de exportatorul nostru. Consultă exemplul specific de lucru cu exportatorul moștenire pentru a rezolva această problemă.

Această discrepanță este un comportament moștenire din Qiskit și va fi rezolvată într-o versiune ulterioară a Qiskit.

Pentru a transmite informații despre o instrucțiune personalizată importatorului OpenQASM 2, folosește clasa qasm2.CustomInstruction. Aceasta necesită patru informații obligatorii, în ordine:

• Numele Gate-ului, utilizat în programul OpenQASM 2
• Numărul de parametri unghiulari pe care Gate-ul îi primește
• Numărul de Qubiți pe care Gate-ul acționează
• Clasa sau funcția Python constructor pentru Gate, care primește parametrii Gate-ului (dar nu Qubiții) ca argumente individuale

Dacă importatorul întâlnește o definiție gate care corespunde unei instrucțiuni personalizate date, va folosi acea informație personalizată pentru a reconstrui obiectul Gate. Dacă o instrucțiune gate corespunde name-ului unei instrucțiuni personalizate, dar nu corespunde atât numărului de parametri, cât și numărului de Qubiți, importatorul va genera o eroare QASM2ParseError, pentru a indica nepotrivirea dintre informațiile furnizate și program.

În plus, un al cincilea argument builtin poate fi setat opțional la True pentru a face Gate-ul disponibil automat în programul OpenQASM 2, chiar dacă nu este definit explicit. Dacă importatorul întâlnește o definiție explicită gate pentru o instrucțiune personalizată integrată, o va accepta în tăcere. Ca și înainte, dacă o definiție explicită cu același nume nu este compatibilă cu instrucțiunea personalizată furnizată, va fi generată o eroare QASM2ParseError. Aceasta este utilă pentru compatibilitatea cu exportatoarele OpenQASM 2 mai vechi și cu anumite alte platforme cuantice care tratează „Gate-urile de bază" ale hardware-ului lor ca instrucțiuni integrate.

Qiskit furnizează un atribut de date pentru a lucra cu programe OpenQASM 2 produse de versiunile moștenire ale capabilităților de export OpenQASM 2 din Qiskit. Acesta este qasm2.LEGACY_CUSTOM_INSTRUCTIONS, care poate fi transmis ca argument custom_instructions la qasm2.load() și qasm2.loads().

Exemplu: importă un program creat de exportatorul moștenire din Qiskit

Acest program OpenQASM 2 folosește Gate-uri care nu se află în versiunea originală a "qelib1.inc" fără a le declara, dar sunt Gate-uri standard în biblioteca Qiskit. Poți folosi qasm2.LEGACY_CUSTOM_INSTRUCTIONS pentru a indica cu ușurință importatorului să folosească același set de Gate-uri pe care exportatorul OpenQASM 2 din Qiskit l-a utilizat anterior.

from qiskit import qasm2

program = """
    OPENQASM 2.0;
    include "qelib1.inc";

    qreg q[4];
    creg c[4];

    h q[0];
    cx q[0], q[1];

    // 'rxx' is not actually in `qelib1.inc`,
    // but Qiskit used to behave as if it were.
    rxx(0.75) q[2], q[3];

    measure q -> c;
"""
circuit = qasm2.loads(
    program,
    custom_instructions=qasm2.LEGACY_CUSTOM_INSTRUCTIONS,
)

Exemplu: folosește o anumită clasă Gate la importul unui program OpenQASM 2

Qiskit nu poate, în general, verifica dacă definiția dintr-o instrucțiune gate în OpenQASM 2 corespunde exact unui Gate din biblioteca standard Qiskit. În schimb, Qiskit alege un Gate personalizat folosind definiția precisă furnizată. Aceasta poate fi mai puțin eficientă decât utilizarea unuia dintre Gate-urile standard integrate sau a unui Gate personalizat definit de utilizator. Poți defini manual instrucțiunile gate cu anumite clase.

from qiskit import qasm2
from qiskit.circuit import Gate
from qiskit.circuit.library import RZXGate

# Define a custom gate that takes one qubit and two angles.
class MyGate(Gate):
    def __init__(self, theta, phi):
        super().__init__("my", 1, [theta, phi])

custom_instructions = [
    # Link the OpenQASM 2 name 'my' with our custom gate.
    qasm2.CustomInstruction("my", 2, 1, MyGate),
    # Link the OpenQASM 2 name 'rzx' with Qiskit's
    # built-in RZXGate.
    qasm2.CustomInstruction("rzx", 1, 2, RZXGate),
]

program = """
    OPENQASM 2.0;

    gate my(theta, phi) q {
        U(theta / 2, phi, -theta / 2) q;
    }
    gate rzx(theta) a, b {
        // It doesn't matter what definition is
        // supplied, if the parameters match;
        // Qiskit will still use `RZXGate`.
    }

    qreg q[2];
    my(0.25, 0.125) q[0];
    rzx(pi) q[0], q[1];
"""

circuit = qasm2.loads(
    program,
    custom_instructions=custom_instructions,
)

Exemplu: definește un Gate integrat nou într-un program OpenQASM 2

Dacă argumentul builtin=True este setat, un Gate personalizat nu trebuie să aibă o definiție asociată.

from qiskit import qasm2
from qiskit.circuit import Gate

# Define a custom gate that takes one qubit and two angles.
class MyGate(Gate):
    def __init__(self, theta, phi):
        super().__init__("my", 1, [theta, phi])

custom_instructions = [
    qasm2.CustomInstruction("my", 2, 1, MyGate, builtin=True),
]

program = """
    OPENQASM 2.0;
    qreg q[1];

    my(0.25, 0.125) q[0];
"""

circuit = qasm2.loads(
    program,
    custom_instructions=custom_instructions,
)

Definește funcții clasice personalizate

OpenQASM 2 include câteva funcții clasice integrate pentru a fi utilizate în argumentele Gate-urilor. Poți extinde limbajul cu mai multe funcții folosind argumentul custom_classical la qasm2.load() și qasm2.loads(), cu clasa qasm2.CustomClassical.

Pentru a defini o funcție clasică personalizată, trebuie să furnizezi:

• Numele funcției așa cum apare în programul OpenQASM 2
• Numărul de argumente în virgulă mobilă pe care le acceptă
• Un obiect Python apelabil care evaluează funcția

Toate funcțiile clasice personalizate definite sunt tratate ca integrate în limbajul OpenQASM 2 de către importator. Nu există nicio modalitate oficială în limbajul OpenQASM 2 de a defini funcții noi; aceasta este o extensie Qiskit.

Exemplu: folosește instrucțiuni clasice personalizate

Aici furnizăm două funcții clasice personalizate. Prima este simplă și adaugă unu la intrarea sa. A doua este funcția math.atan2, care reprezintă operația matematică $\arctan(y/x)$ într-un mod conștient de cadran.

import math
from qiskit import qasm2

program = """
    include "qelib1.inc";
    qreg q[2];
    rx(arctan(pi, 3 + add_one(0.2))) q[0];
    cx q[0], q[1];
"""

def add_one(x):
    return x + 1

customs = [
    # Our `add_one` takes only one parameter.
    qasm2.CustomClassical("add_one", 1, add_one),
    # `arctan` takes two parameters, and `math.atan2` implements it.
    qasm2.CustomClassical("arctan", 2, math.atan2),
]
circuit = qasm2.loads(program, custom_classical=customs)

Modul strict

În mod implicit, acest parser este mai relaxat decât specificația oficială. Permite virgule finale în listele de parametri; puncte și virgulă inutile (instrucțiuni goale); omiterea instrucțiunii de versiune OPENQASM 2.0;; și mai multe alte îmbunătățiri de calitate a vieții fără a emite erori. Totuși, poți folosi modul „conform specificației" cu strict=True.

Exportă un Circuit Qiskit în OpenQASM 2

Qiskit poate de asemenea exporta un QuantumCircuit în OpenQASM 2. Folosești funcția qasm2.dump() pentru a scrie într-un fișier și qasm2.dumps() pentru a scrie într-un șir de caractere. Aceste funcții au în prezent o interfață foarte simplă: acceptă un Circuit și, doar în cazul qasm2.dump(), o locație unde să scrie rezultatul.

avertizare

Exportatorul OpenQASM 2 din Qiskit presupune în continuare o versiune moștenire, non-standard a fișierului include "qelib1.inc". Aceasta va fi rezolvată într-o versiune ulterioară a Qiskit, dar între timp, dacă ai nevoie să reimportezi un program OpenQASM 2 creat cu Qiskit, folosește exemplul de mai sus pentru a indica importatorului Gate-urile moștenire.

Exemplu: exportă un Circuit în OpenQASM 2

from qiskit import QuantumCircuit, qasm2

# Define any circuit.
circuit = QuantumCircuit(2, 2)
circuit.h(0)
circuit.cx(0, 1)
circuit.measure([0, 1], [0, 1])

# Export to a string.
program = qasm2.dumps(circuit)

# Export to a file.
qasm2.dump(circuit, "my_file.qasm")

Pași următori

Recomandări

• Învață cum să generezi cod OpenQASM în ghidul IBM Quantum Composer.
• Consultă referința API-ului OpenQASM 2 din Qiskit.
• Revizuiește subiectul Verifică-ți programul.
• Vizitează Specificația Live OpenQASM.