bloqade-circuit 0.7.12__py3-none-any.whl → 0.8.0__py3-none-any.whl

bloqade/squin/stdlib/broadcast/gate.py

@@ -0,0 +1,260 @@
+import math
+from typing import Any, TypeVar
+
+from kirin.dialects import ilist
+
+from bloqade.types import Qubit
+
+from ...gate import _interface as gate
+from ...groups import kernel
+
+
+@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 x(qubits: ilist.IList[Qubit, Any]) -> None:
+    """Apply a Pauli-X gate to a group of qubits.
+
+    Args:
+        qubits (ilist.IList[Qubit, Any]): Target qubits.
+    """
+    gate.x(qubits)
+
+
+@kernel
+def y(qubits: ilist.IList[Qubit, Any]) -> None:
+    """Apply a Pauli-Y gate to a group of qubits.
+
+    Args:
+        qubits (ilist.IList[Qubit, Any]): Target qubits.
+    """
+    gate.y(qubits)
+
+
+@kernel
+def z(qubits: ilist.IList[Qubit, Any]) -> None:
+    """Apply a Pauli-Z gate to a group of qubits.
+
+    Args:
+        qubits (ilist.IList[Qubit, Any]): Target qubits.
+    """
+    gate.z(qubits)
+
+
+@kernel
+def h(qubits: ilist.IList[Qubit, Any]) -> None:
+    """Apply a Hadamard gate to a group of qubits.
+
+    Args:
+        qubits (ilist.IList[Qubit, Any]): Target qubits.
+    """
+    gate.h(qubits)
+
+
+@kernel
+def t(qubits: ilist.IList[Qubit, Any]) -> None:
+    """Apply a T gate to a group of qubits.
+
+    Args:
+        qubits (ilist.IList[Qubit, Any]): Target qubits.
+    """
+    gate.t(qubits, adjoint=False)
+
+
+@kernel
+def s(qubits: ilist.IList[Qubit, Any]) -> None:
+    """Apply an S gate to a group of qubits.
+
+    Args:
+        qubits (ilist.IList[Qubit, Any]): Target qubits.
+    """
+    gate.s(qubits, adjoint=False)
+
+
+@kernel
+def sqrt_x(qubits: ilist.IList[Qubit, Any]) -> None:
+    """Apply a Sqrt(X) gate to a group of qubits.
+
+    Args:
+        qubits (ilist.IList[Qubit, Any]): Target qubits.
+    """
+    gate.sqrt_x(qubits, adjoint=False)
+
+
+@kernel
+def sqrt_y(qubits: ilist.IList[Qubit, Any]) -> None:
+    """Apply a sqrt(Y) gate to a group of qubits.
+
+    Args:
+        qubits (ilist.IList[Qubit, Any]): Target qubits.
+    """
+    gate.sqrt_y(qubits, adjoint=False)
+
+
+@kernel
+def sqrt_z(qubits: ilist.IList[Qubit, Any]) -> None:
+    """Apply a Sqrt(Z) gate to a group of qubits.
+
+    Args:
+        qubits (ilist.IList[Qubit, Any]): Target qubits.
+    """
+    gate.s(qubits, adjoint=False)
+
+
+@kernel
+def t_adj(qubits: ilist.IList[Qubit, Any]) -> None:
+    """Apply the adjoint of a T gate to a group of qubits.
+
+    Args:
+        qubits (ilist.IList[Qubit, Any]): Target qubits.
+    """
+    gate.t(qubits, adjoint=True)
+
+
+@kernel
+def s_adj(qubits: ilist.IList[Qubit, Any]) -> None:
+    """Apply the adjoint of an S gate to a group of qubits.
+
+    Args:
+        qubits (ilist.IList[Qubit, Any]): Target qubits.
+    """
+    gate.s(qubits, adjoint=True)
+
+
+@kernel
+def sqrt_x_adj(qubits: ilist.IList[Qubit, Any]) -> None:
+    """Apply the adjoint of a Sqrt(X) gate to a group of qubits.
+
+    Args:
+        qubits (ilist.IList[Qubit, Any]): Target qubits.
+    """
+    gate.sqrt_x(qubits, adjoint=True)
+
+
+@kernel
+def sqrt_y_adj(qubits: ilist.IList[Qubit, Any]) -> None:
+    """Apply the adjoint of a Sqrt(Y) gate to a group of qubits.
+
+    Args:
+        qubits (ilist.IList[Qubit, Any]): Target qubits.
+    """
+    gate.sqrt_y(qubits, adjoint=True)
+
+
+@kernel
+def sqrt_z_adj(qubits: ilist.IList[Qubit, Any]) -> None:
+    """Apply the adjoint of a Sqrt(Z) gate to a group of qubits.
+
+    Args:
+        qubits (ilist.IList[Qubit, Any]): Target qubits.
+    """
+    gate.s(qubits, adjoint=True)
+
+
+@kernel
+def rx(angle: float, qubits: ilist.IList[Qubit, Any]) -> None:
+    """Apply an RX rotation gate to a group of qubits.
+
+    Args:
+        angle (float): Rotation angle in radians.
+        qubits (ilist.IList[Qubit, Any]): Target qubits.
+    """
+    gate.rx(_radian_to_turn(angle), qubits)
+
+
+@kernel
+def ry(angle: float, qubits: ilist.IList[Qubit, Any]) -> None:
+    """Apply an RY rotation gate to a group of qubits.
+
+    Args:
+        angle (float): Rotation angle in radians.
+        qubits (ilist.IList[Qubit, Any]): Target qubits.
+    """
+    gate.ry(_radian_to_turn(angle), qubits)
+
+
+@kernel
+def rz(angle: float, qubits: ilist.IList[Qubit, Any]) -> None:
+    """Apply an RZ rotation gate to a group of qubits.
+
+    Args:
+        angle (float): Rotation angle in radians.
+        qubits (ilist.IList[Qubit, Any]): Target qubits.
+    """
+    gate.rz(_radian_to_turn(angle), qubits)
+
+
+Len = TypeVar("Len", bound=int)
+
+
+@kernel
+def cx(controls: ilist.IList[Qubit, Len], targets: ilist.IList[Qubit, Len]) -> None:
+    """Apply a controlled-X gate to pairs of qubits.
+
+    Args:
+        controls (ilist.IList[Qubit, N]): Control qubits.
+        targets (ilist.IList[Qubit, N]): Target qubits.
+    """
+    gate.cx(controls, targets)
+
+
+@kernel
+def cy(controls: ilist.IList[Qubit, Len], targets: ilist.IList[Qubit, Len]) -> None:
+    """Apply a controlled-Y gate to pairs of qubits.
+
+    Args:
+        controls (ilist.IList[Qubit, N]): Control qubits.
+        targets (ilist.IList[Qubit, N]): Target qubits.
+    """
+    gate.cy(controls, targets)
+
+
+@kernel
+def cz(controls: ilist.IList[Qubit, Len], targets: ilist.IList[Qubit, Len]) -> None:
+    """Apply a controlled-Z gate to pairs of qubits.
+
+    Args:
+        controls (ilist.IList[Qubit, N]): Control qubits.
+        targets (ilist.IList[Qubit, N]): Target qubits.
+    """
+    gate.cz(controls, targets)
+
+
+@kernel
+def u3(theta: float, phi: float, lam: float, qubits: ilist.IList[Qubit, Any]):
+    """Apply the U3 gate to 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.
+    """
+    gate.u3(_radian_to_turn(theta), _radian_to_turn(phi), _radian_to_turn(lam), qubits)
+
+
+# NOTE: stdlib not wrapping statements starts here
+
+
+@kernel
+def shift(angle: float, qubits: ilist.IList[Qubit, Any]) -> None:
+    """Apply a phase shift to the |1> state to 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)

bloqade/squin/stdlib/broadcast/noise.py

@@ -0,0 +1,144 @@
+from typing import Any, Literal, TypeVar
+
+from kirin.dialects import ilist
+
+from bloqade.types import Qubit
+
+from ...noise import _interface as noise
+from ...groups import kernel
+
+
+@kernel
+def depolarize(p: float, qubits: ilist.IList[Qubit, Any]) -> None:
+    """
+    Apply a depolarizing noise channel to a list of qubits with probability `p`.
+
+    For each qubit, this will randomly select one of the Pauli operators X, Y, Z
+    with a probability `p / 3` and apply it to the qubit. No operator is applied
+    with a probability of `1 - p`.
+
+    Args:
+        p (float): The probability with which a Pauli operator is applied.
+        qubits (IList[Qubit, Any]): The list of qubits to which the noise channel is applied.
+    """
+    noise.depolarize(p, qubits)
+
+
+N = TypeVar("N", bound=int)
+
+
+@kernel
+def depolarize2(
+    p: float, controls: ilist.IList[Qubit, N], targets: ilist.IList[Qubit, N]
+) -> None:
+    """
+    Symmetric two-qubit depolarization channel applied to a set of control and target qubits.
+
+    For each pair of qubits from the `controls` and `targets` lists, this will randomly select one
+    of the pauli products
+
+    `{IX, IY, IZ, XI, XX, XY, XZ, YI, YX, YY, YZ, ZI, ZX, ZY, ZZ}`
+
+    each with a probability `p / 15`. No noise is applied with a probability of `1 - p`.
+
+    Args:
+        p (float): The probability with which a Pauli product is applied.
+        controls (IList[Qubit, N]): The list of control qubits.
+        targets (IList[Qubit, N]): The list of target qubits.
+    """
+    noise.depolarize2(p, controls, targets)
+
+
+@kernel
+def single_qubit_pauli_channel(
+    px: float, py: float, pz: float, qubits: ilist.IList[Qubit, Any]
+) -> None:
+    """
+    Apply a Pauli error channel with weighted `px, py, pz`. No error is applied with a probability
+    `1 - (px + py + pz)`.
+
+    This randomly selects one of the three Pauli operators X, Y, Z, weighted with the given probabilities in that order.
+
+    Args:
+        probabilities (IList[float, Literal[3]]): A list of 3 probabilities corresponding to the probabilities `(p_x, p_y, p_z)` in that order.
+        qubits (IList[Qubit, Any]): The list of qubits to which the noise channel is applied.
+    """
+    noise.single_qubit_pauli_channel(px, py, pz, qubits)
+
+
+@kernel
+def two_qubit_pauli_channel(
+    probabilities: ilist.IList[float, Literal[15]],
+    controls: ilist.IList[Qubit, N],
+    targets: ilist.IList[Qubit, N],
+) -> None:
+    """
+    Apply a Pauli product error with weighted `probabilities` to the set of control and target qubits.
+
+    No error is applied with the probability `1 - sum(probabilities)`.
+
+    For each pair of qubits from the `controls` and `targets` lists, this will randomly select one
+    of the pauli products
+
+    `{IX, IY, IZ, XI, XX, XY, XZ, YI, YX, YY, YZ, ZI, ZX, ZY, ZZ}`
+
+    weighted with the corresponding list of probabilities.
+
+    **NOTE**: The order of the given probabilities must match the order of the list of Pauli products above!
+    """
+    noise.two_qubit_pauli_channel(probabilities, controls, targets)
+
+
+@kernel
+def qubit_loss(p: float, qubits: ilist.IList[Qubit, Any]) -> None:
+    """
+    Apply a qubit loss channel to each of the qubits in the given list.
+
+    Each qubit in the list is lost with a probability `p`.
+
+    Args:
+        p (float): Probability of the atom being lost.
+        qubits (IList[Qubit, Any]): The list of qubits to which the noise channel is applied.
+    """
+    noise.qubit_loss(p, qubits)
+
+
+@kernel
+def correlated_qubit_loss(
+    p: float, qubits: ilist.IList[ilist.IList[Qubit, N], Any]
+) -> None:
+    """
+    Apply correlated qubit loss channels to groups of qubits.
+
+    For each group of qubits, applies a correlated loss channel where all qubits
+    within the group are lost together with probability `p`. Loss events are independent
+    between different groups.
+
+    Args:
+        p (float): Loss probability for each group.
+        qubits (IList[IList[Qubit, N], Any]): List of qubit groups. Each sublist
+            represents a group of qubits to which a correlated loss channel is applied.
+
+    Example:
+        >>> q1 = squin.qalloc(3) # First group: qubits 0, 1, 2
+        >>> q2 = squin.qalloc(3) # Second group: qubits 3, 4, 5
+        >>> squin.broadcast.correlated_qubit_loss(0.5, [q1, q2])
+        # Each group has 50% chance: either all qubits lost or none lost.
+        # Group 1 and Group 2 outcomes are independent.
+    """
+    noise.correlated_qubit_loss(p, qubits)
+
+
+# NOTE: actual stdlib that doesn't wrap statements starts here
+
+
+@kernel
+def bit_flip(p: float, qubits: ilist.IList[Qubit, Any]) -> None:
+    """
+    Apply a bit flip error channel to the qubits in the given list with probability `p`.
+
+    Args:
+        p (float): Probability of a bit flip error being applied.
+        qubits (IList[Qubit, Any]): The list of qubits to which the noise channel is applied.
+    """
+    single_qubit_pauli_channel(p, 0, 0, qubits)

bloqade/squin/stdlib/simple/__init__.py

@@ -0,0 +1,33 @@
+from .gate 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_adj as s_adj,
+    shift as shift,
+    t_adj as t_adj,
+    sqrt_x as sqrt_x,
+    sqrt_y as sqrt_y,
+    sqrt_z as sqrt_z,
+    sqrt_x_adj as sqrt_x_adj,
+    sqrt_y_adj as sqrt_y_adj,
+    sqrt_z_adj as sqrt_z_adj,
+)
+from .noise import (
+    bit_flip as bit_flip,
+    depolarize as depolarize,
+    qubit_loss as qubit_loss,
+    depolarize2 as depolarize2,
+    correlated_qubit_loss as correlated_qubit_loss,
+    two_qubit_pauli_channel as two_qubit_pauli_channel,
+    single_qubit_pauli_channel as single_qubit_pauli_channel,
+)

bloqade/squin/stdlib/simple/gate.py

@@ -0,0 +1,242 @@
+from kirin.dialects import ilist
+
+from bloqade.types import Qubit
+
+from .. import broadcast
+from ...groups import kernel
+
+
+@kernel
+def x(qubit: Qubit) -> None:
+    """Apply a Pauli-X gate to a qubit.
+
+    Args:
+        qubit (Qubit): Target qubit.
+    """
+    broadcast.x(ilist.IList([qubit]))
+
+
+@kernel
+def y(qubit: Qubit) -> None:
+    """Apply a Pauli-Y gate to a qubit.
+
+    Args:
+        qubit (Qubit): Target qubit.
+    """
+    broadcast.y(ilist.IList([qubit]))
+
+
+@kernel
+def z(qubit: Qubit) -> None:
+    """Apply a Pauli-Z gate to a qubit.
+
+    Args:
+        qubit (Qubit): Target qubit.
+    """
+    broadcast.z(ilist.IList([qubit]))
+
+
+@kernel
+def h(qubit: Qubit) -> None:
+    """Apply a Hadamard gate to a qubit.
+
+    Args:
+        qubit (Qubit): Target qubit.
+    """
+    broadcast.h(ilist.IList([qubit]))
+
+
+@kernel
+def t(qubit: Qubit) -> None:
+    """Apply a T gate to a qubit.
+
+    Args:
+        qubit (Qubit): Target qubit.
+    """
+    broadcast.t(ilist.IList([qubit]))
+
+
+@kernel
+def s(qubit: Qubit) -> None:
+    """Apply an S gate to a qubit.
+
+    Args:
+        qubit (Qubit): Target qubit.
+    """
+    broadcast.s(ilist.IList([qubit]))
+
+
+@kernel
+def sqrt_x(qubit: Qubit) -> None:
+    """Apply a Sqrt(X) gate to a qubit.
+
+    Args:
+        qubit (Qubit): Target qubit.
+    """
+    broadcast.sqrt_x(ilist.IList([qubit]))
+
+
+@kernel
+def sqrt_y(qubit: Qubit) -> None:
+    """Apply a Sqrt(Y) gate to a qubit.
+
+    Args:
+        qubit (Qubit): Target qubit.
+    """
+    broadcast.sqrt_y(ilist.IList([qubit]))
+
+
+@kernel
+def sqrt_z(qubit: Qubit) -> None:
+    """Apply a Sqrt(Z) gate to a qubit.
+
+    Args:
+        qubit (Qubit): Target qubit.
+    """
+    broadcast.s(ilist.IList([qubit]))
+
+
+@kernel
+def t_adj(qubit: Qubit) -> None:
+    """Apply the adjoint of a T gate to a qubit.
+
+    Args:
+        qubit (Qubit): Target qubit.
+    """
+    broadcast.t_adj(ilist.IList([qubit]))
+
+
+@kernel
+def s_adj(qubit: Qubit) -> None:
+    """Apply the adjoint of an S gate to a qubit.
+
+    Args:
+        qubit (Qubit): Target qubit.
+    """
+    broadcast.s_adj(ilist.IList([qubit]))
+
+
+@kernel
+def sqrt_x_adj(qubit: Qubit) -> None:
+    """Apply the adjoint of a Sqrt(X) gate to a qubit.
+
+    Args:
+        qubit (Qubit): Target qubit.
+    """
+    broadcast.sqrt_x_adj(ilist.IList([qubit]))
+
+
+@kernel
+def sqrt_y_adj(qubit: Qubit) -> None:
+    """Apply the adjoint of a Sqrt(Y) gate to a qubit.
+
+    Args:
+        qubit (Qubit): Target qubit.
+    """
+    broadcast.sqrt_y_adj(ilist.IList([qubit]))
+
+
+@kernel
+def sqrt_z_adj(qubit: Qubit) -> None:
+    """Apply the adjoint of a Sqrt(Z) gate to a qubit.
+
+    Args:
+        qubit (Qubit): Target qubit.
+    """
+    broadcast.s_adj(ilist.IList([qubit]))
+
+
+@kernel
+def rx(angle: float, qubit: Qubit) -> None:
+    """Apply an RX rotation gate to a qubit.
+
+    Args:
+        angle (float): Rotation angle in radians.
+        qubit (Qubit): Target qubit.
+    """
+    broadcast.rx(angle, ilist.IList([qubit]))
+
+
+@kernel
+def ry(angle: float, qubit: Qubit) -> None:
+    """Apply an RY rotation gate to a qubit.
+
+    Args:
+        angle (float): Rotation angle in radians.
+        qubit (Qubit): Target qubit.
+    """
+    broadcast.ry(angle, ilist.IList([qubit]))
+
+
+@kernel
+def rz(angle: float, qubit: Qubit) -> None:
+    """Apply an RZ rotation gate to a qubit.
+
+    Args:
+        angle (float): Rotation angle in radians.
+        qubit (Qubit): Target qubit.
+    """
+    broadcast.rz(angle, ilist.IList([qubit]))
+
+
+@kernel
+def cx(control: Qubit, target: Qubit) -> None:
+    """Apply a controlled-X gate to a pair of qubits.
+
+    Args:
+        controls (Qubit): Control qubit.
+        targets (Qubit): Target qubit.
+    """
+    broadcast.cx(ilist.IList([control]), ilist.IList([target]))
+
+
+@kernel
+def cy(control: Qubit, target: Qubit) -> None:
+    """Apply a controlled-Y gate to a pair of qubits.
+
+    Args:
+        controls (Qubit): Control qubit.
+        targets (Qubit): Target qubit.
+    """
+    broadcast.cy(ilist.IList([control]), ilist.IList([target]))
+
+
+@kernel
+def cz(control: Qubit, target: Qubit) -> None:
+    """Apply a controlled-Z gate to a pair of qubits.
+
+    Args:
+        controls (Qubit): Control qubit.
+        targets (Qubit): Target qubit.
+    """
+    broadcast.cz(ilist.IList([control]), ilist.IList([target]))
+
+
+@kernel
+def u3(theta: float, phi: float, lam: float, qubit: Qubit):
+    """Apply the U3 gate of a 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 around Y axis (radians).
+        phi (float): Global phase shift component (radians).
+        lam (float): Z rotations in decomposition (radians).
+        qubit (Qubit): Target qubit.
+    """
+    broadcast.u3(theta, phi, lam, ilist.IList([qubit]))
+
+
+# NOTE: stdlib not wrapping statements starts here
+
+
+@kernel
+def shift(angle: float, qubit: Qubit) -> None:
+    """Apply a phase shift to the |1> state of a qubit.
+    Args:
+        angle (float): Phase shift angle in radians.
+        qubit (Qubit): Target qubit.
+    """
+    broadcast.shift(angle, ilist.IList([qubit]))