bloqade-circuit 0.6.4__py3-none-any.whl → 0.9.1__py3-none-any.whl

bloqade/pyqrack/squin/runtime.py

@@ -1,535 +0,0 @@
-from typing import Any
-from dataclasses import field, dataclass
-
-import numpy as np
-from kirin.dialects import ilist
-
-from pyqrack.pauli import Pauli
-from bloqade.pyqrack import PyQrackQubit
-
-
-@dataclass(frozen=True)
-class OperatorRuntimeABC:
-    """The number of sites the operator applies to (including controls)"""
-
-    @property
-    def n_sites(self) -> int: ...
-
-    def apply(self, *qubits: PyQrackQubit, adjoint: bool = False) -> None:
-        raise NotImplementedError(
-            "Operator runtime base class should not be called directly, override the method"
-        )
-
-    def control_apply(
-        self,
-        controls: tuple[PyQrackQubit, ...],
-        targets: tuple[PyQrackQubit, ...],
-        adjoint: bool = False,
-    ) -> None:
-        raise RuntimeError(f"Can't apply controlled version of {self}")
-
-    def broadcast_apply(self, qubits: ilist.IList[PyQrackQubit, Any], **kwargs) -> None:
-        n = self.n_sites
-
-        if len(qubits) % n != 0:
-            raise RuntimeError(
-                f"Cannot broadcast operator {self} that applies to {n} over {len(qubits)} qubits."
-            )
-
-        for qubit_index in range(0, len(qubits), n):
-            targets = qubits[qubit_index : qubit_index + n]
-            self.apply(*targets, **kwargs)
-
-
-@dataclass(frozen=True)
-class ResetRuntime(OperatorRuntimeABC):
-    """Reset the qubit to the target state"""
-
-    target_state: bool
-
-    @property
-    def n_sites(self) -> int:
-        return 1
-
-    def apply(self, *qubits: PyQrackQubit, adjoint: bool = False) -> None:
-        for qubit in qubits:
-            if not qubit.is_active():
-                continue
-
-            res: bool = qubit.sim_reg.m(qubit.addr)
-            if res != self.target_state:
-                qubit.sim_reg.x(qubit.addr)
-
-
-@dataclass(frozen=True)
-class OperatorRuntime(OperatorRuntimeABC):
-    method_name: str
-
-    @property
-    def n_sites(self) -> int:
-        return 1
-
-    def get_method_name(self, adjoint: bool, control: bool) -> str:
-        method_name = ""
-        if control:
-            method_name += "mc"
-
-        if adjoint and self.method_name in ("s", "t"):
-            method_name += "adj"
-
-        return method_name + self.method_name
-
-    def apply(self, qubit: PyQrackQubit, adjoint: bool = False) -> None:
-        if not qubit.is_active():
-            return
-        method_name = self.get_method_name(adjoint=adjoint, control=False)
-        getattr(qubit.sim_reg, method_name)(qubit.addr)
-
-    def control_apply(
-        self,
-        controls: tuple[PyQrackQubit, ...],
-        targets: tuple[PyQrackQubit],
-        adjoint: bool = False,
-    ) -> None:
-        target = targets[0]
-        if not target.is_active():
-            return
-
-        ctrls: list[int] = []
-        for qbit in controls:
-            if not qbit.is_active():
-                return
-
-            ctrls.append(qbit.addr)
-
-        method_name = self.get_method_name(adjoint=adjoint, control=True)
-        getattr(target.sim_reg, method_name)(ctrls, target.addr)
-
-
-@dataclass(frozen=True)
-class ControlRuntime(OperatorRuntimeABC):
-    op: OperatorRuntimeABC
-    n_controls: int
-
-    @property
-    def n_sites(self) -> int:
-        return self.op.n_sites + self.n_controls
-
-    def apply(self, *qubits: PyQrackQubit, adjoint: bool = False) -> None:
-        ctrls = qubits[: self.n_controls]
-        targets = qubits[self.n_controls :]
-
-        if len(targets) != self.op.n_sites:
-            raise RuntimeError(
-                f"Cannot apply operator {self.op} to {len(targets)} qubits! It applies to {self.op.n_sites}, check your inputs!"
-            )
-
-        self.op.control_apply(controls=ctrls, targets=targets, adjoint=adjoint)
-
-
-@dataclass(frozen=True)
-class ProjectorRuntime(OperatorRuntimeABC):
-    to_state: bool
-
-    @property
-    def n_sites(self) -> int:
-        return 1
-
-    def apply(self, qubit: PyQrackQubit, adjoint: bool = False) -> None:
-        if not qubit.is_active():
-            return
-        qubit.sim_reg.force_m(qubit.addr, self.to_state)
-
-    def control_apply(
-        self,
-        controls: tuple[PyQrackQubit, ...],
-        targets: tuple[PyQrackQubit],
-        adjoint: bool = False,
-    ) -> None:
-        target = targets[0]
-        if not target.is_active():
-            return
-
-        ctrls: list[int] = []
-        for qbit in controls:
-            if not qbit.is_active():
-                return
-
-        m = [not self.to_state, 0, 0, self.to_state]
-        target.sim_reg.mcmtrx(ctrls, m, target.addr)
-
-
-@dataclass(frozen=True)
-class IdentityRuntime(OperatorRuntimeABC):
-    # TODO: do we even need sites? The apply never does anything
-    sites: int
-
-    @property
-    def n_sites(self) -> int:
-        return self.sites
-
-    def apply(self, *qubits: PyQrackQubit, adjoint: bool = False) -> None:
-        pass
-
-    def control_apply(
-        self,
-        controls: tuple[PyQrackQubit, ...],
-        targets: tuple[PyQrackQubit, ...],
-        adjoint: bool = False,
-    ) -> None:
-        pass
-
-
-@dataclass(frozen=True)
-class MultRuntime(OperatorRuntimeABC):
-    lhs: OperatorRuntimeABC
-    rhs: OperatorRuntimeABC
-
-    @property
-    def n_sites(self) -> int:
-        if self.lhs.n_sites != self.rhs.n_sites:
-            raise RuntimeError("Multiplication of operators with unequal size.")
-
-        return self.lhs.n_sites
-
-    def apply(self, *qubits: PyQrackQubit, adjoint: bool = False) -> None:
-        if adjoint:
-            # NOTE: inverted order
-            self.lhs.apply(*qubits, adjoint=adjoint)
-            self.rhs.apply(*qubits, adjoint=adjoint)
-        else:
-            self.rhs.apply(*qubits)
-            self.lhs.apply(*qubits)
-
-    def control_apply(
-        self,
-        controls: tuple[PyQrackQubit, ...],
-        targets: tuple[PyQrackQubit, ...],
-        adjoint: bool = False,
-    ) -> None:
-        if adjoint:
-            self.lhs.control_apply(controls=controls, targets=targets, adjoint=adjoint)
-            self.rhs.control_apply(controls=controls, targets=targets, adjoint=adjoint)
-        else:
-            self.rhs.control_apply(controls=controls, targets=targets, adjoint=adjoint)
-            self.lhs.control_apply(controls=controls, targets=targets, adjoint=adjoint)
-
-
-@dataclass(frozen=True)
-class KronRuntime(OperatorRuntimeABC):
-    lhs: OperatorRuntimeABC
-    rhs: OperatorRuntimeABC
-
-    @property
-    def n_sites(self) -> int:
-        return self.lhs.n_sites + self.rhs.n_sites
-
-    def apply(self, *qubits: PyQrackQubit, adjoint: bool = False) -> None:
-        self.lhs.apply(*qubits[: self.lhs.n_sites], adjoint=adjoint)
-        self.rhs.apply(*qubits[self.lhs.n_sites :], adjoint=adjoint)
-
-    def control_apply(
-        self,
-        controls: tuple[PyQrackQubit, ...],
-        targets: tuple[PyQrackQubit, ...],
-        adjoint: bool = False,
-    ) -> None:
-        self.lhs.control_apply(
-            controls=controls,
-            targets=tuple(targets[: self.lhs.n_sites]),
-            adjoint=adjoint,
-        )
-        self.rhs.control_apply(
-            controls=controls,
-            targets=tuple(targets[self.lhs.n_sites :]),
-            adjoint=adjoint,
-        )
-
-
-@dataclass(frozen=True)
-class ScaleRuntime(OperatorRuntimeABC):
-    op: OperatorRuntimeABC
-    factor: complex
-
-    @property
-    def n_sites(self) -> int:
-        return self.op.n_sites
-
-    @staticmethod
-    def mat(factor, adjoint: bool):
-        if adjoint:
-            return [np.conj(factor), 0, 0, factor]
-        else:
-            return [factor, 0, 0, factor]
-
-    def apply(self, *qubits: PyQrackQubit, adjoint: bool = False) -> None:
-        self.op.apply(*qubits, adjoint=adjoint)
-
-        # NOTE: when applying to multiple qubits, we "spread" the factor evenly
-        applied_factor = self.factor ** (1.0 / len(qubits))
-        for qbit in qubits:
-            if not qbit.is_active():
-                continue
-
-            # NOTE: just factor * eye(2)
-            m = self.mat(applied_factor, adjoint)
-
-            # TODO: output seems to always be normalized -- no-op?
-            qbit.sim_reg.mtrx(m, qbit.addr)
-
-    def control_apply(
-        self,
-        controls: tuple[PyQrackQubit, ...],
-        targets: tuple[PyQrackQubit, ...],
-        adjoint: bool = False,
-    ) -> None:
-
-        ctrls: list[int] = []
-        for qbit in controls:
-            if not qbit.is_active():
-                return
-
-            ctrls.append(qbit.addr)
-
-        self.op.control_apply(controls=controls, targets=targets, adjoint=adjoint)
-
-        applied_factor = self.factor ** (1.0 / len(targets))
-        for target in targets:
-            m = self.mat(applied_factor, adjoint=adjoint)
-            target.sim_reg.mcmtrx(ctrls, m, target.addr)
-
-
-@dataclass(frozen=True)
-class MtrxOpRuntime(OperatorRuntimeABC):
-    def mat(self, adjoint: bool) -> list[complex]:
-        raise NotImplementedError("Override this method in the subclass!")
-
-    @property
-    def n_sites(self) -> int:
-        # NOTE: pyqrack only supports 2x2 matrices, i.e. single qubit applications
-        return 1
-
-    def apply(self, target: PyQrackQubit, adjoint: bool = False) -> None:
-        if not target.is_active():
-            return
-
-        m = self.mat(adjoint=adjoint)
-        target.sim_reg.mtrx(m, target.addr)
-
-    def control_apply(
-        self,
-        controls: tuple[PyQrackQubit, ...],
-        targets: tuple[PyQrackQubit, ...],
-        adjoint: bool = False,
-    ) -> None:
-        target = targets[0]
-        if not target.is_active():
-            return
-
-        ctrls: list[int] = []
-        for qbit in controls:
-            if not qbit.is_active():
-                return
-
-            ctrls.append(qbit.addr)
-
-        m = self.mat(adjoint=adjoint)
-        target.sim_reg.mcmtrx(ctrls, m, target.addr)
-
-
-@dataclass(frozen=True)
-class SpRuntime(MtrxOpRuntime):
-    def mat(self, adjoint: bool) -> list[complex]:
-        if adjoint:
-            return [0, 0, 0.5, 0]
-        else:
-            return [0, 0.5, 0, 0]
-
-
-@dataclass(frozen=True)
-class SnRuntime(MtrxOpRuntime):
-    def mat(self, adjoint: bool) -> list[complex]:
-        if adjoint:
-            return [0, 0.5, 0, 0]
-        else:
-            return [0, 0, 0.5, 0]
-
-
-@dataclass(frozen=True)
-class PhaseOpRuntime(MtrxOpRuntime):
-    theta: float
-    global_: bool
-
-    def mat(self, adjoint: bool) -> list[complex]:
-        sign = (-1) ** (not adjoint)
-        local_phase = np.exp(sign * 1j * self.theta)
-
-        # NOTE: this is just 1 if we want a local shift
-        global_phase = np.exp(sign * 1j * self.theta * self.global_)
-
-        return [global_phase, 0, 0, local_phase]
-
-
-@dataclass(frozen=True)
-class RotRuntime(OperatorRuntimeABC):
-    axis: OperatorRuntimeABC
-    angle: float
-    pyqrack_axis: Pauli = field(init=False)
-
-    @property
-    def n_sites(self) -> int:
-        return 1
-
-    def __post_init__(self):
-        if not isinstance(self.axis, OperatorRuntime):
-            raise RuntimeError(
-                f"Rotation only supported for Pauli operators! Got {self.axis}"
-            )
-
-        try:
-            axis = getattr(Pauli, "Pauli" + self.axis.method_name.upper())
-        except KeyError:
-            raise RuntimeError(
-                f"Rotation only supported for Pauli operators! Got {self.axis}"
-            )
-
-        # NOTE: weird setattr for frozen dataclasses
-        object.__setattr__(self, "pyqrack_axis", axis)
-
-    def apply(self, target: PyQrackQubit, adjoint: bool = False) -> None:
-        if not target.is_active():
-            return
-
-        sign = (-1) ** adjoint
-        angle = sign * self.angle
-        target.sim_reg.r(self.pyqrack_axis, angle, target.addr)
-
-    def control_apply(
-        self,
-        controls: tuple[PyQrackQubit, ...],
-        targets: tuple[PyQrackQubit, ...],
-        adjoint: bool = False,
-    ) -> None:
-        target = targets[0]
-        if not target.is_active():
-            return
-
-        ctrls: list[int] = []
-        for qbit in controls:
-            if not qbit.is_active():
-                return
-
-            ctrls.append(qbit.addr)
-
-        sign = (-1) ** (not adjoint)
-        angle = sign * self.angle
-        target.sim_reg.mcr(self.pyqrack_axis, angle, ctrls, target.addr)
-
-
-@dataclass(frozen=True)
-class AdjointRuntime(OperatorRuntimeABC):
-    op: OperatorRuntimeABC
-
-    @property
-    def n_sites(self) -> int:
-        return self.op.n_sites
-
-    def apply(self, *qubits: PyQrackQubit, adjoint: bool = False) -> None:
-        # NOTE: to account for adjoint(adjoint(op))
-        passed_on_adjoint = not adjoint
-
-        self.op.apply(*qubits, adjoint=passed_on_adjoint)
-
-    def control_apply(
-        self,
-        controls: tuple[PyQrackQubit, ...],
-        targets: tuple[PyQrackQubit, ...],
-        adjoint: bool = False,
-    ) -> None:
-        passed_on_adjoint = not adjoint
-        self.op.control_apply(
-            controls=controls, targets=targets, adjoint=passed_on_adjoint
-        )
-
-
-@dataclass(frozen=True)
-class U3Runtime(OperatorRuntimeABC):
-    theta: float
-    phi: float
-    lam: float
-
-    @property
-    def n_sites(self) -> int:
-        return 1
-
-    def angles(self, adjoint: bool) -> tuple[float, float, float]:
-        if adjoint:
-            # NOTE: adjoint(U(theta, phi, lam)) == U(-theta, -lam, -phi)
-            return -self.theta, -self.lam, -self.phi
-        else:
-            return self.theta, self.phi, self.lam
-
-    def apply(self, target: PyQrackQubit, adjoint: bool = False) -> None:
-        if not target.is_active():
-            return
-
-        angles = self.angles(adjoint=adjoint)
-        target.sim_reg.u(target.addr, *angles)
-
-    def control_apply(
-        self,
-        controls: tuple[PyQrackQubit, ...],
-        targets: tuple[PyQrackQubit, ...],
-        adjoint: bool = False,
-    ) -> None:
-        target = targets[0]
-        if not target.is_active():
-            return
-
-        ctrls: list[int] = []
-        for qbit in controls:
-            if not qbit.is_active():
-                return
-
-            ctrls.append(qbit.addr)
-
-        angles = self.angles(adjoint=adjoint)
-        target.sim_reg.mcu(ctrls, target.addr, *angles)
-
-
-@dataclass(frozen=True)
-class PauliStringRuntime(OperatorRuntimeABC):
-    string: str
-    ops: list[OperatorRuntime]
-
-    @property
-    def n_sites(self) -> int:
-        return sum((op.n_sites for op in self.ops))
-
-    def apply(self, *qubits: PyQrackQubit, adjoint: bool = False):
-        if len(qubits) != self.n_sites:
-            raise RuntimeError(
-                f"Cannot apply Pauli string {self.string} to {len(qubits)} qubits! Make sure the number of qubits matches."
-            )
-
-        qubit_index = 0
-        for op in self.ops:
-            next_qubit_index = qubit_index + op.n_sites
-            op.apply(*qubits[qubit_index:next_qubit_index], adjoint=adjoint)
-            qubit_index = next_qubit_index
-
-    def control_apply(
-        self,
-        controls: tuple[PyQrackQubit, ...],
-        targets: tuple[PyQrackQubit, ...],
-        adjoint: bool = False,
-    ) -> None:
-        if len(targets) != self.n_sites:
-            raise RuntimeError(
-                f"Cannot apply Pauli string {self.string} to {len(targets)} qubits! Make sure the number of qubits matches."
-            )
-
-        for i, op in enumerate(self.ops):
-            # NOTE: this is fine as the size of each op is actually just 1 by definition
-            target = targets[i]
-            op.control_apply(controls=controls, targets=(target,))

bloqade/pyqrack/squin/wire.py

@@ -1,51 +0,0 @@
-from kirin import interp
-
-from bloqade.squin import wire
-from bloqade.pyqrack.reg import PyQrackWire, PyQrackQubit
-from bloqade.pyqrack.base import PyQrackInterpreter
-
-from .runtime import OperatorRuntimeABC
-
-
-@wire.dialect.register(key="pyqrack")
-class PyQrackMethods(interp.MethodTable):
-    # @interp.impl(wire.Wrap)
-    # def wrap(self, interp: PyQrackInterpreter, frame: interp.Frame, stmt: wire.Wrap):
-    #     traits = frozenset({lowering.FromPythonCall(), WireTerminator()})
-    #     wire: ir.SSAValue = info.argument(WireType)
-    #     qubit: ir.SSAValue = info.argument(QubitType)
-
-    @interp.impl(wire.Unwrap)
-    def unwrap(
-        self, interp: PyQrackInterpreter, frame: interp.Frame, stmt: wire.Unwrap
-    ):
-        q: PyQrackQubit = frame.get(stmt.qubit)
-        return (PyQrackWire(q),)
-
-    @interp.impl(wire.Apply)
-    def apply(self, interp: PyQrackInterpreter, frame: interp.Frame, stmt: wire.Apply):
-        ws = stmt.inputs
-        assert isinstance(ws, tuple)
-        qubits: list[PyQrackQubit] = []
-        for w in ws:
-            assert isinstance(w, PyQrackWire)
-            qubits.append(w.qubit)
-        op: OperatorRuntimeABC = frame.get(stmt.operator)
-
-        op.apply(*qubits)
-
-        out_ws = [PyQrackWire(qbit) for qbit in qubits]
-        return (out_ws,)
-
-    @interp.impl(wire.Measure)
-    def measure(
-        self, interp: PyQrackInterpreter, frame: interp.Frame, stmt: wire.Measure
-    ):
-        w: PyQrackWire = frame.get(stmt.wire)
-        qbit = w.qubit
-
-        if not qbit.is_active():
-            return (interp.loss_m_result,)
-
-        res: bool = bool(qbit.sim_reg.m(qbit.addr))
-        return (res,)

bloqade/rewrite/rules/flatten_ilist.py

@@ -1,51 +0,0 @@
-from dataclasses import dataclass
-
-from kirin import ir
-from kirin.dialects import py, ilist
-from kirin.rewrite.abc import RewriteRule, RewriteResult
-
-
-@dataclass
-class FlattenAddOpIList(RewriteRule):
-
-    def rewrite_Statement(self, node: ir.Statement) -> RewriteResult:
-        if not isinstance(node, py.binop.Add):
-            return RewriteResult()
-
-        # check if we are adding two ilist.New objects
-        new_data = ()
-
-        # lhs:
-        if not isinstance(node.lhs.owner, ilist.New):
-            if not (
-                isinstance(node.lhs.owner, py.Constant)
-                and isinstance(
-                    const_ilist := node.lhs.owner.value.unwrap(), ilist.IList
-                )
-                and len(const_ilist.data) == 0
-            ):
-                return RewriteResult()
-
-        else:
-            new_data += node.lhs.owner.values
-
-        # rhs:
-        if not isinstance(node.rhs.owner, ilist.New):
-            if not (
-                isinstance(node.rhs.owner, py.Constant)
-                and isinstance(
-                    const_ilist := node.rhs.owner.value.unwrap(), ilist.IList
-                )
-                and len(const_ilist.data) == 0
-            ):
-                return RewriteResult()
-
-        else:
-            new_data += node.rhs.owner.values
-
-        new_stmt = ilist.New(values=new_data)
-        node.replace_by(new_stmt)
-
-        return RewriteResult(
-            has_done_something=True,
-        )

bloqade/rewrite/rules/inline_getitem_ilist.py

@@ -1,31 +0,0 @@
-from dataclasses import dataclass
-
-from kirin import ir
-from kirin.analysis import const
-from kirin.dialects import py, ilist
-from kirin.rewrite.abc import RewriteRule, RewriteResult
-
-
-@dataclass
-class InlineGetItemFromIList(RewriteRule):
-    constprop_result: dict[ir.SSAValue, const.Result]
-
-    def rewrite_Statement(self, node: ir.Statement) -> RewriteResult:
-        if not isinstance(node, py.indexing.GetItem):
-            return RewriteResult()
-
-        if not isinstance(node.obj.owner, ilist.New):
-            return RewriteResult()
-
-        if not isinstance(
-            index_value := self.constprop_result.get(node.index), const.Value
-        ):
-            return RewriteResult()
-
-        elem_ssa = node.obj.owner.values[index_value.data]
-
-        node.result.replace_by(elem_ssa)
-
-        return RewriteResult(
-            has_done_something=True,
-        )

bloqade/squin/_typeinfer.py

@@ -1,20 +0,0 @@
-from kirin import types, interp
-from kirin.analysis import TypeInference, const
-from kirin.dialects import ilist
-
-from bloqade import squin
-
-
-@squin.qubit.dialect.register(key="typeinfer")
-class TypeInfer(interp.MethodTable):
-    @interp.impl(squin.qubit.New)
-    def _call(self, interp: TypeInference, frame: interp.Frame, stmt: squin.qubit.New):
-        # based on Xiu-zhe (Roger) Luo's get_const_value function
-
-        if (hint := stmt.n_qubits.hints.get("const")) is None:
-            return (ilist.IListType[squin.qubit.QubitType, types.Any],)
-
-        if isinstance(hint, const.Value) and isinstance(hint.data, int):
-            return (ilist.IListType[squin.qubit.QubitType, types.Literal(hint.data)],)
-
-        return (ilist.IListType[squin.qubit.QubitType, types.Any],)