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

bloqade/squin/cirq/emit/emit_circuit.py

@@ -1,129 +0,0 @@
-from typing import Sequence
-from dataclasses import field, dataclass
-
-import cirq
-from kirin import ir, interp
-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 run_callable_region(
-        self,
-        frame: EmitCirqFrame,
-        code: ir.Statement,
-        region: ir.Region,
-        args: tuple,
-    ):
-        if len(region.blocks) > 0:
-            block_args = list(region.blocks[0].args)
-            # NOTE: skip self arg
-            frame.set_values(block_args[1:], args)
-
-        results = self.eval_stmt(frame, code)
-        if isinstance(results, tuple):
-            if len(results) == 0:
-                return self.void
-            elif len(results) == 1:
-                return results[0]
-        raise interp.InterpreterError(f"Unexpected results {results}")
-
-    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!"
-                )

bloqade/squin/cirq/emit/op.py

@@ -1,176 +0,0 @@
-import math
-
-import cirq
-import numpy as np
-from kirin.emit import EmitError
-from kirin.interp import MethodTable, impl
-
-from ... import op
-from .runtime import (
-    SnRuntime,
-    SpRuntime,
-    U3Runtime,
-    KronRuntime,
-    MultRuntime,
-    ScaleRuntime,
-    AdjointRuntime,
-    BasicOpRuntime,
-    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 (BasicOpRuntime(cirq.ResetChannel()),)
-
-    @impl(op.stmts.PauliString)
-    def pauli_string(
-        self, emit: EmitCirq, frame: EmitCirqFrame, stmt: op.stmts.PauliString
-    ):
-        return (PauliStringRuntime(stmt.string),)
-
-    @impl(op.stmts.Rot)
-    def rot(self, emit: EmitCirq, frame: EmitCirqFrame, stmt: op.stmts.Rot):
-        axis: OperatorRuntimeABC = frame.get(stmt.axis)
-
-        if not isinstance(axis, HermitianRuntime):
-            raise EmitError(
-                f"Circuit emission only supported for Pauli operators! Got axis {axis}"
-            )
-
-        angle = frame.get(stmt.angle)
-
-        match axis.gate:
-            case cirq.X:
-                gate = cirq.Rx(rads=angle)
-            case cirq.Y:
-                gate = cirq.Ry(rads=angle)
-            case cirq.Z:
-                gate = cirq.Rz(rads=angle)
-            case _:
-                raise EmitError(
-                    f"Circuit emission only supported for Pauli operators! Got axis {axis.gate}"
-                )
-
-        return (HermitianRuntime(gate=gate),)
-
-    @impl(op.stmts.ResetToOne)
-    def reset_to_one(
-        self, emit: EmitCirq, frame: EmitCirqFrame, stmt: op.stmts.ResetToOne
-    ):
-        # NOTE: just apply a reset to 0 and flip in sequence (we re-use the multiplication runtime since it does exactly that)
-        gate1 = cirq.ResetChannel()
-        gate2 = cirq.X
-
-        rt1 = BasicOpRuntime(gate1)
-        rt2 = HermitianRuntime(gate2)
-
-        # NOTE: mind the order: rhs is applied first
-        return (MultRuntime(rt2, rt1),)
-
-    @impl(op.stmts.SqrtX)
-    def sqrt_x(self, emit: EmitCirq, frame: EmitCirqFrame, stmt: op.stmts.SqrtX):
-        cirq_op = cirq.XPowGate(exponent=0.5)
-        return (UnitaryRuntime(cirq_op),)
-
-    @impl(op.stmts.SqrtY)
-    def sqrt_y(self, emit: EmitCirq, frame: EmitCirqFrame, stmt: op.stmts.SqrtY):
-        cirq_op = cirq.YPowGate(exponent=0.5)
-        return (UnitaryRuntime(cirq_op),)

bloqade/squin/cirq/emit/qubit.py

@@ -1,58 +0,0 @@
-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(qbit) for qbit in 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)
-        qbit_lists = [frame.get(qbit) for qbit in stmt.qubits]
-
-        for qbits in zip(*qbit_lists):
-            frame.circuit.append(op.apply(qbits))
-
-        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 (emit.void,)
-
-    @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 (emit.void,)

bloqade/squin/cirq/emit/runtime.py

@@ -1,242 +0,0 @@
-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]:
-        raise NotImplementedError(
-            f"Apply method needs to be implemented in {self.__class__.__name__}"
-        )
-
-
-@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()
-
-    def unsafe_apply(
-        self, qubits: Sequence[cirq.Qid], adjoint: bool = False
-    ) -> list[cirq.Operation]:
-        return [self.gate(*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)]