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

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

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

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

{bloqade_circuit-0.7.1 → bloqade_circuit-0.7.2}/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.2}/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.2}/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.2/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.2/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.2}/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.2}/uv.lock

@@ -102,7 +102,7 @@ wheels = [
 
 [[package]]
 name = "bloqade-circuit"
-version = "0.7.1"
+version = "0.7.2"
 source = { editable = "." }
 dependencies = [
     { name = "kirin-toolchain" },
@@ -897,16 +897,16 @@ wheels = [
 
 [[package]]
 name = "kirin-toolchain"
-version = "0.17.17"
+version = "0.17.19"
 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/5a/94/76793ff9c1a8884a508eb40f66dc6b059547c152ffc9af3a14c5cb631318/kirin_toolchain-0.17.19.tar.gz", hash = "sha256:0bcf3a3ba6526683d1a64d6a22d751439e84e6d568651215d5b3e72902f16cba", size = 1184235 }
 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/f9/7c/07e30f6b88681b5090b49982651160f8e6d3bfb4e1301965f4c87407be7e/kirin_toolchain-0.17.19-py3-none-any.whl", hash = "sha256:ff5f12567ab4dc2b4853d02ed69c25a5d4892cefa214316374b262086a030a57", size = 227826 },
 ]
 
 [[package]]