Implement stdlib shorthands for direct application of squin gates (#415)

This supersedes #393.

There's now `squin.gate` and `squin.parallel`, which allow the user to
apply simple gates quickly.
Not sure about the naming, but `gate` is basically `apply` and
`parallel` is `broadcast`.

For example

```python
@squin.kernel
def main():
    q = squin.qubit.new(4)
    squin.gate.h(q[0])
    squin.parallel.x(q)
```

One implementation detail here: Due to the `ApplyDesugar` pass, we need
to inline the `gate` calls since it uses `apply`. If we don't inline
those, the desugar pass doesn't do its magic and we are stuck with an
`apply_any`. This can go once we fully remove the syntax `apply(op: Op,
qubits: IList[Qubit])`. For now, however, I also inlined the `parallel`
stuff to ensure they behave the same.

Author: david-pl

src/bloqade/squin/__init__.py

@@ -9,6 +9,10 @@
 )
 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

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)