​
Compilation

​
Inlining & Unrolling

This example demonstrates the capabilities of the PyQASM tool by unrolling a complex OpenQASM program into a simplified form. In PyQASM, “unrolling” refers to the process of simplifying a quantum program by expanding custom gate definitions and flattening complex language constructs like subroutines, loops, and conditional statements into basic operations. This technique, also known as program flattening or inlining, transforms nested and recursive structures into a linear sequence of operations consisting solely of qubit and classical bit declarations, gate operations, and measurement operations. By converting the program into this simplified format, it becomes easier to perform subsequent transpilation or compilation steps before executing the program on a quantum device.
example.qasm
OPENQASM 3.0;
include "stdgates.inc";

// Define custom gates
gate hgate q {
    h q;
}
gate xgate q {
    x q;
}
gate cxgate q1, q2 {
    cx q1, q2;
}

// Define a subroutine for creating a Bell state
def create_bell_state(qubit[2] q) {
    hgate q[0];
    cxgate q[0], q[1];
    return;
}

// Define a subroutine for a generic quantum operation
def generic_operation(qubit[N] q) {
    for int i in [0:N-1] {
        hgate q[i];
        xgate q[i];
        y q[i];
        rx(pi) q[i];
    }
    return;
}

// Main program
const int[32] N = 4;
qubit[N] q;
bit[N] c;

// Create a Bell state using the alias
create_bell_state(q[0:2]);

measure q[0:1] -> c[0:1];

// Perform a generic operation on all qubits
generic_operation(q);

// Classical control flow
if (c[0]) {
    hgate q[0];
} else {
    xgate q[0];
}

// Define an array of angles for parameterized gates
array[float[64], N] angles = {pi/2, pi/4, pi/8, pi/16};

// Apply parameterized rotations
for int i in [0:N-1] {
    rx(angles[i]) q[i];
}

// Measure the qubits
c = measure q;

import pyqasm

module = pyasm.load("example.qasm")

module.validate()
module.unroll()

print(pyqasm.dumps(module))
For complete details about the supported operations, see PyQASM Supported Operations.

​
Analysis

​
num_qubits, num_clbits, and depth

This example demonstrates how to use the num_qubits, num_clbits, and depth methods. 
import pyqasm

qasm_code = """
OPENQASM 3.0;
include "stdgates.inc";
qubit[3] q;
bit[3] c;
h q[0];
cx q[0], q[1];
c[0] = measure q[0];
"""

# Load QASM code from a string into a QasmModule object

module = pyqasm.loads(qasm_code)

# Get the number of qubits and classical bits

num_qubits = module.num_qubits
num_clbits = module.num_clbits

# Calculate the depth of the circuit

depth = module.depth()

print(f"Number of qubits: {num_qubits}")
print(f"Number of classical bits: {num_clbits}")
print(f"Depth of the circuit: {depth}")

​
Transformations

​
has_measurements and remove_measurements

This example demonstrates how to check for measurements and remove them. 
import pyqasm

qasm_code = """
OPENQASM 3.0;
include "stdgates.inc";
qubit[3] q;
bit[3] c;
h q[0];
cx q[0], q[1];
c[0] = measure q[0];
"""

# Load QASM code from a string into a QasmModule object

module = pyqasm.loads(qasm_code)

# Check if the module has measurements

print(f"Has measurements: {module.has_measurements()}")

# Remove measurements

module.remove_measurements()
print("\nModule without measurements: ")
print(pyqasm.dumps(module))

# Check if the module has measurements

print(f"Has measurements: {module.has_measurements()}")
Very similar to the previous example, we also have has_barriers and remove_barriers methods to check for barriers and remove them, respectively.

​
populate_idle_qubits

This example demonstrates how to populate idle qubits with identity gates - 
import pyqasm

qasm_code = """
OPENQASM 3.0;
include "stdgates.inc";
qubit[5] q;
h q[0];
cx q[0], q[1];
"""

# Load QASM code from a string into a QasmModule object

module = pyqasm.loads(qasm_code)

# Populate idle qubits with identity gates

module.populate_idle_qubits()

print(pyqasm.dumps(module))

​
remove_idle_qubits

This example demonstrates how to remove idle qubits from the module and shows the qubit count before and after. 
import pyqasm

qasm_code = """
OPENQASM 3.0;
include "stdgates.inc";
qubit[5] q;
h q[0];
"""

# Load QASM code from a string into a QasmModule object

module = pyqasm.loads(qasm_code)

# Print the number of qubits before removing idle qubits

print(f"Number of qubits before: {module.num_qubits}")

# Remove idle qubits

module.remove_idle_qubits()

# Print the number of qubits after removing idle qubits

print(f"Number of qubits after: {module.num_qubits}")

print(pyqasm.dumps(module))

​
reverse_qubit_order

This example demonstrates how to reverse the order of qubits in the module with a more involved program. 
import pyqasm

qasm_code = """
OPENQASM 3.0;
include "stdgates.inc";
qubit[5] q;
h q[0];
cx q[0], q[1];
cx q[1], q[2];
cx q[2], q[3];
cx q[3], q[4];
"""

# Load QASM code from a string into a QasmModule object

module = pyqasm.loads(qasm_code)

# Reverse the order of qubits

module.reverse_qubit_order()

print(pyqasm.dumps(module))

​
rebase

Unroll and convert an QASM program to a specified basis gate set. The target basis set can be chosen from the options present in the pyqasm.elements.BasisSet class. Currently we support conversion to the following basis sets:
  1. BasisSet.CLIFFORD_T : {"h", "t", "s", "cx", "tdg", "sdg"}
  2. BasisSet.ROTATIONAL_CX : {"rx", "ry", "rz", "cx"}
For example - 
import pyqasm

qasm_code = """
OPENQASM 3.0;
include "stdgates.inc";
qubit[2] q;
bit[2] c;
// Operations
h q;
x q;
cz q[0], q[1];
c = measure q;
"""
module = pyqasm.loads(qasm_code)

module.rebase(pyqasm.elements.BasisSet.ROTATIONAL_CX)

print(pyqasm.dumps(module))
The rebase functionality is useful for converting a program to a basis set that is supported by a specific quantum device. This conversion can be extended to new custom basis sets by adding the required gate decompositions to the pyqasm.maps.decomposition_rules module. Currently we have complete conversion support for the BasisSet.ROTATIONAL_CX basis set, whereas only non-parameterized gate conversion is available for BasisSet.CLIFFORD_T. Refer to the PyQASM API Documentation for more details on the available methods and their usage.