bloqade-circuit 0.7.1__tar.gz → 0.7.3__tar.gz

{bloqade_circuit-0.7.1 → bloqade_circuit-0.7.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bloqade-circuit
-Version: 0.7.1
+Version: 0.7.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.7.1 → bloqade_circuit-0.7.3}/pyproject.toml

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

{bloqade_circuit-0.7.1 → bloqade_circuit-0.7.3}/src/bloqade/qasm2/rewrite/register.py

@@ -2,7 +2,7 @@ from kirin import ir
 from kirin.dialects import py
 from kirin.rewrite.abc import RewriteRule, RewriteResult
 
-from bloqade.qasm2.dialects import core
+from bloqade.qasm2.dialects import core, expr
 
 
 class RaiseRegisterRule(RewriteRule):
@@ -26,7 +26,7 @@ class RaiseRegisterRule(RewriteRule):
         n_qubits_ref = node.n_qubits
 
         n_qubits = n_qubits_ref.owner
-        if isinstance(n_qubits, py.Constant):
+        if isinstance(n_qubits, py.Constant | expr.ConstInt):
             # case where the n_qubits comes from a constant
             new_n_qubits = n_qubits.from_stmt(n_qubits)
             new_n_qubits.insert_before(first_stmt)

{bloqade_circuit-0.7.1 → bloqade_circuit-0.7.3}/src/bloqade/qasm2/rewrite/uop_to_parallel.py

@@ -8,7 +8,7 @@ from kirin.rewrite.abc import RewriteRule, RewriteResult
 from kirin.analysis.const import lattice
 
 from bloqade.analysis import address
-from bloqade.qasm2.dialects import uop, core, parallel
+from bloqade.qasm2.dialects import uop, core, expr, parallel
 from bloqade.squin.analysis.schedule import StmtDag
 
 
@@ -194,6 +194,8 @@ class SimpleMergePolicy(MergePolicyABC):
                     new_qubits.append(new_qubit.result)
                 case core.QRegGet(
                     reg=reg, idx=ir.ResultValue(stmt=py.Constant() as idx)
+                ) | core.QRegGet(
+                    reg=reg, idx=ir.ResultValue(stmt=expr.ConstInt() as idx)
                 ):
                     (new_idx := idx.from_stmt(idx)).insert_before(node)
                     (

{bloqade_circuit-0.7.1 → bloqade_circuit-0.7.3}/src/bloqade/squin/__init__.py

@@ -11,7 +11,8 @@ 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
+from . import parallel as parallel  # isort: skip
+from .stdlib import gate as gate, channel as channel  # isort: skip
 
 try:
     # NOTE: make sure optional cirq dependency is installed

{bloqade_circuit-0.7.1 → bloqade_circuit-0.7.3}/src/bloqade/squin/noise/_wrapper.py

@@ -22,13 +22,13 @@ def depolarize2(p: float) -> Op: ...
 
 @wraps(stmts.SingleQubitPauliChannel)
 def single_qubit_pauli_channel(
-    params: ilist.IList[float, Literal[3]] | list[float] | tuple[float, float, float],
+    params: ilist.IList[float, Literal[3]] | list[float],
 ) -> Op: ...
 
 
 @wraps(stmts.TwoQubitPauliChannel)
 def two_qubit_pauli_channel(
-    params: ilist.IList[float, Literal[15]] | list[float] | tuple[float, ...],
+    params: ilist.IList[float, Literal[15]] | list[float],
 ) -> Op: ...
 
 

{bloqade_circuit-0.7.1 → bloqade_circuit-0.7.3}/src/bloqade/squin/noise/stmts.py

@@ -30,7 +30,11 @@ class Depolarize(NoiseChannel):
 @statement(dialect=dialect)
 class Depolarize2(NoiseChannel):
     """
-    Apply correlated depolarize error to two qubit
+    Apply correlated depolarize error to two qubits
+
+    This will apply one of the randomly chosen Pauli products:
+
+    {IX, IY, IZ, XI, XX, XY, XZ, YI, YX, YY, YZ, ZI, ZX, ZY, ZZ}
     """
 
     p: ir.SSAValue = info.argument(types.Float)
@@ -43,6 +47,16 @@ class SingleQubitPauliChannel(NoiseChannel):
 
 @statement(dialect=dialect)
 class TwoQubitPauliChannel(NoiseChannel):
+    """
+    This will apply one of the randomly chosen Pauli products:
+
+    {IX, IY, IZ, XI, XX, XY, XZ, YI, YX, YY, YZ, ZI, ZX, ZY, ZZ}
+
+    but the choice is weighed with the given probability.
+
+    NOTE: the given parameters are ordered as given in the list above!
+    """
+
     params: ir.SSAValue = info.argument(ilist.IListType[types.Float, types.Literal(15)])
 
 

bloqade_circuit-0.7.3/src/bloqade/squin/stdlib/channel.py

@@ -0,0 +1,86 @@
+from bloqade.types import Qubit
+from bloqade.squin.op.types import PauliOp
+
+from .. import noise, qubit as _qubit, kernel
+
+
+@kernel
+def pauli_error(basis: PauliOp, p: float, qubit: Qubit) -> None:
+    """Apply the pauli operator given as basis with a probability p to qubit.
+
+    NOTE: the `PauliError` actually supports multiple qubits and multi-site bases,
+    it's only the short-hand definition here that is limited to a single qubit.
+    If you want to define a pauli error for multiple qubits, you can do so using
+    the statement, for example
+
+    ```python
+    q = squin.qubit.new(3)
+    multi_qubit_pauli = squin.op.pauli_string(string="XYZ")
+    pauli_error = squin.noise.pauli_error(basis=multi_qubit_pauli, p=0.1)
+    squin.qubit.apply(pauli_error, q[0], q[1], q[2])
+    ```
+
+    """
+    op = noise.pauli_error(basis, p)
+    _qubit.apply(op, qubit)
+
+
+@kernel
+def depolarize(p: float, qubit: Qubit) -> None:
+    """Apply depolarization error with probability p to qubit.
+
+    This means, that with a probability p/3 one of the three Pauli operators is applied.
+    Which Pauli operator is applied is chosen at random with equal probability.
+    """
+    op = noise.depolarize(p)
+    _qubit.apply(op, qubit)
+
+
+@kernel
+def depolarize2(p: float, qubit1: Qubit, qubit2: Qubit) -> None:
+    """Apply the correlated two-qubit depolarization error with probability p to qubits.
+
+    This means, that with a probability of p/15 one of the Pauli products {XX, XY, XZ, XI, YX, YY, ...}
+    is applied to the qubit pair. Which Pauli product is applied is chosen at random with equal probability.
+    """
+
+    op = noise.depolarize2(p)
+    _qubit.apply(op, qubit1, qubit2)
+
+
+@kernel
+def single_qubit_pauli_channel(params: list[float], qubit: Qubit) -> None:
+    """Apply the single qubit Pauli error with probabilities px, py, pz, respectively, to the qubit.
+
+    Similar to `depolarize`, but with distinct probabilities. An error occurs with the probability `px + py + pz`.
+    Which operator is applied is chosen at random, but weighed with the respective probabilities.
+    """
+    op = noise.single_qubit_pauli_channel(params)
+    _qubit.apply(op, qubit)
+
+
+@kernel
+def two_qubit_pauli_channel(params: list[float], qubit1: Qubit, qubit2: Qubit) -> None:
+    """Apply the two-qubit correlated Pauli error with probabilities given in the list above.
+
+    This means one of the operator products
+
+    {IX, IY, IZ, XI, XX, XY, XZ, YI, YX, YY, YZ, ZI, ZX, ZY, ZZ}
+
+    is applied. The choice of which is weighed by the given probabilities.
+
+    NOTE: the given parameters are ordered as given in the list above!
+
+    """
+    op = noise.two_qubit_pauli_channel(params)
+    _qubit.apply(op, qubit1, qubit2)
+
+
+@kernel
+def qubit_loss(p: float, qubit: Qubit) -> None:
+    """Apply a qubit loss channel with probability p.
+
+    When a loss channel is applied, the qubit is marked as lost by setting its state accordingly.
+    """
+    op = noise.qubit_loss(p)
+    _qubit.apply(op, qubit)

{bloqade_circuit-0.7.1/src/bloqade/squin → bloqade_circuit-0.7.3/src/bloqade/squin/stdlib}/gate.py

@@ -1,7 +1,8 @@
 from bloqade.types import Qubit
 
-from . import op as _op, qubit as _qubit
-from .groups import kernel
+from ..groups import kernel
+
+from .. import op as _op, qubit as _qubit  # isort: skip
 
 
 @kernel

{bloqade_circuit-0.7.1 → bloqade_circuit-0.7.3}/test/qasm2/passes/test_uop_to_parallel.py

@@ -38,6 +38,14 @@ def test_one():
     # add this to raise error if there are broken ssa references
     _, _ = address.AddressAnalysis(test.dialects).run_analysis(test, no_raise=False)
 
+    # check that there's parallel statements now
+    assert any(
+        [
+            isinstance(stmt, qasm2.dialects.parallel.UGate)
+            for stmt in test.callable_region.blocks[0].stmts
+        ]
+    )
+
 
 def test_two():
 

{bloqade_circuit-0.7.1 → bloqade_circuit-0.7.3}/test/squin/test_stdlib_shorthands.py

@@ -1,4 +1,5 @@
 import pytest
+from kirin.passes import inline
 
 from bloqade import squin
 from bloqade.types import Qubit
@@ -156,3 +157,112 @@ def test_parameter_gates(op_name: str):
 
     sim = StackMemorySimulator(min_qubits=4)
     sim.run(main)
+
+
+@pytest.mark.parametrize(
+    "op_name",
+    [
+        "depolarize",
+        "qubit_loss",
+    ],
+)
+def test_single_qubit_noise(op_name: str):
+    @squin.kernel
+    def main():
+        q = squin.qubit.new(1)
+        p = 0.1
+        getattr(squin.channel, op_name)(p, q[0])
+
+    main.print()
+
+    # NOTE: need to inline invokes so the noise rewrite can do its thing
+    inline.InlinePass(main.dialects)(main)
+
+    sim = StackMemorySimulator(min_qubits=1)
+    sim.run(main)
+
+
+def test_pauli_error():
+    @squin.kernel
+    def main():
+        q = squin.qubit.new(1)
+        p = 0.1
+        x = squin.op.x()
+        squin.channel.pauli_error(x, p, q[0])
+
+    main.print()
+
+    # NOTE: need to inline invokes so the noise rewrite can do its thing
+    inline.InlinePass(main.dialects)(main)
+
+    sim = StackMemorySimulator(min_qubits=1)
+    sim.run(main)
+
+
+def test_single_qubit_pauli_channel():
+    @squin.kernel
+    def main():
+        q = squin.qubit.new(1)
+        px = 0.1
+        py = 0.1
+        pz = 0.05
+        squin.channel.single_qubit_pauli_channel([px, py, pz], q[0])
+
+    main.print()
+
+    # NOTE: need to inline invokes so the noise rewrite can do its thing
+    inline.InlinePass(main.dialects)(main)
+
+    sim = StackMemorySimulator(min_qubits=1)
+    sim.run(main)
+
+
+def test_depolarize2():
+    @squin.kernel
+    def main():
+        q = squin.qubit.new(2)
+        p = 0.1
+        squin.channel.depolarize2(p, q[0], q[1])
+
+    main.print()
+
+    # NOTE: need to inline invokes so the noise rewrite can do its thing
+    inline.InlinePass(main.dialects)(main)
+
+    sim = StackMemorySimulator(min_qubits=2)
+    sim.run(main)
+
+
+def test_two_qubit_pauli_channel():
+    @squin.kernel
+    def main():
+        q = squin.qubit.new(2)
+
+        # NOTE: this API is not great
+        ps = [
+            0.0001,
+            0.0001,
+            0.0001,
+            0.0001,
+            0.0001,
+            0.0001,
+            0.0001,
+            0.0001,
+            0.0001,
+            0.0001,
+            0.0001,
+            0.0001,
+            0.0001,
+            0.0001,
+            0.0001,
+        ]
+
+        squin.channel.two_qubit_pauli_channel(ps, q[0], q[1])
+
+    main.print()
+
+    # NOTE: need to inline invokes so the noise rewrite can do its thing
+    inline.InlinePass(main.dialects)(main)
+
+    sim = StackMemorySimulator(min_qubits=2)
+    sim.run(main)

{bloqade_circuit-0.7.1 → bloqade_circuit-0.7.3}/uv.lock

@@ -102,7 +102,7 @@ wheels = [
 
 [[package]]
 name = "bloqade-circuit"
-version = "0.7.1"
+version = "0.7.3"
 source = { editable = "." }
 dependencies = [
     { name = "kirin-toolchain" },
@@ -897,16 +897,16 @@ wheels = [
 
 [[package]]
 name = "kirin-toolchain"
-version = "0.17.17"
+version = "0.17.22"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "beartype" },
     { name = "rich" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/2a/0a/dff9a05b58b30f7383bf560aabc344536352f2bd85846fcfc74c430a6a3e/kirin_toolchain-0.17.17.tar.gz", hash = "sha256:1a2ee7adc76f6ce822848d7022e32e8c426d425ddb7915762d346e58545c84a5", size = 1163742 }
+sdist = { url = "https://files.pythonhosted.org/packages/48/58/0fcd2b2c63580cf50aa1a13516d44d329422e35967258696b1bb176d3231/kirin_toolchain-0.17.22.tar.gz", hash = "sha256:a0a05ac5870352564c76c2754f501c158608217613136f17ecf25882cb7e2b03", size = 1184720 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/27/35/f7c58eb8a55d54e2bc3c362c2f61352e06d66f1ef772a1a8e3093f5a59ed/kirin_toolchain-0.17.17-py3-none-any.whl", hash = "sha256:dd9604c648b7d2e9d26b8055c5ad5680e144b534e848f03e4984fec587bbb248", size = 224754 },
+    { url = "https://files.pythonhosted.org/packages/63/a5/295afd71ec6c3c116e875ee94a589baf097045e7cbc35d509c47edf9c2fc/kirin_toolchain-0.17.22-py3-none-any.whl", hash = "sha256:516b4dd85ceaa2e94a5a051a8aa8d6264fd33757e6aafc94ef2118384e45f1f4", size = 228152 },
 ]
 
 [[package]]