bloqade-circuit 0.1.0__py3-none-any.whl → 0.2.1__py3-none-any.whl

bloqade/pyqrack/qasm2/core.py

@@ -1,9 +1,12 @@
+from typing import Any
+
 from kirin import interp
+from kirin.interp import InterpreterError
+from kirin.dialects import ilist
 
 from bloqade.pyqrack.reg import (
     CBitRef,
     CRegister,
-    PyQrackReg,
     QubitState,
     Measurement,
     PyQrackQubit,
@@ -14,20 +17,18 @@ from bloqade.qasm2.dialects import core
 
 @core.dialect.register(key="pyqrack")
 class PyQrackMethods(interp.MethodTable):
-
     @interp.impl(core.QRegNew)
     def qreg_new(
         self, interp: PyQrackInterpreter, frame: interp.Frame, stmt: core.QRegNew
     ):
         n_qubits: int = frame.get(stmt.n_qubits)
-        return (
-            PyQrackReg(
-                size=n_qubits,
-                sim_reg=interp.memory.sim_reg,
-                addrs=interp.memory.allocate(n_qubits),
-                qubit_state=[QubitState.Active] * n_qubits,
-            ),
+        qreg = ilist.IList(
+            [
+                PyQrackQubit(i, interp.memory.sim_reg, QubitState.Active)
+                for i in interp.memory.allocate(n_qubits=n_qubits)
+            ]
         )
+        return (qreg,)
 
     @interp.impl(core.CRegNew)
     def creg_new(
@@ -40,7 +41,9 @@ class PyQrackMethods(interp.MethodTable):
     def qreg_get(
         self, interp: PyQrackInterpreter, frame: interp.Frame, stmt: core.QRegGet
     ):
-        return (PyQrackQubit(ref=frame.get(stmt.reg), pos=frame.get(stmt.idx)),)
+        reg = frame.get(stmt.reg)
+        i = frame.get(stmt.idx)
+        return (reg[i],)
 
     @interp.impl(core.CRegGet)
     def creg_get(
@@ -52,12 +55,25 @@ class PyQrackMethods(interp.MethodTable):
     def measure(
         self, interp: PyQrackInterpreter, frame: interp.Frame, stmt: core.Measure
     ):
-        qarg: PyQrackQubit = frame.get(stmt.qarg)
-        carg: CBitRef = frame.get(stmt.carg)
-        if qarg.is_active():
-            carg.set_value(Measurement(qarg.sim_reg.m(qarg.addr)))
+        qarg: PyQrackQubit | ilist.IList[PyQrackQubit, Any] = frame.get(stmt.qarg)
+        carg: CBitRef | CRegister = frame.get(stmt.carg)
+
+        if isinstance(qarg, PyQrackQubit) and isinstance(carg, CBitRef):
+            if qarg.is_active():
+                carg.set_value(Measurement(qarg.sim_reg.m(qarg.addr)))
+            else:
+                carg.set_value(interp.loss_m_result)
+        elif isinstance(qarg, ilist.IList) and isinstance(carg, CRegister):
+            for i, qubit in enumerate(qarg):
+                cbit = CBitRef(carg, i)
+                if qubit.is_active():
+                    cbit.set_value(Measurement(qubit.sim_reg.m(qubit.addr)))
+                else:
+                    cbit.set_value(interp.loss_m_result)
         else:
-            carg.set_value(interp.loss_m_result)
+            raise InterpreterError(
+                f"Expected measure call on either a single qubit and classical bit, or two registers, but got the types {type(qarg)} and {type(carg)}"
+            )
 
         return ()
 

bloqade/pyqrack/qasm2/glob.py

@@ -0,0 +1,28 @@
+from typing import Any
+
+from kirin import interp
+from kirin.dialects import ilist
+
+from bloqade.pyqrack.reg import PyQrackQubit
+from bloqade.pyqrack.base import PyQrackInterpreter
+from bloqade.qasm2.dialects import glob
+
+
+@glob.dialect.register(key="pyqrack")
+class PyQrackMethods(interp.MethodTable):
+    @interp.impl(glob.UGate)
+    def ugate(self, interp: PyQrackInterpreter, frame: interp.Frame, stmt: glob.UGate):
+        registers: ilist.IList[ilist.IList[PyQrackQubit, Any], Any] = frame.get(
+            stmt.registers
+        )
+        theta, phi, lam = (
+            frame.get(stmt.theta),
+            frame.get(stmt.phi),
+            frame.get(stmt.lam),
+        )
+
+        for qreg in registers:
+            for qarg in qreg:
+                if qarg.is_active():
+                    interp.memory.sim_reg.u(qarg.addr, theta, phi, lam)
+        return ()

bloqade/pyqrack/qasm2/uop.py

@@ -2,6 +2,7 @@ import math
 
 from kirin import interp
 
+from pyqrack.pauli import Pauli
 from bloqade.pyqrack.reg import PyQrackQubit
 from bloqade.qasm2.dialects import uop
 
@@ -26,7 +27,14 @@ class PyQrackMethods(interp.MethodTable):
         "tdg": "adjt",
     }
 
-    AXIS_MAP = {"rx": 1, "ry": 2, "rz": 3, "crx": 1, "cry": 2, "crz": 3}
+    AXIS_MAP = {
+        "rx": Pauli.PauliX,
+        "ry": Pauli.PauliY,
+        "rz": Pauli.PauliZ,
+        "crx": Pauli.PauliX,
+        "cry": Pauli.PauliY,
+        "crz": Pauli.PauliZ,
+    }
 
     @interp.impl(uop.Barrier)
     def barrier(

bloqade/pyqrack/reg.py

@@ -1,8 +1,8 @@
 import enum
-from typing import TYPE_CHECKING, List
+from typing import TYPE_CHECKING
 from dataclasses import dataclass
 
-from bloqade.qasm2.types import QReg, Qubit
+from bloqade.qasm2.types import Qubit
 
 if TYPE_CHECKING:
     from pyqrack import QrackSimulator
@@ -33,7 +33,7 @@ class CBitRef:
     pos: int
     """The position of this bit in the classical register."""
 
-    def set_value(self, value: bool):
+    def set_value(self, value: Measurement):
         self.ref[self.pos] = value
 
     def get_value(self):
@@ -45,55 +45,18 @@ class QubitState(enum.Enum):
     Lost = enum.auto()
 
 
-@dataclass(frozen=True)
-class PyQrackReg(QReg):
-    """Simulation runtime value of a quantum register."""
-
-    size: int
-    """The number of qubits in this register."""
-
-    sim_reg: "QrackSimulator"
-    """The register of the simulator."""
-
-    addrs: tuple[int, ...]
-    """The global addresses of the qubits in this register."""
-
-    qubit_state: List[QubitState]
-    """The state of each qubit in this register."""
-
-    def drop(self, pos: int):
-        """Drop the qubit at the given position in-place.
-
-        Args
-            pos (int): The position of the qubit to drop.
-
-        """
-        assert self.qubit_state[pos] is QubitState.Active, "Qubit already lost"
-        self.qubit_state[pos] = QubitState.Lost
-
-    def __getitem__(self, pos: int):
-        return PyQrackQubit(self, pos)
-
-
-@dataclass(frozen=True)
+@dataclass
 class PyQrackQubit(Qubit):
     """The runtime representation of a qubit reference."""
 
-    ref: PyQrackReg
-    """The quantum register that is holding this qubit."""
-
-    pos: int
-    """The position of this qubit in the quantum register."""
+    addr: int
+    """The address of this qubit in the quantum register."""
 
-    @property
-    def sim_reg(self):
-        """The register of the simulator."""
-        return self.ref.sim_reg
+    sim_reg: "QrackSimulator"
+    """The register of the simulator."""
 
-    @property
-    def addr(self) -> int:
-        """The global address of the qubit."""
-        return self.ref.addrs[self.pos]
+    state: QubitState
+    """The state of the qubit (active/lost)"""
 
     def is_active(self) -> bool:
         """Check if the qubit is active.
@@ -102,8 +65,13 @@ class PyQrackQubit(Qubit):
             True if the qubit is active, False otherwise.
 
         """
-        return self.ref.qubit_state[self.pos] is QubitState.Active
+        return self.state is QubitState.Active
 
     def drop(self):
         """Drop the qubit in-place."""
-        self.ref.drop(self.pos)
+        self.state = QubitState.Lost
+
+
+@dataclass
+class PyQrackWire:
+    qubit: PyQrackQubit

bloqade/pyqrack/squin/op.py

@@ -0,0 +1,154 @@
+from kirin import interp
+
+from bloqade.squin import op
+from bloqade.pyqrack.base import PyQrackInterpreter
+
+from .runtime import (
+    SnRuntime,
+    SpRuntime,
+    U3Runtime,
+    RotRuntime,
+    KronRuntime,
+    MultRuntime,
+    ScaleRuntime,
+    AdjointRuntime,
+    ControlRuntime,
+    PhaseOpRuntime,
+    IdentityRuntime,
+    OperatorRuntime,
+    ProjectorRuntime,
+    OperatorRuntimeABC,
+    PauliStringRuntime,
+)
+
+
+@op.dialect.register(key="pyqrack")
+class PyQrackMethods(interp.MethodTable):
+
+    @interp.impl(op.stmts.Kron)
+    def kron(
+        self, interp: PyQrackInterpreter, frame: interp.Frame, stmt: op.stmts.Kron
+    ) -> tuple[OperatorRuntimeABC]:
+        lhs = frame.get(stmt.lhs)
+        rhs = frame.get(stmt.rhs)
+        return (KronRuntime(lhs, rhs),)
+
+    @interp.impl(op.stmts.Mult)
+    def mult(
+        self, interp: PyQrackInterpreter, frame: interp.Frame, stmt: op.stmts.Mult
+    ) -> tuple[OperatorRuntimeABC]:
+        lhs = frame.get(stmt.lhs)
+        rhs = frame.get(stmt.rhs)
+        return (MultRuntime(lhs, rhs),)
+
+    @interp.impl(op.stmts.Adjoint)
+    def adjoint(
+        self, interp: PyQrackInterpreter, frame: interp.Frame, stmt: op.stmts.Adjoint
+    ) -> tuple[OperatorRuntimeABC]:
+        op = frame.get(stmt.op)
+        return (AdjointRuntime(op),)
+
+    @interp.impl(op.stmts.Scale)
+    def scale(
+        self, interp: PyQrackInterpreter, frame: interp.Frame, stmt: op.stmts.Scale
+    ) -> tuple[OperatorRuntimeABC]:
+        op = frame.get(stmt.op)
+        factor = frame.get(stmt.factor)
+        return (ScaleRuntime(op, factor),)
+
+    @interp.impl(op.stmts.Control)
+    def control(
+        self, interp: PyQrackInterpreter, frame: interp.Frame, stmt: op.stmts.Control
+    ) -> tuple[OperatorRuntimeABC]:
+        op = frame.get(stmt.op)
+        n_controls = stmt.n_controls
+        rt = ControlRuntime(
+            op=op,
+            n_controls=n_controls,
+        )
+        return (rt,)
+
+    @interp.impl(op.stmts.Rot)
+    def rot(
+        self, interp: PyQrackInterpreter, frame: interp.Frame, stmt: op.stmts.Rot
+    ) -> tuple[OperatorRuntimeABC]:
+        axis = frame.get(stmt.axis)
+        angle = frame.get(stmt.angle)
+        return (RotRuntime(axis, angle),)
+
+    @interp.impl(op.stmts.Identity)
+    def identity(
+        self, interp: PyQrackInterpreter, frame: interp.Frame, stmt: op.stmts.Identity
+    ) -> tuple[OperatorRuntimeABC]:
+        return (IdentityRuntime(sites=stmt.sites),)
+
+    @interp.impl(op.stmts.PhaseOp)
+    @interp.impl(op.stmts.ShiftOp)
+    def phaseop(
+        self,
+        interp: PyQrackInterpreter,
+        frame: interp.Frame,
+        stmt: op.stmts.PhaseOp | op.stmts.ShiftOp,
+    ) -> tuple[OperatorRuntimeABC]:
+        theta = frame.get(stmt.theta)
+        global_ = isinstance(stmt, op.stmts.PhaseOp)
+        return (PhaseOpRuntime(theta, global_=global_),)
+
+    @interp.impl(op.stmts.X)
+    @interp.impl(op.stmts.Y)
+    @interp.impl(op.stmts.Z)
+    @interp.impl(op.stmts.H)
+    @interp.impl(op.stmts.S)
+    @interp.impl(op.stmts.T)
+    def operator(
+        self,
+        interp: PyQrackInterpreter,
+        frame: interp.Frame,
+        stmt: (
+            op.stmts.X | op.stmts.Y | op.stmts.Z | op.stmts.H | op.stmts.S | op.stmts.T
+        ),
+    ) -> tuple[OperatorRuntimeABC]:
+        return (OperatorRuntime(method_name=stmt.name.lower()),)
+
+    @interp.impl(op.stmts.P0)
+    @interp.impl(op.stmts.P1)
+    def projector(
+        self,
+        interp: PyQrackInterpreter,
+        frame: interp.Frame,
+        stmt: op.stmts.P0 | op.stmts.P1,
+    ) -> tuple[OperatorRuntimeABC]:
+        state = isinstance(stmt, op.stmts.P1)
+        return (ProjectorRuntime(to_state=state),)
+
+    @interp.impl(op.stmts.Sp)
+    def sp(
+        self, interp: PyQrackInterpreter, frame: interp.Frame, stmt: op.stmts.Sp
+    ) -> tuple[OperatorRuntimeABC]:
+        return (SpRuntime(),)
+
+    @interp.impl(op.stmts.Sn)
+    def sn(
+        self, interp: PyQrackInterpreter, frame: interp.Frame, stmt: op.stmts.Sn
+    ) -> tuple[OperatorRuntimeABC]:
+        return (SnRuntime(),)
+
+    @interp.impl(op.stmts.U3)
+    def u3(
+        self, interp: PyQrackInterpreter, frame: interp.Frame, stmt: op.stmts.U3
+    ) -> tuple[OperatorRuntimeABC]:
+        theta = frame.get(stmt.theta)
+        phi = frame.get(stmt.phi)
+        lam = frame.get(stmt.lam)
+        return (U3Runtime(theta, phi, lam),)
+
+    @interp.impl(op.stmts.PauliString)
+    def clifford_string(
+        self,
+        interp: PyQrackInterpreter,
+        frame: interp.Frame,
+        stmt: op.stmts.PauliString,
+    ) -> tuple[OperatorRuntimeABC]:
+        string = stmt.string
+        ops = [OperatorRuntime(method_name=name.lower()) for name in stmt.string]
+        return (PauliStringRuntime(string, ops),)

bloqade/pyqrack/squin/qubit.py

@@ -0,0 +1,85 @@
+from typing import Any
+
+from kirin import interp
+from kirin.dialects import ilist
+
+from bloqade.squin import qubit
+from bloqade.pyqrack.reg import QubitState, PyQrackQubit
+from bloqade.pyqrack.base import PyQrackInterpreter
+
+from .runtime import OperatorRuntimeABC
+
+
+@qubit.dialect.register(key="pyqrack")
+class PyQrackMethods(interp.MethodTable):
+    @interp.impl(qubit.New)
+    def new(self, interp: PyQrackInterpreter, frame: interp.Frame, stmt: qubit.New):
+        n_qubits: int = frame.get(stmt.n_qubits)
+        qreg = ilist.IList(
+            [
+                PyQrackQubit(i, interp.memory.sim_reg, QubitState.Active)
+                for i in interp.memory.allocate(n_qubits=n_qubits)
+            ]
+        )
+        return (qreg,)
+
+    @interp.impl(qubit.Apply)
+    def apply(self, interp: PyQrackInterpreter, frame: interp.Frame, stmt: qubit.Apply):
+        qubits: ilist.IList[PyQrackQubit, Any] = frame.get(stmt.qubits)
+        operator: OperatorRuntimeABC = frame.get(stmt.operator)
+        operator.apply(*qubits)
+
+    @interp.impl(qubit.Broadcast)
+    def broadcast(
+        self, interp: PyQrackInterpreter, frame: interp.Frame, stmt: qubit.Broadcast
+    ):
+        operator: OperatorRuntimeABC = frame.get(stmt.operator)
+        qubits: ilist.IList[PyQrackQubit, Any] = frame.get(stmt.qubits)
+        operator.broadcast_apply(qubits)
+
+    def _measure_qubit(self, qbit: PyQrackQubit):
+        if qbit.is_active():
+            return bool(qbit.sim_reg.m(qbit.addr))
+
+    @interp.impl(qubit.MeasureQubitList)
+    def measure_qubit_list(
+        self,
+        interp: PyQrackInterpreter,
+        frame: interp.Frame,
+        stmt: qubit.MeasureQubitList,
+    ):
+        qubits: ilist.IList[PyQrackQubit, Any] = frame.get(stmt.qubits)
+        result = ilist.IList([self._measure_qubit(qbit) for qbit in qubits])
+        return (result,)
+
+    @interp.impl(qubit.MeasureQubit)
+    def measure_qubit(
+        self, interp: PyQrackInterpreter, frame: interp.Frame, stmt: qubit.MeasureQubit
+    ):
+        qbit: PyQrackQubit = frame.get(stmt.qubit)
+        result = self._measure_qubit(qbit)
+        return (result,)
+
+    @interp.impl(qubit.MeasureAndReset)
+    def measure_and_reset(
+        self,
+        interp: PyQrackInterpreter,
+        frame: interp.Frame,
+        stmt: qubit.MeasureAndReset,
+    ):
+        qubits: ilist.IList[PyQrackQubit, Any] = frame.get(stmt.qubits)
+        result = []
+        for qbit in qubits:
+            if qbit.is_active():
+                result.append(qbit.sim_reg.m(qbit.addr))
+            else:
+                result.append(None)
+            qbit.sim_reg.force_m(qbit.addr, 0)
+
+        return (ilist.IList(result),)
+
+    @interp.impl(qubit.Reset)
+    def reset(self, interp: PyQrackInterpreter, frame: interp.Frame, stmt: qubit.Reset):
+        qubits: ilist.IList[PyQrackQubit, Any] = frame.get(stmt.qubits)
+        for qbit in qubits:
+            qbit.sim_reg.force_m(qbit.addr, 0)