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

bloqade/squin/stdlib/channel.py

@@ -1,86 +0,0 @@
-from bloqade.types import Qubit
-from bloqade.squin.op.types import PauliOp
-
-from .. import noise, qubit as _qubit, kernel
-
-
-@kernel
-def pauli_error(basis: PauliOp, p: float, qubit: Qubit) -> None:
-    """Apply the pauli operator given as basis with a probability p to qubit.
-
-    NOTE: the `PauliError` actually supports multiple qubits and multi-site bases,
-    it's only the short-hand definition here that is limited to a single qubit.
-    If you want to define a pauli error for multiple qubits, you can do so using
-    the statement, for example
-
-    ```python
-    q = squin.qubit.new(3)
-    multi_qubit_pauli = squin.op.pauli_string(string="XYZ")
-    pauli_error = squin.noise.pauli_error(basis=multi_qubit_pauli, p=0.1)
-    squin.qubit.apply(pauli_error, q[0], q[1], q[2])
-    ```
-
-    """
-    op = noise.pauli_error(basis, p)
-    _qubit.apply(op, qubit)
-
-
-@kernel
-def depolarize(p: float, qubit: Qubit) -> None:
-    """Apply depolarization error with probability p to qubit.
-
-    This means, that with a probability p/3 one of the three Pauli operators is applied.
-    Which Pauli operator is applied is chosen at random with equal probability.
-    """
-    op = noise.depolarize(p)
-    _qubit.apply(op, qubit)
-
-
-@kernel
-def depolarize2(p: float, qubit1: Qubit, qubit2: Qubit) -> None:
-    """Apply the correlated two-qubit depolarization error with probability p to qubits.
-
-    This means, that with a probability of p/15 one of the Pauli products {XX, XY, XZ, XI, YX, YY, ...}
-    is applied to the qubit pair. Which Pauli product is applied is chosen at random with equal probability.
-    """
-
-    op = noise.depolarize2(p)
-    _qubit.apply(op, qubit1, qubit2)
-
-
-@kernel
-def single_qubit_pauli_channel(params: list[float], qubit: Qubit) -> None:
-    """Apply the single qubit Pauli error with probabilities px, py, pz, respectively, to the qubit.
-
-    Similar to `depolarize`, but with distinct probabilities. An error occurs with the probability `px + py + pz`.
-    Which operator is applied is chosen at random, but weighed with the respective probabilities.
-    """
-    op = noise.single_qubit_pauli_channel(params)
-    _qubit.apply(op, qubit)
-
-
-@kernel
-def two_qubit_pauli_channel(params: list[float], qubit1: Qubit, qubit2: Qubit) -> None:
-    """Apply the two-qubit correlated Pauli error with probabilities given in the list above.
-
-    This means one of the operator products
-
-    {IX, IY, IZ, XI, XX, XY, XZ, YI, YX, YY, YZ, ZI, ZX, ZY, ZZ}
-
-    is applied. The choice of which is weighed by the given probabilities.
-
-    NOTE: the given parameters are ordered as given in the list above!
-
-    """
-    op = noise.two_qubit_pauli_channel(params)
-    _qubit.apply(op, qubit1, qubit2)
-
-
-@kernel
-def qubit_loss(p: float, qubit: Qubit) -> None:
-    """Apply a qubit loss channel with probability p.
-
-    When a loss channel is applied, the qubit is marked as lost by setting its state accordingly.
-    """
-    op = noise.qubit_loss(p)
-    _qubit.apply(op, qubit)

bloqade/squin/stdlib/gate.py

@@ -1,201 +0,0 @@
-from bloqade.types import Qubit
-
-from ..groups import kernel
-
-from .. import op as _op, qubit as _qubit  # isort: skip
-
-
-@kernel
-def x(qubit: Qubit) -> None:
-    """x gate applied to qubit."""
-    op = _op.x()
-    _qubit.apply(op, qubit)
-
-
-@kernel
-def y(qubit: Qubit) -> None:
-    """y gate applied to qubit."""
-    op = _op.y()
-    _qubit.apply(op, qubit)
-
-
-@kernel
-def z(qubit: Qubit) -> None:
-    """z gate applied to qubit."""
-    op = _op.z()
-    _qubit.apply(op, qubit)
-
-
-@kernel
-def sqrt_x(qubit: Qubit) -> None:
-    """Square root x gate applied to qubit."""
-    op = _op.sqrt_x()
-    _qubit.apply(op, qubit)
-
-
-@kernel
-def sqrt_x_adj(qubit: Qubit) -> None:
-    """Adjoint sqrt_x gate applied to qubit."""
-    op = _op.sqrt_x()
-    _qubit.apply(_op.adjoint(op), qubit)
-
-
-@kernel
-def sqrt_y(qubit: Qubit) -> None:
-    """Square root y gate applied to qubit."""
-    op = _op.sqrt_y()
-    _qubit.apply(op, qubit)
-
-
-@kernel
-def sqrt_y_adj(qubit: Qubit) -> None:
-    """Adjoint sqrt_y gate applied to qubit."""
-    op = _op.sqrt_y()
-    _qubit.apply(_op.adjoint(op), qubit)
-
-
-@kernel
-def sqrt_z(qubit: Qubit) -> None:
-    """Square root z gate applied to qubit."""
-    op = _op.s()
-    _qubit.apply(op, qubit)
-
-
-@kernel
-def sqrt_z_adj(qubit: Qubit) -> None:
-    """Adjoint square root z gate applied to qubit."""
-    op = _op.s()
-    _qubit.apply(_op.adjoint(op), qubit)
-
-
-@kernel
-def h(qubit: Qubit) -> None:
-    """Hadamard gate applied to qubit."""
-    op = _op.h()
-    _qubit.apply(op, qubit)
-
-
-@kernel
-def s(qubit: Qubit) -> None:
-    """s gate applied to qubit."""
-    op = _op.s()
-    _qubit.apply(op, qubit)
-
-
-@kernel
-def s_adj(qubit: Qubit) -> None:
-    """Adjoint s gate applied to qubit."""
-    op = _op.s()
-    _qubit.apply(_op.adjoint(op), qubit)
-
-
-@kernel
-def t(qubit: Qubit) -> None:
-    """t gate applied to qubit."""
-    op = _op.t()
-    _qubit.apply(op, qubit)
-
-
-@kernel
-def t_adj(qubit: Qubit) -> None:
-    """Adjoint t gate applied to qubit."""
-    op = _op.t()
-    _qubit.apply(_op.adjoint(op), qubit)
-
-
-@kernel
-def p0(qubit: Qubit) -> None:
-    """Projector on 0 applied to qubit."""
-    op = _op.p0()
-    _qubit.apply(op, qubit)
-
-
-@kernel
-def p1(qubit: Qubit) -> None:
-    """Projector on 1 applied to qubit."""
-    op = _op.p1()
-    _qubit.apply(op, qubit)
-
-
-@kernel
-def spin_n(qubit: Qubit) -> None:
-    """Spin lowering gate applied to qubit."""
-    op = _op.spin_n()
-    _qubit.apply(op, qubit)
-
-
-@kernel
-def spin_p(qubit: Qubit) -> None:
-    """Spin raising gate applied to qubit."""
-    op = _op.spin_p()
-    _qubit.apply(op, qubit)
-
-
-@kernel
-def reset(qubit: Qubit) -> None:
-    """Reset qubit to 0."""
-    op = _op.reset()
-    _qubit.apply(op, qubit)
-
-
-@kernel
-def reset_to_one(qubit: Qubit) -> None:
-    """Reset qubit to 1."""
-    op = _op.reset_to_one()
-    _qubit.apply(op, qubit)
-
-
-@kernel
-def cx(control: Qubit, target: Qubit) -> None:
-    """Controlled x gate applied to control and target"""
-    op = _op.cx()
-    _qubit.apply(op, control, target)
-
-
-@kernel
-def cy(control: Qubit, target: Qubit) -> None:
-    """Controlled y gate applied to control and target"""
-    op = _op.cy()
-    _qubit.apply(op, control, target)
-
-
-@kernel
-def cz(control: Qubit, target: Qubit) -> None:
-    """Controlled z gate applied to control and target"""
-    op = _op.cz()
-    _qubit.apply(op, control, target)
-
-
-@kernel
-def ch(control: Qubit, target: Qubit) -> None:
-    """Controlled Hadamard gate applied to control and target"""
-    op = _op.ch()
-    _qubit.apply(op, control, target)
-
-
-@kernel
-def u(theta: float, phi: float, lam: float, qubit: Qubit) -> None:
-    """3D rotation gate applied to control and target"""
-    op = _op.u(theta, phi, lam)
-    _qubit.apply(op, qubit)
-
-
-@kernel
-def rx(theta: float, qubit: Qubit) -> None:
-    """Rotation X gate applied to qubit."""
-    op = _op.rot(_op.x(), theta)
-    _qubit.apply(op, qubit)
-
-
-@kernel
-def ry(theta: float, qubit: Qubit) -> None:
-    """Rotation Y gate applied to qubit."""
-    op = _op.rot(_op.y(), theta)
-    _qubit.apply(op, qubit)
-
-
-@kernel
-def rz(theta: float, qubit: Qubit) -> None:
-    """Rotation Z gate applied to qubit."""
-    op = _op.rot(_op.z(), theta)
-    _qubit.apply(op, qubit)

bloqade/squin/types.py

@@ -1,8 +0,0 @@
-from kirin import types
-
-
-class MeasurementResult:
-    pass
-
-
-MeasurementResultType = types.PyClass(MeasurementResult)

bloqade/squin/wire.py

@@ -1,201 +0,0 @@
-"""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.
-"""
-
-from kirin import ir, types, lowering, exception
-from kirin.decl import info, statement
-from kirin.dialects import func
-from kirin.lowering import wraps
-from kirin.ir.attrs.types import TypeAttribute
-
-from bloqade.types import Qubit, QubitType
-
-from .types import MeasurementResultType
-from .op.types import Op, OpType
-
-# from kirin.lowering import wraps
-
-# from .op.types import Op, OpType
-
-dialect = ir.Dialect("squin.wire")
-
-
-class WireTerminator(ir.StmtTrait):
-    pass
-
-
-class Wire:
-    pass
-
-
-WireType = types.PyClass(Wire)
-
-
-# no return value for `wrap`
-@statement(dialect=dialect)
-class Wrap(ir.Statement):
-    traits = frozenset({lowering.FromPythonCall(), WireTerminator()})
-    wire: ir.SSAValue = info.argument(WireType)
-    qubit: ir.SSAValue = info.argument(QubitType)
-
-
-# "Unwrap the quantum references to expose wires" -> From Quake Dialect documentation
-# Unwrap(Qubit) -> Wire
-@statement(dialect=dialect)
-class Unwrap(ir.Statement):
-    traits = frozenset({lowering.FromPythonCall(), ir.Pure()})
-    qubit: ir.SSAValue = info.argument(QubitType)
-    result: ir.ResultValue = info.result(WireType)
-
-
-@statement(dialect=dialect)
-class Wired(ir.Statement):
-    traits = frozenset()
-
-    qubits: tuple[ir.SSAValue, ...] = info.argument(QubitType)
-    memory_zone: str = info.attribute()
-    body: ir.Region = info.region(multi=True)
-
-    def __init__(
-        self,
-        body: ir.Region,
-        *qubits: ir.SSAValue,
-        memory_zone: str,
-        result_types: tuple[TypeAttribute, ...] | None = None,
-    ):
-        if result_types is None:
-            for block in body.blocks:
-                if isinstance(block.last_stmt, Yield):
-                    result_types = tuple(arg.type for arg in block.last_stmt.values)
-                    break
-
-        if result_types is None:
-            result_types = ()
-
-        super().__init__(
-            args=qubits,
-            args_slice={
-                "qubits": slice(0, None),
-            },
-            regions=[body],
-            attributes={
-                "memory_zone": ir.PyAttr(memory_zone)
-            },  # body of the wired statement
-            result_types=result_types,
-        )
-
-    def check(self):
-        entry_block = self.body.blocks[0]
-
-        if len(entry_block.args) != len(self.qubits):
-            raise exception.StaticCheckError(
-                f"Expected {len(self.qubits)} arguments, got {len(entry_block.args)}."
-            )
-        for arg in entry_block.args:
-            if not arg.type.is_subseteq(WireType):
-                raise exception.StaticCheckError(
-                    f"Expected argument of type {WireType}, got {arg.type}."
-                )
-        for block in self.body.blocks:
-            last_stmt = block.last_stmt
-            if isinstance(last_stmt, func.Return):
-                raise exception.StaticCheckError(
-                    "Return statements are not allowed in the body of a Wired statement."
-                )
-            elif isinstance(last_stmt, Yield) and len(last_stmt.values) != len(
-                self.results
-            ):
-                raise exception.StaticCheckError(
-                    f"Expected {len(self.results)} return values, got {len(last_stmt.values)}."
-                )
-
-
-@statement(dialect=dialect)
-class Yield(ir.Statement):
-    traits = frozenset({})
-    values: tuple[ir.SSAValue, ...] = info.argument(WireType)
-
-    def __init__(self, *args: ir.SSAValue):
-        super().__init__(
-            args=args,
-            args_slice={
-                "values": slice(0, None),
-            },
-        )
-
-
-# In Quake, you put a wire in and get a wire out when you "apply" an operator
-# In this case though we just need to indicate that an operator is applied to list[wires]
-@statement(dialect=dialect)
-class Apply(ir.Statement):  # apply(op, w1, w2, ...)
-    traits = frozenset({lowering.FromPythonCall()})
-    operator: ir.SSAValue = info.argument(OpType)
-    inputs: tuple[ir.SSAValue, ...] = info.argument(WireType)
-
-    def __init__(self, operator: ir.SSAValue, *args: ir.SSAValue):
-        result_types = tuple(WireType for _ in args)
-        super().__init__(
-            args=(operator,) + args,
-            result_types=result_types,  # result types of the Apply statement, should all be WireTypes
-            args_slice={
-                "operator": 0,
-                "inputs": slice(1, None),
-            },  # pretty printing + syntax sugar
-        )  # custom lowering required for wrapper to work here
-
-
-# Carry over from Qubit dialect
-@statement(dialect=dialect)
-class Broadcast(ir.Statement):
-    traits = frozenset({lowering.FromPythonCall(), ir.Pure()})
-    operator: ir.SSAValue = info.argument(OpType)
-    inputs: tuple[ir.SSAValue, ...] = info.argument(WireType)
-
-    def __init__(self, operator: ir.SSAValue, *args: ir.SSAValue):
-        result_types = tuple(WireType for _ in args)
-        super().__init__(
-            args=(operator,) + args,
-            result_types=result_types,
-            args_slice={
-                "operator": 0,
-                "inputs": slice(1, None),
-            },  # pretty printing + syntax sugar
-        )  # custom lowering required for wrapper to work here
-
-
-@statement(dialect=dialect)
-class RegionMeasure(ir.Statement):
-    traits = frozenset({lowering.FromPythonCall(), WireTerminator()})
-    wire: ir.SSAValue = info.argument(WireType)
-    result: ir.ResultValue = info.result(MeasurementResultType)
-
-
-# NOTE: measurement cannot be pure because they will collapse the state
-#       of the qubit. The state is a hidden state that is not visible to
-#      the user in the wire dialect.
-@statement(dialect=dialect)
-class Measure(ir.Statement):
-    traits = frozenset({lowering.FromPythonCall(), WireTerminator()})
-    wire: ir.SSAValue = info.argument(WireType)
-    qubit: ir.SSAValue = info.argument(QubitType)
-    result: ir.ResultValue = info.result(MeasurementResultType)
-
-
-@statement(dialect=dialect)
-class LossResolvingMeasure(ir.Statement):
-    traits = frozenset({lowering.FromPythonCall()})
-    input_wire: ir.SSAValue = info.argument(WireType)
-    result: ir.ResultValue = info.result(MeasurementResultType)
-    out_wire: ir.ResultValue = info.result(WireType)
-
-
-@wraps(Unwrap)
-def unwrap(qubit: Qubit) -> Wire: ...
-
-
-@wraps(Apply)
-def apply(op: Op, w: Wire) -> Wire: ...

bloqade/stim/rewrite/wire_identity_elimination.py

@@ -1,24 +0,0 @@
-from kirin import ir
-from kirin.rewrite.abc import RewriteRule, RewriteResult
-
-from bloqade.squin import wire
-
-
-class SquinWireIdentityElimination(RewriteRule):
-
-    def rewrite_Statement(self, node: ir.Statement) -> RewriteResult:
-        """
-        Handle the case where an unwrap feeds a wire directly into a wrap,
-        equivalent to nothing happening/identity operation
-
-        w = unwrap(qubit)
-        wrap(qubit, w)
-        """
-        if isinstance(node, wire.Wrap):
-            wire_origin_stmt = node.wire.owner
-            if isinstance(wire_origin_stmt, wire.Unwrap):
-                node.delete()  # get rid of wrap
-                wire_origin_stmt.delete()  # get rid of the unwrap
-                return RewriteResult(has_done_something=True)
-
-        return RewriteResult()

bloqade/stim/rewrite/wire_to_stim.py

@@ -1,57 +0,0 @@
-from kirin import ir
-from kirin.rewrite.abc import RewriteRule, RewriteResult
-
-from bloqade.squin import op, wire, noise
-from bloqade.stim.rewrite.util import (
-    SQUIN_STIM_OP_MAPPING,
-    rewrite_Control,
-    rewrite_QubitLoss,
-    insert_qubit_idx_from_wire_ssa,
-)
-
-
-class SquinWireToStim(RewriteRule):
-
-    def rewrite_Statement(self, node: ir.Statement) -> RewriteResult:
-        match node:
-            case wire.Apply() | wire.Broadcast():
-                return self.rewrite_Apply_and_Broadcast(node)
-            case _:
-                return RewriteResult()
-
-    def rewrite_Apply_and_Broadcast(
-        self, stmt: wire.Apply | wire.Broadcast
-    ) -> RewriteResult:
-
-        # this is an SSAValue, need it to be the actual operator
-        applied_op = stmt.operator.owner
-
-        if isinstance(applied_op, noise.stmts.QubitLoss):
-            return rewrite_QubitLoss(stmt)
-
-        assert isinstance(applied_op, op.stmts.Operator)
-
-        if isinstance(applied_op, op.stmts.Control):
-            return rewrite_Control(stmt)
-
-        stim_1q_op = SQUIN_STIM_OP_MAPPING.get(type(applied_op))
-        if stim_1q_op is None:
-            return RewriteResult()
-
-        qubit_idx_ssas = insert_qubit_idx_from_wire_ssa(
-            wire_ssas=stmt.inputs, stmt_to_insert_before=stmt
-        )
-        if qubit_idx_ssas is None:
-            return RewriteResult()
-
-        stim_1q_stmt = stim_1q_op(targets=tuple(qubit_idx_ssas))
-
-        # Get the wires from the inputs of Apply or Broadcast,
-        # then put those as the result of the current stmt
-        # before replacing it entirely
-        for input_wire, output_wire in zip(stmt.inputs, stmt.results):
-            output_wire.replace_by(input_wire)
-
-        stmt.replace_by(stim_1q_stmt)
-
-        return RewriteResult(has_done_something=True)