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

bloqade/native/dialects/{gates → gate}/_interface.py

@@ -3,7 +3,7 @@ import typing
 from kirin import lowering
 from kirin.dialects import ilist
 
-from bloqade.squin import qubit
+from bloqade import qubit
 
 from .stmts import CZ, R, Rz
 
@@ -12,21 +12,21 @@ Len = typing.TypeVar("Len")
 
 @lowering.wraps(CZ)
 def cz(
-    ctrls: ilist.IList[qubit.Qubit, Len],
-    qargs: ilist.IList[qubit.Qubit, Len],
+    controls: ilist.IList[qubit.Qubit, Len],
+    targets: ilist.IList[qubit.Qubit, Len],
 ): ...
 
 
 @lowering.wraps(R)
 def r(
-    inputs: ilist.IList[qubit.Qubit, typing.Any],
     axis_angle: float,
     rotation_angle: float,
+    qubits: ilist.IList[qubit.Qubit, typing.Any],
 ): ...
 
 
 @lowering.wraps(Rz)
 def rz(
-    inputs: ilist.IList[qubit.Qubit, typing.Any],
     rotation_angle: float,
+    qubits: ilist.IList[qubit.Qubit, typing.Any],
 ): ...

bloqade/native/dialects/{gates → gate}/stmts.py

@@ -2,7 +2,7 @@ from kirin import ir, types, lowering
 from kirin.decl import info, statement
 from kirin.dialects import ilist
 
-from bloqade.squin import qubit
+from bloqade.types import QubitType
 
 from ._dialect import dialect
 
@@ -12,20 +12,20 @@ N = types.TypeVar("N")
 @statement(dialect=dialect)
 class CZ(ir.Statement):
     traits = frozenset({lowering.FromPythonCall()})
-    ctrls: ir.SSAValue = info.argument(ilist.IListType[qubit.QubitType, N])
-    qargs: ir.SSAValue = info.argument(ilist.IListType[qubit.QubitType, N])
+    controls: ir.SSAValue = info.argument(ilist.IListType[QubitType, N])
+    targets: ir.SSAValue = info.argument(ilist.IListType[QubitType, N])
 
 
 @statement(dialect=dialect)
 class R(ir.Statement):
     traits = frozenset({lowering.FromPythonCall()})
-    inputs: ir.SSAValue = info.argument(ilist.IListType[qubit.QubitType, types.Any])
     axis_angle: ir.SSAValue = info.argument(types.Float)
     rotation_angle: ir.SSAValue = info.argument(types.Float)
+    qubits: ir.SSAValue = info.argument(ilist.IListType[QubitType, types.Any])
 
 
 @statement(dialect=dialect)
 class Rz(ir.Statement):
     traits = frozenset({lowering.FromPythonCall()})
-    inputs: ir.SSAValue = info.argument(ilist.IListType[qubit.QubitType, types.Any])
     rotation_angle: ir.SSAValue = info.argument(types.Float)
+    qubits: ir.SSAValue = info.argument(ilist.IListType[QubitType, types.Any])

bloqade/native/stdlib/broadcast.py

@@ -3,9 +3,9 @@ from typing import Any, TypeVar
 
 from kirin.dialects import ilist
 
-from bloqade.squin import qubit
+from bloqade import qubit
 from bloqade.native._prelude import kernel
-from bloqade.native.dialects.gates import _interface as native
+from bloqade.native.dialects.gate import _interface as native
 
 
 @kernel
@@ -29,7 +29,7 @@ def rx(angle: float, qubits: ilist.IList[qubit.Qubit, Any]):
         angle (float): Rotation angle in radians.
         qubits (ilist.IList[qubit.Qubit, Any]): Target qubits.
     """
-    native.r(qubits, 0.0, _radian_to_turn(angle))
+    native.r(0.0, _radian_to_turn(angle), qubits)
 
 
 @kernel
@@ -70,7 +70,7 @@ def ry(angle: float, qubits: ilist.IList[qubit.Qubit, Any]):
         angle (float): Rotation angle in radians.
         qubits (ilist.IList[qubit.Qubit, Any]): Target qubits.
     """
-    native.r(qubits, 0.25, _radian_to_turn(angle))
+    native.r(0.25, _radian_to_turn(angle), qubits)
 
 
 @kernel
@@ -111,7 +111,7 @@ def rz(angle: float, qubits: ilist.IList[qubit.Qubit, Any]):
         angle (float): Rotation angle in radians.
         qubits (ilist.IList[qubit.Qubit, Any]): Target qubits.
     """
-    native.rz(qubits, _radian_to_turn(angle))
+    native.rz(_radian_to_turn(angle), qubits)
 
 
 @kernel
@@ -167,43 +167,43 @@ def t(qubits: ilist.IList[qubit.Qubit, Any]):
 
 
 @kernel
-def shift(angle: float, qubits: ilist.IList[qubit.Qubit, Any]):
-    """Apply a phase shift to the |1> state on a group of qubits.
+def t_adj(qubits: ilist.IList[qubit.Qubit, Any]):
+    """Apply the adjoint of aT gate on a group of qubits.
 
     Args:
-        angle (float): Phase shift angle in radians.
         qubits (ilist.IList[qubit.Qubit, Any]): Target qubits.
     """
-    rz(angle / 2.0, qubits)
+    rz(-math.pi / 4.0, qubits)
 
 
 @kernel
-def rot(phi: float, theta: float, omega: float, qubits: ilist.IList[qubit.Qubit, Any]):
-    """Apply a general single-qubit rotation on a group of qubits.
+def shift(angle: float, qubits: ilist.IList[qubit.Qubit, Any]):
+    """Apply a phase shift to the |1> state on a group of qubits.
 
     Args:
-        phi (float): Z rotation before Y (radians).
-        theta (float): Y rotation (radians).
-        omega (float): Z rotation after Y (radians).
+        angle (float): Phase shift angle in radians.
         qubits (ilist.IList[qubit.Qubit, Any]): Target qubits.
     """
-    rz(phi, qubits)
-    ry(theta, qubits)
-    rz(omega, qubits)
+    rz(angle / 2.0, qubits)
 
 
 @kernel
 def u3(theta: float, phi: float, lam: float, qubits: ilist.IList[qubit.Qubit, Any]):
     """Apply the U3 gate on a group of qubits.
 
+    The applied gate is represented by the unitary matrix given by:
+
+    $$ U3(\\theta, \\phi, \\lambda) = R_z(\\phi)R_y(\\theta)R_z(\\lambda) $$
+
     Args:
         theta (float): Rotation around Y axis (radians).
         phi (float): Global phase shift component (radians).
         lam (float): Z rotations in decomposition (radians).
         qubits (ilist.IList[qubit.Qubit, Any]): Target qubits.
     """
-    rot(lam, theta, -lam, qubits)
-    shift(phi + lam, qubits)
+    rz(lam, qubits)
+    ry(theta, qubits)
+    rz(phi, qubits)
 
 
 N = TypeVar("N")

bloqade/native/stdlib/simple.py

@@ -1,6 +1,6 @@
 from kirin.dialects import ilist
 
-from bloqade.squin import qubit
+from bloqade import qubit
 
 from . import broadcast
 from .._prelude import kernel
@@ -150,33 +150,34 @@ def t(qubit: qubit.Qubit):
 
 
 @kernel
-def shift(angle: float, qubit: qubit.Qubit):
-    """Apply a phase shift on the |1> state of a single qubit.
+def t_adj(qubit: qubit.Qubit):
+    """Apply the adjoint of the T gate on a single qubit.
 
     Args:
-        angle (float): Shift angle in radians.
-        qubit (qubit.Qubit): The qubit to apply the shift to.
+        qubit (qubit.Qubit): The qubit to apply the adjoint T gate to.
     """
-    broadcast.shift(angle, ilist.IList([qubit]))
+    broadcast.t_adj(ilist.IList([qubit]))
 
 
 @kernel
-def rot(phi: float, theta: float, omega: float, qubit: qubit.Qubit):
-    """Apply a general single-qubit rotation on a single qubit.
+def shift(angle: float, qubit: qubit.Qubit):
+    """Apply a phase shift on the |1> state of a single qubit.
 
     Args:
-        phi (float): Z rotation before Y (radians).
-        theta (float): Y rotation (radians).
-        omega (float): Z rotation after Y (radians).
-        qubit (qubit.Qubit): The qubit to apply the rotation to.
+        angle (float): Shift angle in radians.
+        qubit (qubit.Qubit): The qubit to apply the shift to.
     """
-    broadcast.rot(phi, theta, omega, ilist.IList([qubit]))
+    broadcast.shift(angle, ilist.IList([qubit]))
 
 
 @kernel
 def u3(theta: float, phi: float, lam: float, qubit: qubit.Qubit):
     """Apply the U3 gate on a single qubit.
 
+    The applied gate is represented by the unitary matrix given by:
+
+    $$ U3(\\theta, \\phi, \\lambda) = R_z(\\phi)R_y(\\theta)R_z(\\lambda) $$
+
     Args:
         theta (float): Rotation angle around the Y axis in radians.
         phi (float): Rotation angle around the Z axis in radians.

bloqade/native/upstream/__init__.py

@@ -0,0 +1,5 @@
+from .squin2native import (
+    GateRule as GateRule,
+    SquinToNative as SquinToNative,
+    SquinToNativePass as SquinToNativePass,
+)

bloqade/native/upstream/squin2native.py

@@ -0,0 +1,136 @@
+from itertools import chain
+from dataclasses import field, dataclass
+
+from kirin import ir, passes, rewrite
+from kirin.dialects import py, func
+from kirin.rewrite.abc import RewriteRule, RewriteResult
+from kirin.passes.callgraph import CallGraphPass, ReplaceMethods
+from kirin.analysis.callgraph import CallGraph
+
+from bloqade.native import kernel, broadcast
+from bloqade.squin.gate import stmts, dialect as gate_dialect
+
+
+class GateRule(RewriteRule):
+    SQUIN_MAPPING: dict[type[ir.Statement], tuple[ir.Method, ...]] = {
+        stmts.X: (broadcast.x,),
+        stmts.Y: (broadcast.y,),
+        stmts.Z: (broadcast.z,),
+        stmts.H: (broadcast.h,),
+        stmts.S: (broadcast.s, broadcast.s_adj),
+        stmts.T: (broadcast.t, broadcast.t_adj),
+        stmts.SqrtX: (broadcast.sqrt_x, broadcast.sqrt_x_adj),
+        stmts.SqrtY: (broadcast.sqrt_y, broadcast.sqrt_y_adj),
+        stmts.Rx: (broadcast.rx,),
+        stmts.Ry: (broadcast.ry,),
+        stmts.Rz: (broadcast.rz,),
+        stmts.CX: (broadcast.cx,),
+        stmts.CY: (broadcast.cy,),
+        stmts.CZ: (broadcast.cz,),
+        stmts.U3: (broadcast.u3,),
+    }
+
+    def rewrite_Statement(self, node: ir.Statement) -> RewriteResult:
+        if (native_methods := self.SQUIN_MAPPING.get(type(node))) is None:
+            return RewriteResult()
+
+        if isinstance(node, stmts.SingleQubitNonHermitianGate):
+            native_method = native_methods[1] if node.adjoint else native_methods[0]
+        else:
+            native_method = native_methods[0]
+
+        # do not rewrite in invoke because callgraph pass will be looking for invoke statements
+        (callee := py.Constant(native_method)).insert_before(node)
+        node.replace_by(func.Call(callee.result, tuple(node.args), kwargs=()))
+
+        return RewriteResult(has_done_something=True)
+
+
+@dataclass
+class UpdateDialectsOnCallGraph(passes.Pass):
+    """Update All dialects on the call graph to a new set of dialects given to this pass.
+
+    Usage:
+        pass_ = UpdateDialectsOnCallGraph(rule=rule, dialects=new_dialects)
+        pass_(some_method)
+
+    Note: This pass does not update the dialects of the input method, but copies
+    all other methods invoked within it before updating their dialects.
+
+    """
+
+    fold_pass: passes.Fold = field(init=False)
+
+    def __post_init__(self):
+        self.fold_pass = passes.Fold(self.dialects, no_raise=self.no_raise)
+
+    def unsafe_run(self, mt: ir.Method) -> RewriteResult:
+        mt_map = {}
+
+        cg = CallGraph(mt)
+
+        all_methods = set(sum(map(tuple, cg.defs.values()), ()))
+        for original_mt in all_methods:
+            if original_mt is mt:
+                new_mt = original_mt
+            else:
+                new_mt = original_mt.similar(self.dialects)
+            mt_map[original_mt] = new_mt
+
+        result = RewriteResult()
+
+        for _, new_mt in mt_map.items():
+            result = (
+                rewrite.Walk(ReplaceMethods(mt_map)).rewrite(new_mt.code).join(result)
+            )
+            self.fold_pass(new_mt)
+
+        return result
+
+
+@dataclass
+class SquinToNativePass(passes.Pass):
+
+    call_graph_pass: CallGraphPass = field(init=False)
+
+    def __post_init__(self):
+        rule = rewrite.Walk(GateRule())
+        self.call_graph_pass = CallGraphPass(
+            self.dialects, rule, no_raise=self.no_raise
+        )
+
+    def unsafe_run(self, mt: ir.Method) -> RewriteResult:
+        return self.call_graph_pass.unsafe_run(mt)
+
+
+class SquinToNative:
+    """A Target that converts Squin gates to native gates."""
+
+    def emit(self, mt: ir.Method, *, no_raise=True) -> ir.Method:
+        """Convert Squin gates to native gates.
+
+        Args:
+            mt (ir.Method): The method to convert.
+            no_raise (bool, optional): Whether to suppress errors. Defaults to True.
+
+        Returns:
+            ir.Method: The converted method.
+        """
+        old_callgraph = CallGraph(mt)
+        all_dialects = chain.from_iterable(
+            ker.dialects.data for kers in old_callgraph.defs.values() for ker in kers
+        )
+        new_dialects = (
+            mt.dialects.union(all_dialects).discard(gate_dialect).union(kernel)
+        )
+
+        out = mt.similar(new_dialects)
+        UpdateDialectsOnCallGraph(new_dialects, no_raise=no_raise)(out)
+        SquinToNativePass(new_dialects, no_raise=no_raise)(out)
+        # verify all kernels in the callgraph
+        new_callgraph = CallGraph(out)
+        all_kernels = (ker for kers in new_callgraph.defs.values() for ker in kers)
+        for ker in all_kernels:
+            ker.verify()
+
+        return out

bloqade/pyqrack/__init__.py

@@ -3,7 +3,6 @@ from .reg import (
     CRegister as CRegister,
     QubitState as QubitState,
     Measurement as Measurement,
-    PyQrackWire as PyQrackWire,
     PyQrackQubit as PyQrackQubit,
 )
 from .base import (
@@ -16,7 +15,7 @@ from .task import PyQrackSimulatorTask as PyQrackSimulatorTask
 # NOTE: The following import is for registering the method tables
 from .noise import native as native
 from .qasm2 import uop as uop, core as core, glob as glob, parallel as parallel
-from .squin import op as op, noise as noise, qubit as qubit
+from .squin import gate as gate, noise as noise, qubit as qubit
 from .device import (
     StackMemorySimulator as StackMemorySimulator,
     DynamicMemorySimulator as DynamicMemorySimulator,

bloqade/pyqrack/device.py

@@ -3,10 +3,8 @@ from dataclasses import field, dataclass
 
 import numpy as np
 from kirin import ir
-from kirin.passes import fold
 from kirin.dialects.ilist import IList
 
-from bloqade.squin import noise as squin_noise
 from pyqrack.pauli import Pauli
 from bloqade.device import AbstractSimulatorDevice
 from bloqade.pyqrack.reg import Measurement, PyQrackQubit
@@ -20,8 +18,7 @@ from bloqade.pyqrack.base import (
 )
 from bloqade.pyqrack.task import PyQrackSimulatorTask
 from pyqrack.qrack_simulator import QrackSimulator
-from bloqade.squin.noise.rewrite import RewriteNoiseStmts
-from bloqade.analysis.address.lattice import AnyAddress
+from bloqade.analysis.address.lattice import UnknownReg, UnknownQubit
 from bloqade.analysis.address.analysis import AddressAnalysis
 
 RetType = TypeVar("RetType")
@@ -33,7 +30,7 @@ class QuantumState(NamedTuple):
     A representation of a quantum state as a density matrix, where the density matrix is
     rho = sum_i eigenvalues[i] |eigenvectors[:,i]><eigenvectors[:,i]|.
 
-    This reprsentation is efficient for low-rank density matrices by only storing
+    This representation is efficient for low-rank density matrices by only storing
     the non-zero eigenvalues and corresponding eigenvectors of the density matrix.
     For example, a pure state has only one non-zero eigenvalue equal to 1.0.
 
@@ -158,7 +155,7 @@ def _pyqrack_reduced_density_matrix(
     # The singular values and vectors are the eigenspace of the reduced density matrix
     s, v, d = np.linalg.svd(vec_svd, full_matrices=False)
 
-    # Remove the negligable singular values
+    # Remove the negligible singular values
     nonzero_inds = np.where(np.abs(v) > tol)[0]
     s = s[:, nonzero_inds]
     v = v[nonzero_inds] ** 2
@@ -191,22 +188,14 @@ class PyQrackSimulatorBase(AbstractSimulatorDevice[PyQrackSimulatorTask]):
         kwargs: dict[str, Any],
         memory: MemoryType,
     ) -> PyQrackSimulatorTask[Params, RetType, MemoryType]:
-        if squin_noise in mt.dialects:
-            # NOTE: rewrite noise statements
-            mt_ = mt.similar(mt.dialects)
-            RewriteNoiseStmts(mt_.dialects)(mt_)
-            fold.Fold(mt_.dialects)(mt_)
-        else:
-            mt_ = mt
-
         interp = PyQrackInterpreter(
-            mt_.dialects,
+            mt.dialects,
             memory=memory,
             rng_state=self.rng_state,
             loss_m_result=self.loss_m_result,
         )
         return PyQrackSimulatorTask(
-            kernel=mt_, args=args, kwargs=kwargs, pyqrack_interp=interp
+            kernel=mt, args=args, kwargs=kwargs, pyqrack_interp=interp
         )
 
     def state_vector(
@@ -366,7 +355,7 @@ class StackMemorySimulator(PyQrackSimulatorBase):
         address_analysis = AddressAnalysis(dialects=kernel.dialects)
         frame, _ = address_analysis.run_analysis(kernel)
         if self.min_qubits == 0 and any(
-            isinstance(a, AnyAddress) for a in frame.entries.values()
+            isinstance(a, (UnknownQubit, UnknownReg)) for a in frame.entries.values()
         ):
             raise ValueError(
                 "All addresses must be resolved. Or set min_qubits to a positive integer."

bloqade/pyqrack/native.py

@@ -7,29 +7,29 @@ from kirin.dialects import ilist
 from pyqrack import Pauli
 from bloqade.pyqrack import PyQrackQubit
 from bloqade.pyqrack.base import PyQrackInterpreter
-from bloqade.native.dialects import gates
+from bloqade.native.dialects.gate import stmts
 
 
-@gates.dialect.register(key="pyqrack")
+@stmts.dialect.register(key="pyqrack")
 class NativeMethods(interp.MethodTable):
 
-    @interp.impl(gates.CZ)
-    def cz(self, _interp: PyQrackInterpreter, frame: interp.Frame, stmt: gates.CZ):
-        ctrls = frame.get_casted(stmt.ctrls, ilist.IList[PyQrackQubit, Any])
-        qargs = frame.get_casted(stmt.qargs, ilist.IList[PyQrackQubit, Any])
+    @interp.impl(stmts.CZ)
+    def cz(self, _interp: PyQrackInterpreter, frame: interp.Frame, stmt: stmts.CZ):
+        controls = frame.get_casted(stmt.controls, ilist.IList[PyQrackQubit, Any])
+        targets = frame.get_casted(stmt.targets, ilist.IList[PyQrackQubit, Any])
 
-        for ctrl, qarg in zip(ctrls, qargs):
-            if ctrl.is_active() and qarg.is_active():
-                ctrl.sim_reg.mcz([ctrl.addr], qarg.addr)
+        for ctrl, trgt in zip(controls, targets):
+            if ctrl.is_active() and trgt.is_active():
+                ctrl.sim_reg.mcz([ctrl.addr], trgt.addr)
 
         return ()
 
-    @interp.impl(gates.R)
-    def r(self, _interp: PyQrackInterpreter, frame: interp.Frame, stmt: gates.R):
-        inputs = frame.get_casted(stmt.inputs, ilist.IList[PyQrackQubit, Any])
+    @interp.impl(stmts.R)
+    def r(self, _interp: PyQrackInterpreter, frame: interp.Frame, stmt: stmts.R):
+        qubits = frame.get_casted(stmt.qubits, ilist.IList[PyQrackQubit, Any])
         rotation_angle = 2 * math.pi * frame.get_casted(stmt.rotation_angle, float)
         axis_angle = 2 * math.pi * frame.get_casted(stmt.axis_angle, float)
-        for qubit in inputs:
+        for qubit in qubits:
             if qubit.is_active():
                 qubit.sim_reg.r(Pauli.PauliZ, axis_angle, qubit.addr)
                 qubit.sim_reg.r(Pauli.PauliX, rotation_angle, qubit.addr)
@@ -37,12 +37,12 @@ class NativeMethods(interp.MethodTable):
 
         return ()
 
-    @interp.impl(gates.Rz)
-    def rz(self, _interp: PyQrackInterpreter, frame: interp.Frame, stmt: gates.Rz):
-        inputs = frame.get_casted(stmt.inputs, ilist.IList[PyQrackQubit, Any])
+    @interp.impl(stmts.Rz)
+    def rz(self, _interp: PyQrackInterpreter, frame: interp.Frame, stmt: stmts.Rz):
+        qubits = frame.get_casted(stmt.qubits, ilist.IList[PyQrackQubit, Any])
         rotation_angle = 2 * math.pi * frame.get_casted(stmt.rotation_angle, float)
 
-        for qubit in inputs:
+        for qubit in qubits:
             if qubit.is_active():
                 qubit.sim_reg.r(Pauli.PauliZ, rotation_angle, qubit.addr)
 

bloqade/pyqrack/reg.py

@@ -2,8 +2,8 @@ import enum
 from typing import TYPE_CHECKING
 from dataclasses import dataclass
 
+from bloqade.types import MeasurementResult
 from bloqade.qasm2.types import Qubit
-from bloqade.squin.types import MeasurementResult
 
 if TYPE_CHECKING:
     from pyqrack import QrackSimulator
@@ -75,8 +75,3 @@ class PyQrackQubit(Qubit):
     def drop(self):
         """Drop the qubit in-place."""
         self.state = QubitState.Lost
-
-
-@dataclass
-class PyQrackWire:
-    qubit: PyQrackQubit

bloqade/pyqrack/squin/gate/__init__.py

@@ -0,0 +1 @@
+from . import gate as gate

bloqade/pyqrack/squin/gate/gate.py

@@ -0,0 +1,136 @@
+import math
+from typing import Any
+
+from kirin import interp
+from kirin.dialects import ilist
+
+from bloqade.squin import gate
+from pyqrack.pauli import Pauli
+from bloqade.pyqrack.reg import PyQrackQubit
+from bloqade.pyqrack.target import PyQrackInterpreter
+from bloqade.squin.gate.stmts import (
+    CX,
+    CY,
+    CZ,
+    U3,
+    H,
+    S,
+    T,
+    X,
+    Y,
+    Z,
+    Rx,
+    Ry,
+    Rz,
+    SqrtX,
+    SqrtY,
+)
+
+
+@gate.dialect.register(key="pyqrack")
+class PyQrackMethods(interp.MethodTable):
+
+    @interp.impl(X)
+    @interp.impl(Y)
+    @interp.impl(Z)
+    @interp.impl(H)
+    def single_qubit_gate(
+        self, interp: PyQrackInterpreter, frame: interp.Frame, stmt: X | Y | Z | H
+    ):
+        qubits: ilist.IList[PyQrackQubit, Any] = frame.get(stmt.qubits)
+        method_name = stmt.name.lower()
+        for qbit in qubits:
+            if qbit.is_active():
+                getattr(qbit.sim_reg, method_name)(qbit.addr)
+
+    @interp.impl(T)
+    @interp.impl(S)
+    def single_qubit_nh_gate(
+        self, interp: PyQrackInterpreter, frame: interp.Frame, stmt: S | T
+    ):
+        qubits: ilist.IList[PyQrackQubit, Any] = frame.get(stmt.qubits)
+
+        method_name = stmt.name.lower()
+        if stmt.adjoint:
+            method_name = "adj" + method_name
+
+        for qbit in qubits:
+            if qbit.is_active():
+                getattr(qbit.sim_reg, method_name)(qbit.addr)
+                qbit.sim_reg.r
+
+    @interp.impl(SqrtX)
+    @interp.impl(SqrtY)
+    def sqrt_x(
+        self, interp: PyQrackInterpreter, frame: interp.Frame, stmt: SqrtX | SqrtY
+    ):
+        angle = math.pi / 2
+
+        if isinstance(stmt, SqrtX):
+            axis = Pauli.PauliX
+        else:
+            angle *= -1
+            axis = Pauli.PauliY
+
+        if stmt.adjoint:
+            angle *= -1
+
+        qubits: ilist.IList[PyQrackQubit, Any] = frame.get(stmt.qubits)
+        for qbit in qubits:
+            if qbit.is_active():
+                qbit.sim_reg.r(axis, angle, qbit.addr)
+
+    @interp.impl(Rx)
+    @interp.impl(Ry)
+    @interp.impl(Rz)
+    def rot(self, interp: PyQrackInterpreter, frame: interp.Frame, stmt: Rx | Ry | Rz):
+        match stmt:
+            case Rx():
+                axis = Pauli.PauliX
+            case Ry():
+                axis = Pauli.PauliY
+            case Rz():
+                axis = Pauli.PauliZ
+
+        qubits: ilist.IList[PyQrackQubit, Any] = frame.get(stmt.qubits)
+
+        # NOTE: convert turns to radians
+        angle = frame.get(stmt.angle) * 2 * math.pi
+
+        for qbit in qubits:
+            if qbit.is_active():
+                qbit.sim_reg.r(axis, angle, qbit.addr)
+
+    @interp.impl(CX)
+    @interp.impl(CY)
+    @interp.impl(CZ)
+    def control(
+        self, interp: PyQrackInterpreter, frame: interp.Frame, stmt: CX | CY | CZ
+    ):
+        controls: ilist.IList[PyQrackQubit, Any] = frame.get(stmt.controls)
+        targets: ilist.IList[PyQrackQubit, Any] = frame.get(stmt.targets)
+
+        if len(controls) != len(targets):
+            raise RuntimeError(
+                f"Found {len(controls)} controls but {len(targets)} targets when trying to evaluate {stmt}."
+            )
+
+        # NOTE: pyqrack convention "multi-control-x"
+        method_name = "m" + stmt.name.lower()
+
+        for control, target in zip(controls, targets):
+            if control.is_active() and target.is_active():
+                getattr(control.sim_reg, method_name)([control.addr], target.addr)
+
+    @interp.impl(U3)
+    def u3(self, interp: PyQrackInterpreter, frame: interp.Frame, stmt: U3):
+        theta = frame.get(stmt.theta) * 2 * math.pi
+        phi = frame.get(stmt.phi) * 2 * math.pi
+        lam = frame.get(stmt.lam) * 2 * math.pi
+        qubits: ilist.IList[PyQrackQubit, Any] = frame.get(stmt.qubits)
+
+        for qbit in qubits:
+            if not qbit.is_active():
+                continue
+
+            qbit.sim_reg.u(qbit.addr, theta, phi, lam)