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

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,92 +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,)
-
-
-@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,265 +0,0 @@
-from typing import Any, Sequence
-
-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,
-) -> 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:
-        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.
-
-    ## 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, 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 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."
-        )
-
-    emitter = EmitCirq(qubits=qubits)
-
-    # Rewrite noise statements
-    mt_ = mt.similar(mt.dialects)
-    RewriteNoiseStmts(mt_.dialects)(mt_)
-
-    return emitter.run(mt_, args=())
-
-
-def dump_circuit(mt: ir.Method, qubits: Sequence[cirq.Qid] | None = None, **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:
-        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.
-
-    """
-    circuit = emit_circuit(mt, qubits=qubits)
-    return cirq.to_json(circuit, **kwargs)

bloqade/squin/cirq/emit/emit_circuit.py

@@ -1,109 +0,0 @@
-from typing import Sequence
-from dataclasses import field, dataclass
-
-import cirq
-from kirin import ir
-from kirin.emit import EmitABC, EmitError, EmitFrame
-from kirin.interp import MethodTable, impl
-from kirin.dialects import func
-from typing_extensions import Self
-
-from ... import kernel
-
-
-@dataclass
-class EmitCirqFrame(EmitFrame):
-    qubit_index: int = 0
-    qubits: Sequence[cirq.Qid] | None = None
-    circuit: cirq.Circuit = field(default_factory=cirq.Circuit)
-
-
-def _default_kernel():
-    return kernel
-
-
-@dataclass
-class EmitCirq(EmitABC[EmitCirqFrame, cirq.Circuit]):
-    keys = ["emit.cirq", "main"]
-    dialects: ir.DialectGroup = field(default_factory=_default_kernel)
-    void = cirq.Circuit()
-    qubits: Sequence[cirq.Qid] | None = None
-    _cached_circuit_operations: dict[int, cirq.CircuitOperation] = field(
-        init=False, default_factory=dict
-    )
-
-    def initialize(self) -> Self:
-        return super().initialize()
-
-    def initialize_frame(
-        self, code: ir.Statement, *, has_parent_access: bool = False
-    ) -> EmitCirqFrame:
-        return EmitCirqFrame(
-            code, has_parent_access=has_parent_access, qubits=self.qubits
-        )
-
-    def run_method(self, method: ir.Method, args: tuple[cirq.Circuit, ...]):
-        return self.run_callable(method.code, args)
-
-    def emit_block(self, frame: EmitCirqFrame, block: ir.Block) -> cirq.Circuit:
-        for stmt in block.stmts:
-            result = self.eval_stmt(frame, stmt)
-            if isinstance(result, tuple):
-                frame.set_values(stmt.results, result)
-
-        return frame.circuit
-
-
-@func.dialect.register(key="emit.cirq")
-class FuncEmit(MethodTable):
-
-    @impl(func.Function)
-    def emit_func(self, emit: EmitCirq, frame: EmitCirqFrame, stmt: func.Function):
-        emit.run_ssacfg_region(frame, stmt.body, ())
-        return (frame.circuit,)
-
-    @impl(func.Invoke)
-    def emit_invoke(self, emit: EmitCirq, frame: EmitCirqFrame, stmt: func.Invoke):
-        stmt_hash = hash((stmt.callee, stmt.inputs))
-        if (
-            cached_circuit_op := emit._cached_circuit_operations.get(stmt_hash)
-        ) is not None:
-            # NOTE: cache hit
-            frame.circuit.append(cached_circuit_op)
-            return ()
-
-        ret = stmt.result
-
-        with emit.new_frame(stmt.callee.code, has_parent_access=True) as sub_frame:
-            sub_frame.qubit_index = frame.qubit_index
-            sub_frame.qubits = frame.qubits
-
-            region = stmt.callee.callable_region
-            if len(region.blocks) > 1:
-                raise EmitError(
-                    "Subroutine with more than a single block encountered. This is not supported!"
-                )
-
-            # NOTE: get the arguments, "self" is just an empty circuit
-            method_self = emit.void
-            args = [frame.get(arg_) for arg_ in stmt.inputs]
-            emit.run_ssacfg_region(
-                sub_frame, stmt.callee.callable_region, args=(method_self, *args)
-            )
-            sub_circuit = sub_frame.circuit
-
-            # NOTE: check to see if the call terminates with a return value and fetch the value;
-            # we don't support multiple return statements via control flow so we just pick the first one
-            block = region.blocks[0]
-            return_stmt = next(
-                (stmt for stmt in block.stmts if isinstance(stmt, func.Return)), None
-            )
-            if return_stmt is not None:
-                frame.entries[ret] = sub_frame.get(return_stmt.value)
-
-        circuit_op = cirq.CircuitOperation(
-            sub_circuit.freeze(), use_repetition_ids=False
-        )
-        emit._cached_circuit_operations[stmt_hash] = circuit_op
-        frame.circuit.append(circuit_op)
-        return ()

bloqade/squin/cirq/emit/noise.py

@@ -1,49 +0,0 @@
-import cirq
-from kirin.emit import EmitError
-from kirin.interp import MethodTable, impl
-
-from ... import noise
-from .runtime import (
-    KronRuntime,
-    BasicOpRuntime,
-    OperatorRuntimeABC,
-    PauliStringRuntime,
-)
-from .emit_circuit import EmitCirq, EmitCirqFrame
-
-
-@noise.dialect.register(key="emit.cirq")
-class EmitCirqNoiseMethods(MethodTable):
-
-    @impl(noise.stmts.StochasticUnitaryChannel)
-    def stochastic_unitary_channel(
-        self,
-        emit: EmitCirq,
-        frame: EmitCirqFrame,
-        stmt: noise.stmts.StochasticUnitaryChannel,
-    ):
-        ops = frame.get(stmt.operators)
-        ps = frame.get(stmt.probabilities)
-
-        error_probabilities = {self._op_to_key(op_): p for op_, p in zip(ops, ps)}
-        cirq_op = cirq.asymmetric_depolarize(error_probabilities=error_probabilities)
-        return (BasicOpRuntime(cirq_op),)
-
-    @staticmethod
-    def _op_to_key(operator: OperatorRuntimeABC) -> str:
-        match operator:
-            case KronRuntime():
-                key_lhs = EmitCirqNoiseMethods._op_to_key(operator.lhs)
-                key_rhs = EmitCirqNoiseMethods._op_to_key(operator.rhs)
-                return key_lhs + key_rhs
-
-            case BasicOpRuntime():
-                return str(operator.gate)
-
-            case PauliStringRuntime():
-                return operator.string
-
-            case _:
-                raise EmitError(
-                    f"Unexpected operator runtime in StochasticUnitaryChannel of type {type(operator).__name__} encountered!"
-                )