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

bloqade/squin/op/__init__.py

@@ -1,41 +0,0 @@
-from . import stmts as stmts, types as types, rewrite as rewrite
-from .stdlib import (
-    ch as ch,
-    cx as cx,
-    cy as cy,
-    cz as cz,
-    rx as rx,
-    ry as ry,
-    rz as rz,
-    cphase as cphase,
-)
-from .traits import Unitary as Unitary, MaybeUnitary as MaybeUnitary
-from ._dialect import dialect as dialect
-from ._wrapper import (
-    h as h,
-    s as s,
-    t as t,
-    u as u,
-    x as x,
-    y as y,
-    z as z,
-    p0 as p0,
-    p1 as p1,
-    rot as rot,
-    kron as kron,
-    mult as mult,
-    phase as phase,
-    reset as reset,
-    scale as scale,
-    shift as shift,
-    spin_n as spin_n,
-    spin_p as spin_p,
-    sqrt_x as sqrt_x,
-    sqrt_y as sqrt_y,
-    sqrt_z as sqrt_z,
-    adjoint as adjoint,
-    control as control,
-    identity as identity,
-    pauli_string as pauli_string,
-    reset_to_one as reset_to_one,
-)

bloqade/squin/op/_dialect.py

@@ -1,3 +0,0 @@
-from kirin import ir
-
-dialect = ir.Dialect("squin.op")

bloqade/squin/op/_wrapper.py

@@ -1,121 +0,0 @@
-from kirin.lowering import wraps
-
-from . import stmts, types
-
-
-@wraps(stmts.Kron)
-def kron(lhs: types.Op, rhs: types.Op) -> types.Op: ...
-
-
-@wraps(stmts.Mult)
-def mult(lhs: types.Op, rhs: types.Op) -> types.Op: ...
-
-
-@wraps(stmts.Scale)
-def scale(op: types.Op, factor: complex) -> types.Op: ...
-
-
-@wraps(stmts.Adjoint)
-def adjoint(op: types.Op) -> types.Op: ...
-
-
-@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
-    """
-    ...
-
-
-@wraps(stmts.Reset)
-def reset() -> types.Op: ...
-
-
-@wraps(stmts.ResetToOne)
-def reset_to_one() -> types.Op: ...
-
-
-@wraps(stmts.Identity)
-def identity(*, sites: int) -> types.Op: ...
-
-
-@wraps(stmts.Rot)
-def rot(axis: types.Op, angle: float) -> types.Op: ...
-
-
-@wraps(stmts.ShiftOp)
-def shift(theta: float) -> types.Op: ...
-
-
-@wraps(stmts.PhaseOp)
-def phase(theta: float) -> types.Op: ...
-
-
-@wraps(stmts.X)
-def x() -> types.PauliOp: ...
-
-
-@wraps(stmts.Y)
-def y() -> types.PauliOp: ...
-
-
-@wraps(stmts.Z)
-def z() -> types.PauliOp: ...
-
-
-@wraps(stmts.SqrtX)
-def sqrt_x() -> types.Op: ...
-
-
-@wraps(stmts.SqrtY)
-def sqrt_y() -> types.Op: ...
-
-
-@wraps(stmts.S)
-def sqrt_z() -> types.Op: ...
-
-
-@wraps(stmts.H)
-def h() -> types.Op: ...
-
-
-@wraps(stmts.S)
-def s() -> types.Op: ...
-
-
-@wraps(stmts.T)
-def t() -> types.Op: ...
-
-
-@wraps(stmts.P0)
-def p0() -> types.Op: ...
-
-
-@wraps(stmts.P1)
-def p1() -> types.Op: ...
-
-
-@wraps(stmts.Sn)
-def spin_n() -> types.Op: ...
-
-
-@wraps(stmts.Sp)
-def spin_p() -> types.Op: ...
-
-
-@wraps(stmts.U3)
-def u(theta: float, phi: float, lam: float) -> types.Op: ...
-
-
-@wraps(stmts.PauliString)
-def pauli_string(*, string: str) -> types.PauliStringOp: ...

bloqade/squin/op/number.py

@@ -1,5 +0,0 @@
-import numbers
-
-from kirin.ir.attrs.types import PyClass
-
-NumberType = PyClass(numbers.Number)

bloqade/squin/op/rewrite.py

@@ -1,46 +0,0 @@
-"""Rewrite py.binop.mult to Mult stmt"""
-
-from kirin import ir
-from kirin.passes import Pass
-from kirin.rewrite import Walk
-from kirin.dialects import py
-from kirin.rewrite.abc import RewriteRule, RewriteResult
-
-from .stmts import Mult, Scale
-from .types import OpType
-
-
-class _PyMultToSquinMult(RewriteRule):
-
-    def rewrite_Statement(self, node: ir.Statement) -> RewriteResult:
-        if not isinstance(node, py.Mult):
-            return RewriteResult()
-
-        lhs_is_op = node.lhs.type.is_subseteq(OpType)
-        rhs_is_op = node.rhs.type.is_subseteq(OpType)
-
-        if not lhs_is_op and not rhs_is_op:
-            return RewriteResult()
-
-        if lhs_is_op and rhs_is_op:
-            mult = Mult(node.lhs, node.rhs)
-            node.replace_by(mult)
-            return RewriteResult(has_done_something=True)
-
-        if lhs_is_op:
-            scale = Scale(node.lhs, node.rhs)
-            node.replace_by(scale)
-            return RewriteResult(has_done_something=True)
-
-        if rhs_is_op:
-            scale = Scale(node.rhs, node.lhs)
-            node.replace_by(scale)
-            return RewriteResult(has_done_something=True)
-
-        return RewriteResult()
-
-
-class PyMultToSquinMult(Pass):
-
-    def unsafe_run(self, mt: ir.Method) -> RewriteResult:
-        return Walk(_PyMultToSquinMult()).rewrite(mt.code)

bloqade/squin/op/stdlib.py

@@ -1,62 +0,0 @@
-from kirin import ir
-from kirin.prelude import structural_no_opt
-
-from . import types
-from ._dialect import dialect
-from ._wrapper import h, x, y, z, rot, phase, control
-
-
-@ir.dialect_group(structural_no_opt.add(dialect))
-def op(self):
-    def run_pass(method):
-        pass
-
-    return run_pass
-
-
-@op
-def rx(theta: float) -> types.Op:
-    """Rotation X gate."""
-    return rot(x(), theta)
-
-
-@op
-def ry(theta: float) -> types.Op:
-    """Rotation Y gate."""
-    return rot(y(), theta)
-
-
-@op
-def rz(theta: float) -> types.Op:
-    """Rotation Z gate."""
-    return rot(z(), theta)
-
-
-@op
-def cx() -> types.Op:
-    """Controlled X gate."""
-    return control(x(), n_controls=1)
-
-
-@op
-def cy() -> types.Op:
-    """Controlled Y gate."""
-    return control(y(), n_controls=1)
-
-
-@op
-def cz() -> types.Op:
-    """Control Z gate."""
-    return control(z(), n_controls=1)
-
-
-@op
-def ch() -> types.Op:
-    """Control H gate."""
-    return control(h(), n_controls=1)
-
-
-@op
-def cphase(theta: float) -> types.Op:
-    """Control Phase gate."""
-    return control(phase(theta), n_controls=1)

bloqade/squin/op/stmts.py

@@ -1,300 +0,0 @@
-from kirin import ir, types, lowering
-from kirin.decl import info, statement
-
-from .types import (
-    OpType,
-    ROpType,
-    XOpType,
-    YOpType,
-    ZOpType,
-    KronType,
-    MultType,
-    PauliOpType,
-    ControlOpType,
-    PauliStringType,
-    ControlledOpType,
-)
-from .number import NumberType
-from .traits import Unitary, HasSites, FixedSites, MaybeUnitary
-from ._dialect import dialect
-
-
-@statement
-class Operator(ir.Statement):
-    result: ir.ResultValue = info.result(OpType)
-
-
-@statement
-class PrimitiveOp(Operator):
-    pass
-
-
-@statement
-class CompositeOp(Operator):
-    pass
-
-
-LhsType = types.TypeVar("Lhs", bound=OpType)
-RhsType = types.TypeVar("Rhs", bound=OpType)
-
-
-@statement
-class BinaryOp(CompositeOp):
-    lhs: ir.SSAValue = info.argument(LhsType)
-    rhs: ir.SSAValue = info.argument(RhsType)
-
-
-@statement(dialect=dialect)
-class Kron(BinaryOp):
-    traits = frozenset({ir.Pure(), lowering.FromPythonCall(), MaybeUnitary()})
-    is_unitary: bool = info.attribute(default=False)
-    result: ir.ResultValue = info.result(KronType[LhsType, RhsType])
-
-
-@statement(dialect=dialect)
-class Mult(BinaryOp):
-    traits = frozenset({ir.Pure(), lowering.FromPythonCall(), MaybeUnitary()})
-    is_unitary: bool = info.attribute(default=False)
-    result: ir.ResultValue = info.result(MultType[LhsType, RhsType])
-
-
-@statement(dialect=dialect)
-class Adjoint(CompositeOp):
-    traits = frozenset({ir.Pure(), lowering.FromPythonCall(), MaybeUnitary()})
-    is_unitary: bool = info.attribute(default=False)
-    op: ir.SSAValue = info.argument(OpType)
-
-
-@statement(dialect=dialect)
-class Scale(CompositeOp):
-    traits = frozenset({ir.Pure(), lowering.FromPythonCall(), MaybeUnitary()})
-    is_unitary: bool = info.attribute(default=False)
-    op: ir.SSAValue = info.argument(OpType)
-    factor: ir.SSAValue = info.argument(NumberType)
-
-
-@statement(dialect=dialect)
-class Control(CompositeOp):
-    traits = frozenset({ir.Pure(), lowering.FromPythonCall(), MaybeUnitary()})
-    is_unitary: bool = info.attribute(default=False)
-    op: ir.SSAValue = info.argument(ControlledOpType)
-    n_controls: int = info.attribute()
-    result: ir.ResultValue = info.result(ControlOpType[ControlledOpType])
-
-
-RotationAxisType = types.TypeVar("RotationAxis", bound=OpType)
-
-
-@statement(dialect=dialect)
-class Rot(CompositeOp):
-    traits = frozenset({ir.Pure(), lowering.FromPythonCall(), Unitary()})
-    axis: ir.SSAValue = info.argument(RotationAxisType)
-    angle: ir.SSAValue = info.argument(types.Float)
-    result: ir.ResultValue = info.result(ROpType[RotationAxisType])
-
-
-@statement(dialect=dialect)
-class Identity(CompositeOp):
-    traits = frozenset({ir.Pure(), lowering.FromPythonCall(), Unitary(), HasSites()})
-    sites: int = info.attribute()
-
-
-@statement
-class ConstantOp(PrimitiveOp):
-    traits = frozenset(
-        {ir.Pure(), lowering.FromPythonCall(), ir.ConstantLike(), FixedSites(1)}
-    )
-
-
-@statement
-class ConstantUnitary(ConstantOp):
-    traits = frozenset(
-        {
-            ir.Pure(),
-            lowering.FromPythonCall(),
-            ir.ConstantLike(),
-            Unitary(),
-            FixedSites(1),
-        }
-    )
-
-
-@statement(dialect=dialect)
-class U3(PrimitiveOp):
-    """
-    The rotation operator U3(theta, phi, lam).
-    Note that we use the convention from the QASM2 specification, namely
-
-    $$
-    U_3(\\theta, \\phi, \\lambda) = R_z(\\phi) R_y(\\theta) R_z(\\lambda)
-    $$
-    """
-
-    traits = frozenset({ir.Pure(), lowering.FromPythonCall(), Unitary(), FixedSites(1)})
-    theta: ir.SSAValue = info.argument(types.Float)
-    phi: ir.SSAValue = info.argument(types.Float)
-    lam: ir.SSAValue = info.argument(types.Float)
-
-
-@statement(dialect=dialect)
-class PhaseOp(PrimitiveOp):
-    """
-    A phase operator.
-
-    $$
-    \\text{PhaseOp}(\\theta) = e^{i \\theta} I
-    $$
-    """
-
-    traits = frozenset({ir.Pure(), lowering.FromPythonCall(), Unitary(), FixedSites(1)})
-    theta: ir.SSAValue = info.argument(types.Float)
-
-
-@statement(dialect=dialect)
-class ShiftOp(PrimitiveOp):
-    """
-    A phase shift operator.
-
-    $$
-    \\text{Shift}(\\theta) = \\begin{bmatrix} 1 & 0 \\\\ 0 & e^{i \\theta} \\end{bmatrix}
-    $$
-    """
-
-    traits = frozenset({ir.Pure(), lowering.FromPythonCall(), Unitary(), FixedSites(1)})
-    theta: ir.SSAValue = info.argument(types.Float)
-
-
-@statement(dialect=dialect)
-class Reset(PrimitiveOp):
-    """
-    Reset operator for qubits and wires.
-    """
-
-    traits = frozenset({ir.Pure(), lowering.FromPythonCall(), FixedSites(1)})
-
-
-@statement(dialect=dialect)
-class ResetToOne(PrimitiveOp):
-    """
-    Reset qubits to the one state. Mainly needed to accommodate cirq's GeneralizedAmplitudeDampingChannel
-    """
-
-    traits = frozenset({ir.Pure(), lowering.FromPythonCall(), FixedSites(1)})
-
-
-@statement
-class CliffordOp(ConstantUnitary):
-    pass
-
-
-@statement
-class PauliOp(CliffordOp):
-    result: ir.ResultValue = info.result(type=PauliOpType)
-
-
-@statement(dialect=dialect)
-class PauliString(ConstantUnitary):
-    traits = frozenset({ir.Pure(), lowering.FromPythonCall(), Unitary(), HasSites()})
-    string: str = info.attribute()
-    result: ir.ResultValue = info.result(type=PauliStringType)
-
-    def verify(self) -> None:
-        if not set("XYZ").issuperset(self.string):
-            raise ValueError(
-                f"Invalid Pauli string: {self.string}. Must be a combination of 'X', 'Y', and 'Z'."
-            )
-
-
-@statement(dialect=dialect)
-class X(PauliOp):
-    result: ir.ResultValue = info.result(XOpType)
-
-
-@statement(dialect=dialect)
-class Y(PauliOp):
-    result: ir.ResultValue = info.result(YOpType)
-
-
-@statement(dialect=dialect)
-class Z(PauliOp):
-    result: ir.ResultValue = info.result(ZOpType)
-
-
-@statement(dialect=dialect)
-class SqrtX(ConstantUnitary):
-    pass
-
-
-@statement(dialect=dialect)
-class SqrtY(ConstantUnitary):
-    pass
-
-
-# NOTE no SqrtZ since its equal to S
-
-
-@statement(dialect=dialect)
-class H(ConstantUnitary):
-    pass
-
-
-@statement(dialect=dialect)
-class S(ConstantUnitary):
-    pass
-
-
-@statement(dialect=dialect)
-class T(ConstantUnitary):
-    pass
-
-
-@statement(dialect=dialect)
-class P0(ConstantOp):
-    """
-    The $P_0$ projection operator.
-
-    $$
-    P0 = \\begin{bmatrix} 1 & 0 \\\\ 0 & 0 \\end{bmatrix}
-    $$
-    """
-
-    pass
-
-
-@statement(dialect=dialect)
-class P1(ConstantOp):
-    """
-    The $P_1$ projection operator.
-
-    $$
-    P1 = \\begin{bmatrix} 0 & 0 \\\\ 0 & 1 \\end{bmatrix}
-    $$
-    """
-
-    pass
-
-
-@statement(dialect=dialect)
-class Sn(ConstantOp):
-    """
-    $S_{-}$ operator.
-
-    $$
-    Sn = \\frac{1}{2} (S_x - i S_y) = \\frac{1}{2} \\begin{bmatrix} 0 & 0 \\\\ 1 & 0 \\end{bmatrix}
-    $$
-    """
-
-    pass
-
-
-@statement(dialect=dialect)
-class Sp(ConstantOp):
-    """
-    $S_{+}$ operator.
-
-    $$
-    Sp = \\frac{1}{2} (S_x + i S_y) = \\frac{1}{2}\\begin{bmatrix} 0 & 1 \\\\ 0 & 0 \\end{bmatrix}
-    $$
-    """
-
-    pass

bloqade/squin/op/traits.py

@@ -1,43 +0,0 @@
-from typing import cast
-from dataclasses import dataclass
-
-from kirin import ir
-
-
-@dataclass(frozen=True)
-class FixedSites(ir.StmtTrait):
-    data: int
-
-
-@dataclass(frozen=True)
-class HasSites(ir.StmtTrait):
-    """An operator with a `sites` attribute."""
-
-    def get_sites(self, stmt: ir.Statement):
-        attr = stmt.get_attr_or_prop("sites")
-        if attr is None:
-            raise ValueError(f"Missing sites attribute in {stmt}")
-        return cast(ir.PyAttr[int], attr).data
-
-    def set_sites(self, stmt: ir.Statement, value: int):
-        stmt.attributes["sites"] = ir.PyAttr(value)
-        return
-
-
-@dataclass(frozen=True)
-class Unitary(ir.StmtTrait):
-    pass
-
-
-@dataclass(frozen=True)
-class MaybeUnitary(ir.StmtTrait):
-
-    def is_unitary(self, stmt: ir.Statement):
-        attr = stmt.get_attr_or_prop("is_unitary")
-        if attr is None:
-            return False
-        return cast(ir.PyAttr[bool], attr).data
-
-    def set_unitary(self, stmt: ir.Statement, value: bool):
-        stmt.attributes["is_unitary"] = ir.PyAttr(value)
-        return