OpenQASM 2 at ang Qiskit SDK

Mga bersyon ng package

Ang code sa pahinang ito ay ginawa gamit ang mga sumusunod na requirements. Inirerekomenda naming gamitin ang mga bersyong ito o mas bago pa.

qiskit[all]~=2.3.0

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

Ang Qiskit SDK ay nagbibigay ng ilang mga kasangkapan para sa pag-convert sa pagitan ng mga OpenQASM na representasyon ng mga quantum program, at ng klase na QuantumCircuit.

Mag-import ng OpenQASM 2 program sa Qiskit

May dalawang function na nag-iimport ng mga OpenQASM 2 program sa Qiskit. Ang mga ito ay qasm2.load(), na tumatanggap ng filename, at qasm2.loads(), na tumatanggap ng OpenQASM 2 program bilang string.

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)

Tingnan ang OpenQASM 2 Qiskit API para sa karagdagang impormasyon.

Mag-import ng simpleng mga program

Para sa karamihan ng mga OpenQASM 2 program, maaari mo lang gamitin ang qasm2.load at qasm2.loads na may isang argument.

Halimbawa: mag-import ng OpenQASM 2 program bilang string

Gamitin ang qasm2.loads() para mag-import ng OpenQASM 2 program bilang string sa isang 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

Halimbawa: mag-import ng OpenQASM 2 program mula sa file

Gamitin ang load() para mag-import ng OpenQASM 2 program mula sa file sa isang QuantumCircuit:

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

I-link ang mga OpenQASM 2 gate sa mga Qiskit gate

Sa default, ang OpenQASM 2 importer ng Qiskit ay tinatrato ang include file na "qelib1.inc" bilang isang de facto standard library. Tinatrato ng importer ang file na ito bilang naglalaman ng eksaktong mga gate na inilalarawan nito sa orihinal na papel na nagtatakda ng OpenQASM 2. Gagamitin ng Qiskit ang mga built-in na gate sa circuit library para kumatawan sa mga gate sa "qelib1.inc". Ang mga gate na tinukoy sa program sa pamamagitan ng manu-manong OpenQASM 2 na gate statement ay, sa default, itatayo bilang custom na Qiskit Gate subclasses.

Maaari mong sabihin sa importer na gumamit ng mga partikular na klase ng Gate para sa mga gate statement na nararamdaman nito. Maaari mo ring gamitin ang mekanismong ito para tratuhin ang mga karagdagang pangalan ng gate bilang "built-in", ibig sabihin, hindi nangangailangan ng eksplisitong kahulugan. Kung itutukoy mo kung aling mga klase ng gate ang gagamitin para sa mga gate statement na wala sa "qelib1.inc", ang resultang circuit ay karaniwang magiging mas mahusay na gamitin.

babala

Simula sa Qiskit SDK v1.0, ang OpenQASM 2 exporter ng Qiskit (tingnan ang I-export ang Qiskit circuit sa OpenQASM 2) ay nagpapatuloy na kumilos na parang ang "qelib1.inc" ay may mas maraming gate kaysa sa talagang mayroon ito. Ibig sabihin nito, maaaring hindi maka-import ang default na mga setting ng importer ng isang program na na-export ng aming importer. Tingnan ang ang partikular na halimbawa sa pakikipagtulungan sa legacy exporter para malutas ang problemang ito.

Ang pagkakaibang ito ay legacy na gawi ng Qiskit, at ito ay malulutas sa isang susunod na release ng Qiskit.

Para makapasa ng impormasyon tungkol sa custom na instruction sa OpenQASM 2 importer, gamitin ang ang klase na qasm2.CustomInstruction. Ito ay may apat na kinakailangang impormasyon, sa pagkakasunod:

Ang pangalan ng gate, na ginagamit sa OpenQASM 2 program
Ang bilang ng angle parameter na tinatanggap ng gate
Ang bilang ng qubit na pinapatakbo ng gate
Ang Python constructor na klase o function para sa gate, na tumatanggap ng mga parameter ng gate (ngunit hindi ang mga qubit) bilang mga indibidwal na argument

Kung makatagpo ang importer ng isang gate na kahulugan na tumutugma sa isang ibinigay na custom na instruction, gagamitin nito ang custom na impormasyong iyon para muling buuin ang gate object. Kung makatagpo ng gate statement na tumutugma sa name ng isang custom na instruction, ngunit hindi tumutugma sa bilang ng mga parameter at bilang ng mga qubit, ang importer ay magtataas ng QASM2ParseError, upang ipahiwatig ang hindi pagkatugma sa pagitan ng ibinigay na impormasyon at ng program.

Bukod pa rito, ang ikalimang argument na builtin ay maaaring opsyonal na itakda sa True para gawing awtomatikong available ang gate sa loob ng OpenQASM 2 program, kahit na hindi ito eksplisitong tinukoy. Kung makatagpo ang importer ng eksplisitong gate na kahulugan para sa isang built-in na custom na instruction, tatanggapin nito ito nang tahimik. Tulad ng dati, kung ang eksplisitong kahulugan ng parehong pangalan ay hindi tugma sa ibinigay na custom na instruction, isang QASM2ParseError ang itataas. Ito ay kapaki-pakinabang para sa compatibility sa mga mas lumang OpenQASM 2 exporter, at sa ilang iba pang mga quantum platform na tinatrato ang "basis gates" ng kanilang hardware bilang mga built-in na instruction.

Nagbibigay ang Qiskit ng data attribute para sa pakikipagtulungan sa mga OpenQASM 2 program na ginawa ng mga legacy na bersyon ng mga kakayahan ng OpenQASM 2 export ng Qiskit. Ito ay qasm2.LEGACY_CUSTOM_INSTRUCTIONS, na maaaring ibigay bilang custom_instructions argument sa qasm2.load() at qasm2.loads().

Halimbawa: mag-import ng program na ginawa ng legacy exporter ng Qiskit

Ang OpenQASM 2 program na ito ay gumagamit ng mga gate na wala sa orihinal na bersyon ng "qelib1.inc" nang hindi ito inihahayag, ngunit mga standard na gate sa library ng Qiskit. Maaari mong gamitin ang qasm2.LEGACY_CUSTOM_INSTRUCTIONS para madaling sabihin sa importer na gamitin ang parehong hanay ng mga gate na dati nang ginagamit ng OpenQASM 2 exporter ng Qiskit.

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,
)

Halimbawa: gumamit ng partikular na klase ng gate kapag nag-iimport ng OpenQASM 2 program

Hindi kayang i-verify ng Qiskit, sa pangkalahatan, kung ang kahulugan sa isang OpenQASM 2 gate statement ay eksaktong tumutugma sa isang standard-library gate ng Qiskit. Sa halip, pumipili ang Qiskit ng custom na gate gamit ang eksaktong kahulugang ibinigay. Maaaring ito ay hindi gaanong mahusay kaysa sa paggamit ng isa sa mga built-in na standard gate, o isang user-defined na custom gate. Maaari mong manu-manong tukuyin ang mga gate statement na may mga partikular na klase.

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,
)

Halimbawa: tukuyin ang isang bagong built-in na gate sa isang OpenQASM 2 program

Kung ang argument na builtin=True ay itinakda, ang isang custom na gate ay hindi na kailangang magkaroon ng kasamang kahulugan.

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,
)

Tukuyin ang mga custom na classical function

Ang OpenQASM 2 ay may kasamang ilang mga built-in na classical function para gamitin sa mga gate argument. Maaari mong palawakin ang wika ng mas maraming function sa pamamagitan ng paggamit ng custom_classical argument sa qasm2.load() at qasm2.loads(), kasama ang klase na qasm2.CustomClassical.

Para tukuyin ang isang custom na classical function, dapat mong ibigay:

Ang pangalan ng function na lumilitaw sa OpenQASM 2 program
Ang bilang ng mga floating-point na argument na tinatanggap nito
Isang callable na Python object na nagsusuri ng function

Lahat ng tinukoy na custom na classical function ay tinatrato bilang built-in sa OpenQASM 2 na wika ng importer. Walang opisyal na paraan sa loob ng OpenQASM 2 na wika para tukuyin ang mga bagong function; ito ay isang extension ng Qiskit.

Halimbawa: gumamit ng mga custom na classical instruction

Narito ay nagbibigay tayo ng dalawang custom na classical function. Ang una ay simple, at nagdadagdag lang ng isa sa input nito. Ang pangalawa ay ang function na math.atan2, na kumakatawan sa mathematical na operasyon na $\arctan(y/x)$ sa isang paraan na may kamalayan sa quadrant.

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)

Strict mode

Sa default, ang parser na ito ay mas maluwag kaysa sa opisyal na specification. Pinapayagan nito ang mga trailing comma sa mga listahan ng parameter; mga hindi kinakailangang (walang laman na statement) semicolon; pagtanggal ng OPENQASM 2.0; na version statement; at ilang iba pang mga pagpapabuti sa kalidad ng buhay nang hindi naglalabas ng anumang error. Gayunpaman, maaari mong gamitin ang "letter-of-the-spec" mode gamit ang strict=True.

I-export ang Qiskit circuit sa OpenQASM 2

Maaari ring mag-export ang Qiskit ng QuantumCircuit sa OpenQASM 2. Ginagamit mo ang function na qasm2.dump() para sumulat sa file, at qasm2.dumps() para sumulat sa string. Ang mga function na ito ay kasalukuyang may napaka-simpleng interface: tinatanggap nila ang isang circuit at, sa kaso lamang ng qasm2.dump(), isang lokasyon para isulat ang output.

babala

Ang OpenQASM 2 exporter ng Qiskit ay nagpapatuloy na inaakala ang isang legacy, hindi standard na bersyon ng "qelib1.inc" na include file. Ito ay malulutas sa isang susunod na release ng Qiskit, ngunit sa samantala, kung kailangan mong mag-reimport ng OpenQASM 2 program na ginawa gamit ang Qiskit, gamitin ang ang halimbawa sa itaas para sabihin sa importer ang tungkol sa mga legacy gate.

Halimbawa: i-export ang circuit sa 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")

Mga susunod na hakbang

Mga Rekomendasyon

Alamin kung paano gumawa ng OpenQASM code sa gabay na IBM Quantum Composer.
Tingnan ang sanggunian ng OpenQASM 2 Qiskit API.
Suriin ang paksa na I-verify ang iyong program.
Bisitahin ang OpenQASM Live Specification.

Mag-import ng OpenQASM 2 program sa Qiskit​

Mag-import ng simpleng mga program​

Halimbawa: mag-import ng OpenQASM 2 program bilang string​

Halimbawa: mag-import ng OpenQASM 2 program mula sa file​

I-link ang mga OpenQASM 2 gate sa mga Qiskit gate​

Halimbawa: mag-import ng program na ginawa ng legacy exporter ng Qiskit​

Halimbawa: gumamit ng partikular na klase ng gate kapag nag-iimport ng OpenQASM 2 program​

Halimbawa: tukuyin ang isang bagong built-in na gate sa isang OpenQASM 2 program​

Tukuyin ang mga custom na classical function​

Halimbawa: gumamit ng mga custom na classical instruction​

Strict mode​

I-export ang Qiskit circuit sa OpenQASM 2​

Halimbawa: i-export ang circuit sa OpenQASM 2​

Mga susunod na hakbang​