Warning

This page is under construction. The content may be incomplete or incorrect. Submit an issue on GitHub if you need help or want to contribute.

QASM2 and its extensions

Bloqade provides a set of dialects (missing link) for QASM2 and our custom extensions to model parallel gates in neutral atom architectures. The basic QASM2 functionality can be enabled via

pip install bloqade[qasm2]

Quick Example

When programming with QASM2, the most common usage is via the qasm2.extended decorator, e.g the following Quantum Fourier Transform (QFT) circuit:

import math
from bloqade import qasm2

@qasm2.extended
def qft(qreg: qasm2.QReg, n: int):
    if n == 0:
        return qreg

    qasm2.h(qreg[0])
    for i in range(1, n):
        qasm2.cu1(qreg[i], qreg[0], 2 * math.pi / 2**i)
    qft(qreg, n - 1)
    return qreg

While the syntax is similar to Python, the qasm2.extended decorator actually compiles the qft function into lower-level intermediate representation (IR) code that can be later executed on a simulator (available via PyQrack) or a quantum computer.

You can inspect the initial IR code by calling the pretty printer:

qft.print()

Running simulations

The program can be executed via a simulator backend, e.g. PyQrack, you can install it via

pip install bloqade[pyqrack]
# or if you want to use the CPU only version
pip install bloqade[pyqrack-cpu]

@qasm2.extended
def main():
    return qft(qasm2.qreg(3), 3)

device = PyQrack()
qreg = device.run(main)
print(qreg)

Emitting QASM2 code

You can also emit QASM2 code from the IR code:

from bloqade.qasm2.emit import QASM2 # the QASM2 target
from bloqade.qasm2.parse import pprint # the QASM2 pretty printer

target = QASM2()
ast = target.emit(main)
pprint(ast)

Understanding the compilation process

The compilation process is divided into several stages:

1. Lowering: the decorator qasm2.extended takes Python Abstract Syntax Tree (AST) and lowers it into Kirin IR in the Static Single Assignment (SSA) form.
2. Interpretation: when invoking the PyQrack backend, the IR code is interpreted via Kirin's IR interpreter (missing link) with the PyQrack runtime backend.
3. Target code generation: when emitting QASM2 code:
4. The IR code gets aggressively inlined and all constant expressions are evaluated.
5. All loops and control flow are unrolled.
6. All compatible Python expressions (e.g sin, arithmetics) are translated into QASM2 expression.
7. The QASM2 code is emitted as QASM2 AST for pretty printing.

In fact, the decorator qasm2.extended is a group of smaller dialects:

extended = structural_no_opt.union(
     [
         inline,
         uop,
         glob,
         noise,
         parallel,
         core,
     ]
 )

where structural_no_opt is the base dialect group that provides the basic control flow, common Python expressions (but not all), then:

• core provides the core QASM2 operations such as register allocation, measurement and reset.
• uop provides the unary operations, such as standard Pauli gates, rotation gates, etc.

The following dialects are specific to neutral atom quantum computing as an extension:

• glob provides the global gates (Rydberg specific)
• noise provides the noise channels
• parallel provides the parallel gate support (Rydberg specific).
• inline dialect provides the inline QASM string

Strict QASM2 mode

While the qasm2.extended decorator provides a lot of high-level features as an extension of QASM2, you may want to program in strict QASM2 mode for compatibility reasons. You can do this by using the qasm2.main and qasm2.gate decorators:

@qasm2.main
def main():
    qasm2.h(0)
    qasm2.cx(0, 1)
    qasm2.measure(0)
    qasm2.measure(1)
    return qasm2.qreg(2)

which corresponding to the following QASM2 code:

OPENQASM 2.0;
include "qelib1.inc";

qreg q[2];
creg c[2];

h q[0];
cx q[0], q[1];
measure q[0] -> c[0];
measure q[1] -> c[1];

Note that the return values are all ignore due to lack of equivalent in QASM2.

API Reference

barrier

barrier(qargs: tuple[Qubit, ...]) -> None

Barrier instruction.

Parameters:

Name	Type	Description	Default
qargs	tuple[Qubit, ...]	The qubits to apply the barrier to.	required

Source code in src/bloqade/qasm2/_wrappers.py

@wraps(uop.Barrier)
def barrier(qargs: tuple[Qubit, ...]) -> None:
    """
    Barrier instruction.

    Args:
        qargs: The qubits to apply the barrier to.
    """

    ...

ccx

ccx(ctrl1: Qubit, ctrl2: Qubit, qarg: Qubit) -> None

Toffoli gate.

Parameters:

Name	Type	Description	Default
ctrl1	Qubit	The first control qubit.	required
ctrl2	Qubit	The second control qubit.	required
qarg	Qubit	The target qubit.	required

Source code in src/bloqade/qasm2/_wrappers.py

@wraps(uop.CCX)
def ccx(ctrl1: Qubit, ctrl2: Qubit, qarg: Qubit) -> None:
    """
    Toffoli gate.

    Args:
        ctrl1: The first control qubit.
        ctrl2: The second control qubit.
        qarg: The target qubit.
    """
    ...

ch

ch(ctrl: Qubit, qarg: Qubit) -> None

Controlled-Hadamard gate.

Parameters:

Name	Type	Description	Default
ctrl	Qubit	The control qubit.	required
qarg	Qubit	The target qubit	required

Source code in src/bloqade/qasm2/_wrappers.py

@wraps(uop.CH)
def ch(ctrl: Qubit, qarg: Qubit) -> None:
    """
    Controlled-Hadamard gate.

    Args:
        ctrl: The control qubit.
        qarg: The target qubit

    """

    ...

cos

cos(value: float) -> float

Cosine math function.

Parameters:

Name	Type	Description	Default
value	float	The value to take the cosine of.	required

Returns:

Type	Description
float	The cosine of value.

Source code in src/bloqade/qasm2/_wrappers.py

@wraps(expr.Cos)
def cos(value: float) -> float:
    """
    Cosine math function.

    Args:
        value: The value to take the cosine of.

    Returns:
        The cosine of `value`.

    """

    ...

cp

cp(ctrl: Qubit, qarg: Qubit, lam: float) -> None

Controlled phase rotation gate. Same as cu1

Parameters:

Name	Type	Description	Default
ctrl	Qubit	The control qubit.	required
qarg	Qubit	The target qubit.	required
lam	float	The angle of rotation.	required

Source code in src/bloqade/qasm2/_wrappers.py

@wraps(uop.CU1)
def cp(ctrl: Qubit, qarg: Qubit, lam: float) -> None:
    """
    Controlled phase rotation gate. Same as cu1

    Args:
        ctrl: The control qubit.
        qarg: The target qubit.
        lam: The angle of rotation.
    """

    ...

creg

creg(n_bits: int) -> CReg

Create a new classical register with n_bits bits.

Parameters:

Name	Type	Description	Default
n_bits	int	The number of bits in the register.	required

Returns:

Type	Description
CReg	The newly created classical register.

Source code in src/bloqade/qasm2/_wrappers.py

@wraps(core.CRegNew)
def creg(n_bits: int) -> CReg:
    """
    Create a new classical register with `n_bits` bits.

    Args:
        n_bits: The number of bits in the register.

    Returns:
        The newly created classical register.

    """
    ...

crx

crx(ctrl: Qubit, qarg: Qubit, lam: float) -> None

Controlled Rx rotation gate.

Parameters:

Name	Type	Description	Default
ctrl	Qubit	The control qubit.	required
qarg	Qubit	The target qubit.	required
lam	float	The angle of rotation.	required

Source code in src/bloqade/qasm2/_wrappers.py

@wraps(uop.CRX)
def crx(ctrl: Qubit, qarg: Qubit, lam: float) -> None:
    """
    Controlled Rx rotation gate.

    Args:
        ctrl: The control qubit.
        qarg: The target qubit.
        lam: The angle of rotation.

    """

    ...

cry

cry(ctrl: Qubit, qarg: Qubit, lam: float) -> None

Controlled Ry rotation gate.

Parameters:

Name	Type	Description	Default
ctrl	Qubit	The control qubit.	required
qarg	Qubit	The target qubit.	required
lam	float	The angle of rotation.	required

Source code in src/bloqade/qasm2/_wrappers.py

@wraps(uop.CRY)
def cry(ctrl: Qubit, qarg: Qubit, lam: float) -> None:
    """
    Controlled Ry rotation gate.

    Args:
        ctrl: The control qubit.
        qarg: The target qubit.
        lam: The angle of rotation.

    """

    ...

crz

crz(ctrl: Qubit, qarg: Qubit, lam: float) -> None

Controlled Rz rotation gate.

Parameters:

Name	Type	Description	Default
ctrl	Qubit	The control qubit.	required
qarg	Qubit	The target qubit.	required
lam	float	The angle of rotation.	required

Source code in src/bloqade/qasm2/_wrappers.py

@wraps(uop.CRZ)
def crz(ctrl: Qubit, qarg: Qubit, lam: float) -> None:
    """
    Controlled Rz rotation gate.

    Args:
        ctrl: The control qubit.
        qarg: The target qubit.
        lam: The angle of rotation.

    """
    ...

cswap

cswap(ctrl: Qubit, qarg1: Qubit, qarg2: Qubit) -> None

Controlled Swap gate (Fredkin gate).

Parameters:

Name	Type	Description	Default
ctrl	Qubit	The control qubit.	required
qarg1	Qubit	The first target qubit.	required
qarg2	Qubit	The second target qubit.	required

Source code in src/bloqade/qasm2/_wrappers.py

@wraps(uop.CSwap)
def cswap(ctrl: Qubit, qarg1: Qubit, qarg2: Qubit) -> None:
    """
    Controlled Swap gate (Fredkin gate).

    Args:
        ctrl: The control qubit.
        qarg1: The first target qubit.
        qarg2: The second target qubit.
    """
    ...

csx

csx(ctrl: Qubit, qarg: Qubit) -> None

Controlled-Sqrt(X) gate.

Parameters:

Name	Type	Description	Default
ctrl	Qubit	The control qubit.	required
qarg	Qubit	The target qubit	required

Source code in src/bloqade/qasm2/_wrappers.py

@wraps(uop.CSX)
def csx(ctrl: Qubit, qarg: Qubit) -> None:
    """
    Controlled-Sqrt(X) gate.

    Args:
        ctrl: The control qubit.
        qarg: The target qubit
    """
    ...

cu

cu(
    ctrl: Qubit,
    qarg: Qubit,
    theta: float,
    phi: float,
    lam: float,
    gamma: float,
) -> None

Controlled 4-parameter unitary gate.

This is equal to:

gate cu(theta,phi,lambda,gamma) c, t{ p(gamma) c; p((lambda+phi)/2) c; p((lambda-phi)/2) t; cx c,t; u(-theta/2,0,-(phi+lambda)/2) t; cx c,t; u(theta/2,phi,0) t; }

Parameters:

Name	Type	Description	Default
ctrl	Qubit	The control qubit.	required
qarg	Qubit	The target qubit.	required
theta	float	The angle of rotation.	required
phi	float	The angle of rotation.	required
lam	float	The angle of rotation.	required
gamma	float	The angle of rotation.	required

Source code in src/bloqade/qasm2/_wrappers.py

@wraps(uop.CU)
def cu(
    ctrl: Qubit, qarg: Qubit, theta: float, phi: float, lam: float, gamma: float
) -> None:
    """
    Controlled 4-parameter unitary gate.

    This is equal to:

    gate cu(theta,phi,lambda,gamma) c, t{
        p(gamma) c;
        p((lambda+phi)/2) c;
        p((lambda-phi)/2) t;
        cx c,t;
        u(-theta/2,0,-(phi+lambda)/2) t;
        cx c,t;
        u(theta/2,phi,0) t;
    }

    Args:
        ctrl: The control qubit.
        qarg: The target qubit.
        theta: The angle of rotation.
        phi: The angle of rotation.
        lam: The angle of rotation.
        gamma: The angle of rotation.
    """
    ...

cu1

cu1(ctrl: Qubit, qarg: Qubit, lam: float) -> None

Controlled phase rotation gate.

Parameters:

Name	Type	Description	Default
ctrl	Qubit	The control qubit.	required
qarg	Qubit	The target qubit.	required
lam	float	The angle of rotation.	required

Source code in src/bloqade/qasm2/_wrappers.py

@wraps(uop.CU1)
def cu1(ctrl: Qubit, qarg: Qubit, lam: float) -> None:
    """
    Controlled phase rotation gate.

    Args:
        ctrl: The control qubit.
        qarg: The target qubit.
        lam: The angle of rotation.
    """

    ...

cu3

cu3(
    ctrl: Qubit,
    qarg: Qubit,
    theta: float,
    phi: float,
    lam: float,
) -> None

Controlled 3-parameter unitary gate.

Parameters:

Name	Type	Description	Default
ctrl	Qubit	The control qubit.	required
qarg	Qubit	The target qubit.	required
theta	float	The angle of rotation.	required
phi	float	The angle of rotation.	required
lam	float	The angle of rotation.	required

Source code in src/bloqade/qasm2/_wrappers.py

@wraps(uop.CU3)
def cu3(ctrl: Qubit, qarg: Qubit, theta: float, phi: float, lam: float) -> None:
    """
    Controlled 3-parameter unitary gate.

    Args:
        ctrl: The control qubit.
        qarg: The target qubit.
        theta: The angle of rotation.
        phi: The angle of rotation.
        lam: The angle of rotation.

    """
    ...

cx

cx(ctrl: Qubit, qarg: Qubit) -> None

Controlled-X (CNOT) gate.

Parameters:

Name	Type	Description	Default
ctrl	Qubit	The control qubit.	required
qarg	Qubit	The target qubit.	required

Source code in src/bloqade/qasm2/_wrappers.py

@wraps(uop.CX)
def cx(ctrl: Qubit, qarg: Qubit) -> None:
    """
    Controlled-X (CNOT) gate.

    Args:
        ctrl: The control qubit.
        qarg: The target qubit.
    """
    ...

cy

cy(ctrl: Qubit, qarg: Qubit) -> None

Controlled-Y gate.

Parameters:

Name	Type	Description	Default
ctrl	Qubit	The control qubit.	required
qarg	Qubit	The target qubit	required

Source code in src/bloqade/qasm2/_wrappers.py

@wraps(uop.CY)
def cy(ctrl: Qubit, qarg: Qubit) -> None:
    """
    Controlled-Y gate.

    Args:
        ctrl: The control qubit.
        qarg: The target qubit
    """

    ...

cz

cz(ctrl: Qubit, qarg: Qubit) -> None

Controlled-Z gate.

Parameters:

Name	Type	Description	Default
ctrl	Qubit	The control qubit.	required
qarg	Qubit	The target qubit	required

Source code in src/bloqade/qasm2/_wrappers.py

@wraps(uop.CZ)
def cz(ctrl: Qubit, qarg: Qubit) -> None:
    """
    Controlled-Z gate.

    Args:
        ctrl: The control qubit.
        qarg: The target qubit
    """
    ...

exp

exp(value: float) -> float

Exponential math function.

Parameters:

Name	Type	Description	Default
value	float	The value to exponentiate.	required

Returns:

Type	Description
float	The exponential of value.

Source code in src/bloqade/qasm2/_wrappers.py

@wraps(expr.Exp)
def exp(value: float) -> float:
    """
    Exponential math function.

    Args:
        value: The value to exponentiate.

    Returns:
        The exponential of `value`.

    """

    ...

h

h(qarg: Qubit) -> None

Hadamard gate.

Parameters:

Name	Type	Description	Default
qarg	Qubit	The qubit to apply the gate to.	required

Source code in src/bloqade/qasm2/_wrappers.py

@wraps(uop.H)
def h(qarg: Qubit) -> None:
    """
    Hadamard gate.

    Args:
        qarg: The qubit to apply the gate to.

    """
    ...

id

id(qarg: Qubit) -> None

Identity gate.

Parameters:

Name	Type	Description	Default
qarg	Qubit	The qubit to apply the gate to.	required

Source code in src/bloqade/qasm2/_wrappers.py

@wraps(uop.Id)
def id(qarg: Qubit) -> None:
    """
    Identity gate.

    Args:
        qarg: The qubit to apply the gate to.

    """
    ...

inline

inline(text: str) -> None

Inline QASM code into the current program.

Parameters:

Name	Type	Description	Default
text	str	The QASM code to inline.	required

Source code in src/bloqade/qasm2/_wrappers.py

@wraps(inline_.InlineQASM)
def inline(text: str) -> None:
    """
    Inline QASM code into the current program.

    Args:
        text: The QASM code to inline.
    """
    ...

ln

ln(value: float) -> float

logarithm math function.

Parameters:

Name	Type	Description	Default
value	float	The value to take the natural logarithm of.	required

Returns:

Type	Description
float	The natural logarithm of value.

Source code in src/bloqade/qasm2/_wrappers.py

@wraps(expr.Log)
def ln(value: float) -> float:
    """
    logarithm math function.

    Args:
        value: The value to take the natural logarithm of.

    Returns:
        The natural logarithm of `value`.

    """

    ...

measure

measure(qarg: Qubit, cbit: Bit) -> None

Measure the qubit qarg and store the result in the classical bit cbit.

Parameters:

Name	Type	Description	Default
qarg	Qubit	The qubit to measure.	required
cbit	Bit	The classical bit to store the result in.	required

Source code in src/bloqade/qasm2/_wrappers.py

@wraps(core.Measure)
def measure(qarg: Qubit, cbit: Bit) -> None:
    """
    Measure the qubit `qarg` and store the result in the classical bit `cbit`.

    Args:
        qarg: The qubit to measure.
        cbit: The classical bit to store the result in.
    """
    ...

p

p(qarg: Qubit, lam: float) -> None

Phase gate.

This is equivalent to u(0,0,lam), and u1(lam)

Parameters:

Name	Type	Description	Default
qarg	Qubit	The qubit to apply the gate to.	required
lam	float	The angle of phase.	required

Source code in src/bloqade/qasm2/_wrappers.py

@wraps(uop.U1)
def p(qarg: Qubit, lam: float) -> None:
    """
    Phase gate.

    This is equivalent to u(0,0,lam), and u1(lam)

    Args:
        qarg: The qubit to apply the gate to.
        lam: The angle of phase.

    """
    ...

qreg

qreg(n_qubits: int) -> QReg

Create a new quantum register with n_qubits qubits.

Parameters:

Name	Type	Description	Default
n_qubits	int	The number of qubits in the register.	required

Returns:

Type	Description
QReg	The newly created quantum register.

Source code in src/bloqade/qasm2/_wrappers.py

@wraps(core.QRegNew)
def qreg(n_qubits: int) -> QReg:
    """
    Create a new quantum register with `n_qubits` qubits.

    Args:
        n_qubits: The number of qubits in the register.

    Returns:
        The newly created quantum register.

    """
    ...

reset

reset(qarg: Qubit) -> None

Reset the qubit qarg to the |0⟩ state.

Parameters:

Name	Type	Description	Default
qarg	Qubit	The qubit to reset.	required

Source code in src/bloqade/qasm2/_wrappers.py

@wraps(core.Reset)
def reset(qarg: Qubit) -> None:
    """
    Reset the qubit `qarg` to the |0⟩ state.

    Args:
        qarg: The qubit to reset.

    """

    ...

rx

rx(qarg: Qubit, theta: float) -> None

Single qubit rotation about the X axis on block sphere

Parameters:

Name	Type	Description	Default
qarg	Qubit	The qubit to apply the gate to.	required
theta	float	The angle of rotation.	required

Source code in src/bloqade/qasm2/_wrappers.py

@wraps(uop.RX)
def rx(qarg: Qubit, theta: float) -> None:
    """
    Single qubit rotation about the X axis on block sphere

    Args:
        qarg: The qubit to apply the gate to.
        theta: The angle of rotation.
    """
    ...

rxx

rxx(ctrl: Qubit, qarg: Qubit, theta: float) -> None

XX rotation gate.

Parameters:

Name	Type	Description	Default
ctrl	Qubit	The first qubit.	required
qarg	Qubit	The second qubit.	required
theta	float	The angle of rotation.	required

Source code in src/bloqade/qasm2/_wrappers.py

@wraps(uop.RXX)
def rxx(ctrl: Qubit, qarg: Qubit, theta: float) -> None:
    """
    XX rotation gate.

    Args:
        ctrl: The first qubit.
        qarg: The second qubit.
        theta: The angle of rotation.

    """
    ...

ry

ry(qarg: Qubit, theta: float) -> None

Single qubit rotation about the Y axis on block sphere

Parameters:

Name	Type	Description	Default
qarg	Qubit	The qubit to apply the gate to.	required
theta	float	The angle of rotation.	required

Source code in src/bloqade/qasm2/_wrappers.py

@wraps(uop.RY)
def ry(qarg: Qubit, theta: float) -> None:
    """
    Single qubit rotation about the Y axis on block sphere

    Args:
        qarg: The qubit to apply the gate to.
        theta: The angle of rotation.

    """

    ...

rz

rz(qarg: Qubit, theta: float) -> None

Single qubit rotation about the Z axis on block sphere

Parameters:

Name	Type	Description	Default
qarg	Qubit	The qubit to apply the gate to.	required
theta	float	The angle of rotation.	required

Source code in src/bloqade/qasm2/_wrappers.py

@wraps(uop.RZ)
def rz(qarg: Qubit, theta: float) -> None:
    """
    Single qubit rotation about the Z axis on block sphere

    Args:
        qarg: The qubit to apply the gate to.
        theta: The angle of rotation.
    """
    ...

rzz

rzz(ctrl: Qubit, qarg: Qubit, theta: float) -> None

ZZ rotation gate.

Parameters:

Name	Type	Description	Default
ctrl	Qubit	The first qubit.	required
qarg	Qubit	The second qubit.	required
theta	float	The angle of rotation.	required

Source code in src/bloqade/qasm2/_wrappers.py

@wraps(uop.RZZ)
def rzz(ctrl: Qubit, qarg: Qubit, theta: float) -> None:
    """
    ZZ rotation gate.

    Args:
        ctrl: The first qubit.
        qarg: The second qubit.
        theta: The angle of rotation.

    """
    ...

s

s(qarg: Qubit) -> None

S gate.

Parameters:

Name	Type	Description	Default
qarg	Qubit	The qubit to apply the gate to.	required

Source code in src/bloqade/qasm2/_wrappers.py

@wraps(uop.S)
def s(qarg: Qubit) -> None:
    """
    S gate.

    Args:
        qarg: The qubit to apply the gate to.
    """

    ...

sdg

sdg(qarg: Qubit) -> None

Hermitian conjugate of the S gate.

Parameters:

Name	Type	Description	Default
qarg	Qubit	The qubit to apply the gate to.	required

Source code in src/bloqade/qasm2/_wrappers.py

@wraps(uop.Sdag)
def sdg(qarg: Qubit) -> None:
    """
    Hermitian conjugate of the S gate.

    Args:
        qarg: The qubit to apply the gate to.

    """

    ...

sin

sin(value: float) -> float

Sine math function.

Parameters:

Name	Type	Description	Default
value	float	The value to take the sine of.	required

Returns:

Type	Description
float	The sine of value.

Source code in src/bloqade/qasm2/_wrappers.py

@wraps(expr.Sin)
def sin(value: float) -> float:
    """
    Sine math function.

    Args:
        value: The value to take the sine of.

    Returns:
        The sine of `value`.

    """
    ...

sqrt

sqrt(value: float) -> float

Square root math function.

Parameters:

Name	Type	Description	Default
value	float	The value to take the square root of.	required

Returns:

Type	Description
float	The square root of value.

Source code in src/bloqade/qasm2/_wrappers.py

@wraps(expr.Sqrt)
def sqrt(value: float) -> float:
    """
    Square root math function.

    Args:
        value: The value to take the square root of.

    Returns:
        The square root of `value`.
    """
    ...

sx

sx(qarg: Qubit) -> None

Sqrt(X) gate.

Parameters:

Name	Type	Description	Default
qarg	Qubit	The qubit to apply the gate to.	required

Source code in src/bloqade/qasm2/_wrappers.py

@wraps(uop.SX)
def sx(qarg: Qubit) -> None:
    """
    Sqrt(X) gate.

    Args:
        qarg: The qubit to apply the gate to.
    """

    ...

sxdg

sxdg(qarg: Qubit) -> None

Hermitian conjugate of Sqrt(X) gate.

Parameters:

Name	Type	Description	Default
qarg	Qubit	The qubit to apply the gate to.	required

Source code in src/bloqade/qasm2/_wrappers.py

@wraps(uop.SXdag)
def sxdg(qarg: Qubit) -> None:
    """
    Hermitian conjugate of Sqrt(X) gate.

    Args:
        qarg: The qubit to apply the gate to.
    """

    ...

t

t(qarg: Qubit) -> None

T gate.

Parameters:

Name	Type	Description	Default
qarg	Qubit	The qubit to apply the gate to.	required

Source code in src/bloqade/qasm2/_wrappers.py

@wraps(uop.T)
def t(qarg: Qubit) -> None:
    """
    T gate.

    Args:
        qarg: The qubit to apply the gate to.
    """

    ...

tan

tan(value: float) -> float

Tangent math function.

Parameters:

Name	Type	Description	Default
value	float	The value to take the tangent of.	required

Returns:

Type	Description
float	The tangent of value.

Source code in src/bloqade/qasm2/_wrappers.py

@wraps(expr.Tan)
def tan(value: float) -> float:
    """
    Tangent math function.

    Args:
        value: The value to take the tangent of.

    Returns:
        The tangent of `value`.

    """

    ...

tdg

tdg(qarg: Qubit) -> None

Hermitian conjugate of the T gate.

Parameters:

Name	Type	Description	Default
qarg	Qubit	The qubit to apply the gate to.	required

Source code in src/bloqade/qasm2/_wrappers.py

@wraps(uop.Tdag)
def tdg(qarg: Qubit) -> None:
    """
    Hermitian conjugate of the T gate.

    Args:
        qarg: The qubit to apply the gate to.

    """

    ...

u

u(
    qarg: Qubit, theta: float, phi: float, lam: float
) -> None

U gate.

Note

See https://arxiv.org/pdf/1707.03429 for definition of angles.

Parameters:

Name	Type	Description	Default
qarg	Qubit	The qubit to apply the gate to.	required
theta	float	The angle of rotation	required
phi	float	The angle of rotation	required
lam	float	The angle of rotation	required

Source code in src/bloqade/qasm2/_wrappers.py

@wraps(uop.UGate)
def u(qarg: Qubit, theta: float, phi: float, lam: float) -> None:
    """
    U gate.

    Note:
        See https://arxiv.org/pdf/1707.03429 for definition of angles.

    Args:
        qarg: The qubit to apply the gate to.
        theta: The angle of rotation
        phi: The angle of rotation
        lam: The angle of rotation

    """
    ...

u1

u1(qarg: Qubit, lam: float) -> None

1 Parameter single qubit unitary gate.

This is equivalent to u(0,0,lambda).

Parameters:

Name	Type	Description	Default
qarg	Qubit	The qubit to apply the gate to.	required
lam	float	The angle of rotation.	required

Source code in src/bloqade/qasm2/_wrappers.py

@wraps(uop.U1)
def u1(qarg: Qubit, lam: float) -> None:
    """
    1 Parameter single qubit unitary gate.

    This is equivalent to u(0,0,lambda).

    Args:
        qarg: The qubit to apply the gate to.
        lam: The angle of rotation.
    """
    ...

u2

u2(qarg: Qubit, phi: float, lam: float) -> None

2 Parameter single qubit unitary gate.

This is equivalent to u(pi/2,phi,lambda)

Parameters:

Name	Type	Description	Default
qarg	Qubit	The qubit to apply the gate to.	required
phi	float	The angle of rotation.	required
lam	float	The angle of rotation.	required

Source code in src/bloqade/qasm2/_wrappers.py

@wraps(uop.U2)
def u2(qarg: Qubit, phi: float, lam: float) -> None:
    """
    2 Parameter single qubit unitary gate.

    This is equivalent to u(pi/2,phi,lambda)

    Args:
        qarg: The qubit to apply the gate to.
        phi: The angle of rotation.
        lam: The angle of rotation.
    """
    ...

u3

u3(
    qarg: Qubit, theta: float, phi: float, lam: float
) -> None

U3 gate, same as u

Note

See https://arxiv.org/pdf/1707.03429 for definition of angles.

Parameters:

Name	Type	Description	Default
qarg	Qubit	The qubit to apply the gate to.	required
theta	float	The angle of rotation	required
phi	float	The angle of rotation	required
lam	float	The angle of rotation	required

Source code in src/bloqade/qasm2/_wrappers.py

@wraps(uop.UGate)
def u3(qarg: Qubit, theta: float, phi: float, lam: float) -> None:
    """
    U3 gate, same as u

    Note:
        See https://arxiv.org/pdf/1707.03429 for definition of angles.

    Args:
        qarg: The qubit to apply the gate to.
        theta: The angle of rotation
        phi: The angle of rotation
        lam: The angle of rotation

    """
    ...

x

x(qarg: Qubit) -> None

Pauli-X gate.

Parameters:

Name	Type	Description	Default
qarg	Qubit	The qubit to apply the gate to.	required

Source code in src/bloqade/qasm2/_wrappers.py

@wraps(uop.X)
def x(qarg: Qubit) -> None:
    """
    Pauli-X gate.

    Args:
        qarg: The qubit to apply the gate to.
    """

    ...

y

y(qarg: Qubit) -> None

Pauli-Y gate.

Parameters:

Name	Type	Description	Default
qarg	Qubit	The qubit to apply the gate to.	required

Source code in src/bloqade/qasm2/_wrappers.py

@wraps(uop.Y)
def y(qarg: Qubit) -> None:
    """
    Pauli-Y gate.

    Args:
        qarg: The qubit to apply the gate to.

    """
    ...

z

z(qarg: Qubit) -> None

Pauli-Z gate.

Parameters:

Name	Type	Description	Default
qarg	Qubit	The qubit to apply the gate to.	required

Source code in src/bloqade/qasm2/_wrappers.py

@wraps(uop.Z)
def z(qarg: Qubit) -> None:
    """
    Pauli-Z gate.

    Args:
        qarg: The qubit to apply the gate to.

    """
    ...