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

bloqade/pyqrack/squin/wire.py

@@ -1,51 +0,0 @@
-from kirin import interp
-
-from bloqade.squin import wire
-from bloqade.pyqrack.reg import PyQrackWire, PyQrackQubit
-from bloqade.pyqrack.base import PyQrackInterpreter
-
-from .runtime import OperatorRuntimeABC
-
-
-@wire.dialect.register(key="pyqrack")
-class PyQrackMethods(interp.MethodTable):
-    # @interp.impl(wire.Wrap)
-    # def wrap(self, interp: PyQrackInterpreter, frame: interp.Frame, stmt: wire.Wrap):
-    #     traits = frozenset({lowering.FromPythonCall(), WireTerminator()})
-    #     wire: ir.SSAValue = info.argument(WireType)
-    #     qubit: ir.SSAValue = info.argument(QubitType)
-
-    @interp.impl(wire.Unwrap)
-    def unwrap(
-        self, interp: PyQrackInterpreter, frame: interp.Frame, stmt: wire.Unwrap
-    ):
-        q: PyQrackQubit = frame.get(stmt.qubit)
-        return (PyQrackWire(q),)
-
-    @interp.impl(wire.Apply)
-    def apply(self, interp: PyQrackInterpreter, frame: interp.Frame, stmt: wire.Apply):
-        ws = stmt.inputs
-        assert isinstance(ws, tuple)
-        qubits: list[PyQrackQubit] = []
-        for w in ws:
-            assert isinstance(w, PyQrackWire)
-            qubits.append(w.qubit)
-        op: OperatorRuntimeABC = frame.get(stmt.operator)
-
-        op.apply(*qubits)
-
-        out_ws = [PyQrackWire(qbit) for qbit in qubits]
-        return (out_ws,)
-
-    @interp.impl(wire.Measure)
-    def measure(
-        self, interp: PyQrackInterpreter, frame: interp.Frame, stmt: wire.Measure
-    ):
-        w: PyQrackWire = frame.get(stmt.wire)
-        qbit = w.qubit
-
-        if not qbit.is_active():
-            return (interp.loss_m_result,)
-
-        res: bool = bool(qbit.sim_reg.m(qbit.addr))
-        return (res,)

bloqade/squin/_typeinfer.py

@@ -1,20 +0,0 @@
-from kirin import types, interp
-from kirin.analysis import TypeInference, const
-from kirin.dialects import ilist
-
-from bloqade import squin
-
-
-@squin.qubit.dialect.register(key="typeinfer")
-class TypeInfer(interp.MethodTable):
-    @interp.impl(squin.qubit.New)
-    def _call(self, interp: TypeInference, frame: interp.Frame, stmt: squin.qubit.New):
-        # based on Xiu-zhe (Roger) Luo's get_const_value function
-
-        if (hint := stmt.n_qubits.hints.get("const")) is None:
-            return (ilist.IListType[squin.qubit.QubitType, types.Any],)
-
-        if isinstance(hint, const.Value) and isinstance(hint.data, int):
-            return (ilist.IListType[squin.qubit.QubitType, types.Literal(hint.data)],)
-
-        return (ilist.IListType[squin.qubit.QubitType, types.Any],)

bloqade/squin/analysis/address_impl.py

@@ -1,71 +0,0 @@
-from kirin import interp
-from kirin.analysis import ForwardFrame
-
-from bloqade.analysis.address.lattice import (
-    Address,
-    AddressReg,
-    AddressWire,
-    AddressQubit,
-)
-from bloqade.analysis.address.analysis import AddressAnalysis
-
-from .. import wire, qubit
-
-# Address lattice elements we can work with:
-## NotQubit (bottom), AnyAddress (top)
-
-## AddressTuple -> data: tuple[Address, ...]
-### Recursive type, could contain itself or other variants
-### This pops up in cases where you can have an IList/Tuple
-### That contains elements that could be other Address types
-
-## AddressReg -> data: Sequence[int]
-### specific to creation of a register of qubits
-
-## AddressQubit -> data: int
-### Base qubit address type
-
-
-@wire.dialect.register(key="qubit.address")
-class SquinWireMethodTable(interp.MethodTable):
-
-    @interp.impl(wire.Unwrap)
-    def unwrap(
-        self,
-        interp_: AddressAnalysis,
-        frame: ForwardFrame[Address],
-        stmt: wire.Unwrap,
-    ):
-
-        origin_qubit = frame.get(stmt.qubit)
-
-        if isinstance(origin_qubit, AddressQubit):
-            return (AddressWire(origin_qubit=origin_qubit),)
-        else:
-            return (Address.top(),)
-
-    @interp.impl(wire.Apply)
-    def apply(
-        self,
-        interp_: AddressAnalysis,
-        frame: ForwardFrame[Address],
-        stmt: wire.Apply,
-    ):
-        return frame.get_values(stmt.inputs)
-
-
-@qubit.dialect.register(key="qubit.address")
-class SquinQubitMethodTable(interp.MethodTable):
-
-    # This can be treated like a QRegNew impl
-    @interp.impl(qubit.New)
-    def new(
-        self,
-        interp_: AddressAnalysis,
-        frame: ForwardFrame[Address],
-        stmt: qubit.New,
-    ):
-        n_qubits = interp_.get_const_value(int, stmt.n_qubits)
-        addr = AddressReg(range(interp_.next_address, interp_.next_address + n_qubits))
-        interp_.next_address += n_qubits
-        return (addr,)

bloqade/squin/analysis/nsites/__init__.py

@@ -1,9 +0,0 @@
-# Need this for impl registration to work properly!
-from . import impls as impls
-from .lattice import (
-    Sites as Sites,
-    NoSites as NoSites,
-    AnySites as AnySites,
-    NumberSites as NumberSites,
-)
-from .analysis import NSitesAnalysis as NSitesAnalysis

bloqade/squin/analysis/nsites/analysis.py

@@ -1,50 +0,0 @@
-# from typing import cast
-
-from kirin import ir
-from kirin.analysis import Forward
-from kirin.analysis.forward import ForwardFrame
-
-from bloqade.squin.op.types import OpType
-from bloqade.squin.op.traits import HasSites, FixedSites
-
-from .lattice import Sites, NoSites, NumberSites
-
-
-class NSitesAnalysis(Forward[Sites]):
-
-    keys = ["op.nsites"]
-    lattice = Sites
-
-    # Take a page from how constprop works in Kirin
-
-    ## This gets called before the registry look up
-    def eval_stmt(self, frame: ForwardFrame, stmt: ir.Statement):
-        method = self.lookup_registry(frame, stmt)
-        if method is not None:
-            return method(self, frame, stmt)
-        elif stmt.has_trait(HasSites):
-            has_sites_trait = stmt.get_present_trait(HasSites)
-            sites = has_sites_trait.get_sites(stmt)
-            return (NumberSites(sites=sites),)
-        elif stmt.has_trait(FixedSites):
-            sites_trait = stmt.get_present_trait(FixedSites)
-            return (NumberSites(sites=sites_trait.data),)
-        else:
-            return (NoSites(),)
-
-    # For when no implementation is found for the statement
-    def eval_stmt_fallback(
-        self, frame: ForwardFrame[Sites], stmt: ir.Statement
-    ) -> tuple[Sites, ...]:  # some form of Sites will go back into the frame
-        return tuple(
-            (
-                self.lattice.top()
-                if result.type.is_subseteq(OpType)
-                else self.lattice.bottom()
-            )
-            for result in stmt.results
-        )
-
-    def run_method(self, method: ir.Method, args: tuple[Sites, ...]):
-        # NOTE: we do not support dynamic calls here, thus no need to propagate method object
-        return self.run_callable(method.code, (self.lattice.bottom(),) + args)

bloqade/squin/analysis/nsites/impls.py

@@ -1,99 +0,0 @@
-from kirin import interp
-from kirin.dialects import scf, func
-from kirin.dialects.scf.typeinfer import TypeInfer as ScfTypeInfer
-
-from bloqade.squin import op, wire
-
-from .lattice import (
-    NoSites,
-    NumberSites,
-)
-from .analysis import NSitesAnalysis
-
-
-@wire.dialect.register(key="op.nsites")
-class SquinWire(interp.MethodTable):
-
-    @interp.impl(wire.Apply)
-    @interp.impl(wire.Broadcast)
-    def apply(
-        self,
-        interp: NSitesAnalysis,
-        frame: interp.Frame,
-        stmt: wire.Apply | wire.Broadcast,
-    ):
-
-        return tuple(frame.get(input) for input in stmt.inputs)
-
-
-@op.dialect.register(key="op.nsites")
-class SquinOp(interp.MethodTable):
-
-    @interp.impl(op.stmts.Kron)
-    def kron(self, interp: NSitesAnalysis, frame: interp.Frame, stmt: op.stmts.Kron):
-        lhs = frame.get(stmt.lhs)
-        rhs = frame.get(stmt.rhs)
-        if isinstance(lhs, NumberSites) and isinstance(rhs, NumberSites):
-            new_n_sites = lhs.sites + rhs.sites
-            return (NumberSites(sites=new_n_sites),)
-        else:
-            return (NoSites(),)
-
-    @interp.impl(op.stmts.Mult)
-    def mult(self, interp: NSitesAnalysis, frame: interp.Frame, stmt: op.stmts.Mult):
-        lhs = frame.get(stmt.lhs)
-        rhs = frame.get(stmt.rhs)
-
-        if isinstance(lhs, NumberSites) and isinstance(rhs, NumberSites):
-            lhs_sites = lhs.sites
-            rhs_sites = rhs.sites
-            # I originally considered throwing an exception here
-            # but Xiu-zhe (Roger) Luo has pointed out it would be
-            # a much better UX to add a type element that
-            # could explicitly indicate the error. The downside
-            # is you'll have some added complexity in the type lattice.
-            if lhs_sites != rhs_sites:
-                return (NoSites(),)
-            else:
-                return (NumberSites(sites=lhs_sites + rhs_sites),)
-        else:
-            return (NoSites(),)
-
-    @interp.impl(op.stmts.Control)
-    def control(
-        self, interp: NSitesAnalysis, frame: interp.Frame, stmt: op.stmts.Control
-    ):
-        op_sites = frame.get(stmt.op)
-
-        if isinstance(op_sites, NumberSites):
-            n_sites = op_sites.sites
-            return (NumberSites(sites=n_sites + stmt.n_controls),)
-        else:
-            return (NoSites(),)
-
-    @interp.impl(op.stmts.Rot)
-    def rot(self, interp: NSitesAnalysis, frame: interp.Frame, stmt: op.stmts.Rot):
-        op_sites = frame.get(stmt.axis)
-        return (op_sites,)
-
-    @interp.impl(op.stmts.Scale)
-    def scale(self, interp: NSitesAnalysis, frame: interp.Frame, stmt: op.stmts.Scale):
-        op_sites = frame.get(stmt.op)
-        return (op_sites,)
-
-    @interp.impl(op.stmts.PauliString)
-    def pauli_string(
-        self, interp: NSitesAnalysis, frame: interp.Frame, stmt: op.stmts.PauliString
-    ):
-        s = stmt.string
-        return (NumberSites(sites=len(s)),)
-
-
-@scf.dialect.register(key="op.nsites")
-class ScfSquinOp(ScfTypeInfer):
-    pass
-
-
-@func.dialect.register(key="op.nsites")
-class FuncSquinOp(func.typeinfer.TypeInfer):
-    pass

bloqade/squin/analysis/nsites/lattice.py

@@ -1,49 +0,0 @@
-from typing import final
-from dataclasses import dataclass
-
-from kirin.lattice import (
-    SingletonMeta,
-    BoundedLattice,
-    SimpleJoinMixin,
-    SimpleMeetMixin,
-)
-
-
-@dataclass
-class Sites(
-    SimpleJoinMixin["Sites"], SimpleMeetMixin["Sites"], BoundedLattice["Sites"]
-):
-    @classmethod
-    def bottom(cls) -> "Sites":
-        return NoSites()
-
-    @classmethod
-    def top(cls) -> "Sites":
-        return AnySites()
-
-
-@final
-@dataclass
-class NoSites(Sites, metaclass=SingletonMeta):
-
-    def is_subseteq(self, other: Sites) -> bool:
-        return True
-
-
-@final
-@dataclass
-class AnySites(Sites, metaclass=SingletonMeta):
-
-    def is_subseteq(self, other: Sites) -> bool:
-        return isinstance(other, Sites)
-
-
-@final
-@dataclass
-class NumberSites(Sites):
-    sites: int
-
-    def is_subseteq(self, other: Sites) -> bool:
-        if isinstance(other, NumberSites):
-            return self.sites == other.sites
-        return False

bloqade/squin/cirq/__init__.py

@@ -1,306 +0,0 @@
-from typing import Any, Sequence
-from warnings import warn
-
-import cirq
-from kirin import ir, types
-from kirin.emit import EmitError
-from kirin.dialects import func
-
-from . import lowering as lowering
-from .. import kernel
-
-# NOTE: just to register methods
-from .emit import op as op, noise as noise, qubit as qubit
-from .lowering import Squin
-from ..noise.rewrite import RewriteNoiseStmts
-from .emit.emit_circuit import EmitCirq
-
-
-def load_circuit(
-    circuit: cirq.Circuit,
-    kernel_name: str = "main",
-    dialects: ir.DialectGroup = kernel,
-    register_as_argument: bool = False,
-    return_register: bool = False,
-    register_argument_name: str = "q",
-    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`.
-        register_as_argument (bool): Determine whether the resulting kernel function should accept
-            a single `ilist.IList[Qubit, Any]` argument that is a list of qubits used within the
-            function. This allows you to compose kernel functions generated from circuits.
-            Defaults to `False`.
-        return_register (bool): Determine whether the resulting kernel functionr returns a
-            single value of type `ilist.IList[Qubit, Any]` that is the list of qubits used
-            in the kernel function. Useful when you want to compose multiple kernel functions
-            generated from circuits. Defaults to `False`.
-        register_argument_name (str): The name of the argument that represents the qubit register.
-            Only used when `register_as_argument=True`. Defaults to "q".
-        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.
-
-    ## Usage Examples:
-
-    ```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()
-    ```
-
-    You can also compose kernel functions generated from circuits by passing in
-    and / or returning the respective quantum registers:
-
-    ```python
-    q = cirq.LineQubit.range(2)
-    circuit = cirq.Circuit(cirq.H(q[0]), cirq.CX(*q))
-
-    get_entangled_qubits = squin.cirq.load_circuit(
-        circuit, return_register=True, kernel_name="get_entangled_qubits"
-    )
-    get_entangled_qubits.print()
-
-    entangle_qubits = squin.cirq.load_circuit(
-        circuit, register_as_argument=True, kernel_name="entangle_qubits"
-    )
-
-    @squin.kernel
-    def main():
-        qreg = get_entangled_qubits()
-        qreg2 = squin.qubit.new(1)
-        entangle_qubits([qreg[1], qreg2[0]])
-        return squin.qubit.measure(qreg2)
-    ```
-    """
-
-    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,
-        register_as_argument=register_as_argument,
-        register_argument_name=register_argument_name,
-    )
-
-    if return_register:
-        return_value = target.qreg
-    else:
-        return_value = func.ConstantNone()
-        body.blocks[0].stmts.append(return_value)
-
-    return_node = func.Return(value_or_stmt=return_value)
-    body.blocks[0].stmts.append(return_node)
-
-    self_arg_name = kernel_name + "_self"
-    arg_names = [self_arg_name]
-    if register_as_argument:
-        args = (target.qreg.type,)
-        arg_names.append(register_argument_name)
-    else:
-        args = ()
-
-    # NOTE: add _self as argument; need to know signature before so do it after lowering
-    signature = func.Signature(args, return_node.value.type)
-    body.blocks[0].args.insert_from(
-        0,
-        types.Generic(ir.Method, types.Tuple.where(signature.inputs), signature.output),
-        self_arg_name,
-    )
-
-    code = func.Function(
-        sym_name=kernel_name,
-        signature=signature,
-        body=body,
-    )
-
-    return ir.Method(
-        mod=None,
-        py_func=None,
-        sym_name=kernel_name,
-        arg_names=arg_names,
-        dialects=dialects,
-        code=code,
-    )
-
-
-def emit_circuit(
-    mt: ir.Method,
-    qubits: Sequence[cirq.Qid] | None = None,
-    circuit_qubits: Sequence[cirq.Qid] | None = None,
-    args: tuple = (),
-    ignore_returns: bool = False,
-) -> cirq.Circuit:
-    """Converts a squin.kernel method to a cirq.Circuit object.
-
-    Args:
-        mt (ir.Method): The kernel method from which to construct the circuit.
-
-    Keyword Args:
-        circuit_qubits (Sequence[cirq.Qid] | None):
-            A list of qubits to use as the qubits in the circuit. Defaults to None.
-            If this is None, then `cirq.LineQubit`s are inserted for every `squin.qubit.new`
-            statement in the order they appear inside the kernel.
-            **Note**: If a list of qubits is provided, make sure that there is a sufficient
-            number of qubits for the resulting circuit.
-        args (tuple):
-            The arguments of the kernel function from which to emit a circuit.
-        ignore_returns (bool):
-            If `False`, emitting a circuit from a kernel that returns a value will error.
-            Set it to `True` in order to ignore the return value(s). Defaults to `False`.
-
-    ## Examples:
-
-    Here's a very basic example:
-
-    ```python
-    from bloqade import squin
-
-    @squin.kernel
-    def main():
-        q = squin.qubit.new(2)
-        h = squin.op.h()
-        squin.qubit.apply(h, q[0])
-        cx = squin.op.cx()
-        squin.qubit.apply(cx, q)
-
-    circuit = squin.cirq.emit_circuit(main)
-
-    print(circuit)
-    ```
-
-    You can also compose multiple kernels. Those are emitted as subcircuits within the "main" circuit.
-    Subkernels can accept arguments and return a value.
-
-    ```python
-    from bloqade import squin
-    from kirin.dialects import ilist
-    from typing import Literal
-    import cirq
-
-    @squin.kernel
-    def entangle(q: ilist.IList[squin.qubit.Qubit, Literal[2]]):
-        h = squin.op.h()
-        squin.qubit.apply(h, q[0])
-        cx = squin.op.cx()
-        squin.qubit.apply(cx, q)
-        return cx
-
-    @squin.kernel
-    def main():
-        q = squin.qubit.new(2)
-        cx = entangle(q)
-        q2 = squin.qubit.new(3)
-        squin.qubit.apply(cx, [q[1], q2[2]])
-
-
-    # custom list of qubits on grid
-    qubits = [cirq.GridQubit(i, i+1) for i in range(5)]
-
-    circuit = squin.cirq.emit_circuit(main, circuit_qubits=qubits)
-    print(circuit)
-
-    ```
-
-    We also passed in a custom list of qubits above. This allows you to provide a custom geometry
-    and manipulate the qubits in other circuits directly written in cirq as well.
-    """
-
-    if circuit_qubits is None and qubits is not None:
-        circuit_qubits = qubits
-        warn(
-            "The keyword argument `qubits` is deprecated. Use `circuit_qubits` instead."
-        )
-
-    if (
-        not ignore_returns
-        and isinstance(mt.code, func.Function)
-        and not mt.code.signature.output.is_subseteq(types.NoneType)
-    ):
-        raise EmitError(
-            "The method you are trying to convert to a circuit has a return value, but returning from a circuit is not supported."
-            " Set `ignore_returns = True` in order to simply ignore the return values and emit a circuit."
-        )
-
-    if len(args) != len(mt.args):
-        raise ValueError(
-            f"The method from which you're trying to emit a circuit takes {len(mt.args)} as input, but you passed in {len(args)} via the `args` keyword!"
-        )
-
-    emitter = EmitCirq(qubits=qubits)
-
-    # Rewrite noise statements
-    mt_ = mt.similar(mt.dialects)
-    RewriteNoiseStmts(mt_.dialects)(mt_)
-
-    return emitter.run(mt_, args=args)
-
-
-def dump_circuit(
-    mt: ir.Method,
-    circuit_qubits: Sequence[cirq.Qid] | None = None,
-    args: tuple = (),
-    qubits: Sequence[cirq.Qid] | None = None,
-    ignore_returns: bool = False,
-    **kwargs,
-):
-    """Converts a squin.kernel method to a cirq.Circuit object and dumps it as JSON.
-
-    This just runs `emit_circuit` and calls the `cirq.to_json` function to emit a JSON.
-
-    Args:
-        mt (ir.Method): The kernel method from which to construct the circuit.
-
-    Keyword Args:
-        circuit_qubits (Sequence[cirq.Qid] | None):
-            A list of qubits to use as the qubits in the circuit. Defaults to None.
-            If this is None, then `cirq.LineQubit`s are inserted for every `squin.qubit.new`
-            statement in the order they appear inside the kernel.
-            **Note**: If a list of qubits is provided, make sure that there is a sufficient
-            number of qubits for the resulting circuit.
-        args (tuple):
-            The arguments of the kernel function from which to emit a circuit.
-        ignore_returns (bool):
-            If `False`, emitting a circuit from a kernel that returns a value will error.
-            Set it to `True` in order to ignore the return value(s). Defaults to `False`.
-
-    """
-    circuit = emit_circuit(
-        mt,
-        circuit_qubits=circuit_qubits,
-        qubits=qubits,
-        args=args,
-        ignore_returns=ignore_returns,
-    )
-    return cirq.to_json(circuit, **kwargs)