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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bloqade-circuit
-Version: 0.6.2
+Version: 0.6.3
 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.2 → bloqade_circuit-0.6.3}/pyproject.toml

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

{bloqade_circuit-0.6.2 → bloqade_circuit-0.6.3}/src/bloqade/pyqrack/device.py

@@ -3,7 +3,9 @@ from dataclasses import field, dataclass
 
 import numpy as np
 from kirin import ir
+from kirin.passes import fold
 
+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
@@ -16,6 +18,7 @@ from bloqade.pyqrack.base import (
     _default_pyqrack_args,
 )
 from bloqade.pyqrack.task import PyQrackSimulatorTask
+from bloqade.squin.noise.rewrite import RewriteNoiseStmts
 from bloqade.analysis.address.lattice import AnyAddress
 from bloqade.analysis.address.analysis import AddressAnalysis
 
@@ -47,14 +50,23 @@ 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(

{bloqade_circuit-0.6.2 → bloqade_circuit-0.6.3}/src/bloqade/pyqrack/squin/op.py

@@ -1,3 +1,5 @@
+import math
+
 from kirin import interp
 
 from bloqade.squin import op
@@ -122,6 +124,18 @@ class PyQrackMethods(interp.MethodTable):
     ) -> tuple[OperatorRuntimeABC]:
         return (OperatorRuntime(method_name=stmt.name.lower()),)
 
+    @interp.impl(op.stmts.SqrtX)
+    @interp.impl(op.stmts.SqrtY)
+    def sqrt(
+        self,
+        interp: PyQrackInterpreter,
+        frame: interp.Frame,
+        stmt: op.stmts.SqrtX | op.stmts.SqrtY,
+    ):
+        axis_name = "x" if isinstance(stmt, op.stmts.SqrtX) else "y"
+        axis = OperatorRuntime(method_name=axis_name)
+        return (RotRuntime(axis=axis, angle=-0.5 * math.pi),)
+
     @interp.impl(op.stmts.P0)
     @interp.impl(op.stmts.P1)
     def projector(

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

@@ -157,6 +157,7 @@ def load_circuit(
 def emit_circuit(
     mt: ir.Method,
     qubits: Sequence[cirq.Qid] | None = None,
+    ignore_returns: bool = False,
 ) -> cirq.Circuit:
     """Converts a squin.kernel method to a cirq.Circuit object.
 
@@ -170,6 +171,9 @@ def emit_circuit(
             statement in the order they appear inside the kernel.
             **Note**: If a list of qubits is provided, make sure that there is a sufficient
             number of qubits for the resulting circuit.
+        ignore_returns (bool):
+            If `False`, emitting a circuit from a kernel that returns a value will error.
+            Set it to `True` in order to ignore the return value(s). Defaults to `False`.
 
     ## Examples:
 
@@ -228,11 +232,14 @@ def emit_circuit(
     and manipulate the qubits in other circuits directly written in cirq as well.
     """
 
-    if isinstance(mt.code, func.Function) and not mt.code.signature.output.is_subseteq(
-        types.NoneType
+    if (
+        not ignore_returns
+        and isinstance(mt.code, func.Function)
+        and not mt.code.signature.output.is_subseteq(types.NoneType)
     ):
         raise EmitError(
             "The method you are trying to convert to a circuit has a return value, but returning from a circuit is not supported."
+            " Set `ignore_returns = True` in order to simply ignore the return values and emit a circuit."
         )
 
     emitter = EmitCirq(qubits=qubits)
@@ -244,7 +251,12 @@ def emit_circuit(
     return emitter.run(mt_, args=())
 
 
-def dump_circuit(mt: ir.Method, qubits: Sequence[cirq.Qid] | None = None, **kwargs):
+def dump_circuit(
+    mt: ir.Method,
+    qubits: Sequence[cirq.Qid] | None = None,
+    ignore_returns: bool = False,
+    **kwargs,
+):
     """Converts a squin.kernel method to a cirq.Circuit object and dumps it as JSON.
 
     This just runs `emit_circuit` and calls the `cirq.to_json` function to emit a JSON.
@@ -259,7 +271,10 @@ def dump_circuit(mt: ir.Method, qubits: Sequence[cirq.Qid] | None = None, **kwar
             statement in the order they appear inside the kernel.
             **Note**: If a list of qubits is provided, make sure that there is a sufficient
             number of qubits for the resulting circuit.
+        ignore_returns (bool):
+            If `False`, emitting a circuit from a kernel that returns a value will error.
+            Set it to `True` in order to ignore the return value(s). Defaults to `False`.
 
     """
-    circuit = emit_circuit(mt, qubits=qubits)
+    circuit = emit_circuit(mt, qubits=qubits, ignore_returns=ignore_returns)
     return cirq.to_json(circuit, **kwargs)

{bloqade_circuit-0.6.2 → bloqade_circuit-0.6.3}/test/cirq_utils/noise/test_noise_models.py

@@ -82,7 +82,7 @@ def test_simple_model(model: cirq.NoiseModel, qubits):
         assert math.isclose(pops[1], 0.0, abs_tol=1e-1)
         assert math.isclose(pops[2], 0.0, abs_tol=1e-1)
 
-        assert pops[0] < 0.5
-        assert pops[3] < 0.5
+        assert pops[0] < 0.5001
+        assert pops[3] < 0.5001
         assert pops[1] > 0.0
         assert pops[2] > 0.0

{bloqade_circuit-0.6.2 → bloqade_circuit-0.6.3}/test/pyqrack/squin/test_kernel.py

@@ -59,6 +59,9 @@ def test_x():
         "h",
         "s",
         "t",
+        "sqrt_x",
+        "sqrt_y",
+        "sqrt_z",
     ],
 )
 def test_basic_ops(op_name: str):
@@ -66,7 +69,7 @@ def test_basic_ops(op_name: str):
     def main():
         q = squin.qubit.new(1)
         op = getattr(squin.op, op_name)()
-        squin.qubit.apply(op, q)
+        squin.qubit.apply(op, q[0])
         return q
 
     target = PyQrack(1)

{bloqade_circuit-0.6.2 → bloqade_circuit-0.6.3}/test/pyqrack/squin/test_noise.py

@@ -1,5 +1,7 @@
+import math
+
 from bloqade import squin
-from bloqade.pyqrack import PyQrack, PyQrackQubit
+from bloqade.pyqrack import PyQrack, PyQrackQubit, StackMemorySimulator
 from bloqade.squin.noise.stmts import NoiseChannel, StochasticUnitaryChannel
 from bloqade.squin.noise.rewrite import RewriteNoiseStmts
 
@@ -157,3 +159,53 @@ def test_depolarize():
 
     target = PyQrack(1)
     target.run(main)
+
+
+def test_without_rewrite():
+    @squin.kernel
+    def main():
+        q = squin.qubit.new(1)
+        x = squin.op.x()
+        squin.qubit.apply(x, q[0])
+
+        x_err = squin.noise.pauli_error(x, 0.1)
+        squin.qubit.apply(x_err, q[0])
+        return q
+
+    sim = StackMemorySimulator(min_qubits=1)
+    sim.state_vector(main)
+
+    main.print()
+
+    # make sure the method wasn't updated in-place
+    stmts = list(main.callable_region.blocks[0].stmts)
+    assert sum([isinstance(s, StochasticUnitaryChannel) for s in stmts]) == 0
+    assert sum([isinstance(s, squin.noise.stmts.PauliError) for s in stmts]) == 1
+
+
+def test_pauli_string_error():
+    @squin.kernel
+    def main():
+        q = squin.qubit.new(2)
+        x = squin.op.x()
+
+        err = squin.noise.pauli_error(x, 1.0)
+        squin.qubit.apply(err, q[0])
+
+        s = squin.op.pauli_string(string="XX")
+        err2 = squin.noise.pauli_error(s, 1.0)
+        squin.qubit.apply(err2, q)
+
+    main.print()
+
+    RewriteNoiseStmts(main.dialects)(main)
+
+    main.print()
+
+    sim = StackMemorySimulator(min_qubits=2)
+
+    ket = sim.state_vector(main)
+
+    print(ket)
+
+    assert math.isclose(abs(ket[2]) ** 2, 1.0, abs_tol=1e-5)

{bloqade_circuit-0.6.2 → bloqade_circuit-0.6.3}/test/squin/cirq/test_squin_to_cirq.py

@@ -144,6 +144,18 @@ def test_return_value():
     with pytest.raises(EmitError):
         squin.cirq.emit_circuit(sub_kernel)
 
+    @squin.kernel
+    def main2():
+        q = squin.qubit.new(2)
+        h_ = sub_kernel(q)
+        squin.qubit.apply(h_, q[1])
+        return h_
+
+    circuit2 = squin.cirq.emit_circuit(main2, ignore_returns=True)
+    print(circuit2)
+
+    assert circuit2 == circuit
+
 
 def test_return_qubits():
     @squin.kernel
@@ -335,3 +347,6 @@ def test_invoke_cache():
     print(circuit)
 
     assert len(target._cached_circuit_operations) == 2
+
+
+test_return_value()

{bloqade_circuit-0.6.2 → bloqade_circuit-0.6.3}/uv.lock

@@ -102,7 +102,7 @@ wheels = [
 
 [[package]]
 name = "bloqade-circuit"
-version = "0.6.2"
+version = "0.6.3"
 source = { editable = "." }
 dependencies = [
     { name = "kirin-toolchain" },