bloqade-circuit 0.6.3__tar.gz → 0.6.5__tar.gz

{bloqade_circuit-0.6.3 → bloqade_circuit-0.6.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bloqade-circuit
-Version: 0.6.3
+Version: 0.6.5
 Summary: The software development toolkit for neutral atom arrays.
 Author-email: Roger-luo <rluo@quera.com>, kaihsin <khwu@quera.com>, weinbe58 <pweinberg@quera.com>, johnzl-777 <jlong@quera.com>
 License-File: LICENSE

{bloqade_circuit-0.6.3 → bloqade_circuit-0.6.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "bloqade-circuit"
-version = "0.6.3"
+version = "0.6.5"
 description = "The software development toolkit for neutral atom arrays."
 readme = "README.md"
 authors = [

bloqade_circuit-0.6.5/src/bloqade/analysis/measure_id/__init__.py

@@ -0,0 +1,5 @@
+from . import impls as impls
+from .analysis import (
+    MeasureIDFrame as MeasureIDFrame,
+    MeasurementIDAnalysis as MeasurementIDAnalysis,
+)

{bloqade_circuit-0.6.3 → bloqade_circuit-0.6.5}/src/bloqade/analysis/measure_id/analysis.py

@@ -1,13 +1,19 @@
 from typing import TypeVar
+from dataclasses import field, dataclass
 
 from kirin import ir, interp
-from kirin.analysis import Forward, const
+from kirin.analysis import ForwardExtra, const
 from kirin.analysis.forward import ForwardFrame
 
 from .lattice import MeasureId, NotMeasureId
 
 
-class MeasurementIDAnalysis(Forward[MeasureId]):
+@dataclass
+class MeasureIDFrame(ForwardFrame[MeasureId]):
+    num_measures_at_stmt: dict[ir.Statement, int] = field(default_factory=dict)
+
+
+class MeasurementIDAnalysis(ForwardExtra[MeasureIDFrame, MeasureId]):
 
     keys = ["measure_id"]
     lattice = MeasureId
@@ -15,6 +21,11 @@ class MeasurementIDAnalysis(Forward[MeasureId]):
     # then use this to generate the negative values for target rec indices
     measure_count = 0
 
+    def initialize_frame(
+        self, code: ir.Statement, *, has_parent_access: bool = False
+    ) -> MeasureIDFrame:
+        return MeasureIDFrame(code, has_parent_access=has_parent_access)
+
     # Still default to bottom,
     # but let constants return the softer "NoMeasureId" type from impl
     def eval_stmt_fallback(

{bloqade_circuit-0.6.3 → bloqade_circuit-0.6.5}/src/bloqade/analysis/measure_id/impls.py

@@ -1,4 +1,5 @@
 from kirin import types as kirin_types, interp
+from kirin.analysis import const
 from kirin.dialects import py, scf, func, ilist
 
 from bloqade.squin import wire, qubit
@@ -10,7 +11,7 @@ from .lattice import (
     MeasureIdTuple,
     InvalidMeasureId,
 )
-from .analysis import MeasurementIDAnalysis
+from .analysis import MeasureIDFrame, MeasurementIDAnalysis
 
 ## Can't do wire right now because of
 ## unresolved RFC on return type
@@ -113,6 +114,15 @@ class PyIndexing(interp.MethodTable):
             return (InvalidMeasureId(),)
 
 
+@py.assign.dialect.register(key="measure_id")
+class PyAssign(interp.MethodTable):
+    @interp.impl(py.Alias)
+    def alias(
+        self, interp: MeasurementIDAnalysis, frame: interp.Frame, stmt: py.assign.Alias
+    ):
+        return (frame.get(stmt.value),)
+
+
 @py.binop.dialect.register(key="measure_id")
 class PyBinOp(interp.MethodTable):
     @interp.impl(py.Add)
@@ -152,4 +162,33 @@ class Func(interp.MethodTable):
 # scf, particularly IfElse
 @scf.dialect.register(key="measure_id")
 class Scf(scf.absint.Methods):
-    pass
+
+    @interp.impl(scf.IfElse)
+    def if_else(
+        self,
+        interp_: MeasurementIDAnalysis,
+        frame: MeasureIDFrame,
+        stmt: scf.IfElse,
+    ):
+
+        frame.num_measures_at_stmt[stmt] = interp_.measure_count
+
+        # rest of the code taken directly from scf.absint.Methods base implementation
+
+        if isinstance(hint := stmt.cond.hints.get("const"), const.Value):
+            if hint.data:
+                return self._infer_if_else_cond(interp_, frame, stmt, stmt.then_body)
+            else:
+                return self._infer_if_else_cond(interp_, frame, stmt, stmt.else_body)
+        then_results = self._infer_if_else_cond(interp_, frame, stmt, stmt.then_body)
+        else_results = self._infer_if_else_cond(interp_, frame, stmt, stmt.else_body)
+
+        match (then_results, else_results):
+            case (interp.ReturnValue(then_value), interp.ReturnValue(else_value)):
+                return interp.ReturnValue(then_value.join(else_value))
+            case (interp.ReturnValue(then_value), _):
+                return then_results
+            case (_, interp.ReturnValue(else_value)):
+                return else_results
+            case _:
+                return interp_.join_results(then_results, else_results)

{bloqade_circuit-0.6.3 → bloqade_circuit-0.6.5}/src/bloqade/pyqrack/base.py

@@ -48,7 +48,7 @@ def _default_pyqrack_args() -> PyQrackOptions:
         isSchmidtDecomposeMulti=True,
         isSchmidtDecompose=True,
         isStabilizerHybrid=False,
-        isBinaryDecisionTree=True,
+        isBinaryDecisionTree=False,
         isPaged=True,
         isCpuGpuHybrid=True,
         isOpenCL=True,

{bloqade_circuit-0.6.3 → bloqade_circuit-0.6.5}/src/bloqade/squin/__init__.py

@@ -9,6 +9,10 @@ from . import (
 )
 from .groups import wired as wired, kernel as kernel
 
+# NOTE: it's important to keep these imports here since they import squin.kernel
+# we skip isort here
+from . import gate as gate, parallel as parallel  # isort: skip
+
 try:
     # NOTE: make sure optional cirq dependency is installed
     import cirq as cirq_package  # noqa: F401

bloqade_circuit-0.6.5/src/bloqade/squin/gate.py

@@ -0,0 +1,193 @@
+from bloqade.types import Qubit
+
+from . import op as _op, qubit as _qubit
+from .groups import kernel
+
+
+@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 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_circuit-0.6.5/src/bloqade/squin/parallel.py

@@ -0,0 +1,200 @@
+from typing import Any, TypeVar
+
+from kirin.dialects import ilist
+
+from bloqade.types import Qubit
+
+from . import op as _op, qubit as _qubit
+from .groups import kernel
+
+
+@kernel
+def x(qubits: ilist.IList[Qubit, Any]) -> None:
+    """x gate applied to qubits in parallel."""
+    op = _op.x()
+    _qubit.broadcast(op, qubits)
+
+
+@kernel
+def y(qubits: ilist.IList[Qubit, Any]) -> None:
+    """y gate applied to qubits in parallel."""
+    op = _op.y()
+    _qubit.broadcast(op, qubits)
+
+
+@kernel
+def z(qubits: ilist.IList[Qubit, Any]) -> None:
+    """z gate applied to qubits in parallel."""
+    op = _op.z()
+    _qubit.broadcast(op, qubits)
+
+
+@kernel
+def sqrt_x(qubits: ilist.IList[Qubit, Any]) -> None:
+    """Square root x gate applied to qubits in parallel."""
+    op = _op.sqrt_x()
+    _qubit.broadcast(op, qubits)
+
+
+@kernel
+def sqrt_y(qubits: ilist.IList[Qubit, Any]) -> None:
+    """Square root y gate applied to qubits in parallel."""
+    op = _op.sqrt_y()
+    _qubit.broadcast(op, qubits)
+
+
+@kernel
+def sqrt_z(qubits: ilist.IList[Qubit, Any]) -> None:
+    """Square root gate applied to qubits in parallel."""
+    op = _op.s()
+    _qubit.broadcast(op, qubits)
+
+
+@kernel
+def h(qubits: ilist.IList[Qubit, Any]) -> None:
+    """Hadamard gate applied to qubits in parallel."""
+    op = _op.h()
+    _qubit.broadcast(op, qubits)
+
+
+@kernel
+def s(qubits: ilist.IList[Qubit, Any]) -> None:
+    """s gate applied to qubits in parallel."""
+    op = _op.s()
+    _qubit.broadcast(op, qubits)
+
+
+@kernel
+def t(qubits: ilist.IList[Qubit, Any]) -> None:
+    """t gate applied to qubits in parallel."""
+    op = _op.t()
+    _qubit.broadcast(op, qubits)
+
+
+@kernel
+def p0(qubits: ilist.IList[Qubit, Any]) -> None:
+    """Projector on 0 applied to qubits in parallel."""
+    op = _op.p0()
+    _qubit.broadcast(op, qubits)
+
+
+@kernel
+def p1(qubits: ilist.IList[Qubit, Any]) -> None:
+    """Projector on 1 applied to qubits in parallel."""
+    op = _op.p1()
+    _qubit.broadcast(op, qubits)
+
+
+@kernel
+def spin_n(qubits: ilist.IList[Qubit, Any]) -> None:
+    """Spin lowering gate applied to qubits in parallel."""
+    op = _op.spin_n()
+    _qubit.broadcast(op, qubits)
+
+
+@kernel
+def spin_p(qubits: ilist.IList[Qubit, Any]) -> None:
+    """Spin raising gate applied to qubits in parallel."""
+    op = _op.spin_p()
+    _qubit.broadcast(op, qubits)
+
+
+@kernel
+def reset(qubits: ilist.IList[Qubit, Any]) -> None:
+    """Reset qubit to 0."""
+    op = _op.reset()
+    _qubit.broadcast(op, qubits)
+
+
+N = TypeVar("N")
+
+
+@kernel
+def cx(controls: ilist.IList[Qubit, N], targets: ilist.IList[Qubit, N]) -> None:
+    """Controlled x gate applied to controls and targets in parallel."""
+    op = _op.cx()
+    _qubit.broadcast(op, controls, targets)
+
+
+@kernel
+def cy(controls: ilist.IList[Qubit, N], targets: ilist.IList[Qubit, N]) -> None:
+    """Controlled y gate applied to controls and targets in parallel."""
+    op = _op.cy()
+    _qubit.broadcast(op, controls, targets)
+
+
+@kernel
+def cz(controls: ilist.IList[Qubit, N], targets: ilist.IList[Qubit, N]) -> None:
+    """Controlled z gate applied to controls and targets in parallel."""
+    op = _op.cz()
+    _qubit.broadcast(op, controls, targets)
+
+
+@kernel
+def ch(controls: ilist.IList[Qubit, N], targets: ilist.IList[Qubit, N]) -> None:
+    """Controlled Hadamard gate applied to controls and targets in parallel."""
+    op = _op.ch()
+    _qubit.broadcast(op, controls, targets)
+
+
+@kernel
+def u(theta: float, phi: float, lam: float, qubits: ilist.IList[Qubit, Any]) -> None:
+    """3D rotation gate applied to controls and targets in parallel."""
+    op = _op.u(theta, phi, lam)
+    _qubit.broadcast(op, qubits)
+
+
+@kernel
+def rx(theta: float, qubits: ilist.IList[Qubit, Any]) -> None:
+    """Rotation X gate applied to qubits in parallel."""
+    op = _op.rot(_op.x(), theta)
+    _qubit.broadcast(op, qubits)
+
+
+@kernel
+def ry(theta: float, qubits: ilist.IList[Qubit, Any]) -> None:
+    """Rotation Y gate applied to qubits in parallel."""
+    op = _op.rot(_op.y(), theta)
+    _qubit.broadcast(op, qubits)
+
+
+@kernel
+def rz(theta: float, qubits: ilist.IList[Qubit, Any]) -> None:
+    """Rotation Z gate applied to qubits in parallel."""
+    op = _op.rot(_op.z(), theta)
+    _qubit.broadcast(op, qubits)
+
+
+@kernel
+def sqrt_x_adj(qubits: ilist.IList[Qubit, Any]) -> None:
+    """Adjoint sqrt_x gate applied to qubits in parallel."""
+    op = _op.sqrt_x()
+    _qubit.broadcast(_op.adjoint(op), qubits)
+
+
+@kernel
+def sqrt_y_adj(qubits: ilist.IList[Qubit, Any]) -> None:
+    """Adjoint sqrt_y gate applied to qubits in parallel."""
+    op = _op.sqrt_y()
+    _qubit.broadcast(_op.adjoint(op), qubits)
+
+
+@kernel
+def sqrt_z_adj(qubits: ilist.IList[Qubit, Any]) -> None:
+    """Adjoint square root z gate applied to qubits in parallel."""
+    op = _op.s()
+    _qubit.broadcast(_op.adjoint(op), qubits)
+
+
+@kernel
+def s_adj(qubits: ilist.IList[Qubit, Any]) -> None:
+    """Adjoint s gate applied to qubits in parallel."""
+    op = _op.s()
+    _qubit.broadcast(_op.adjoint(op), qubits)
+
+
+@kernel
+def t_adj(qubits: ilist.IList[Qubit, Any]) -> None:
+    """Adjoint t gate applied to qubits in parallel."""
+    op = _op.t()
+    _qubit.broadcast(_op.adjoint(op), qubits)

bloqade_circuit-0.6.5/src/bloqade/stim/passes/__init__.py

@@ -0,0 +1,5 @@
+from .squin_to_stim import (
+    SquinToStimPass as SquinToStimPass,
+    StimSimplifyIfs as StimSimplifyIfs,
+    AggressiveForLoopUnroll as AggressiveForLoopUnroll,
+)

{bloqade_circuit-0.6.3 → bloqade_circuit-0.6.5}/src/bloqade/stim/passes/simplify_ifs.py

@@ -9,6 +9,7 @@ from kirin.rewrite import (
     ConstantFold,
     CommonSubexpressionElimination,
 )
+from kirin.dialects.ilist.passes import ConstList2IList
 
 from ..rewrite.ifs_to_stim import StimLiftThenBody, StimSplitIfStmts
 
@@ -23,8 +24,16 @@ class StimSimplifyIfs(Pass):
             Walk(StimSplitIfStmts()),
         ).rewrite(mt.code)
 
+        # because nested python lists don't have their
+        # member lists converted to ILists, ConstantFold
+        # can add python lists that can't be hashed, causing
+        # issues with CSE. ConstList2IList remedies that problem here.
         result = (
-            Fixpoint(Walk(Chain(ConstantFold(), CommonSubexpressionElimination())))
+            Chain(
+                Fixpoint(Walk(ConstantFold())),
+                Walk(ConstList2IList()),
+                Walk(CommonSubexpressionElimination()),
+            )
             .rewrite(mt.code)
             .join(result)
         )