analysis

schedule

StmtDag dataclass

StmtDag(
    id_table: IdTable[
        Statement
    ] = lambda: idtable.IdTable()(),
    stmts: Dict[str, Statement] = OrderedDict(),
    out_edges: Dict[str, Set[str]] = OrderedDict(),
    inc_edges: Dict[str, Set[str]] = OrderedDict(),
    stmt_index: Dict[Statement, int] = OrderedDict(),
)

Bases: Graph[Statement]

topological_groups

topological_groups()

Split the dag into topological groups where each group contains nodes that have no dependencies on each other, but have dependencies on nodes in one or more previous groups.

Yields:

Type	Description
	List[str]: A list of node ids in a topological group

Raises:

Type	Description
ValueError	If a cyclic dependency is detected

The idea is to yield all nodes with no dependencies, then remove those nodes from the graph repeating until no nodes are left or we reach some upper limit. Worse case is a linear dag, so we can use len(dag.stmts) as the upper limit

If we reach the limit and there are still nodes left, then we have a cyclic dependency.

Source code in .venv/lib/python3.12/site-packages/bloqade/squin/analysis/schedule.py

def topological_groups(self):
    """Split the dag into topological groups where each group
    contains nodes that have no dependencies on each other, but
    have dependencies on nodes in one or more previous groups.

    Yields:
        List[str]: A list of node ids in a topological group


    Raises:
        ValueError: If a cyclic dependency is detected


    The idea is to yield all nodes with no dependencies, then remove
    those nodes from the graph repeating until no nodes are left
    or we reach some upper limit. Worse case is a linear dag,
    so we can use len(dag.stmts) as the upper limit

    If we reach the limit and there are still nodes left, then we
    have a cyclic dependency.
    """

    inc_edges = {k: set(v) for k, v in self.inc_edges.items()}

    check_next = inc_edges.keys()

    for _ in range(len(self.stmts)):
        if len(inc_edges) == 0:
            break

        group = [node_id for node_id in check_next if len(inc_edges[node_id]) == 0]
        yield group

        check_next = set()
        for n in group:
            inc_edges.pop(n)
            for m in self.out_edges[n]:
                check_next.add(m)
                inc_edges[m].remove(n)

    if inc_edges:
        raise ValueError("Cyclic dependency detected")

noise

stmts

Depolarize

Bases: NoiseChannel

Apply n-qubit depolaize error to qubits NOTE For Stim, this can only accept 1 or 2 qubits

PPError

Bases: NoiseChannel

Pauli Product Error

op

ch

ch() -> types.Op

Control H gate.

Source code in .venv/lib/python3.12/site-packages/bloqade/squin/op/__init__.py

@op
def ch() -> types.Op:
    """Control H gate."""
    return control(h(), n_controls=1)

control

control(op: Op, *, n_controls: int) -> types.Op

Create a controlled operator.

Note, that when considering atom loss, the operator will not be applied if any of the controls has been lost.

Parameters:

Name	Type	Description	Default
operator		The operator to apply under the control.	required
n_controls	int	The number qubits to be used as control.	required

Returns:

Type	Description
Op	Operator

Source code in .venv/lib/python3.12/site-packages/bloqade/squin/op/__init__.py

@_wraps(stmts.Control)
def control(op: types.Op, *, n_controls: int) -> types.Op:
    """
    Create a controlled operator.

    Note, that when considering atom loss, the operator will not be applied if
    any of the controls has been lost.

    Args:
        operator: The operator to apply under the control.
        n_controls: The number qubits to be used as control.

    Returns:
        Operator
    """
    ...

cphase

cphase(theta: float) -> types.Op

Control Phase gate.

Source code in .venv/lib/python3.12/site-packages/bloqade/squin/op/__init__.py

@op
def cphase(theta: float) -> types.Op:
    """Control Phase gate."""
    return control(phase(theta), n_controls=1)

cx

cx() -> types.Op

Controlled X gate.

Source code in .venv/lib/python3.12/site-packages/bloqade/squin/op/__init__.py

@op
def cx() -> types.Op:
    """Controlled X gate."""
    return control(x(), n_controls=1)

cy

cy() -> types.Op

Controlled Y gate.

Source code in .venv/lib/python3.12/site-packages/bloqade/squin/op/__init__.py

@op
def cy() -> types.Op:
    """Controlled Y gate."""
    return control(y(), n_controls=1)

cz

cz() -> types.Op

Control Z gate.

Source code in .venv/lib/python3.12/site-packages/bloqade/squin/op/__init__.py

@op
def cz() -> types.Op:
    """Control Z gate."""
    return control(z(), n_controls=1)

rx

rx(theta: float) -> types.Op

Rotation X gate.

Source code in .venv/lib/python3.12/site-packages/bloqade/squin/op/__init__.py

@op
def rx(theta: float) -> types.Op:
    """Rotation X gate."""
    return rot(x(), theta)

ry

ry(theta: float) -> types.Op

Rotation Y gate.

Source code in .venv/lib/python3.12/site-packages/bloqade/squin/op/__init__.py

@op
def ry(theta: float) -> types.Op:
    """Rotation Y gate."""
    return rot(y(), theta)

rz

rz(theta: float) -> types.Op

Rotation Z gate.

Source code in .venv/lib/python3.12/site-packages/bloqade/squin/op/__init__.py

@op
def rz(theta: float) -> types.Op:
    """Rotation Z gate."""
    return rot(z(), theta)

rewrite

Rewrite py.binop.mult to Mult stmt

stmts

P0

Bases: ConstantOp

The \(P_0\) projection operator.

\[ P0 = \begin{bmatrix} 1 & 0 \\ 0 & 0 \end{bmatrix} \]

P1

Bases: ConstantOp

The \(P_1\) projection operator.

\[ P1 = \begin{bmatrix} 0 & 0 \\ 0 & 1 \end{bmatrix} \]

PhaseOp

Bases: PrimitiveOp

A phase operator.

\[ PhaseOp(theta) = e^{i heta} I \]

ShiftOp

Bases: PrimitiveOp

A phase shift operator.

\[ Shift(theta) = \begin{bmatrix} 1 & 0 \\ 0 & e^{i \theta} \end{bmatrix} \]

Sn

Bases: ConstantOp

\(S_{-}\) operator.

\[ Sn = \frac{1}{2} (S_x - i S_y) = \frac{1}{2} \begin{bmatrix} 0 & 0 \\ 1 & 0 \end{bmatrix} \]

Sp

Bases: ConstantOp

\(S_{+}\) operator.

\[ Sp = \frac{1}{2} (S_x + i S_y) = \frac{1}{2}\begin{bmatrix} 0 & 1 \\ 0 & 0 \end{bmatrix} \]

traits

HasSites dataclass

HasSites()

Bases: StmtTrait

An operator with a sites attribute.

qubit

qubit dialect for squin language.

This dialect defines the operations that can be performed on qubits.

Depends on: - bloqade.squin.op: provides the OpType type and semantics for operators applied to qubits. - kirin.dialects.ilist: provides the ilist.IListType type for lists of qubits.

apply

apply(
    operator: Op, qubits: IList[Qubit, Any] | list[Qubit]
) -> None

Apply an operator to a list of qubits.

Note, that when considering atom loss, lost qubits will be skipped.

Parameters:

Name	Type	Description	Default
operator	Op	The operator to apply.	required
qubits	IList[Qubit, Any] | list[Qubit]	The list of qubits to apply the operator to. The size of the list must be inferable and match the number of qubits expected by the operator.	required

Returns:

Type	Description
None	None

Source code in .venv/lib/python3.12/site-packages/bloqade/squin/qubit.py

@wraps(Apply)
def apply(operator: Op, qubits: ilist.IList[Qubit, Any] | list[Qubit]) -> None:
    """Apply an operator to a list of qubits.

    Note, that when considering atom loss, lost qubits will be skipped.

    Args:
        operator: The operator to apply.
        qubits: The list of qubits to apply the operator to. The size of the list
            must be inferable and match the number of qubits expected by the operator.

    Returns:
        None
    """
    ...

broadcast

broadcast(
    operator: Op, qubits: IList[Qubit, Any] | list[Qubit]
) -> None

Broadcast and apply an operator to a list of qubits. For example, an operator that expects 2 qubits can be applied to a list of 2n qubits, where n is an integer > 0.

For controlled operators, the list of qubits is interpreted as sets of (controls, targets). For example

apply(CX, [q0, q1, q2, q3])

is equivalent to

apply(CX, [q0, q1])
apply(CX, [q2, q3])

Parameters:

Name	Type	Description	Default
operator	Op	The operator to broadcast and apply.	required
qubits	IList[Qubit, Any] | list[Qubit]	The list of qubits to broadcast and apply the operator to. The size of the list must be inferable and match the number of qubits expected by the operator.	required

Returns:

Type	Description
None	None

Source code in .venv/lib/python3.12/site-packages/bloqade/squin/qubit.py

@wraps(Broadcast)
def broadcast(operator: Op, qubits: ilist.IList[Qubit, Any] | list[Qubit]) -> None:
    """Broadcast and apply an operator to a list of qubits. For example, an operator
    that expects 2 qubits can be applied to a list of 2n qubits, where n is an integer > 0.

    For controlled operators, the list of qubits is interpreted as sets of (controls, targets).
    For example

    ```
    apply(CX, [q0, q1, q2, q3])
    ```

    is equivalent to

    ```
    apply(CX, [q0, q1])
    apply(CX, [q2, q3])
    ```

    Args:
        operator: The operator to broadcast and apply.
        qubits: The list of qubits to broadcast and apply the operator to. The size of the list
            must be inferable and match the number of qubits expected by the operator.

    Returns:
        None
    """
    ...

measure

measure(input: Qubit) -> bool

measure(
    input: IList[Qubit, Any] | list[Qubit],
) -> ilist.IList[bool, Any]

measure(input: Any) -> Any

Measure a qubit or qubits in the list.

Parameters:

Name	Type	Description	Default
input	Any	A qubit or a list of qubits to measure.	required

Returns:

Type	Description
Any	bool | list[bool]: The result of the measurement. If a single qubit is measured, a single boolean is returned. If a list of qubits is measured, a list of booleans is returned.

Source code in .venv/lib/python3.12/site-packages/bloqade/squin/qubit.py

@wraps(MeasureAny)
def measure(input: Any) -> Any:
    """Measure a qubit or qubits in the list.

    Args:
        input: A qubit or a list of qubits to measure.

    Returns:
        bool | list[bool]: The result of the measurement. If a single qubit is measured,
            a single boolean is returned. If a list of qubits is measured, a list of booleans
            is returned.
    """
    ...

measure_and_reset

measure_and_reset(
    qubits: IList[Qubit, Any],
) -> ilist.IList[bool, Any]

Measure the qubits in the list and reset them."

Parameters:

Name	Type	Description	Default
qubits	IList[Qubit, Any]	The list of qubits to measure and reset.	required

Returns:

Type	Description
IList[bool, Any]	list[bool]: The result of the measurement.

Source code in .venv/lib/python3.12/site-packages/bloqade/squin/qubit.py

@wraps(MeasureAndReset)
def measure_and_reset(qubits: ilist.IList[Qubit, Any]) -> ilist.IList[bool, Any]:
    """Measure the qubits in the list and reset them."

    Args:
        qubits: The list of qubits to measure and reset.

    Returns:
        list[bool]: The result of the measurement.
    """
    ...

new

new(n_qubits: int) -> ilist.IList[Qubit, Any]

Create a new list of qubits.

Parameters:

Name	Type	Description	Default
n_qubits(int)		The number of qubits to create.	required

Returns:

Type	Description
IList[Qubit, Any]	(ilist.IList[Qubit, n_qubits]) A list of qubits.

Source code in .venv/lib/python3.12/site-packages/bloqade/squin/qubit.py

@wraps(New)
def new(n_qubits: int) -> ilist.IList[Qubit, Any]:
    """Create a new list of qubits.

    Args:
        n_qubits(int): The number of qubits to create.

    Returns:
        (ilist.IList[Qubit, n_qubits]) A list of qubits.
    """
    ...

reset

reset(qubits: IList[Qubit, Any]) -> None

Reset the qubits in the list."

Parameters:

Name	Type	Description	Default
qubits	IList[Qubit, Any]	The list of qubits to reset.	required

Source code in .venv/lib/python3.12/site-packages/bloqade/squin/qubit.py

@wraps(Reset)
def reset(qubits: ilist.IList[Qubit, Any]) -> None:
    """Reset the qubits in the list."

    Args:
        qubits: The list of qubits to reset.
    """
    ...

rewrite

measure_desugar

MeasureDesugarRule

Bases: RewriteRule

Desugar measure operations in the circuit.

wire

A NVIDIA QUAKE-like wire dialect.

This dialect is expected to be used in combination with the operator dialect as an intermediate representation for analysis and optimization of quantum circuits. Thus we do not define wrapping functions for the statements in this dialect.