bloqade-circuit 0.4.2__py3-none-any.whl → 0.4.4__py3-none-any.whl

bloqade/squin/analysis/nsites/impls.py

@@ -1,4 +1,6 @@
 from kirin import interp
+from kirin.dialects import scf
+from kirin.dialects.scf.typeinfer import TypeInfer as ScfTypeInfer
 
 from bloqade.squin import op, wire
 
@@ -78,3 +80,8 @@ class SquinOp(interp.MethodTable):
     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

bloqade/squin/cirq/__init__.py

@@ -1,12 +1,17 @@
-from typing import Any
+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, qubit as qubit
 from .lowering import Squin
+from .emit.emit_circuit import EmitCirq
 
 
 def load_circuit(
@@ -87,3 +92,109 @@ def load_circuit(
         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)
+    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

@@ -0,0 +1,109 @@
+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/op.py

@@ -0,0 +1,125 @@
+import math
+
+import cirq
+import numpy as np
+from kirin.interp import MethodTable, impl
+
+from ... import op
+from .runtime import (
+    SnRuntime,
+    SpRuntime,
+    U3Runtime,
+    KronRuntime,
+    MultRuntime,
+    ScaleRuntime,
+    AdjointRuntime,
+    ControlRuntime,
+    UnitaryRuntime,
+    HermitianRuntime,
+    ProjectorRuntime,
+    OperatorRuntimeABC,
+    PauliStringRuntime,
+)
+from .emit_circuit import EmitCirq, EmitCirqFrame
+
+
+@op.dialect.register(key="emit.cirq")
+class EmitCirqOpMethods(MethodTable):
+
+    @impl(op.stmts.X)
+    @impl(op.stmts.Y)
+    @impl(op.stmts.Z)
+    @impl(op.stmts.H)
+    def hermitian(
+        self, emit: EmitCirq, frame: EmitCirqFrame, stmt: op.stmts.ConstantUnitary
+    ):
+        cirq_op = getattr(cirq, stmt.name.upper())
+        return (HermitianRuntime(cirq_op),)
+
+    @impl(op.stmts.S)
+    @impl(op.stmts.T)
+    def unitary(
+        self, emit: EmitCirq, frame: EmitCirqFrame, stmt: op.stmts.ConstantUnitary
+    ):
+        cirq_op = getattr(cirq, stmt.name.upper())
+        return (UnitaryRuntime(cirq_op),)
+
+    @impl(op.stmts.P0)
+    @impl(op.stmts.P1)
+    def projector(
+        self, emit: EmitCirq, frame: EmitCirqFrame, stmt: op.stmts.P0 | op.stmts.P1
+    ):
+        return (ProjectorRuntime(isinstance(stmt, op.stmts.P1)),)
+
+    @impl(op.stmts.Sn)
+    def sn(self, emit: EmitCirq, frame: EmitCirqFrame, stmt: op.stmts.Sn):
+        return (SnRuntime(),)
+
+    @impl(op.stmts.Sp)
+    def sp(self, emit: EmitCirq, frame: EmitCirqFrame, stmt: op.stmts.Sp):
+        return (SpRuntime(),)
+
+    @impl(op.stmts.Identity)
+    def identity(self, emit: EmitCirq, frame: EmitCirqFrame, stmt: op.stmts.Identity):
+        op = HermitianRuntime(cirq.IdentityGate(num_qubits=stmt.sites))
+        return (op,)
+
+    @impl(op.stmts.Control)
+    def control(self, emit: EmitCirq, frame: EmitCirqFrame, stmt: op.stmts.Control):
+        op: OperatorRuntimeABC = frame.get(stmt.op)
+        return (ControlRuntime(op, stmt.n_controls),)
+
+    @impl(op.stmts.Kron)
+    def kron(self, emit: EmitCirq, frame: EmitCirqFrame, stmt: op.stmts.Kron):
+        lhs = frame.get(stmt.lhs)
+        rhs = frame.get(stmt.rhs)
+        op = KronRuntime(lhs, rhs)
+        return (op,)
+
+    @impl(op.stmts.Mult)
+    def mult(self, emit: EmitCirq, frame: EmitCirqFrame, stmt: op.stmts.Mult):
+        lhs = frame.get(stmt.lhs)
+        rhs = frame.get(stmt.rhs)
+        op = MultRuntime(lhs, rhs)
+        return (op,)
+
+    @impl(op.stmts.Adjoint)
+    def adjoint(self, emit: EmitCirq, frame: EmitCirqFrame, stmt: op.stmts.Adjoint):
+        op_ = frame.get(stmt.op)
+        return (AdjointRuntime(op_),)
+
+    @impl(op.stmts.Scale)
+    def scale(self, emit: EmitCirq, frame: EmitCirqFrame, stmt: op.stmts.Scale):
+        op_ = frame.get(stmt.op)
+        factor = frame.get(stmt.factor)
+        return (ScaleRuntime(operator=op_, factor=factor),)
+
+    @impl(op.stmts.U3)
+    def u3(self, emit: EmitCirq, frame: EmitCirqFrame, stmt: op.stmts.U3):
+        theta = frame.get(stmt.theta)
+        phi = frame.get(stmt.phi)
+        lam = frame.get(stmt.lam)
+        return (U3Runtime(theta=theta, phi=phi, lam=lam),)
+
+    @impl(op.stmts.PhaseOp)
+    def phaseop(self, emit: EmitCirq, frame: EmitCirqFrame, stmt: op.stmts.PhaseOp):
+        theta = frame.get(stmt.theta)
+        op_ = HermitianRuntime(cirq.IdentityGate(num_qubits=1))
+        return (ScaleRuntime(operator=op_, factor=np.exp(1j * theta)),)
+
+    @impl(op.stmts.ShiftOp)
+    def shiftop(self, emit: EmitCirq, frame: EmitCirqFrame, stmt: op.stmts.ShiftOp):
+        theta = frame.get(stmt.theta)
+
+        # NOTE: ShiftOp(theta) == U3(pi, theta, 0)
+        return (U3Runtime(math.pi, theta, 0),)
+
+    @impl(op.stmts.Reset)
+    def reset(self, emit: EmitCirq, frame: EmitCirqFrame, stmt: op.stmts.Reset):
+        return (HermitianRuntime(cirq.ResetChannel()),)
+
+    @impl(op.stmts.PauliString)
+    def pauli_string(
+        self, emit: EmitCirq, frame: EmitCirqFrame, stmt: op.stmts.PauliString
+    ):
+        return (PauliStringRuntime(stmt.string),)

bloqade/squin/cirq/emit/qubit.py

@@ -0,0 +1,60 @@
+import cirq
+from kirin.interp import MethodTable, impl
+
+from ... import qubit
+from .op import OperatorRuntimeABC
+from .emit_circuit import EmitCirq, EmitCirqFrame
+
+
+@qubit.dialect.register(key="emit.cirq")
+class EmitCirqQubitMethods(MethodTable):
+    @impl(qubit.New)
+    def new(self, emit: EmitCirq, frame: EmitCirqFrame, stmt: qubit.New):
+        n_qubits = frame.get(stmt.n_qubits)
+
+        if frame.qubits is not None:
+            cirq_qubits = [frame.qubits[i + frame.qubit_index] for i in range(n_qubits)]
+        else:
+            cirq_qubits = [
+                cirq.LineQubit(i + frame.qubit_index) for i in range(n_qubits)
+            ]
+
+        frame.qubit_index += n_qubits
+        return (cirq_qubits,)
+
+    @impl(qubit.Apply)
+    def apply(self, emit: EmitCirq, frame: EmitCirqFrame, stmt: qubit.Apply):
+        op: OperatorRuntimeABC = frame.get(stmt.operator)
+        qbits = frame.get(stmt.qubits)
+        operations = op.apply(qbits)
+        for operation in operations:
+            frame.circuit.append(operation)
+        return ()
+
+    @impl(qubit.Broadcast)
+    def broadcast(self, emit: EmitCirq, frame: EmitCirqFrame, stmt: qubit.Broadcast):
+        op = frame.get(stmt.operator)
+        qbits = frame.get(stmt.qubits)
+
+        cirq_ops = []
+        for qbit in qbits:
+            cirq_ops.extend(op.apply([qbit]))
+
+        frame.circuit.append(cirq.Moment(cirq_ops))
+        return ()
+
+    @impl(qubit.MeasureQubit)
+    def measure_qubit(
+        self, emit: EmitCirq, frame: EmitCirqFrame, stmt: qubit.MeasureQubit
+    ):
+        qbit = frame.get(stmt.qubit)
+        frame.circuit.append(cirq.measure(qbit))
+        return ()
+
+    @impl(qubit.MeasureQubitList)
+    def measure_qubit_list(
+        self, emit: EmitCirq, frame: EmitCirqFrame, stmt: qubit.MeasureQubitList
+    ):
+        qbits = frame.get(stmt.qubits)
+        frame.circuit.append(cirq.measure(qbits))
+        return ()

bloqade/squin/cirq/emit/runtime.py

@@ -0,0 +1,234 @@
+import math
+from typing import Sequence
+from numbers import Number
+from dataclasses import dataclass
+
+import cirq
+
+
+@dataclass
+class OperatorRuntimeABC:
+    def num_qubits(self) -> int: ...
+
+    def check_qubits(self, qubits: Sequence[cirq.Qid]):
+        assert self.num_qubits() == len(qubits)
+
+    def apply(
+        self, qubits: Sequence[cirq.Qid], adjoint: bool = False
+    ) -> list[cirq.Operation]:
+        self.check_qubits(qubits)
+        return self.unsafe_apply(qubits, adjoint=adjoint)
+
+    def unsafe_apply(
+        self, qubits: Sequence[cirq.Qid], adjoint: bool = False
+    ) -> list[cirq.Operation]: ...
+
+
+@dataclass
+class UnsafeOperatorRuntimeABC(OperatorRuntimeABC):
+    def check_qubits(self, qubits: Sequence[cirq.Qid]):
+        # NOTE: let's let cirq check this one
+        pass
+
+
+@dataclass
+class BasicOpRuntime(UnsafeOperatorRuntimeABC):
+    gate: cirq.Gate
+
+    def num_qubits(self) -> int:
+        return self.gate.num_qubits()
+
+
+@dataclass
+class UnitaryRuntime(BasicOpRuntime):
+    def unsafe_apply(
+        self, qubits: Sequence[cirq.Qid], adjoint: bool = False
+    ) -> list[cirq.Operation]:
+        exponent = (-1) ** adjoint
+        return [self.gate(*qubits) ** exponent]
+
+
+@dataclass
+class HermitianRuntime(BasicOpRuntime):
+    def unsafe_apply(
+        self, qubits: Sequence[cirq.Qid], adjoint: bool = False
+    ) -> list[cirq.Operation]:
+        return [self.gate(*qubits)]
+
+
+@dataclass
+class ProjectorRuntime(UnsafeOperatorRuntimeABC):
+    target_state: bool
+
+    def num_qubits(self) -> int:
+        return 1
+
+    def unsafe_apply(
+        self, qubits: Sequence[cirq.Qid], adjoint: bool = False
+    ) -> list[cirq.Operation]:
+        # NOTE: this doesn't scale well, but works
+        sign = (-1) ** self.target_state
+        p = (1 + sign * cirq.Z(*qubits)) / 2
+        return [p]
+
+
+@dataclass
+class SpRuntime(UnsafeOperatorRuntimeABC):
+    def num_qubits(self) -> int:
+        return 1
+
+    def unsafe_apply(
+        self, qubits: Sequence[cirq.Qid], adjoint: bool = False
+    ) -> list[cirq.Operation]:
+        if adjoint:
+            return SnRuntime().unsafe_apply(qubits, adjoint=False)
+
+        return [(cirq.X(*qubits) - 1j * cirq.Y(*qubits)) / 2]  # type: ignore  -- we're not dealing with cirq's type issues
+
+
+@dataclass
+class SnRuntime(UnsafeOperatorRuntimeABC):
+    def num_qubits(self) -> int:
+        return 1
+
+    def unsafe_apply(
+        self, qubits: Sequence[cirq.Qid], adjoint: bool = False
+    ) -> list[cirq.Operation]:
+        if adjoint:
+            return SpRuntime().unsafe_apply(qubits, adjoint=False)
+
+        return [(cirq.X(*qubits) + 1j * cirq.Y(*qubits)) / 2]  # type: ignore  -- we're not dealing with cirq's type issues
+
+
+@dataclass
+class MultRuntime(OperatorRuntimeABC):
+    lhs: OperatorRuntimeABC
+    rhs: OperatorRuntimeABC
+
+    def num_qubits(self) -> int:
+        n = self.lhs.num_qubits()
+        assert n == self.rhs.num_qubits()
+        return n
+
+    def unsafe_apply(
+        self, qubits: Sequence[cirq.Qid], adjoint: bool = False
+    ) -> list[cirq.Operation]:
+        rhs = self.rhs.unsafe_apply(qubits, adjoint=adjoint)
+        lhs = self.lhs.unsafe_apply(qubits, adjoint=adjoint)
+
+        if adjoint:
+            return lhs + rhs
+        else:
+            return rhs + lhs
+
+
+@dataclass
+class KronRuntime(OperatorRuntimeABC):
+    lhs: OperatorRuntimeABC
+    rhs: OperatorRuntimeABC
+
+    def num_qubits(self) -> int:
+        return self.lhs.num_qubits() + self.rhs.num_qubits()
+
+    def unsafe_apply(
+        self, qubits: Sequence[cirq.Qid], adjoint: bool = False
+    ) -> list[cirq.Operation]:
+        n = self.lhs.num_qubits()
+        cirq_ops = self.lhs.unsafe_apply(qubits[:n], adjoint=adjoint)
+        cirq_ops.extend(self.rhs.unsafe_apply(qubits[n:], adjoint=adjoint))
+        return cirq_ops
+
+
+@dataclass
+class ControlRuntime(OperatorRuntimeABC):
+    operator: OperatorRuntimeABC
+    n_controls: int
+
+    def num_qubits(self) -> int:
+        return self.n_controls + self.operator.num_qubits()
+
+    def unsafe_apply(
+        self, qubits: Sequence[cirq.Qid], adjoint: bool = False
+    ) -> list[cirq.Operation]:
+        m = len(qubits) - self.n_controls
+        cirq_ops = self.operator.unsafe_apply(qubits[m:], adjoint=adjoint)
+        controlled_ops = [cirq_op.controlled_by(*qubits[:m]) for cirq_op in cirq_ops]
+        return controlled_ops
+
+
+@dataclass
+class AdjointRuntime(OperatorRuntimeABC):
+    operator: OperatorRuntimeABC
+
+    def num_qubits(self) -> int:
+        return self.operator.num_qubits()
+
+    def unsafe_apply(
+        self, qubits: Sequence[cirq.Qid], adjoint: bool = False
+    ) -> list[cirq.Operation]:
+        # NOTE: to account for e.g. adjoint(adjoint(op))
+        passed_on_adjoint = not adjoint
+        return self.operator.unsafe_apply(qubits, adjoint=passed_on_adjoint)
+
+
+@dataclass
+class U3Runtime(UnsafeOperatorRuntimeABC):
+    theta: float
+    phi: float
+    lam: float
+
+    def num_qubits(self) -> int:
+        return 1
+
+    def angles(self, adjoint: bool) -> tuple[float, float, float]:
+        if adjoint:
+            # NOTE: adjoint(U(theta, phi, lam)) == U(-theta, -lam, -phi)
+            return -self.theta, -self.lam, -self.phi
+        else:
+            return self.theta, self.phi, self.lam
+
+    def unsafe_apply(
+        self, qubits: Sequence[cirq.Qid], adjoint: bool = False
+    ) -> list[cirq.Operation]:
+        theta, phi, lam = self.angles(adjoint=adjoint)
+
+        ops = [
+            cirq.Rz(rads=lam)(*qubits),
+            cirq.Rx(rads=math.pi / 2)(*qubits),
+            cirq.Rz(rads=theta)(*qubits),
+            cirq.Rx(rads=-math.pi / 2)(*qubits),
+            cirq.Rz(rads=phi)(*qubits),
+        ]
+
+        return ops
+
+
+@dataclass
+class ScaleRuntime(OperatorRuntimeABC):
+    factor: Number
+    operator: OperatorRuntimeABC
+
+    def num_qubits(self) -> int:
+        return self.operator.num_qubits()
+
+    def unsafe_apply(
+        self, qubits: Sequence[cirq.Qid], adjoint: bool = False
+    ) -> list[cirq.Operation]:
+        cirq_ops = self.operator.unsafe_apply(qubits=qubits, adjoint=adjoint)
+        return [self.factor * cirq_ops[0]] + cirq_ops[1:]  # type: ignore
+
+
+@dataclass
+class PauliStringRuntime(OperatorRuntimeABC):
+    string: str
+
+    def num_qubits(self) -> int:
+        return len(self.string)
+
+    def unsafe_apply(
+        self, qubits: Sequence[cirq.Qid], adjoint: bool = False
+    ) -> list[cirq.Operation]:
+        pauli_mapping = {
+            qbit: pauli_label for (qbit, pauli_label) in zip(qubits, self.string)
+        }
+        return [cirq.PauliString(pauli_mapping)]