bloqade-circuit 0.6.2__py3-none-any.whl → 0.9.1__py3-none-any.whl

bloqade/gemini/groups.py

@@ -0,0 +1,67 @@
+from typing import Annotated
+
+from kirin import ir
+from kirin.passes import Default
+from kirin.prelude import structural_no_opt
+from kirin.dialects import py, func, ilist
+from typing_extensions import Doc
+from kirin.passes.inline import InlinePass
+
+from bloqade.squin import gate, qubit
+from bloqade.validation import KernelValidation
+from bloqade.rewrite.passes import AggressiveUnroll
+
+from .analysis import GeminiLogicalValidationAnalysis
+
+
+@ir.dialect_group(structural_no_opt.union([gate, py.constant, qubit, func, ilist]))
+def logical(self):
+    """Compile a function to a Gemini logical 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 `True`"),
+        ] = True,
+        fold: Annotated[bool, Doc("run folding passes")] = True,
+        aggressive: Annotated[
+            bool, Doc("run aggressive folding passes if `fold=True`")
+        ] = False,
+        inline: Annotated[bool, Doc("inline function calls, default `True`")] = True,
+        aggressive_unroll: Annotated[
+            bool,
+            Doc(
+                "Run aggressive inlining and unrolling pass on the IR, default `False`"
+            ),
+        ] = False,
+        no_raise: Annotated[bool, Doc("do not raise exception during analysis")] = True,
+    ) -> None:
+
+        if inline and not aggressive_unroll:
+            InlinePass(mt.dialects, no_raise=no_raise).fixpoint(mt)
+
+        if aggressive_unroll:
+            AggressiveUnroll(mt.dialects, no_raise=no_raise).fixpoint(mt)
+        else:
+            default_pass = Default(
+                self,
+                verify=verify,
+                fold=fold,
+                aggressive=aggressive,
+                typeinfer=typeinfer,
+                no_raise=no_raise,
+            )
+
+            default_pass.fixpoint(mt)
+
+        if verify:
+            validator = KernelValidation(GeminiLogicalValidationAnalysis)
+            validator.run(mt, no_raise=no_raise)
+            mt.verify()
+
+    return run_pass

bloqade/native/__init__.py

@@ -0,0 +1,23 @@
+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,
+    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/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 import qubit
+
+from .dialects import gate
+
+
+@ir.dialect_group(structural_no_opt.union([gate, 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/native/dialects/gate/__init__.py

@@ -0,0 +1,2 @@
+from . import stmts as stmts
+from ._dialect import dialect as dialect

bloqade/native/dialects/gate/_dialect.py

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

bloqade/native/dialects/gate/_interface.py

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

bloqade/native/dialects/gate/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.types import QubitType
+
+from ._dialect import dialect
+
+N = types.TypeVar("N")
+
+
+@statement(dialect=dialect)
+class CZ(ir.Statement):
+    traits = frozenset({lowering.FromPythonCall()})
+    controls: ir.SSAValue = info.argument(ilist.IListType[QubitType, N])
+    targets: ir.SSAValue = info.argument(ilist.IListType[QubitType, N])
+
+
+@statement(dialect=dialect)
+class R(ir.Statement):
+    traits = frozenset({lowering.FromPythonCall()})
+    axis_angle: ir.SSAValue = info.argument(types.Float)
+    rotation_angle: ir.SSAValue = info.argument(types.Float)
+    qubits: ir.SSAValue = info.argument(ilist.IListType[QubitType, types.Any])
+
+
+@statement(dialect=dialect)
+class Rz(ir.Statement):
+    traits = frozenset({lowering.FromPythonCall()})
+    rotation_angle: ir.SSAValue = info.argument(types.Float)
+    qubits: ir.SSAValue = info.argument(ilist.IListType[QubitType, types.Any])

bloqade/native/stdlib/broadcast.py

@@ -0,0 +1,246 @@
+import math
+from typing import Any, TypeVar
+
+from kirin.dialects import ilist
+
+from bloqade import qubit
+from bloqade.native._prelude import kernel
+from bloqade.native.dialects.gate 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(0.0, _radian_to_turn(angle), qubits)
+
+
+@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(0.25, _radian_to_turn(angle), qubits)
+
+
+@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(_radian_to_turn(angle), qubits)
+
+
+@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 t_adj(qubits: ilist.IList[qubit.Qubit, Any]):
+    """Apply the adjoint of aT 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 u3(theta: float, phi: float, lam: float, qubits: ilist.IList[qubit.Qubit, Any]):
+    """Apply the U3 gate on a group of qubits.
+
+    The applied gate is represented by the unitary matrix given by:
+
+    $$ U3(\\theta, \\phi, \\lambda) = R_z(\\phi)R_y(\\theta)R_z(\\lambda) $$
+
+    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.
+    """
+    rz(lam, qubits)
+    ry(theta, qubits)
+    rz(phi, 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/native/stdlib/simple.py

@@ -0,0 +1,220 @@
+from kirin.dialects import ilist
+
+from bloqade 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 t_adj(qubit: qubit.Qubit):
+    """Apply the adjoint of the T gate on a single qubit.
+
+    Args:
+        qubit (qubit.Qubit): The qubit to apply the adjoint T gate to.
+    """
+    broadcast.t_adj(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 u3(theta: float, phi: float, lam: float, qubit: qubit.Qubit):
+    """Apply the U3 gate on a single qubit.
+
+    The applied gate is represented by the unitary matrix given by:
+
+    $$ U3(\\theta, \\phi, \\lambda) = R_z(\\phi)R_y(\\theta)R_z(\\lambda) $$
+
+    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/native/upstream/__init__.py

@@ -0,0 +1,4 @@
+from .squin2native import (
+    GateRule as GateRule,
+    SquinToNative as SquinToNative,
+)