OpenQASM 2 dan Qiskit SDK

Versi paket

Kode di halaman ini dikembangkan menggunakan persyaratan berikut. Kami merekomendasikan menggunakan versi ini atau yang lebih baru.

qiskit[all]~=2.3.0

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

Qiskit SDK menyediakan beberapa alat untuk mengonversi antara representasi OpenQASM dari program kuantum dan kelas QuantumCircuit.

Impor program OpenQASM 2 ke Qiskit

Ada dua fungsi untuk mengimpor program OpenQASM 2 ke Qiskit. Fungsi tersebut adalah qasm2.load(), yang menerima nama file, dan qasm2.loads(), yang menerima program OpenQASM 2 sebagai 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)

Lihat OpenQASM 2 Qiskit API untuk informasi lebih lanjut.

Impor program sederhana

Untuk sebagian besar program OpenQASM 2, kamu bisa langsung menggunakan qasm2.load dan qasm2.loads dengan satu argumen saja.

Contoh: impor program OpenQASM 2 sebagai string

Gunakan qasm2.loads() untuk mengimpor program OpenQASM 2 sebagai string ke dalam 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

Contoh: impor program OpenQASM 2 dari file

Gunakan load() untuk mengimpor program OpenQASM 2 dari file ke dalam QuantumCircuit:

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

Hubungkan Gate OpenQASM 2 dengan Gate Qiskit

Secara default, importer OpenQASM 2 milik Qiskit memperlakukan file include "qelib1.inc" sebagai library standar de facto. Importer memperlakukan file ini sebagai berisi tepat Gate-Gate yang dijelaskan dalam makalah asli yang mendefinisikan OpenQASM 2. Qiskit akan menggunakan Gate bawaan dari circuit library untuk merepresentasikan Gate-Gate dalam "qelib1.inc". Gate yang didefinisikan dalam program melalui pernyataan gate OpenQASM 2 secara manual akan, secara default, dikonstruksi sebagai subkelas Qiskit Gate khusus.

Kamu bisa memberi tahu importer untuk menggunakan kelas Gate tertentu untuk pernyataan gate yang ditemukan. Kamu juga bisa menggunakan mekanisme ini untuk memperlakukan nama Gate tambahan sebagai "bawaan", artinya tidak memerlukan definisi eksplisit. Jika kamu menentukan kelas Gate yang akan digunakan untuk pernyataan gate di luar "qelib1.inc", Circuit yang dihasilkan biasanya akan lebih efisien untuk digunakan.

peringatan

Mulai Qiskit SDK v1.0, exporter OpenQASM 2 milik Qiskit (lihat Ekspor Circuit Qiskit ke OpenQASM 2) masih berperilaku seolah-olah "qelib1.inc" memiliki lebih banyak Gate daripada yang sebenarnya ada. Ini berarti pengaturan default importer mungkin tidak bisa mengimpor program yang diekspor oleh exporter kita. Lihat contoh khusus untuk bekerja dengan exporter lama untuk mengatasi masalah ini.

Ketidaksesuaian ini adalah perilaku lama Qiskit, dan akan diselesaikan pada rilis Qiskit berikutnya.

Untuk meneruskan informasi tentang instruksi khusus ke importer OpenQASM 2, gunakan kelas qasm2.CustomInstruction. Kelas ini memerlukan empat informasi wajib, secara berurutan:

• Nama Gate, yang digunakan dalam program OpenQASM 2
• Jumlah parameter sudut yang diterima Gate
• Jumlah Qubit yang dioperasikan Gate
• Kelas konstruktor Python atau fungsi untuk Gate tersebut, yang menerima parameter Gate (tapi bukan Qubit) sebagai argumen individual

Jika importer menemukan definisi gate yang cocok dengan instruksi khusus yang diberikan, importer akan menggunakan informasi khusus tersebut untuk merekonstruksi objek Gate. Jika pernyataan gate ditemukan yang cocok dengan name instruksi khusus, tapi tidak cocok dengan jumlah parameter maupun jumlah Qubit, importer akan memunculkan QASM2ParseError, untuk menunjukkan ketidaksesuaian antara informasi yang diberikan dan program.

Selain itu, argumen kelima builtin bisa secara opsional diatur ke True untuk membuat Gate tersedia secara otomatis dalam program OpenQASM 2, meskipun tidak didefinisikan secara eksplisit. Jika importer menemukan definisi gate eksplisit untuk instruksi khusus bawaan, importer akan menerimanya secara diam-diam. Seperti sebelumnya, jika definisi eksplisit dengan nama yang sama tidak kompatibel dengan instruksi khusus yang diberikan, QASM2ParseError akan dimunculkan. Ini berguna untuk kompatibilitas dengan exporter OpenQASM 2 yang lebih lama, dan dengan platform kuantum tertentu yang memperlakukan "gate dasar" hardware mereka sebagai instruksi bawaan.

Qiskit menyediakan atribut data untuk bekerja dengan program OpenQASM 2 yang dihasilkan oleh versi lama dari kemampuan ekspor OpenQASM 2 Qiskit. Atribut ini adalah qasm2.LEGACY_CUSTOM_INSTRUCTIONS, yang bisa diberikan sebagai argumen custom_instructions ke qasm2.load() dan qasm2.loads().

Contoh: impor program yang dibuat oleh exporter lama Qiskit

Program OpenQASM 2 ini menggunakan Gate yang tidak ada dalam versi asli "qelib1.inc" tanpa mendeklarasikannya, tapi merupakan Gate standar dalam library Qiskit. Kamu bisa menggunakan qasm2.LEGACY_CUSTOM_INSTRUCTIONS untuk dengan mudah memberi tahu importer agar menggunakan set Gate yang sama yang sebelumnya digunakan oleh exporter OpenQASM 2 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,
)

Contoh: gunakan kelas Gate tertentu saat mengimpor program OpenQASM 2

Qiskit tidak bisa, secara umum, memverifikasi apakah definisi dalam pernyataan gate OpenQASM 2 sesuai persis dengan Gate library standar Qiskit. Sebagai gantinya, Qiskit memilih Gate khusus menggunakan definisi yang tepat yang diberikan. Ini bisa kurang efisien dibandingkan menggunakan salah satu Gate standar bawaan, atau Gate khusus yang didefinisikan pengguna. Kamu bisa mendefinisikan pernyataan gate secara manual dengan kelas-kelas tertentu.

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

Contoh: definisikan Gate bawaan baru dalam program OpenQASM 2

Jika argumen builtin=True diatur, Gate khusus tidak perlu memiliki definisi yang terkait.

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

Definisikan fungsi klasik khusus

OpenQASM 2 menyertakan beberapa fungsi klasik bawaan untuk digunakan dalam argumen Gate. Kamu bisa memperluas bahasa dengan lebih banyak fungsi menggunakan argumen custom_classical ke qasm2.load() dan qasm2.loads(), dengan kelas qasm2.CustomClassical.

Untuk mendefinisikan fungsi klasik khusus, kamu harus menyediakan:

• Nama fungsi seperti yang muncul dalam program OpenQASM 2
• Jumlah argumen floating-point yang diterima
• Objek Python yang bisa dipanggil untuk mengevaluasi fungsi

Semua fungsi klasik khusus yang didefinisikan diperlakukan sebagai bawaan bahasa OpenQASM 2 oleh importer. Tidak ada cara resmi dalam bahasa OpenQASM 2 untuk mendefinisikan fungsi baru; ini adalah ekstensi Qiskit.

Contoh: gunakan instruksi klasik khusus

Di sini kita menyediakan dua fungsi klasik khusus. Yang pertama sederhana, hanya menambahkan satu ke inputnya. Yang kedua adalah fungsi math.atan2, yang merepresentasikan operasi matematika $\arctan(y/x)$ dengan memperhatikan kuadran.

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)

Mode ketat

Secara default, parser ini lebih fleksibel dari spesifikasi resmi. Parser mengizinkan koma di akhir daftar parameter; tanda titik koma yang tidak perlu (pernyataan kosong); penghilangan pernyataan versi OPENQASM 2.0;; dan beberapa peningkatan kenyamanan lainnya tanpa mengeluarkan error apapun. Namun, kamu bisa menggunakan mode "sesuai spesifikasi" dengan strict=True.

Ekspor Circuit Qiskit ke OpenQASM 2

Qiskit juga bisa mengekspor QuantumCircuit ke OpenQASM 2. Kamu menggunakan fungsi qasm2.dump() untuk menulis ke file, dan qasm2.dumps() untuk menulis ke string. Fungsi-fungsi ini saat ini memiliki antarmuka yang sangat sederhana: mereka menerima sebuah Circuit dan, hanya untuk qasm2.dump(), lokasi untuk menulis outputnya.

peringatan

Exporter OpenQASM 2 milik Qiskit masih mengasumsikan versi lama dan non-standar dari file include "qelib1.inc". Hal ini akan diselesaikan pada rilis Qiskit berikutnya, tapi sementara itu, jika kamu perlu mengimpor ulang program OpenQASM 2 yang dibuat dengan Qiskit, gunakan contoh di atas tentang cara memberi tahu importer tentang Gate lama.

Contoh: ekspor Circuit ke 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")

Langkah selanjutnya

Rekomendasi

• Pelajari cara menghasilkan kode OpenQASM dalam panduan IBM Quantum Composer.
• Lihat referensi OpenQASM 2 Qiskit API.
• Tinjau topik Verifikasi program kamu.
• Kunjungi Spesifikasi Langsung OpenQASM.