概述

OpenQASM（open quantum assembly language），即開放量子匯編語言，是一種命令式編程語言，它的特性類似于硬件描述語言（hardware description language），由 IBM 于 2017 年 7 月在其量子計算平臺推出，它能夠使用電路模型、基于測量的模型和近期量子計算實驗來描述通用的量子計算，也是目前適用范圍較廣的量子匯編語言，目前已更新至 3.0 版本。

OpenQASM 作為一個開源框架，廣泛用于基于門的設備的量子程序規(guī)范。借助 OpenQASM，用戶可以對構成量子計算基石的量子門和測量操作進行編程。目前，許多量子編程庫使用先前版本的 OpenQASM 2.0 來描述簡單的程序。

OpenQASM 在框架中提供了一組參數(shù)化的物理邏輯門和并發(fā)的實時經(jīng)典計算的集合。它的主要目標是作為高級編譯器與量子硬件通信的中間表示載體，在表示形式上，也考慮到了人們使用它時的易讀性。特別是，該語言允許同一程序的不同表示形式，所以 OpenQASM 可以由 Composer 生成，也支持手寫，或者由更高層次的軟件工具來完成，比如 ProjectQ、Quil、Liquid 等等。

設計目標

OpenQASM 3.0 與之前版本相比，增加了更多功能，例如脈沖電平控制、門定時和經(jīng)典控制流程，以彌補最終用戶界面和硬件描述語言之間的差距。總結起來，基本集中在以下三個方面：

• 具有經(jīng)典邏輯的更廣泛的計算系列。OpenQASM 3.0 引入經(jīng)典控制流、指令和數(shù)據(jù)類型來定義包括經(jīng)典數(shù)據(jù)實時計算的電路。外部機制允許對作用于運行時數(shù)據(jù)的通用經(jīng)典計算進行不透明引用。
• 顯式計時。OpenQASM 3.0 引入了一種靈活的機制來描述指令調度的設計意圖，同時保持獨立于門校準確定的特定持續(xù)時間。例如，這可以實現(xiàn)動態(tài)去耦，同時保留電路的柵極級描述。
• 嵌入式脈沖電平定義。一種可擴展的機制，用于將低級定義附加到門。這與校準任務特別相關，校準任務使用最容易在門級描述的誤差放大序列來優(yōu)化脈沖參數(shù)。

細節(jié)實現(xiàn)

遵循上述設計目標，OpenQASM 3.0 相比之前的 OpenQASM 2.0 規(guī)范進行了大幅擴展升級。增加了許多經(jīng)典控制流和計算的新功能，使編寫量子算法更容易，并描述構成這些算法一部分的經(jīng)典數(shù)據(jù)處理。然而，該語言并非設計用于通用經(jīng)典計算，并且在短期內，任何執(zhí)行 OpenQASM 3.0 程序的硬件都不太可能支持該語言可以描述的全套數(shù)據(jù)操作。

OpenQASM 3.0 的硬件能夠保證它們在運行時將處理性能穩(wěn)定在高效和實時執(zhí)行的操作上。這組操作在不同的實現(xiàn)工具下，實現(xiàn)方式會根據(jù)硬件種類略有所不同，需要提前了解不同硬件在運行時可以實現(xiàn)哪些語言功能。隨著時間的推移，隨著量子控制的要求變得不那么繁重，實現(xiàn)組件可能會變得更加強大。

在將來 OpenQASM 3.0 的編譯器也會支持一些經(jīng)典操作，這些經(jīng)典操作會被合理地判斷為編譯時常量，并在編譯時執(zhí)行這些操作。上面所說到的“合理推斷”是指聲明為常量的值以及字面意義。例如，這意味著“科學計算器函數(shù)”（如sin、exp 等）將始終對只涉及兼容類型的字面符號和聲明為常量的值的表達式起作用，而且編譯器會將這些表達式完全折疊成單個常量。具體能夠如何實現(xiàn)，還需要我們繼續(xù)等待相關的適配工作。

示例

因為目前不是所有基于門的量子設備和模擬器都支持 OpenQASM 3.0 ，所以在一些代碼示例中，將會使用部分 OpenQASM 2.0 的內容。

首先展示一下如何利用 OpenQASM 中的語法規(guī)則設置部分量子門：

OPENQASM 2.0;
include "qelib1.inc";
qreg q[10];
creg c[10];
x q[0];
h q[1];
tdg q[2];
sdg q[2];
cx q[0],q[2];
cx q[1],q[4];
u1(pi) q[0];
u2(pi,pi) q[1];
u3(pi,pi,pi) q[2];
cz q[2],q[5];
ccx q[3],q[4],q[6];
cu3(pi,pi,pi) q[0],q[1];
measure q[2] -> c[2];
measure q[0] -> c[0];

可以看到，OpenQASM 會直接對需要進行轉置共軛操作的量子邏輯門與量子線路進行直接轉化；并且在對量子程序轉化 QASM 指令集之前，會對其中包含的控制操作進行分解。

目前在已開源的量子編程框架中，本源量子的 QPanda 框架提供了 QASM 轉換的工具接口的，接口為std::string convert_qprog_to_qasm(QProg &, QuantumMachine*)，使用方式也較為簡單。接下來我們可以來看看QPanda框架是如何進行QASM轉換的：

#include "QPanda.h"
USING_QPANDA
int main(void)
{
    auto qvm = CPUQVM();
    qvm.init();
    auto prog = QProg();
    auto cir = Circuit();
    auto q = qvm.qAllocMany(6);
    auto c = qvm.cAllocMany(6);
    // 構建量子程序
    cir << Y(q[2]) << H(q[2]);
    cir.setDagger(true);
    auto h1 = H(q[1]);
    h1.setDagger(true);
    prog << H(q[1])
         << X(q[2])
         << h1
         << RX(q[1], 2 / PI)
         << cir
         << CR(q[1], q[2], PI / 2)
         <<MeasureAll(q,c);
    // 量子程序轉換QASM，并打印QASM
    std::cout << convert_qprog_to_qasm(prog,qvm);
    return 0;
}

具體的操作步驟是這樣的：

1. 首先在主程序中用 CPUQVM() 初始化一個量子虛擬機對象，用于管理后續(xù)一系列行為
2. 然后調用init()函數(shù)來初始化虛擬機
3. 接著用 qAllocMany() 和 cAllocMany() 初始化量子比特與經(jīng)典寄存器數(shù)目
4. 然后調用 QProg() 構建量子程序
5. 最后調用接口 convert_qprog_to_qasm 輸出QASM指令集并用 destroyQuantumMachine 釋放系統(tǒng)資源

最終的輸出結果如下：

OPENQASM 2.0;
include "qelib1.inc";
qreg q[6];
creg c[6];
h q[1];
x q[2];
h q[1];
rx(0.636620) q[1];
h q[2];
y q[2];
rz(-0.785398) q[2];
cx q[1],q[2];
rz(-0.785398) q[2];
cx q[1],q[2];
rz(1.570796) q[2];
rx(1.570796) q[1];
ry(-0.785398) q[1];
rx(-1.570796) q[1];
measure q[0] -> c[0];
measure q[1] -> c[1];
measure q[2] -> c[2];
measure q[3] -> c[3];
measure q[4] -> c[4];
measure q[5] -> c[5];

接下來我們可以看看目前已經(jīng)支持了 OpenQASM 3.0 的 Amazon Braket，是如何利用 OpenQASM 3.0 語言的：

具體示例為如何利用 Braket 創(chuàng)建一個 OpenQASM 3.0 任務。比如，從準備一個Gz狀態(tài)開始：

// ghz.qasm
// Prepare a GHZ state
OPENQASM 3;
qubit[3] q;
bit[3] c;
h q[0];
cnot q[0], q[1];
cnot q[1], q[2];
c = measure q;

或者我們還可以使用 Boto 3 創(chuàng)建 OpenQASM 3.0 任務。在下面的實例中，使用了 ghz.qasm：

import boto3
import json
my_bucket = "Amazon-braket-my-bucket"
s3_prefix = "openqasm-tasks"
with open("ghz.qasm") as f:
    source = f.read()
action = {
    "braketSchemaHeader": {
        "name": "braket.ir.openqasm.program",
        "version": "1"
    },
    "source": source
}
device_parameters = {}
device_arn = "arn:aws:braket:::device/qpu/rigetti/Aspen-11"
shots = 100
braket_client = boto3.client('braket', region_name='us-west-1')
rsp = braket_client.create_quantum_task(
    action=json.dumps(
        action
    ),
    deviceParameters=json.dumps(
        device_parameters
    ),
    deviceArn=device_arn,
    shots=shots,
    outputS3Bucket=my_bucket,
    outputS3KeyPrefix=s3_prefix,
)

在噪聲模擬方面，我們也可以使用 OpenQASM 3.0 來完成。在 Braket 中提交以下程序即可完成噪聲模擬：

// ghz.qasm
// Prepare a GHZ state
OPENQASM 3;
qubit[3] q;
bit[3] c;
h q[0];
#pragma braket noise depolarizing(0.75) q[0] cnot q[0], q[1];
#pragma braket noise depolarizing(0.75) q[0]
#pragma braket noise depolarizing(0.75) q[1] cnot q[1], q[2];
#pragma braket noise depolarizing(0.75) q[0]
#pragma braket noise depolarizing(0.75) q[1]
c = measure q;

以下列表中提供了所有受支持的編譯指示噪聲運算符的規(guī)范：

#pragma braket noise bit_flip(<float>) <qubit>
#pragma braket noise phase_flip(<float>) <qubit>
#pragma braket noise pauli_channel(<float>, <float>, <float>)  <qubit>
#pragma braket noise depolarizing(<float in [0,3/4]>) <qubit>
#pragma braket noise two_qubit_depolarizing(<float in [0,15/16]>) <qubit>, <qubit>
#pragma braket noise two_qubit_dephasing(<float in [0,3/4]>) <qubit>, <qubit>
#pragma braket noise amplitude_damping(<float in [0,1]>) <qubit>
#pragma braket noise generalized_amplitude_damping(<float in [0,1]> <float in [0,1]>)  <qubit>
#pragma braket noise phase_damping(<float in [0,1]>) <qubit>
#pragma braket noise kraus([[<complex m0_00>, ], ...], [[<complex m1_00>, ], ...], ...) <qubit>[, <qubit>]     // maximum of 2 qubits and maximum of 4 matrices for 1 qubit, 16 for 2
) <qubit>[, <qubit>]     // maximum of 2 qubits

QuQASM量子匯編語言

目前除了較為通用的 OpenQASM 開放量子匯編語言外，其實還存在很多專用匯編語言，這些語言在對應設備的適配兼容性上，可能表現(xiàn)會更好。比如，啟科量子推出的一款量子匯編語言—— QuQASM ，是針對自研的量子編程框架 QuTrunk 來進行適配的。

QuTrunk 使用 Python 作為宿主語言，利用 Python 的語法特性實現(xiàn)針對量子程序的 DSL (領域專用語言)， 把用于量子編程的專用語言稱為：QuQASM。它的主要特點是最左邊是一個量子門操作，中間加入( * )號鏈接符，最右邊是操作的量子比特，形式如下：

gate * qubits

為了方便理解，我們可以再多看看幾個例子：

H * q[0];               # 對q[0]做hadamard門操作
CNOT * (q[0], q[1]);    # q[0]為控制位，q[1]為目標位
All(Measure) * q        # 對q代表的所有量子比特做測量操作

使用該標準是充分利用了 Python 語法對( * )運算符的重載特性。該表形式更接近量子物理計算公式，同時 ( * )在計算機編程語言上表示乘法的意思，借此表示左邊的量子門操作實際上是對量子比特做矩陣乘法運算。

使用該標準編寫的量子匯編是可以直接被 QuTrunk 解析運行的，不需要做語法方面的解析處理工作。基于該特性，QuTrunk 可以無縫銜接 QuBranch 通過可視化量子編程生成的量子線路。即 QuTrunk可以直接運行 QuBranch 生成的量子線路（只需做一些簡單的初始化工作），而無需做語法上的轉譯處理。

下面是 QuQASM 每個量子門操作介紹：

//H(hadamard): 哈德馬門，對a做H門操作，常用于使量子比特處于疊加態(tài)
H * a
//X(NOT): 非門（Pauli-X）對a進行取反操作, 量子比特繞布洛赫球的x軸旋轉pi角度
X * a
//Y: Pauli-Y, 量子比特繞布洛赫球的y軸旋轉pi角度
Y * a
//Z: Pauli-Z, 量子比特繞布洛赫球的z軸旋轉pi角度
Z * a
//CNOT(CX): 受控非門，a作為控制位，b為目標位，如果a為1則對b進行取反，如果a為0則不做任何操作
CNOT * (a, b)
//Toffoli: 托佛利門，a, b作為控制位，c為目標位, 如果a,b均為1則對b進行取反，否則不做任何操作
Toffoli * (a, b, c)
//Measure: 測量門，對a進行測量，結果要么是0，要么是1，測量結果受概率振幅影響
Measure * a
//P: 相移門，將量子比特0>態(tài)和1>態(tài)的相位根據(jù)給定的角度進行移動
P(theta) * a
//Rx: 量子比特繞布洛赫球的x軸旋轉theta角度
Rx(theta) * a
//Ry: 量子比特繞布洛赫球的y軸旋轉theta角度
Ry(theta) * a
//Rz: 量子比特繞布洛赫球的z軸旋轉theta角度
Rz(theta) * a
//S: 量子比特繞布洛赫球的z軸旋轉pi/2角度
S * a
//Sdg: 對S門的反向操作, 繞布洛赫球的z軸反方向旋轉pi/2角度
Sdg * a
//T: 量子比特繞布洛赫球的z軸旋轉pi/4角度
T * a
//Tdg: 對T門的反向操作, 繞布洛赫球的z軸反方向旋轉pi/4角度
Tdg * a
//Swap: 交換兩個量子比特的狀態(tài)
Swap * (a, b)
//SqrtSwap: 對兩個量子比特做sqrt交換
SqrtSwap * (a, b)
//SqrtX: 平方根X門
SqrtX * a
//Rxx: 兩個量子比特繞x^x旋轉，旋轉角度為theta
Rxx(theta) * (a, b)
//Ryy: 兩個量子比特繞y^y旋轉，旋轉角度為theta
Ryy(theta) * (a, b)
//Rzz: 兩個量子比特繞z^z旋轉，旋轉角度為theta
Rzz(theta) * (a, b)
//Barrier: 分隔量子比特，阻止量子線路對相應量子比特做優(yōu)化等處理
Barrier * a
Barrier * (a, b)
//U1: 對單個量子比特繞z軸旋轉
U1(lambda) * a
//U2: 對單個量子比特繞x+z軸旋轉
U1(phi, lambda) * a
//U3: 通用單量子比特旋轉門
U1(theta, phi, lambda) * a
//All: 對其他量子門操作進行封裝，提供對多量子比特便捷操作
All(Measure) * qreg (對qreg代表的所有量子比特進行測量)
All(H) * qreg (對qreg代表的所有量子比特進行H門操作)

我們可以利用 QuQASM 語言來完成量子電路圖的編譯和輸出，具體操作方法如下：

# import package
from QuTrunk.circuit import QCircuit
from QuTrunk.circuit.gates import H, CNOT, Measure, All
# allocate resource
qc = QCircuit()
qr = qc.allocate(2)
# apply quantum gates
H * qr[0]
CNOT * (qr[0], qr[1])
All(Measure) * qr
# print circuit
qc.print()
# run circuit
res = qc.run(shots=1024)
# print result
print(res.get_counts())
# draw circuit
print(qc.draw())

輸出結果如下所示：

qreg q[2]
creg c[2]
H(0) * (q[0])
CX(1) * (q[0], q[1])
Measure(0) * (q[0])
Measure(0) * (q[1])
[{"00": 519}, {"11": 505}]

參考鏈接：

1. OpenQASM 3.0.x Live Specification — OpenQASM Live Specification 文檔
2. 動態(tài)電路簡介 – IBM Quantum
3. IBM量子計算機編程語言-OpenQASM簡介
4. 量子程序轉化QASM — QPanda 文檔 (qpanda-tutorial.readthedocs.io)
5. 使用 OpenQASM 3.0 運行你的電路 – Amazon Braket