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

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

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

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

{bloqade_circuit-0.6.4 → 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.4 → 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.4 → bloqade_circuit-0.6.5}/test/pyqrack/squin/test_kernel.py

@@ -519,3 +519,35 @@ def test_reset():
 
     assert math.isclose(abs(ket[3]), 1, abs_tol=1e-6)
     assert ket[0] == ket[1] == ket[2] == 0
+
+
+def test_feed_forward():
+    @squin.kernel
+    def main():
+        q = squin.qubit.new(3)
+        h = squin.op.h()
+        squin.qubit.apply(h, q[0])
+        squin.qubit.apply(h, q[1])
+
+        cx = squin.op.cx()
+        squin.qubit.apply(cx, q[0], q[2])
+        squin.qubit.apply(cx, q[1], q[2])
+
+        squin.qubit.measure(q[2])
+
+    sim = StackMemorySimulator(min_qubits=3)
+
+    ket = sim.state_vector(main)
+
+    print(ket)
+
+    zero_count = 0
+    half_count = 0
+
+    for k in ket:
+        k_abs2 = abs(k) ** 2
+        zero_count += k_abs2 == 0
+        half_count += math.isclose(k_abs2, 0.5, abs_tol=1e-4)
+
+    assert zero_count == 6
+    assert half_count == 2

bloqade_circuit-0.6.5/test/squin/test_stdlib_shorthands.py

@@ -0,0 +1,158 @@
+import pytest
+
+from bloqade import squin
+from bloqade.types import Qubit
+from bloqade.pyqrack import StackMemorySimulator
+
+
+@pytest.mark.parametrize(
+    "op_name",
+    [
+        "x",
+        "y",
+        "z",
+        "sqrt_x",
+        "sqrt_y",
+        "sqrt_z",
+        "sqrt_x_adj",
+        "sqrt_y_adj",
+        "sqrt_z_adj",
+        "h",
+        "s",
+        "s_adj",
+        "t",
+        "t_adj",
+        "p0",
+        "p1",
+        "spin_n",
+        "spin_p",
+        "reset",
+    ],
+)
+def test_single_qubit_apply(op_name: str):
+    @squin.kernel
+    def main():
+        q = squin.qubit.new(1)
+        getattr(squin.gate, op_name)(q[0])
+
+    main.print()
+
+    sim = StackMemorySimulator(min_qubits=1)
+
+    sim.run(main)
+
+
+@pytest.mark.parametrize(
+    "op_name",
+    [
+        "cx",
+        "cy",
+        "cz",
+        "ch",
+    ],
+)
+def test_control_apply(op_name: str):
+    @squin.kernel
+    def main():
+        q = squin.qubit.new(2)
+        getattr(squin.gate, op_name)(q[0], q[1])
+
+    main.print()
+    sim = StackMemorySimulator(min_qubits=2)
+    sim.run(main)
+
+
+@pytest.mark.parametrize(
+    "op_name",
+    [
+        "x",
+        "y",
+        "z",
+        "sqrt_x",
+        "sqrt_y",
+        "sqrt_z",
+        "sqrt_x_adj",
+        "sqrt_y_adj",
+        "sqrt_z_adj",
+        "h",
+        "s",
+        "s_adj",
+        "t",
+        "t_adj",
+        "p0",
+        "p1",
+        "spin_n",
+        "spin_p",
+        "reset",
+    ],
+)
+def test_single_qubit_broadcast(op_name: str):
+    @squin.kernel
+    def main():
+        q = squin.qubit.new(4)
+        getattr(squin.parallel, op_name)(q)
+
+    main.print()
+
+    sim = StackMemorySimulator(min_qubits=4)
+
+    sim.run(main)
+
+
+@pytest.mark.parametrize(
+    "op_name",
+    [
+        "cx",
+        "cy",
+        "cz",
+        "ch",
+    ],
+)
+def test_control_broadcast(op_name: str):
+    @squin.kernel
+    def main():
+        controls = squin.qubit.new(3)
+        targets = squin.qubit.new(3)
+        getattr(squin.parallel, op_name)(controls, targets)
+
+    main.print()
+    sim = StackMemorySimulator(min_qubits=6)
+    sim.run(main)
+
+
+def test_nested_kernel_inline():
+    @squin.kernel
+    def subkernel(q: Qubit):
+        squin.gate.x(q)
+
+    @squin.kernel
+    def main():
+        q = squin.qubit.new(1)
+        subkernel(q[0])
+
+    main.print()
+    sim = StackMemorySimulator(min_qubits=1)
+    sim.run(main)
+
+
+@pytest.mark.parametrize(
+    "op_name",
+    [
+        "rx",
+        "ry",
+        "rz",
+    ],
+)
+def test_parameter_gates(op_name: str):
+    @squin.kernel
+    def main():
+        q = squin.qubit.new(4)
+        theta = 0.123
+        getattr(squin.gate, op_name)(theta, q[0])
+
+        getattr(squin.parallel, op_name)(theta, q)
+
+    main.print()
+
+    sim = StackMemorySimulator(min_qubits=4)
+    sim.run(main)

{bloqade_circuit-0.6.4 → bloqade_circuit-0.6.5}/uv.lock

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