bloqade-circuit 0.7.4__tar.gz → 0.7.5__tar.gz

{bloqade_circuit-0.7.4 → bloqade_circuit-0.7.5}/PKG-INFO

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

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

bloqade_circuit-0.7.5/src/bloqade/native/__init__.py

@@ -0,0 +1,24 @@
+from .stdlib import broadcast as broadcast
+from ._prelude import kernel as kernel
+from .stdlib.simple import (
+    h as h,
+    s as s,
+    t as t,
+    x as x,
+    y as y,
+    z as z,
+    cx as cx,
+    cy as cy,
+    cz as cz,
+    rx as rx,
+    ry as ry,
+    rz as rz,
+    u3 as u3,
+    rot as rot,
+    s_dag as s_dag,
+    shift as shift,
+    sqrt_x as sqrt_x,
+    sqrt_y as sqrt_y,
+    sqrt_x_adj as sqrt_x_adj,
+    sqrt_y_adj as sqrt_y_adj,
+)

bloqade_circuit-0.7.5/src/bloqade/native/_prelude.py

@@ -0,0 +1,45 @@
+from typing import Annotated
+
+from kirin import ir
+from kirin.passes import Default
+from kirin.prelude import structural_no_opt
+from typing_extensions import Doc
+
+from bloqade.squin import qubit
+
+from .dialects import gates
+
+
+@ir.dialect_group(structural_no_opt.union([gates, qubit]))
+def kernel(self):
+    """Compile a function to a native kernel."""
+
+    def run_pass(
+        mt,
+        *,
+        verify: Annotated[
+            bool, Doc("run `verify` before running passes, default is `True`")
+        ] = True,
+        typeinfer: Annotated[
+            bool,
+            Doc(
+                "run type inference and apply the inferred type to IR, default `False`"
+            ),
+        ] = False,
+        fold: Annotated[bool, Doc("run folding passes")] = True,
+        aggressive: Annotated[
+            bool, Doc("run aggressive folding passes if `fold=True`")
+        ] = False,
+        no_raise: Annotated[bool, Doc("do not raise exception during analysis")] = True,
+    ) -> None:
+        default_pass = Default(
+            self,
+            verify=verify,
+            fold=fold,
+            aggressive=aggressive,
+            typeinfer=typeinfer,
+            no_raise=no_raise,
+        )
+        default_pass.fixpoint(mt)
+
+    return run_pass

bloqade_circuit-0.7.5/src/bloqade/native/dialects/gates/__init__.py

@@ -0,0 +1,3 @@
+from .stmts import CZ as CZ, R as R, Rz as Rz
+from ._dialect import dialect as dialect
+from ._interface import r as r, cz as cz, rz as rz

bloqade_circuit-0.7.5/src/bloqade/native/dialects/gates/_dialect.py

@@ -0,0 +1,3 @@
+from kirin import ir
+
+dialect = ir.Dialect("bloqade.native")

bloqade_circuit-0.7.5/src/bloqade/native/dialects/gates/_interface.py

@@ -0,0 +1,32 @@
+import typing
+
+from kirin import lowering
+from kirin.dialects import ilist
+
+from bloqade.squin import qubit
+
+from .stmts import CZ, R, Rz
+
+Len = typing.TypeVar("Len")
+
+
+@lowering.wraps(CZ)
+def cz(
+    ctrls: ilist.IList[qubit.Qubit, Len],
+    qargs: ilist.IList[qubit.Qubit, Len],
+): ...
+
+
+@lowering.wraps(R)
+def r(
+    inputs: ilist.IList[qubit.Qubit, typing.Any],
+    axis_angle: float,
+    rotation_angle: float,
+): ...
+
+
+@lowering.wraps(Rz)
+def rz(
+    inputs: ilist.IList[qubit.Qubit, typing.Any],
+    rotation_angle: float,
+): ...

bloqade_circuit-0.7.5/src/bloqade/native/dialects/gates/stmts.py

@@ -0,0 +1,31 @@
+from kirin import ir, types, lowering
+from kirin.decl import info, statement
+from kirin.dialects import ilist
+
+from bloqade.squin import qubit
+
+from ._dialect import dialect
+
+N = types.TypeVar("N")
+
+
+@statement(dialect=dialect)
+class CZ(ir.Statement):
+    traits = frozenset({lowering.FromPythonCall()})
+    ctrls: ir.SSAValue = info.argument(ilist.IListType[qubit.QubitType, N])
+    qargs: ir.SSAValue = info.argument(ilist.IListType[qubit.QubitType, N])
+
+
+@statement(dialect=dialect)
+class R(ir.Statement):
+    traits = frozenset({lowering.FromPythonCall()})
+    inputs: ir.SSAValue = info.argument(ilist.IListType[qubit.QubitType, types.Any])
+    axis_angle: ir.SSAValue = info.argument(types.Float)
+    rotation_angle: ir.SSAValue = info.argument(types.Float)
+
+
+@statement(dialect=dialect)
+class Rz(ir.Statement):
+    traits = frozenset({lowering.FromPythonCall()})
+    inputs: ir.SSAValue = info.argument(ilist.IListType[qubit.QubitType, types.Any])
+    rotation_angle: ir.SSAValue = info.argument(types.Float)

bloqade_circuit-0.7.5/src/bloqade/native/stdlib/broadcast.py

@@ -0,0 +1,246 @@
+import math
+from typing import Any, TypeVar
+
+from kirin.dialects import ilist
+
+from bloqade.squin import qubit
+from bloqade.native._prelude import kernel
+from bloqade.native.dialects.gates import _interface as native
+
+
+@kernel
+def _radian_to_turn(angle: float) -> float:
+    """Convert an angle from radians to turns.
+
+    Args:
+        angle (float): Angle in radians.
+
+    Returns:
+        float: Equivalent angle in turns.
+    """
+    return angle / (2 * math.pi)
+
+
+@kernel
+def rx(angle: float, qubits: ilist.IList[qubit.Qubit, Any]):
+    """Apply an RX rotation gate on a group of qubits.
+
+    Args:
+        angle (float): Rotation angle in radians.
+        qubits (ilist.IList[qubit.Qubit, Any]): Target qubits.
+    """
+    native.r(qubits, 0.0, _radian_to_turn(angle))
+
+
+@kernel
+def x(qubits: ilist.IList[qubit.Qubit, Any]):
+    """Apply a Pauli-X gate on a group of qubits.
+
+    Args:
+        qubits (ilist.IList[qubit.Qubit, Any]): Target qubits.
+    """
+    rx(math.pi, qubits)
+
+
+@kernel
+def sqrt_x(qubits: ilist.IList[qubit.Qubit, Any]):
+    """Apply a sqrt(X) gate on a group of qubits.
+
+    Args:
+        qubits (ilist.IList[qubit.Qubit, Any]): Target qubits.
+    """
+    rx(math.pi / 2.0, qubits)
+
+
+@kernel
+def sqrt_x_adj(qubits: ilist.IList[qubit.Qubit, Any]):
+    """Apply the adjoint of sqrt(X) on a group of qubits.
+
+    Args:
+        qubits (ilist.IList[qubit.Qubit, Any]): Target qubits.
+    """
+    rx(-math.pi / 2.0, qubits)
+
+
+@kernel
+def ry(angle: float, qubits: ilist.IList[qubit.Qubit, Any]):
+    """Apply an RY rotation gate on a group of qubits.
+
+    Args:
+        angle (float): Rotation angle in radians.
+        qubits (ilist.IList[qubit.Qubit, Any]): Target qubits.
+    """
+    native.r(qubits, 0.25, _radian_to_turn(angle))
+
+
+@kernel
+def y(qubits: ilist.IList[qubit.Qubit, Any]):
+    """Apply a Pauli-Y gate on a group of qubits.
+
+    Args:
+        qubits (ilist.IList[qubit.Qubit, Any]): Target qubits.
+    """
+    ry(math.pi, qubits)
+
+
+@kernel
+def sqrt_y(qubits: ilist.IList[qubit.Qubit, Any]):
+    """Apply a sqrt(Y) gate on a group of qubits.
+
+    Args:
+        qubits (ilist.IList[qubit.Qubit, Any]): Target qubits.
+    """
+    ry(-math.pi / 2.0, qubits)
+
+
+@kernel
+def sqrt_y_adj(qubits: ilist.IList[qubit.Qubit, Any]):
+    """Apply the adjoint of sqrt(Y) on a group of qubits.
+
+    Args:
+        qubits (ilist.IList[qubit.Qubit, Any]): Target qubits.
+    """
+    ry(math.pi / 2.0, qubits)
+
+
+@kernel
+def rz(angle: float, qubits: ilist.IList[qubit.Qubit, Any]):
+    """Apply an RZ rotation gate on a group of qubits.
+
+    Args:
+        angle (float): Rotation angle in radians.
+        qubits (ilist.IList[qubit.Qubit, Any]): Target qubits.
+    """
+    native.rz(qubits, _radian_to_turn(angle))
+
+
+@kernel
+def z(qubits: ilist.IList[qubit.Qubit, Any]):
+    """Apply a Pauli-Z gate on a group of qubits.
+
+    Args:
+        qubits (ilist.IList[qubit.Qubit, Any]): Target qubits.
+    """
+    rz(math.pi, qubits)
+
+
+@kernel
+def s(qubits: ilist.IList[qubit.Qubit, Any]):
+    """Apply an S gate on a group of qubits.
+
+    Args:
+        qubits (ilist.IList[qubit.Qubit, Any]): Target qubits.
+    """
+    rz(math.pi / 2.0, qubits)
+
+
+@kernel
+def s_adj(qubits: ilist.IList[qubit.Qubit, Any]):
+    """Apply the adjoint of the S gate on a group of qubits.
+
+    Args:
+        qubits (ilist.IList[qubit.Qubit, Any]): Target qubits.
+    """
+    rz(-math.pi / 2.0, qubits)
+
+
+@kernel
+def h(qubits: ilist.IList[qubit.Qubit, Any]):
+    """Apply a Hadamard gate on a group of qubits.
+
+    Args:
+        qubits (ilist.IList[qubit.Qubit, Any]): Target qubits.
+    """
+    s(qubits)
+    sqrt_x(qubits)
+    s(qubits)
+
+
+@kernel
+def t(qubits: ilist.IList[qubit.Qubit, Any]):
+    """Apply a T gate on a group of qubits.
+
+    Args:
+        qubits (ilist.IList[qubit.Qubit, Any]): Target qubits.
+    """
+    rz(math.pi / 4.0, qubits)
+
+
+@kernel
+def shift(angle: float, qubits: ilist.IList[qubit.Qubit, Any]):
+    """Apply a phase shift to the |1> state on a group of qubits.
+
+    Args:
+        angle (float): Phase shift angle in radians.
+        qubits (ilist.IList[qubit.Qubit, Any]): Target qubits.
+    """
+    rz(angle / 2.0, qubits)
+
+
+@kernel
+def rot(phi: float, theta: float, omega: float, qubits: ilist.IList[qubit.Qubit, Any]):
+    """Apply a general single-qubit rotation on a group of qubits.
+
+    Args:
+        phi (float): Z rotation before Y (radians).
+        theta (float): Y rotation (radians).
+        omega (float): Z rotation after Y (radians).
+        qubits (ilist.IList[qubit.Qubit, Any]): Target qubits.
+    """
+    rz(phi, qubits)
+    ry(theta, qubits)
+    rz(omega, qubits)
+
+
+@kernel
+def u3(theta: float, phi: float, lam: float, qubits: ilist.IList[qubit.Qubit, Any]):
+    """Apply the U3 gate on a group of qubits.
+
+    Args:
+        theta (float): Rotation around Y axis (radians).
+        phi (float): Global phase shift component (radians).
+        lam (float): Z rotations in decomposition (radians).
+        qubits (ilist.IList[qubit.Qubit, Any]): Target qubits.
+    """
+    rot(lam, theta, -lam, qubits)
+    shift(phi + lam, qubits)
+
+
+N = TypeVar("N")
+
+
+@kernel
+def cz(controls: ilist.IList[qubit.Qubit, N], qubits: ilist.IList[qubit.Qubit, N]):
+    """Apply a controlled-Z gate on a pairs of qubits.
+
+    Args:
+        controls (ilist.IList[qubit.Qubit, N]): Control qubits.
+        qubits (ilist.IList[qubit.Qubit, N]): Target qubits.
+    """
+    native.cz(controls, qubits)
+
+
+@kernel
+def cx(controls: ilist.IList[qubit.Qubit, N], targets: ilist.IList[qubit.Qubit, N]):
+    """Apply a controlled-X gate on a pairs of qubits.
+
+    Args:
+        controls (ilist.IList[qubit.Qubit, N]): Control qubits.
+        targets (ilist.IList[qubit.Qubit, N]): Target qubits.
+    """
+    sqrt_y_adj(targets)
+    cz(controls, targets)
+    sqrt_y(targets)
+
+
+@kernel
+def cy(controls: ilist.IList[qubit.Qubit, N], targets: ilist.IList[qubit.Qubit, N]):
+    """Apply a controlled-Y gate on a pairs of qubits.
+
+    Args:
+        controls (ilist.IList[qubit.Qubit, N]): Control qubits.
+        targets (ilist.IList[qubit.Qubit, N]): Target qubits.
+    """
+    sqrt_x(targets)
+    cz(controls, targets)
+    sqrt_x_adj(targets)

bloqade_circuit-0.7.5/src/bloqade/native/stdlib/simple.py

@@ -0,0 +1,219 @@
+from kirin.dialects import ilist
+
+from bloqade.squin import qubit
+
+from . import broadcast
+from .._prelude import kernel
+
+
+@kernel
+def rx(angle: float, qubit: qubit.Qubit):
+    """Apply an RX rotation gate on a single qubit.
+
+    Args:
+        angle (float): Rotation angle in radians.
+        qubit (qubit.Qubit): The qubit to apply the rotation to.
+    """
+    broadcast.rx(angle, ilist.IList([qubit]))
+
+
+@kernel
+def x(qubit: qubit.Qubit):
+    """Apply a Pauli-X gate on a single qubit.
+
+    Args:
+        qubit (qubit.Qubit): The qubit to apply the X gate to.
+    """
+    broadcast.x(ilist.IList([qubit]))
+
+
+@kernel
+def sqrt_x(qubit: qubit.Qubit):
+    """Apply a sqrt(X) gate on a single qubit.
+
+    Args:
+        qubit (qubit.Qubit): The qubit to apply the sqrt(X) gate to.
+    """
+    broadcast.sqrt_x(ilist.IList([qubit]))
+
+
+@kernel
+def sqrt_x_adj(qubit: qubit.Qubit):
+    """Apply the adjoint of sqrt(X) on a single qubit.
+
+    Args:
+        qubit (qubit.Qubit): The qubit to apply the adjoint sqrt(X) gate to.
+    """
+    broadcast.sqrt_x_adj(ilist.IList([qubit]))
+
+
+@kernel
+def ry(angle: float, qubit: qubit.Qubit):
+    """Apply an RY rotation gate on a single qubit.
+
+    Args:
+        angle (float): Rotation angle in radians.
+        qubit (qubit.Qubit): The qubit to apply the rotation to.
+    """
+    broadcast.ry(angle, ilist.IList([qubit]))
+
+
+@kernel
+def y(qubit: qubit.Qubit):
+    """Apply a Pauli-Y gate on a single qubit.
+
+    Args:
+        qubit (qubit.Qubit): The qubit to apply the Y gate to.
+    """
+    broadcast.y(ilist.IList([qubit]))
+
+
+@kernel
+def sqrt_y(qubit: qubit.Qubit):
+    """Apply a sqrt(Y) gate on a single qubit.
+
+    Args:
+        qubit (qubit.Qubit): The qubit to apply the sqrt(Y) gate to.
+    """
+    broadcast.sqrt_y(ilist.IList([qubit]))
+
+
+@kernel
+def sqrt_y_adj(qubit: qubit.Qubit):
+    """Apply the adjoint of sqrt(Y) on a single qubit.
+
+    Args:
+        qubit (qubit.Qubit): The qubit to apply the adjoint sqrt(Y) gate to.
+    """
+    broadcast.sqrt_y_adj(ilist.IList([qubit]))
+
+
+@kernel
+def rz(angle: float, qubit: qubit.Qubit):
+    """Apply an RZ rotation gate on a single qubit.
+
+    Args:
+        angle (float): Rotation angle in radians.
+        qubit (qubit.Qubit): The qubit to apply the rotation to.
+    """
+    broadcast.rz(angle, ilist.IList([qubit]))
+
+
+@kernel
+def z(qubit: qubit.Qubit):
+    """Apply a Pauli-Z gate on a single qubit.
+
+    Args:
+        qubit (qubit.Qubit): The qubit to apply the Z gate to.
+    """
+    broadcast.z(ilist.IList([qubit]))
+
+
+@kernel
+def s(qubit: qubit.Qubit):
+    """Apply an S gate on a single qubit.
+
+    Args:
+        qubit (qubit.Qubit): The qubit to apply the S gate to.
+    """
+    broadcast.s(ilist.IList([qubit]))
+
+
+@kernel
+def s_dag(qubit: qubit.Qubit):
+    """Apply the adjoint of the S gate on a single qubit.
+
+    Args:
+        qubit (qubit.Qubit): The qubit to apply the adjoint S gate to.
+    """
+    broadcast.s_adj(ilist.IList([qubit]))
+
+
+@kernel
+def h(qubit: qubit.Qubit):
+    """Apply a Hadamard gate on a single qubit.
+
+    Args:
+        qubit (qubit.Qubit): The qubit to apply the Hadamard gate to.
+    """
+    broadcast.h(ilist.IList([qubit]))
+
+
+@kernel
+def t(qubit: qubit.Qubit):
+    """Apply a T gate on a single qubit.
+
+    Args:
+        qubit (qubit.Qubit): The qubit to apply the T gate to.
+    """
+    broadcast.t(ilist.IList([qubit]))
+
+
+@kernel
+def shift(angle: float, qubit: qubit.Qubit):
+    """Apply a phase shift on the |1> state of a single qubit.
+
+    Args:
+        angle (float): Shift angle in radians.
+        qubit (qubit.Qubit): The qubit to apply the shift to.
+    """
+    broadcast.shift(angle, ilist.IList([qubit]))
+
+
+@kernel
+def rot(phi: float, theta: float, omega: float, qubit: qubit.Qubit):
+    """Apply a general single-qubit rotation on a single qubit.
+
+    Args:
+        phi (float): Z rotation before Y (radians).
+        theta (float): Y rotation (radians).
+        omega (float): Z rotation after Y (radians).
+        qubit (qubit.Qubit): The qubit to apply the rotation to.
+    """
+    broadcast.rot(phi, theta, omega, ilist.IList([qubit]))
+
+
+@kernel
+def u3(theta: float, phi: float, lam: float, qubit: qubit.Qubit):
+    """Apply the U3 gate on a single qubit.
+
+    Args:
+        theta (float): Rotation angle around the Y axis in radians.
+        phi (float): Rotation angle around the Z axis in radians.
+        lam (float): Rotation angle around the Z axis in radians.
+        qubit (qubit.Qubit): The qubit to apply the U3 gate to.
+    """
+    broadcast.u3(theta, phi, lam, ilist.IList([qubit]))
+
+
+@kernel
+def cz(control: qubit.Qubit, target: qubit.Qubit):
+    """Apply a controlled-Z gate on two qubits.
+
+    Args:
+        control (qubit.Qubit): The control qubit.
+        target (qubit.Qubit): The target qubit.
+    """
+    broadcast.cz(ilist.IList([control]), ilist.IList([target]))
+
+
+@kernel
+def cx(control: qubit.Qubit, target: qubit.Qubit):
+    """Apply a controlled-X gate on two qubits.
+
+    Args:
+        control (qubit.Qubit): The control qubit.
+        target (qubit.Qubit): The target qubit.
+    """
+    broadcast.cx(ilist.IList([control]), ilist.IList([target]))
+
+
+@kernel
+def cy(control: qubit.Qubit, targets: qubit.Qubit):
+    """Apply a controlled-Y gate on two qubits.
+
+    Args:
+        control (qubit.Qubit): The control qubit.
+        targets (qubit.Qubit): The target qubit.
+    """
+    broadcast.cy(ilist.IList([control]), ilist.IList([targets]))

{bloqade_circuit-0.7.4 → bloqade_circuit-0.7.5}/src/bloqade/pyqrack/__init__.py

@@ -21,4 +21,5 @@ from .device import (
     StackMemorySimulator as StackMemorySimulator,
     DynamicMemorySimulator as DynamicMemorySimulator,
 )
+from .native import NativeMethods as NativeMethods
 from .target import PyQrack as PyQrack

bloqade_circuit-0.7.5/src/bloqade/pyqrack/native.py

@@ -0,0 +1,49 @@
+import math
+from typing import Any
+
+from kirin import interp
+from kirin.dialects import ilist
+
+from pyqrack import Pauli
+from bloqade.pyqrack import PyQrackQubit
+from bloqade.pyqrack.base import PyQrackInterpreter
+from bloqade.native.dialects import gates
+
+
+@gates.dialect.register(key="pyqrack")
+class NativeMethods(interp.MethodTable):
+
+    @interp.impl(gates.CZ)
+    def cz(self, _interp: PyQrackInterpreter, frame: interp.Frame, stmt: gates.CZ):
+        ctrls = frame.get_casted(stmt.ctrls, ilist.IList[PyQrackQubit, Any])
+        qargs = frame.get_casted(stmt.qargs, ilist.IList[PyQrackQubit, Any])
+
+        for ctrl, qarg in zip(ctrls, qargs):
+            if ctrl.is_active() and qarg.is_active():
+                ctrl.sim_reg.mcz([ctrl.addr], qarg.addr)
+
+        return ()
+
+    @interp.impl(gates.R)
+    def r(self, _interp: PyQrackInterpreter, frame: interp.Frame, stmt: gates.R):
+        inputs = frame.get_casted(stmt.inputs, ilist.IList[PyQrackQubit, Any])
+        rotation_angle = 2 * math.pi * frame.get_casted(stmt.rotation_angle, float)
+        axis_angle = 2 * math.pi * frame.get_casted(stmt.axis_angle, float)
+        for qubit in inputs:
+            if qubit.is_active():
+                qubit.sim_reg.r(Pauli.PauliZ, axis_angle, qubit.addr)
+                qubit.sim_reg.r(Pauli.PauliX, rotation_angle, qubit.addr)
+                qubit.sim_reg.r(Pauli.PauliZ, -axis_angle, qubit.addr)
+
+        return ()
+
+    @interp.impl(gates.Rz)
+    def rz(self, _interp: PyQrackInterpreter, frame: interp.Frame, stmt: gates.Rz):
+        inputs = frame.get_casted(stmt.inputs, ilist.IList[PyQrackQubit, Any])
+        rotation_angle = 2 * math.pi * frame.get_casted(stmt.rotation_angle, float)
+
+        for qubit in inputs:
+            if qubit.is_active():
+                qubit.sim_reg.r(Pauli.PauliZ, rotation_angle, qubit.addr)
+
+        return ()

{bloqade_circuit-0.7.4 → bloqade_circuit-0.7.5}/src/bloqade/squin/cirq/emit/qubit.py

@@ -36,11 +36,9 @@ class EmitCirqQubitMethods(MethodTable):
         op = frame.get(stmt.operator)
         qbit_lists = [frame.get(qbit) for qbit in stmt.qubits]
 
-        cirq_ops = []
         for qbits in zip(*qbit_lists):
-            cirq_ops.extend(op.apply(qbits))
+            frame.circuit.append(op.apply(qbits))
 
-        frame.circuit.append(cirq.Moment(cirq_ops))
         return ()
 
     @impl(qubit.MeasureQubit)