bloqade-circuit 0.7.12__py3-none-any.whl → 0.8.0__py3-none-any.whl

bloqade/squin/op/types.py

@@ -1,128 +0,0 @@
-from typing import Generic, TypeVar, overload
-
-from kirin import types
-
-
-class Op:
-
-    def __matmul__(self, other: "Op") -> "Op":
-        raise NotImplementedError("@ can only be used within a squin kernel program")
-
-    @overload
-    def __mul__(self, other: "Op") -> "Op": ...
-
-    @overload
-    def __mul__(self, other: complex) -> "Op": ...
-
-    def __mul__(self, other) -> "Op":
-        raise NotImplementedError("@ can only be used within a squin kernel program")
-
-    def __rmul__(self, other: complex) -> "Op":
-        raise NotImplementedError("@ can only be used within a squin kernel program")
-
-
-OpType = types.PyClass(Op)
-
-
-class CompositeOp(Op):
-    pass
-
-
-CompositeOpType = types.PyClass(CompositeOp)
-
-LhsType = TypeVar("LhsType", bound=Op)
-RhsType = TypeVar("RhsType", bound=Op)
-
-
-class BinaryOp(Op, Generic[LhsType, RhsType]):
-    lhs: LhsType
-    rhs: RhsType
-
-
-BinaryOpType = types.Generic(BinaryOp, OpType, OpType)
-
-
-class Mult(BinaryOp[LhsType, RhsType]):
-    pass
-
-
-MultType = types.Generic(Mult, OpType, OpType)
-
-
-class Kron(BinaryOp[LhsType, RhsType]):
-    pass
-
-
-KronType = types.Generic(Kron, OpType, OpType)
-
-
-class MultiQubitPauliOp(Op):
-    pass
-
-
-MultiQubitPauliOpType = types.PyClass(MultiQubitPauliOp)
-
-
-class PauliStringOp(MultiQubitPauliOp):
-    pass
-
-
-PauliStringType = types.PyClass(PauliStringOp)
-
-
-class PauliOp(MultiQubitPauliOp):
-    pass
-
-
-PauliOpType = types.PyClass(PauliOp)
-
-
-class XOp(PauliOp):
-    pass
-
-
-XOpType = types.PyClass(XOp)
-
-
-class YOp(PauliOp):
-    pass
-
-
-YOpType = types.PyClass(YOp)
-
-
-class ZOp(PauliOp):
-    pass
-
-
-ZOpType = types.PyClass(ZOp)
-
-
-ControlledOp = TypeVar("ControlledOp", bound=Op)
-
-
-class ControlOp(CompositeOp, Generic[ControlledOp]):
-    op: ControlledOp
-
-
-ControlledOpType = types.TypeVar("ControlledOp", bound=OpType)
-ControlOpType = types.Generic(ControlOp, ControlledOpType)
-CXOpType = ControlOpType[XOpType]
-CYOpType = ControlOpType[YOpType]
-CZOpType = ControlOpType[ZOpType]
-
-RotationAxis = TypeVar("RotationAxis", bound=Op)
-
-
-class ROp(CompositeOp, Generic[RotationAxis]):
-    axis: RotationAxis
-    angle: float
-
-
-ROpType = types.Generic(ROp, OpType)
-RxOpType = ROpType[XOpType]
-RyOpType = ROpType[YOpType]
-RzOpType = ROpType[ZOpType]
-
-
-NumOperators = types.TypeVar("NumOperators", bound=types.Int)

bloqade/squin/parallel.py

@@ -1,200 +0,0 @@
-from typing import Any, TypeVar
-
-from kirin.dialects import ilist
-
-from bloqade.types import Qubit
-
-from . import op as _op, qubit as _qubit
-from .groups import kernel
-
-
-@kernel
-def x(qubits: ilist.IList[Qubit, Any]) -> None:
-    """x gate applied to qubits in parallel."""
-    op = _op.x()
-    _qubit.broadcast(op, qubits)
-
-
-@kernel
-def y(qubits: ilist.IList[Qubit, Any]) -> None:
-    """y gate applied to qubits in parallel."""
-    op = _op.y()
-    _qubit.broadcast(op, qubits)
-
-
-@kernel
-def z(qubits: ilist.IList[Qubit, Any]) -> None:
-    """z gate applied to qubits in parallel."""
-    op = _op.z()
-    _qubit.broadcast(op, qubits)
-
-
-@kernel
-def sqrt_x(qubits: ilist.IList[Qubit, Any]) -> None:
-    """Square root x gate applied to qubits in parallel."""
-    op = _op.sqrt_x()
-    _qubit.broadcast(op, qubits)
-
-
-@kernel
-def sqrt_y(qubits: ilist.IList[Qubit, Any]) -> None:
-    """Square root y gate applied to qubits in parallel."""
-    op = _op.sqrt_y()
-    _qubit.broadcast(op, qubits)
-
-
-@kernel
-def sqrt_z(qubits: ilist.IList[Qubit, Any]) -> None:
-    """Square root gate applied to qubits in parallel."""
-    op = _op.s()
-    _qubit.broadcast(op, qubits)
-
-
-@kernel
-def h(qubits: ilist.IList[Qubit, Any]) -> None:
-    """Hadamard gate applied to qubits in parallel."""
-    op = _op.h()
-    _qubit.broadcast(op, qubits)
-
-
-@kernel
-def s(qubits: ilist.IList[Qubit, Any]) -> None:
-    """s gate applied to qubits in parallel."""
-    op = _op.s()
-    _qubit.broadcast(op, qubits)
-
-
-@kernel
-def t(qubits: ilist.IList[Qubit, Any]) -> None:
-    """t gate applied to qubits in parallel."""
-    op = _op.t()
-    _qubit.broadcast(op, qubits)
-
-
-@kernel
-def p0(qubits: ilist.IList[Qubit, Any]) -> None:
-    """Projector on 0 applied to qubits in parallel."""
-    op = _op.p0()
-    _qubit.broadcast(op, qubits)
-
-
-@kernel
-def p1(qubits: ilist.IList[Qubit, Any]) -> None:
-    """Projector on 1 applied to qubits in parallel."""
-    op = _op.p1()
-    _qubit.broadcast(op, qubits)
-
-
-@kernel
-def spin_n(qubits: ilist.IList[Qubit, Any]) -> None:
-    """Spin lowering gate applied to qubits in parallel."""
-    op = _op.spin_n()
-    _qubit.broadcast(op, qubits)
-
-
-@kernel
-def spin_p(qubits: ilist.IList[Qubit, Any]) -> None:
-    """Spin raising gate applied to qubits in parallel."""
-    op = _op.spin_p()
-    _qubit.broadcast(op, qubits)
-
-
-@kernel
-def reset(qubits: ilist.IList[Qubit, Any]) -> None:
-    """Reset qubit to 0."""
-    op = _op.reset()
-    _qubit.broadcast(op, qubits)
-
-
-N = TypeVar("N")
-
-
-@kernel
-def cx(controls: ilist.IList[Qubit, N], targets: ilist.IList[Qubit, N]) -> None:
-    """Controlled x gate applied to controls and targets in parallel."""
-    op = _op.cx()
-    _qubit.broadcast(op, controls, targets)
-
-
-@kernel
-def cy(controls: ilist.IList[Qubit, N], targets: ilist.IList[Qubit, N]) -> None:
-    """Controlled y gate applied to controls and targets in parallel."""
-    op = _op.cy()
-    _qubit.broadcast(op, controls, targets)
-
-
-@kernel
-def cz(controls: ilist.IList[Qubit, N], targets: ilist.IList[Qubit, N]) -> None:
-    """Controlled z gate applied to controls and targets in parallel."""
-    op = _op.cz()
-    _qubit.broadcast(op, controls, targets)
-
-
-@kernel
-def ch(controls: ilist.IList[Qubit, N], targets: ilist.IList[Qubit, N]) -> None:
-    """Controlled Hadamard gate applied to controls and targets in parallel."""
-    op = _op.ch()
-    _qubit.broadcast(op, controls, targets)
-
-
-@kernel
-def u(theta: float, phi: float, lam: float, qubits: ilist.IList[Qubit, Any]) -> None:
-    """3D rotation gate applied to controls and targets in parallel."""
-    op = _op.u(theta, phi, lam)
-    _qubit.broadcast(op, qubits)
-
-
-@kernel
-def rx(theta: float, qubits: ilist.IList[Qubit, Any]) -> None:
-    """Rotation X gate applied to qubits in parallel."""
-    op = _op.rot(_op.x(), theta)
-    _qubit.broadcast(op, qubits)
-
-
-@kernel
-def ry(theta: float, qubits: ilist.IList[Qubit, Any]) -> None:
-    """Rotation Y gate applied to qubits in parallel."""
-    op = _op.rot(_op.y(), theta)
-    _qubit.broadcast(op, qubits)
-
-
-@kernel
-def rz(theta: float, qubits: ilist.IList[Qubit, Any]) -> None:
-    """Rotation Z gate applied to qubits in parallel."""
-    op = _op.rot(_op.z(), theta)
-    _qubit.broadcast(op, qubits)
-
-
-@kernel
-def sqrt_x_adj(qubits: ilist.IList[Qubit, Any]) -> None:
-    """Adjoint sqrt_x gate applied to qubits in parallel."""
-    op = _op.sqrt_x()
-    _qubit.broadcast(_op.adjoint(op), qubits)
-
-
-@kernel
-def sqrt_y_adj(qubits: ilist.IList[Qubit, Any]) -> None:
-    """Adjoint sqrt_y gate applied to qubits in parallel."""
-    op = _op.sqrt_y()
-    _qubit.broadcast(_op.adjoint(op), qubits)
-
-
-@kernel
-def sqrt_z_adj(qubits: ilist.IList[Qubit, Any]) -> None:
-    """Adjoint square root z gate applied to qubits in parallel."""
-    op = _op.s()
-    _qubit.broadcast(_op.adjoint(op), qubits)
-
-
-@kernel
-def s_adj(qubits: ilist.IList[Qubit, Any]) -> None:
-    """Adjoint s gate applied to qubits in parallel."""
-    op = _op.s()
-    _qubit.broadcast(_op.adjoint(op), qubits)
-
-
-@kernel
-def t_adj(qubits: ilist.IList[Qubit, Any]) -> None:
-    """Adjoint t gate applied to qubits in parallel."""
-    op = _op.t()
-    _qubit.broadcast(_op.adjoint(op), qubits)

bloqade/squin/qubit.py

@@ -1,194 +0,0 @@
-"""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.
-"""
-
-from typing import Any, TypeVar, overload
-
-from kirin import ir, types, lowering
-from kirin.decl import info, statement
-from kirin.dialects import ilist
-from kirin.lowering import wraps
-
-from bloqade.types import Qubit, QubitType
-from bloqade.squin.op.types import Op, OpType
-
-from .types import MeasurementResult, MeasurementResultType
-from .lowering import ApplyAnyCallLowering, BroadcastCallLowering
-
-dialect = ir.Dialect("squin.qubit")
-
-
-@statement(dialect=dialect)
-class New(ir.Statement):
-    traits = frozenset({lowering.FromPythonCall()})
-    n_qubits: ir.SSAValue = info.argument(types.Int)
-    result: ir.ResultValue = info.result(ilist.IListType[QubitType, types.Any])
-
-
-@statement(dialect=dialect)
-class Apply(ir.Statement):
-    traits = frozenset({lowering.FromPythonCall()})
-    operator: ir.SSAValue = info.argument(OpType)
-    qubits: tuple[ir.SSAValue, ...] = info.argument(QubitType)
-
-
-@statement(dialect=dialect)
-class ApplyAny(ir.Statement):
-    # NOTE: custom lowering to deal with vararg calls
-    traits = frozenset({ApplyAnyCallLowering()})
-    operator: ir.SSAValue = info.argument(OpType)
-    qubits: tuple[ir.SSAValue, ...] = info.argument()
-
-
-@statement(dialect=dialect)
-class Broadcast(ir.Statement):
-    traits = frozenset({BroadcastCallLowering()})
-    operator: ir.SSAValue = info.argument(OpType)
-    qubits: tuple[ir.SSAValue, ...] = info.argument(ilist.IListType[QubitType])
-
-
-@statement(dialect=dialect)
-class MeasureAny(ir.Statement):
-    name = "measure"
-
-    traits = frozenset({lowering.FromPythonCall()})
-    input: ir.SSAValue = info.argument(types.Any)
-    result: ir.ResultValue = info.result(types.Any)
-
-
-@statement(dialect=dialect)
-class MeasureQubit(ir.Statement):
-    name = "measure.qubit"
-
-    traits = frozenset({lowering.FromPythonCall()})
-    qubit: ir.SSAValue = info.argument(QubitType)
-    result: ir.ResultValue = info.result(MeasurementResultType)
-
-
-@statement(dialect=dialect)
-class MeasureQubitList(ir.Statement):
-    name = "measure.qubit.list"
-
-    traits = frozenset({lowering.FromPythonCall()})
-    qubits: ir.SSAValue = info.argument(ilist.IListType[QubitType])
-    result: ir.ResultValue = info.result(ilist.IListType[MeasurementResultType])
-
-
-@statement(dialect=dialect)
-class QubitId(ir.Statement):
-    traits = frozenset({lowering.FromPythonCall(), ir.Pure()})
-    qubit: ir.SSAValue = info.argument(QubitType)
-    result: ir.ResultValue = info.result(types.Int)
-
-
-@statement(dialect=dialect)
-class MeasurementId(ir.Statement):
-    traits = frozenset({lowering.FromPythonCall(), ir.Pure()})
-    measurement: ir.SSAValue = info.argument(MeasurementResultType)
-    result: ir.ResultValue = info.result(types.Int)
-
-
-# NOTE: no dependent types in Python, so we have to mark it Any...
-@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.
-    """
-    ...
-
-
-@wraps(ApplyAny)
-def apply(operator: Op, *qubits: Qubit) -> None:
-    """Apply an operator to qubits. The number of qubit arguments must match the
-    size of the operator.
-
-    Note, that when considering atom loss, lost qubits will be skipped.
-
-    Args:
-        operator: The operator to apply.
-        *qubits: The qubits to apply the operator to. The number of qubits must
-            match the size of the operator.
-
-    Returns:
-        None
-    """
-    ...
-
-
-@overload
-def measure(input: Qubit) -> MeasurementResult: ...
-@overload
-def measure(
-    input: ilist.IList[Qubit, Any] | list[Qubit],
-) -> ilist.IList[MeasurementResult, Any]: ...
-
-
-@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:
-        MeasurementResult | list[MeasurementResult]: The result of the measurement. If a single qubit is measured,
-            a single result is returned. If a list of qubits is measured, a list of results
-            is returned.
-            A MeasurementResult can represent both 0 and 1, but also atoms that are lost.
-    """
-    ...
-
-
-OpSize = TypeVar("OpSize")
-
-
-@wraps(Broadcast)
-def broadcast(operator: Op, *qubits: ilist.IList[Qubit, OpSize] | list[Qubit]) -> None:
-    """Broadcast and apply an operator to lists of qubits. The number of qubit lists must
-    match the size of the operator and the lists must be of same length. The operator is
-    then applied to the list elements similar to what python's map function does.
-
-    ## Usage examples
-
-    ```python
-    from bloqade import squin
-
-    @squin.kernel
-    def ghz():
-        controls = squin.qubit.new(4)
-        targets = squin.qubit.new(4)
-
-        h = squin.op.h()
-        squin.qubit.broadcast(h, controls)
-
-        cx = squin.op.cx()
-        squin.qubit.broadcast(cx, controls, targets)
-    ```
-
-    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
-    """
-    ...
-
-
-@wraps(QubitId)
-def get_qubit_id(qubit: Qubit) -> int: ...
-
-
-@wraps(MeasurementId)
-def get_measurement_id(measurement: MeasurementResult) -> int: ...

bloqade/squin/rewrite/canonicalize.py

@@ -1,60 +0,0 @@
-from typing import cast
-
-from kirin import ir
-from kirin.rewrite import abc
-from kirin.dialects import cf
-
-from .. import wire
-
-
-class CanonicalizeWired(abc.RewriteRule):
-    def rewrite_Statement(self, node: ir.Statement) -> abc.RewriteResult:
-
-        if (
-            not isinstance(node, wire.Wired)
-            or len(node.qubits) != 0
-            or (parent_region := node.parent_region) is None
-        ):
-            return abc.RewriteResult()
-
-        parent_block = cast(ir.Block, node.parent_block)
-
-        # the body doesn't contain any quantum operations so we can safely inline the
-        # body into the parent block
-
-        # move all statements after `node` in the current block into another block
-        after_block = ir.Block()
-
-        stmt = node.next_stmt
-        while stmt is not None:
-            stmt.detach()
-            after_block.stmts.append(stmt)
-            stmt = node.next_stmt
-
-        # remap all results of the node to the arguments of the after_block
-        for result in node.results:
-            arg = after_block.args.append_from(result.type, result.name)
-            result.replace_by(arg)
-
-        parent_block_idx = parent_region._block_idx[parent_block]
-        # insert goto of parent block to the body block of the node.
-        parent_region.blocks.insert(parent_block_idx + 1, after_block)
-        # insert all blocks of the body of the node after the parent region
-        # making sure to convert any yield statements to jump statements to the after_block
-        parent_block.stmts.append(
-            cf.Branch(
-                arguments=(),
-                successor=node.body.blocks[0],
-            )
-        )
-        for block in reversed(node.body.blocks):
-            block.detach()
-            if isinstance((yield_stmt := block.last_stmt), wire.Yield):
-                yield_stmt.replace_by(
-                    cf.Branch(yield_stmt.values, successor=after_block)
-                )
-
-            parent_region.blocks.insert(parent_block_idx + 1, block)
-
-        node.delete()
-        return abc.RewriteResult(has_done_something=True)

bloqade/squin/rewrite/desugar.py

@@ -1,102 +0,0 @@
-from warnings import warn
-
-from kirin import ir, types
-from kirin.dialects import py, ilist
-from kirin.rewrite.abc import RewriteRule, RewriteResult
-
-from bloqade.squin.qubit import (
-    Apply,
-    ApplyAny,
-    QubitType,
-    MeasureAny,
-    MeasureQubit,
-    MeasureQubitList,
-)
-
-
-class MeasureDesugarRule(RewriteRule):
-    """
-    Desugar measure operations in the circuit.
-    """
-
-    def rewrite_Statement(self, node: ir.Statement) -> RewriteResult:
-
-        if not isinstance(node, MeasureAny):
-            return RewriteResult()
-
-        if node.input.type.is_subseteq(QubitType):
-            node.replace_by(
-                MeasureQubit(
-                    qubit=node.input,
-                )
-            )
-            return RewriteResult(has_done_something=True)
-        elif node.input.type.is_subseteq(ilist.IListType[QubitType, types.Any]):
-            node.replace_by(
-                MeasureQubitList(
-                    qubits=node.input,
-                )
-            )
-            return RewriteResult(has_done_something=True)
-
-        return RewriteResult()
-
-
-class ApplyDesugarRule(RewriteRule):
-    """
-    Desugar apply operators in the kernel.
-
-    NOTE: this pass can be removed once we decide to disallow the syntax apply(op: Op, qubits: list)
-    """
-
-    def rewrite_Statement(self, node: ir.Statement) -> RewriteResult:
-
-        if not isinstance(node, ApplyAny):
-            return RewriteResult()
-
-        op = node.operator
-        qubits = node.qubits
-
-        if len(qubits) == 0:
-            # NOTE: this is invalid syntax, but we don't error in rewrites
-            return RewriteResult()
-
-        if all(q.type.is_subseteq(QubitType) for q in qubits):
-            # NOTE: this is the syntax we want; the entire rewrite becomes unnecessary
-            # once we disallow the old syntax (just wrap Apply directly)
-            apply_stmt = Apply(op, qubits)
-            node.replace_by(apply_stmt)
-            return RewriteResult(has_done_something=True)
-
-        if len(qubits) > 1:
-            # NOTE: multiple arguments, that aren't qubits, let's bail
-            return RewriteResult()
-
-        qubit_type = qubits[0].type
-        is_qubit_list = qubit_type.is_subseteq(ilist.IListType[QubitType, types.Any])
-
-        if not is_qubit_list:
-            return RewriteResult()
-
-        # NOTE: deprecated syntax: we have a single list of qubits here
-        warn(
-            "The syntax `apply(operator: Op, qubits: list[Qubit])` is deprecated and may already lead to errors. Use `apply(operator: Op, *qubits: Qubit)` instead."
-        )
-        if not isinstance(qubit_type.vars[1], types.Literal):
-            # NOTE: unknown size, nothing we can do here, it will probably error down the road somewhere
-            return RewriteResult()
-
-        n = qubit_type.vars[1].data
-        if not isinstance(n, int):
-            # wat?
-            return RewriteResult()
-
-        qubits_rewrite = []
-        for i in range(n):
-            (idx := py.Constant(i)).insert_before(node)
-            (get_item := py.GetItem(qubits[0], idx.result)).insert_before(node)
-            qubits_rewrite.append(get_item.result)
-
-        apply_stmt = Apply(op, tuple(qubits_rewrite))
-        node.replace_by(apply_stmt)
-        return RewriteResult(has_done_something=True)