Skip to main content

​
Currently Supported Constructs

The qbraid_qir.qasm3.qasm3_to_qir() converter supports the following OpenQASM 3 constructs:

​
1. Register Declarations

OpenQASM declarations of all forms qreg, qubit, bit, and creg are supported. 
OPENQASM 3;

// qubit declaration
qubit q1;
qubit[2] q2;
qreg q3[3];
qubit[1] q4;

// bit declaration
bit c1;
bit[2] c2;
creg c3[3];
bit[1] c4;

​
2. Quantum Measurements

OpenQASM measurements are supported which involve single qubit measurement and full register measurements. Range based measurements are not supported currently. 
OPENQASM 3;

qubit[2] q1;
qubit[5] q2;
qubit q3;

bit[2] c1;
bit c2;

// supported
c1 = measure q1;
measure q1 -> c1;
c2[0] = measure q3[0];

//ERROR: not supported
c1[0:2] = measure q1[0:2];

​
3. Quantum Reset

Resets are supported on declared quantum registers in all forms. 
OPENQASM 3;

include "stdgates.inc";

// qubit declarations
qubit q1;
qubit[2] q2;
qreg q3[3];

// reset operations
reset q1;
reset q2[1];
reset q3[2];
reset q3[:2];

​
4. Quantum Gates

  • pyqir._native gates are supported along with support for U3 and U2 gates. The U[x] gates are defined in terms of existing rx and rz gates according to the decomposition present on the Qiskit UGate documentation and PhaseGate documentation.
  • Full set of the openqasm3 “stdgates.inc” gates are supported. These gates are decomposed with the help of the pyqir._native gate set and subsequently converted to QIR.

​
5. Quantum Barriers

Barriers are supported only if they are placed on ALL the qubits in the circuit. For example: 
qubit q[2];

U(0.1, 0.2, 0.3) q[0];

// Barrier on all qubits
barrier q;

// ERROR: Barrier on a subset of qubits
barrier q[0];

​
6. Custom Quantum Gates

Gates defined by users are supported as long as they are defined in terms of pyqir._native gate set. Identifier mapping in gate parameter expressions is not supported at the moment. Example: 
OPENQASM 3.0;
include "stdgates.inc";

// Supported
gate custom2(g) s {
  h s;
  rz(g) s;
}

// Supported
gate custom(a,b,c) p, q {
  custom2(a) q;
  h p;
  cx p,q;
  rx(a) q;
  ry(0.5/0.1) q;
}

qubit[2] q;
custom(2 + 3 - 1/5, 0.1, 0.3) q[0], q[1];

​
7. Simple Branching Statements

Since QIR supports branching on a measurement result, single bit branching statements are supported at the moment. General boolean expressions and support for branching on full registers will be added in future. For example: 
OPENQASM 3;
include "stdgates.inc";
qubit[4] q;
bit[4] c;
h q;
measure q -> c;

// supported
if (c[0]) {
    x q[0];
    cx q[0], q[1];
}

if (c[1] == 1) {
    cx q[1], q[2];
}

if (!c[2]) {
    h q[2];
}

// ERROR: not supported
if (c == 8) {
    x q[0];
}
// ERROR: not supported
int[4] element;
if (element > 5) {
    y q[1];
}

​
8. Expressions

  • General expression evaluation involving literals and constants is supported.
  • Expressions involving constants and variables are fully supported.
  • Expressions with arrays are also supported (in global scopes).
OPENQASM 3;
qubit q;

// supported
rx(1.57) q;
rz(3-2*3) q;
rz(3-2*3\*(8/2)) q;
rx(-1.57) q;
rx(4%2) q;

​
9. Variables and Types

  • Scalar types int, uint, float, bool and bit with arbitrary sizes are supported.
  • array type is supported for int, uint, float, bool and bit.
  • complex and angle types are not supported yet.
OPENQASM 3;
// declarations
int a;
uint b;
int[2] c = 1;
uint[13] d = 2;
float[32] my_pi = 3.14;

// assignments and expressions
a = 5 \* c;
b = 6 - d;

​
10. Loops

Both for and while loops are supported at the moment. For example: 
OPENQASM 3.0;
include "stdgates.inc";

qubit[2] q;
int[32] i;
for int[32] i in [0:2] {
h q[i];
}

​
11. Aliasing

  • Aliasing quantum registers is supported and can be used to refer to the same quantum register with different names.
  • Aliases are currently supported in global scope of the qasm3 program, with support for function scopes coming soon.
OPENQASM 3.0;
include "stdgates.inc";

qubit[5] q;

let myqreg0 = q;
let myqreg1 = q[1];
let myqreg2 = q[1:];
let myqreg3 = q[:4];
let myqreg4 = q[1:4];
let myqreg5 = q[1:2:4];
let myqreg6 = q[{0, 1}];

x myqreg0[0];
h myqreg1;
cx myqreg2[0], myqreg2[1];
cx myqreg3[2], myqreg3[3];
ccx myqreg4;
swap myqreg5[0], myqreg5[1];
cz myqreg6;

​
12. Subroutines

We support QASM3 subroutines in the QIR converter
Subroutines are supported in QASM3 and can be defined using the def keyword and are only allowed in the global scope.
OPENQASM 3;
include "stdgates.inc";
def my_function(qubit q) { // void function
    h q;
    return;
}
Subroutines can be called from within the main program or from other subroutines.
OPENQASM 3.0;
include "stdgates.inc";

def my_function(qubit a, float[32] b) {
    rx(b) a;
    float[64] c = 2*b;
    rx(c) a;
    return;
}
qubit q;
bit c;
float[32] r = 3.14;
my_function(q, r);
  • Quantum arguments of type qubit are supported in subroutines.
  • Classical arguments are supported for any scalar type and can return values of any scalar type.
  • All argument validations mentioned in the OpenQASM3 specification are supported. 
    OPENQASM 3;
include "stdgates.inc";

def my_function(qubit q, int[32] a, float[32] b) {
    rz(a) q;
    rx(b) q;
    return;
}
qubit q;
int[32] n = 5;
float[32] b = 3.14;
my_function(q, n, b);
  • Add mutable and readonly arrays as classical arguments in a subroutines
  • Support looping statements inside a subroutine - Support switch statements inside a subroutine - Support for aliasing in a subroutine

​
13. Switch

Switch statements in QASM3 are supported in the QIR converter. These are defined according to the OpenQASM3 spec and support all the features mentioned in the specification. 
OPENQASM 3.0;
include "stdgates.inc";

const int i = 4;
const int j = 4;
qubit q;

switch(i) {
    case 6, j {
        x q;
    }
    default {
        z q;
    }
}