bloqade-circuit 0.7.13__tar.gz → 0.8.0__tar.gz

{bloqade_circuit-0.7.13 → bloqade_circuit-0.8.0}/.github/workflows/ci.yml

@@ -21,7 +21,7 @@ jobs:
     steps:
       - uses: actions/checkout@v5
       - name: Install uv
-        uses: astral-sh/setup-uv@v6
+        uses: astral-sh/setup-uv@v7
         with:
           # Install a specific version of uv.
           version: "0.8.4"
@@ -43,7 +43,7 @@ jobs:
           token: ${{ secrets.CODECOV_TOKEN }} # required
       - name: Archive code coverage results
         if: matrix.python-version == '3.12'
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v5
         with:
           name: code-coverage-report
           path: coverage.xml
@@ -55,7 +55,7 @@ jobs:
     steps:
         - uses: actions/checkout@v5
         - name: download covearge
-          uses: actions/download-artifact@v5
+          uses: actions/download-artifact@v6
           with:
             name: code-coverage-report
         - name: check coverage

{bloqade_circuit-0.7.13 → bloqade_circuit-0.8.0}/.github/workflows/release.yml

@@ -10,7 +10,7 @@ jobs:
     steps:
     - uses: actions/checkout@v5
     - name: Install uv
-      uses: astral-sh/setup-uv@v6
+      uses: astral-sh/setup-uv@v7
       with:
         # Install a specific version of uv.
         version: "0.5.5"
@@ -19,7 +19,7 @@ jobs:
     - name: Build distribution 📦
       run: uv build
     - name: Store the distribution packages
-      uses: actions/upload-artifact@v4
+      uses: actions/upload-artifact@v5
       with:
         name: python-package-distributions
         path: dist/
@@ -39,7 +39,7 @@ jobs:
 
     steps:
     - name: Download all the dists
-      uses: actions/download-artifact@v5
+      uses: actions/download-artifact@v6
       with:
         name: python-package-distributions
         path: dist/
@@ -60,12 +60,12 @@ jobs:
 
     steps:
     - name: Download all the dists
-      uses: actions/download-artifact@v5
+      uses: actions/download-artifact@v6
       with:
         name: python-package-distributions
         path: dist/
     - name: Sign the dists with Sigstore
-      uses: sigstore/gh-action-sigstore-python@v3.0.1
+      uses: sigstore/gh-action-sigstore-python@v3.1.0
       with:
         inputs: >-
           ./dist/*.tar.gz

{bloqade_circuit-0.7.13 → bloqade_circuit-0.8.0}/.pre-commit-config.yaml

@@ -2,7 +2,7 @@
 # See https://pre-commit.com/hooks.html for more hooks
 repos:
 - repo: https://github.com/pre-commit/pre-commit-hooks
-  rev: v5.0.0
+  rev: v6.0.0
   hooks:
     - id: check-yaml
       args: ['--unsafe']
@@ -14,12 +14,12 @@ repos:
     - id: isort
       name: isort (python)
 - repo: https://github.com/psf/black
-  rev: 25.1.0
+  rev: 25.9.0
   hooks:
     - id: black
 - repo: https://github.com/charliermarsh/ruff-pre-commit
   # Ruff version.
-  rev: "v0.12.1"
+  rev: "v0.13.2"
   hooks:
     - id: ruff
 - repo: https://github.com/crate-ci/typos

{bloqade_circuit-0.7.13 → bloqade_circuit-0.8.0}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: bloqade-circuit
-Version: 0.7.13
+Version: 0.8.0
 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
 Requires-Python: >=3.10
-Requires-Dist: kirin-toolchain~=0.17.26
+Requires-Dist: kirin-toolchain~=0.17.30
 Requires-Dist: numpy>=1.22.0
 Requires-Dist: pandas>=2.2.3
 Requires-Dist: pydantic<2.11.0,>=1.3.0

{bloqade_circuit-0.7.13 → bloqade_circuit-0.8.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "bloqade-circuit"
-version = "0.7.13"
+version = "0.8.0"
 description = "The software development toolkit for neutral atom arrays."
 readme = "README.md"
 authors = [
@@ -13,7 +13,7 @@ requires-python = ">=3.10"
 dependencies = [
     "numpy>=1.22.0",
     "scipy>=1.13.1",
-    "kirin-toolchain~=0.17.26",
+    "kirin-toolchain~=0.17.30",
     "rich>=13.9.4",
     "pydantic>=1.3.0,<2.11.0",
     "pandas>=2.2.3",
@@ -118,3 +118,6 @@ include = ["src/bloqade/*"]
 
 [tool.pytest.ini_options]
 testpaths = "test/"
+filterwarnings = [
+    "ignore:In cirq 1.6 the default value of `use_repetition_ids`:FutureWarning:cirq.circuits.circuit_operation",
+]

bloqade_circuit-0.8.0/src/bloqade/analysis/address/__init__.py

@@ -0,0 +1,15 @@
+from . import impls as impls
+from .lattice import (
+    Bottom as Bottom,
+    Address as Address,
+    Unknown as Unknown,
+    AddressReg as AddressReg,
+    UnknownReg as UnknownReg,
+    ConstResult as ConstResult,
+    AddressQubit as AddressQubit,
+    PartialIList as PartialIList,
+    PartialTuple as PartialTuple,
+    UnknownQubit as UnknownQubit,
+    PartialLambda as PartialLambda,
+)
+from .analysis import AddressAnalysis as AddressAnalysis

bloqade_circuit-0.8.0/src/bloqade/analysis/address/analysis.py

@@ -0,0 +1,150 @@
+from typing import Any, Type, TypeVar
+from dataclasses import field
+
+from kirin import ir, types, interp
+from kirin.analysis import Forward, const
+from kirin.dialects.ilist import IList
+from kirin.analysis.forward import ForwardFrame
+from kirin.analysis.const.lattice import PartialLambda
+
+from .lattice import Address, AddressReg, ConstResult, PartialIList, PartialTuple
+
+
+class AddressAnalysis(Forward[Address]):
+    """
+    This analysis pass can be used to track the global addresses of qubits and wires.
+    """
+
+    keys = ["qubit.address"]
+    _const_prop: const.Propagate
+    lattice = Address
+    next_address: int = field(init=False)
+
+    def initialize(self):
+        super().initialize()
+        self.next_address: int = 0
+        self._const_prop = const.Propagate(self.dialects)
+        self._const_prop.initialize()
+        return self
+
+    @property
+    def qubit_count(self) -> int:
+        """Total number of qubits found by the analysis."""
+        return self.next_address
+
+    T = TypeVar("T")
+
+    def to_address(self, result: const.Result):
+        return ConstResult(result)
+
+    def try_eval_const_prop(
+        self,
+        frame: ForwardFrame[Address],
+        stmt: ir.Statement,
+        args: tuple[ConstResult, ...],
+    ) -> interp.StatementResult[Address]:
+        _frame = self._const_prop.initialize_frame(frame.code)
+        _frame.set_values(stmt.args, tuple(x.result for x in args))
+        result = self._const_prop.eval_stmt(_frame, stmt)
+
+        match result:
+            case interp.ReturnValue(constant_ret):
+                return interp.ReturnValue(self.to_address(constant_ret))
+            case interp.YieldValue(constant_values):
+                return interp.YieldValue(tuple(map(self.to_address, constant_values)))
+            case interp.Successor(block, block_args):
+                return interp.Successor(block, *map(self.to_address, block_args))
+            case tuple():
+                return tuple(map(self.to_address, result))
+            case _:
+                return result
+
+    def unpack_iterable(self, iterable: Address):
+        """Extract the values of a container lattice element.
+
+        Args:
+            iterable: The lattice element representing a container.
+
+        Returns:
+            A tuple of the container type and the contained values.
+
+        """
+
+        def from_constant(constant: const.Result) -> Address:
+            return ConstResult(constant)
+
+        def from_literal(literal: Any) -> Address:
+            return ConstResult(const.Value(literal))
+
+        match iterable:
+            case PartialIList(data):
+                return PartialIList, data
+            case PartialTuple(data):
+                return PartialTuple, data
+            case AddressReg():
+                return PartialIList, iterable.qubits
+            case ConstResult(const.Value(IList() as data)):
+                return PartialIList, tuple(map(from_literal, data))
+            case ConstResult(const.Value(tuple() as data)):
+                return PartialTuple, tuple(map(from_literal, data))
+            case ConstResult(const.PartialTuple(data)):
+                return PartialTuple, tuple(map(from_constant, data))
+            case _:
+                return None, ()
+
+    def run_lattice(
+        self,
+        callee: Address,
+        inputs: tuple[Address, ...],
+        kwargs: tuple[str, ...],
+    ) -> Address:
+        """Run a callable lattice element with the given inputs and keyword arguments.
+
+        Args:
+            callee (Address): The lattice element representing the callable.
+            inputs (tuple[Address, ...]): The input lattice elements.
+            kwargs (tuple[str, ...]): The keyword argument names.
+
+        Returns:
+            Address: The resulting lattice element after invoking the callable.
+
+        """
+
+        match callee:
+            case PartialLambda(code=code, argnames=argnames):
+                _, ret = self.run_callable(
+                    code, (callee,) + self.permute_values(argnames, inputs, kwargs)
+                )
+                return ret
+            case ConstResult(const.Value(ir.Method() as method)):
+                _, ret = self.run_method(
+                    method,
+                    self.permute_values(method.arg_names, inputs, kwargs),
+                )
+                return ret
+            case _:
+                return Address.top()
+
+    def get_const_value(self, addr: Address, typ: Type[T]) -> T | None:
+        if not isinstance(addr, ConstResult):
+            return None
+
+        if not isinstance(result := addr.result, const.Value):
+            return None
+
+        if not isinstance(value := result.data, typ):
+            return None
+
+        return value
+
+    def eval_stmt_fallback(self, frame: ForwardFrame[Address], stmt: ir.Statement):
+        args = frame.get_values(stmt.args)
+        if types.is_tuple_of(args, ConstResult):
+            return self.try_eval_const_prop(frame, stmt, args)
+
+        return tuple(Address.from_type(result.type) for result in stmt.results)
+
+    def run_method(self, method: ir.Method, args: tuple[Address, ...]):
+        # NOTE: we do not support dynamic calls here, thus no need to propagate method object
+        self_mt = ConstResult(const.Value(method))
+        return self.run_callable(method.code, (self_mt,) + args)

bloqade_circuit-0.8.0/src/bloqade/analysis/address/impls.py

@@ -0,0 +1,381 @@
+"""
+qubit.address method table for a few builtin dialects.
+"""
+
+from itertools import chain
+
+from kirin import ir, interp
+from kirin.analysis import ForwardFrame, const
+from kirin.dialects import cf, py, scf, func, ilist
+
+from .lattice import (
+    Address,
+    ConstResult,
+    PartialIList,
+    PartialTuple,
+    PartialLambda,
+)
+from .analysis import AddressAnalysis
+
+
+@py.constant.dialect.register(key="qubit.address")
+class PyConstant(interp.MethodTable):
+    @interp.impl(py.Constant)
+    def constant(
+        self,
+        interp_: AddressAnalysis,
+        frame: ForwardFrame[Address],
+        stmt: py.Constant,
+    ):
+        return (ConstResult(const.Value(stmt.value.unwrap())),)
+
+
+@py.binop.dialect.register(key="qubit.address")
+class PyBinOp(interp.MethodTable):
+    @interp.impl(py.Add)
+    def add(
+        self,
+        interp_: AddressAnalysis,
+        frame: ForwardFrame[Address],
+        stmt: py.Add,
+    ):
+        lhs = frame.get(stmt.lhs)
+        rhs = frame.get(stmt.rhs)
+
+        lhs_type, lhs_values = interp_.unpack_iterable(lhs)
+        rhs_type, rhs_values = interp_.unpack_iterable(rhs)
+
+        if lhs_type is None or rhs_type is None:
+            return (Address.top(),)
+
+        if lhs_type is not rhs_type:
+            return (Address.bottom(),)
+
+        return (lhs_type(tuple(chain(lhs_values, rhs_values))),)
+
+
+@py.tuple.dialect.register(key="qubit.address")
+class PyTuple(interp.MethodTable):
+    @interp.impl(py.tuple.New)
+    def new_tuple(
+        self,
+        interp_: AddressAnalysis,
+        frame: ForwardFrame[Address],
+        stmt: py.tuple.New,
+    ):
+        return (PartialTuple(frame.get_values(stmt.args)),)
+
+
+@ilist.dialect.register(key="qubit.address")
+class IListMethods(interp.MethodTable):
+    @interp.impl(ilist.New)
+    def new_ilist(
+        self,
+        interp_: AddressAnalysis,
+        frame: ForwardFrame[Address],
+        stmt: ilist.New,
+    ):
+        return (PartialIList(frame.get_values(stmt.args)),)
+
+    @interp.impl(ilist.ForEach)
+    @interp.impl(ilist.Map)
+    def map_(
+        self,
+        interp_: AddressAnalysis,
+        frame: ForwardFrame[Address],
+        stmt: ilist.Map | ilist.ForEach,
+    ):
+        fn = frame.get(stmt.fn)
+        collection = frame.get(stmt.collection)
+        collection_type, values = interp_.unpack_iterable(collection)
+
+        if collection_type is None:
+            return (Address.top(),)
+
+        if collection_type is not PartialIList:
+            return (Address.bottom(),)
+
+        results = []
+        for ele in values:
+            ret = interp_.run_lattice(fn, (ele,), ())
+            results.append(ret)
+
+        if isinstance(stmt, ilist.Map):
+            return (PartialIList(tuple(results)),)
+
+
+@py.len.dialect.register(key="qubit.address")
+class PyLen(interp.MethodTable):
+    @interp.impl(py.Len)
+    def len_(
+        self, interp_: AddressAnalysis, frame: ForwardFrame[Address], stmt: py.Len
+    ):
+        obj = frame.get(stmt.value)
+        _, values = interp_.unpack_iterable(obj)
+
+        if values is None:
+            return (Address.top(),)
+
+        return (ConstResult(const.Value(len(values))),)
+
+
+@py.indexing.dialect.register(key="qubit.address")
+class PyIndexing(interp.MethodTable):
+    @interp.impl(py.GetItem)
+    def getitem(
+        self,
+        interp_: AddressAnalysis,
+        frame: ForwardFrame[Address],
+        stmt: py.GetItem,
+    ):
+        # determine if the index is an int constant
+        # or a slice
+        obj = frame.get(stmt.obj)
+        index = frame.get(stmt.index)
+
+        typ, values = interp_.unpack_iterable(obj)
+        if typ is None:
+            return (Address.top(),)
+
+        int_index = interp_.get_const_value(index, int)
+        if int_index is not None:
+            return (values[int_index],)
+
+        slice_index = interp_.get_const_value(index, slice)
+        if slice_index is not None:
+            return (typ(values[slice_index]),)
+
+        return (Address.top(),)
+
+
+@py.assign.dialect.register(key="qubit.address")
+class PyAssign(interp.MethodTable):
+    @interp.impl(py.Alias)
+    def alias(
+        self,
+        interp: AddressAnalysis,
+        frame: ForwardFrame[Address],
+        stmt: py.Alias,
+    ):
+        return (frame.get(stmt.value),)
+
+
+# TODO: look for abstract method table for func.
+@func.dialect.register(key="qubit.address")
+class Func(interp.MethodTable):
+    @interp.impl(func.Return)
+    def return_(
+        self,
+        _: AddressAnalysis,
+        frame: ForwardFrame[Address],
+        stmt: func.Return,
+    ):
+        return interp.ReturnValue(frame.get(stmt.value))
+
+    # TODO: replace with the generic implementation
+    @interp.impl(func.Invoke)
+    def invoke(
+        self,
+        interp_: AddressAnalysis,
+        frame: ForwardFrame[Address],
+        stmt: func.Invoke,
+    ):
+
+        args = interp_.permute_values(
+            stmt.callee.arg_names, frame.get_values(stmt.inputs), stmt.kwargs
+        )
+        _, ret = interp_.run_method(
+            stmt.callee,
+            args,
+        )
+
+        return (ret,)
+
+    @interp.impl(func.Lambda)
+    def lambda_(
+        self,
+        inter_: AddressAnalysis,
+        frame: ForwardFrame[Address],
+        stmt: func.Lambda,
+    ):
+        arg_names = [
+            arg.name or str(idx) for idx, arg in enumerate(stmt.body.blocks[0].args)
+        ]
+        return (
+            PartialLambda(
+                arg_names,
+                stmt,
+                frame.get_values(stmt.captured),
+            ),
+        )
+
+    @interp.impl(func.Call)
+    def call(
+        self,
+        interp_: AddressAnalysis,
+        frame: ForwardFrame[Address],
+        stmt: func.Call,
+    ):
+        result = interp_.run_lattice(
+            frame.get(stmt.callee),
+            frame.get_values(stmt.inputs),
+            stmt.kwargs,
+        )
+        return (result,)
+
+    @interp.impl(func.GetField)
+    def get_field(
+        self,
+        interp_: AddressAnalysis,
+        frame: ForwardFrame[Address],
+        stmt: func.GetField,
+    ):
+        self_mt = frame.get(stmt.obj)
+        match self_mt:
+            case PartialLambda(captured=captured):
+                return (captured[stmt.field],)
+            case ConstResult(const.Value(ir.Method() as mt)):
+                return (ConstResult(const.Value(mt.fields[stmt.field])),)
+
+        return (Address.top(),)
+
+
+@cf.dialect.register(key="qubit.address")
+class Cf(interp.MethodTable):
+
+    @interp.impl(cf.Branch)
+    def branch(
+        self,
+        interp_: AddressAnalysis,
+        frame: ForwardFrame[Address],
+        stmt: cf.Branch,
+    ):
+        frame.worklist.append(
+            interp.Successor(stmt.successor, *frame.get_values(stmt.arguments))
+        )
+        return ()
+
+    @interp.impl(cf.ConditionalBranch)
+    def conditional_branch(
+        self,
+        interp_: const.Propagate,
+        frame: ForwardFrame[Address],
+        stmt: cf.ConditionalBranch,
+    ):
+        address_cond = frame.get(stmt.cond)
+
+        if isinstance(address_cond, ConstResult) and isinstance(
+            cond := address_cond.result, const.Value
+        ):
+            else_successor = interp.Successor(
+                stmt.else_successor, *frame.get_values(stmt.else_arguments)
+            )
+            then_successor = interp.Successor(
+                stmt.then_successor, *frame.get_values(stmt.then_arguments)
+            )
+            if cond.data:
+                frame.worklist.append(then_successor)
+            else:
+                frame.worklist.append(else_successor)
+        else:
+            frame.entries[stmt.cond] = ConstResult(const.Value(True))
+            then_successor = interp.Successor(
+                stmt.then_successor, *frame.get_values(stmt.then_arguments)
+            )
+            frame.worklist.append(then_successor)
+
+            frame.entries[stmt.cond] = ConstResult(const.Value(False))
+            else_successor = interp.Successor(
+                stmt.else_successor, *frame.get_values(stmt.else_arguments)
+            )
+            frame.worklist.append(else_successor)
+
+            frame.entries[stmt.cond] = address_cond
+        return ()
+
+
+@scf.dialect.register(key="qubit.address")
+class Scf(interp.MethodTable):
+    @interp.impl(scf.Yield)
+    def yield_(
+        self,
+        interp_: AddressAnalysis,
+        frame: ForwardFrame[Address],
+        stmt: scf.Yield,
+    ):
+        return interp.YieldValue(frame.get_values(stmt.values))
+
+    @interp.impl(scf.IfElse)
+    def ifelse(
+        self,
+        interp_: AddressAnalysis,
+        frame: ForwardFrame[Address],
+        stmt: scf.IfElse,
+    ):
+        address_cond = frame.get(stmt.cond)
+        # run specific branch
+        if isinstance(address_cond, ConstResult) and isinstance(
+            const_cond := address_cond.result, const.Value
+        ):
+            body = stmt.then_body if const_cond.data else stmt.else_body
+            with interp_.new_frame(stmt, has_parent_access=True) as body_frame:
+                ret = interp_.run_ssacfg_region(body_frame, body, (address_cond,))
+                # interp_.set_values(frame, body_frame.entries.keys(), body_frame.entries.values())
+                return ret
+        else:
+            # run both branches
+            with interp_.new_frame(stmt, has_parent_access=True) as then_frame:
+                then_results = interp_.run_ssacfg_region(
+                    then_frame, stmt.then_body, (address_cond,)
+                )
+                interp_.set_values(
+                    frame, then_frame.entries.keys(), then_frame.entries.values()
+                )
+
+            with interp_.new_frame(stmt, has_parent_access=True) as else_frame:
+                else_results = interp_.run_ssacfg_region(
+                    else_frame, stmt.else_body, (address_cond,)
+                )
+                interp_.set_values(
+                    frame, else_frame.entries.keys(), else_frame.entries.values()
+                )
+            # TODO: pick the non-return value
+            if isinstance(then_results, interp.ReturnValue) and isinstance(
+                else_results, interp.ReturnValue
+            ):
+                return interp.ReturnValue(then_results.value.join(else_results.value))
+            elif isinstance(then_results, interp.ReturnValue):
+                ret = else_results
+            elif isinstance(else_results, interp.ReturnValue):
+                ret = then_results
+            else:
+                ret = interp_.join_results(then_results, else_results)
+
+            return ret
+
+    @interp.impl(scf.For)
+    def for_loop(
+        self,
+        interp_: AddressAnalysis,
+        frame: ForwardFrame[Address],
+        stmt: scf.For,
+    ):
+        loop_vars = frame.get_values(stmt.initializers)
+        iter_type, iterable = interp_.unpack_iterable(frame.get(stmt.iterable))
+
+        if iter_type is None:
+            return interp_.eval_stmt_fallback(frame, stmt)
+
+        for value in iterable:
+            with interp_.new_frame(stmt, has_parent_access=True) as body_frame:
+                loop_vars = interp_.run_ssacfg_region(
+                    body_frame, stmt.body, (value,) + loop_vars
+                )
+
+            if loop_vars is None:
+                loop_vars = ()
+
+            elif isinstance(loop_vars, interp.ReturnValue):
+                return loop_vars
+
+        return loop_vars