Implement lowering a cirq.Circuit to squin (#294)

Addresses #283 

For now, I went with the syntax `squin.load_circuit(circuit:
cirq.Circuit)`.

So you can e.g. do

```python
q0 = cirq.NamedQubit("q0")
q1 = cirq.NamedQubit("q1")

circuit = cirq.Circuit(
    cirq.H(q1),
    cirq.X(q0).controlled_by(q1),
    cirq.Rx(rads=math.pi / 4).on(q0).controlled_by(q1),
    cirq.measure(q0, q1),
)

main = squin.load_circuit(circuit)
```


~~@Roger-luo @weinbe58 one open question here: cirq support arbitrary
powers of gates, e.g. `cirq.H(q0)**0.123`. Should we add a `Pow`
statement to squin to properly support this? I think pyqrack can also
handle it, but I'll have to check again. Also, not sure what this should
look like when running on hardware, but we can still error in the
runtime.~~

**Edit**: turns out arbitrary powers are quite easy since we can just
use the cirq helper `in_su2` to get the corresponding rotation and lower
that. Also, for multi-qubit gates they usually mean "apply a controlled
single qubit gate with an exponent", which again corresponds to a
rotation. Thanks @kaihsin for pointing to the helper method.

## TODOs:

- [x] support (arbitrary) powers of operators?
- ~~[ ] Lowering of noisy circuits~~ done, except #301 
- [x] Add missing gates (e.g. three-qubit controls are still missing)
- [ ] Make sure the set of supported gates is complete
- ~~ [ ] Optionally return the quantum register (and possibly other
things) ~~ see #302
- ~~ [ ] Optionally pass in the quantum register as argument to the
method ~~ see #302
- ~~[ ] Support classical control by lowering to `if` ~~ see #303

Author: david-pl

src/bloqade/squin/__init__.py

@@ -6,3 +6,12 @@
     lowering as lowering,
 )
 from .groups import wired as wired, kernel as kernel
+
+try:
+    # NOTE: make sure optional cirq dependency is installed
+    import cirq as cirq_package  # noqa: F401
+except ImportError:
+    pass
+else:
+    from . import cirq as cirq
+    from .cirq import load_circuit as load_circuit

src/bloqade/squin/cirq/__init__.py

@@ -0,0 +1,89 @@
+from typing import Any
+
+import cirq
+from kirin import ir, types
+from kirin.dialects import func
+
+from . import lowering as lowering
+from .. import kernel
+from .lowering import Squin
+
+
+def load_circuit(
+    circuit: cirq.Circuit,
+    kernel_name: str = "main",
+    dialects: ir.DialectGroup = kernel,
+    globals: dict[str, Any] | None = None,
+    file: str | None = None,
+    lineno_offset: int = 0,
+    col_offset: int = 0,
+    compactify: bool = True,
+):
+    """Converts a cirq.Circuit object into a squin kernel.
+
+    Args:
+        circuit (cirq.Circuit): The circuit to load.
+
+    Keyword Args:
+        kernel_name (str): The name of the kernel to load. Defaults to "main".
+        dialects (ir.DialectGroup | None): The dialects to use. Defaults to `squin.kernel`.
+        globals (dict[str, Any] | None): The global variables to use. Defaults to None.
+        file (str | None): The file name for error reporting. Defaults to None.
+        lineno_offset (int): The line number offset for error reporting. Defaults to 0.
+        col_offset (int): The column number offset for error reporting. Defaults to 0.
+        compactify (bool): Whether to compactify the output. Defaults to True.
+
+    Example:
+
+    ```python
+    # from cirq's "hello qubit" example
+    import cirq
+    from bloqade import squin
+
+    # Pick a qubit.
+    qubit = cirq.GridQubit(0, 0)
+
+    # Create a circuit.
+    circuit = cirq.Circuit(
+        cirq.X(qubit)**0.5,  # Square root of NOT.
+        cirq.measure(qubit, key='m')  # Measurement.
+    )
+
+    # load the circuit as squin
+    main = squin.load_circuit(circuit)
+
+    # print the resulting IR
+    main.print()
+    ```
+    """
+
+    target = Squin(dialects=dialects, circuit=circuit)
+    body = target.run(
+        circuit,
+        source=str(circuit),  # TODO: proper source string
+        file=file,
+        globals=globals,
+        lineno_offset=lineno_offset,
+        col_offset=col_offset,
+        compactify=compactify,
+    )
+
+    # NOTE: no return value
+    return_value = func.ConstantNone()
+    body.blocks[0].stmts.append(return_value)
+    body.blocks[0].stmts.append(func.Return(value_or_stmt=return_value))
+
+    code = func.Function(
+        sym_name=kernel_name,
+        signature=func.Signature((), types.NoneType),
+        body=body,
+    )
+
+    return ir.Method(
+        mod=None,
+        py_func=None,
+        sym_name=kernel_name,
+        arg_names=[],
+        dialects=dialects,
+        code=code,
+    )