bloqade-circuit 0.6.8__py3-none-any.whl → 0.7.0__py3-none-any.whl

bloqade/analysis/measure_id/analysis.py

@@ -1,7 +1,7 @@
 from typing import TypeVar
 from dataclasses import field, dataclass
 
-from kirin import ir, interp
+from kirin import ir
 from kirin.analysis import ForwardExtra, const
 from kirin.analysis.forward import ForwardFrame
 
@@ -37,20 +37,19 @@ class MeasurementIDAnalysis(ForwardExtra[MeasureIDFrame, MeasureId]):
         # 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)
 
-    T = TypeVar("T")
-
     # Xiu-zhe (Roger) Luo came up with this in the address analysis,
-    # reused here for convenience
+    # reused here for convenience (now modified to be a bit more graceful)
     # TODO: Remove this function once upgrade to kirin 0.18 happens,
     #       method is built-in to interpreter then
-    def get_const_value(self, input_type: type[T], value: ir.SSAValue) -> T:
+
+    T = TypeVar("T")
+
+    def get_const_value(
+        self, input_type: type[T], value: ir.SSAValue
+    ) -> type[T] | None:
         if isinstance(hint := value.hints.get("const"), const.Value):
             data = hint.data
             if isinstance(data, input_type):
                 return hint.data
-            raise interp.InterpreterError(
-                f"Expected constant value <type = {input_type}>, got {data}"
-            )
-        raise interp.InterpreterError(
-            f"Expected constant value <type = {input_type}>, got {value}"
-        )
+
+        return None

bloqade/analysis/measure_id/impls.py

@@ -103,10 +103,23 @@ class PyIndexing(interp.MethodTable):
     def getitem(
         self, interp: MeasurementIDAnalysis, frame: interp.Frame, stmt: py.GetItem
     ):
-        idx = interp.get_const_value(int, stmt.index)
+
+        idx_or_slice = interp.get_const_value((int, slice), stmt.index)
+        if idx_or_slice is None:
+            return (InvalidMeasureId(),)
+
+        # hint = stmt.index.hints.get("const")
+        # if hint is None or not isinstance(hint, const.Value):
+        #    return (InvalidMeasureId(),)
+
         obj = frame.get(stmt.obj)
         if isinstance(obj, MeasureIdTuple):
-            return (obj.data[idx],)
+            if isinstance(idx_or_slice, slice):
+                return (MeasureIdTuple(data=obj.data[idx_or_slice]),)
+            elif isinstance(idx_or_slice, int):
+                return (obj.data[idx_or_slice],)
+            else:
+                return (InvalidMeasureId(),)
         # just propagate these down the line
         elif isinstance(obj, (AnyMeasureId, NotMeasureId)):
             return (obj,)

bloqade/cirq_utils/noise/__init__.py

@@ -3,8 +3,6 @@
 from .model import (
     GeminiOneZoneNoiseModel as GeminiOneZoneNoiseModel,
     GeminiTwoZoneNoiseModel as GeminiTwoZoneNoiseModel,
-    GeminiOneZoneNoiseModelABC as GeminiOneZoneNoiseModelABC,
-    GeminiOneZoneNoiseModelCorrelated as GeminiOneZoneNoiseModelCorrelated,
     GeminiOneZoneNoiseModelConflictGraphMoves as GeminiOneZoneNoiseModelConflictGraphMoves,
 )
 from .transform import transform_circuit as transform_circuit

bloqade/cirq_utils/noise/_two_zone_utils.py

@@ -264,8 +264,9 @@ def get_gate_error_channel(
     moment: cirq.Moment,
     sq_loc_rates: np.ndarray,
     sq_glob_rates: np.ndarray,
-    cz_rates: np.ndarray,
+    two_qubit_pauli: cirq.Gate,
     unp_cz_rates: np.ndarray,
+    nqubs: int,
 ):
     """Applies gate errors to the circuit
 
@@ -273,15 +274,15 @@ def get_gate_error_channel(
         moment: A cirq.Moment object.
         sq_loc_rates: single local qubit rotation Pauli noise channel parameters (px, py, pz)
         sq_glob_rates: single global qubit rotation Pauli noise channel parameters (px,py,pz)
-        cz_rates: two-qubit rotation Pauli noise channel parameters (ctrl_px, ctrl_py,ctrl_pz,tar_px,tar_py,tar_pz)
+        two_qubit_pauli: correlated two-qubit noise channel (ctrl_px, ctrl_py,ctrl_pz,tar_px,tar_py,tar_pz)
         unp_cz_rates: Pauli noise channel parameters for qubits in the gate zone and outside blockade radius
+        nqubs: total number of qubits
     Returns:
         A new cirq.Moment object with the gate errors applied.
     """
     # Check for the moment (layer) layout: global single qubit gates, or mixture of single qubit gates and two qubit gates
 
     gates_in_layer = extract_u3_and_cz_qargs(moment)
-    # new_moment = cirq.Moment()
     new_moments = cirq.Circuit()
 
     if gates_in_layer["cz"] == []:
@@ -294,7 +295,7 @@ def get_gate_error_channel(
         if all(
             np.all(np.isclose(element, gates_in_layer["angles"][0]))
             for element in gates_in_layer["angles"]
-        ):
+        ) and nqubs == len(gates_in_layer["u3"]):
             pauli_channel = cirq.AsymmetricDepolarizingChannel(
                 p_x=sq_glob_rates[0], p_y=sq_glob_rates[1], p_z=sq_glob_rates[2]
             )
@@ -314,12 +315,6 @@ def get_gate_error_channel(
 
     else:
         # there is at least one CZ gate...
-        ctrl_pauli_channel = cirq.AsymmetricDepolarizingChannel(
-            p_x=cz_rates[0], p_y=cz_rates[1], p_z=cz_rates[2]
-        )
-        tar_pauli_channel = cirq.AsymmetricDepolarizingChannel(
-            p_x=cz_rates[3], p_y=cz_rates[4], p_z=cz_rates[5]
-        )
         loc_rot_pauli_channel = cirq.AsymmetricDepolarizingChannel(
             p_x=sq_loc_rates[0], p_y=sq_loc_rates[1], p_z=sq_loc_rates[2]
         )
@@ -327,18 +322,15 @@ def get_gate_error_channel(
             p_x=unp_cz_rates[0], p_y=unp_cz_rates[1], p_z=unp_cz_rates[2]
         )
 
+        # apply correlated noise to paired qubits
         for qub in gates_in_layer["cz"]:
-            new_moments.append(ctrl_pauli_channel(qub[0]))
-            new_moments.append(tar_pauli_channel(qub[1]))
-            # new_moment=new_moment+ctrl_pauli_channel(qub[0])
-            # new_moment=new_moment+tar_pauli_channel(qub[1])
+            new_moments.append(two_qubit_pauli.on(qub[0], qub[1]))
 
         for qub in gates_in_layer["u3"]:
             new_moments.append(
                 unp_cz_pauli_channel(qub[0])
             )  ###qubits in the gate zone get unpaired_cz error
             new_moments.append(loc_rot_pauli_channel(qub[0]))
-            # new_moment = new_moment + loc_rot_pauli_channel(qub[0])
 
     return new_moments
 

bloqade/cirq_utils/noise/model.py

@@ -1,5 +1,5 @@
-from typing import Iterable, Sequence
-from dataclasses import field, dataclass
+from typing import Iterable, Sequence, cast
+from dataclasses import dataclass
 
 import cirq
 import numpy as np
@@ -11,6 +11,33 @@ from ..parallelize import parallelize
 from .conflict_graph import OneZoneConflictGraph
 
 
+def _default_cz_paired_correlated_rates() -> dict:
+    rates = np.array(
+        [
+            [9.93492628e-01, 2.27472300e-04, 2.27472300e-04, 1.51277730e-03],
+            [2.27472300e-04, 1.42864200e-04, 1.42864200e-04, 1.43082900e-04],
+            [2.27472300e-04, 1.42864200e-04, 1.42864200e-04, 1.43082900e-04],
+            [1.51277730e-03, 1.43082900e-04, 1.43082900e-04, 1.42813990e-03],
+        ]
+    )
+
+    return correlated_noise_array_to_dict(noise_rates=rates)
+
+
+def correlated_noise_array_to_dict(noise_rates: np.ndarray) -> dict:
+    paulis = ("I", "X", "Y", "Z")
+    error_probabilities = {}
+    for idx1, p1 in enumerate(paulis):
+        for idx2, p2 in enumerate(paulis):
+            probability = noise_rates[idx1, idx2]
+
+            if probability > 0:
+                key = p1 + p2
+                error_probabilities[key] = probability
+
+    return error_probabilities
+
+
 @dataclass(frozen=True)
 class GeminiNoiseModelABC(cirq.NoiseModel, MoveNoiseModelABC):
     """Abstract base class for all Gemini noise models."""
@@ -22,6 +49,47 @@ class GeminiNoiseModelABC(cirq.NoiseModel, MoveNoiseModelABC):
 
     """
 
+    cz_paired_correlated_rates: np.ndarray | None = None
+    """The correlated CZ error rates as a 4x4 array."""
+
+    cz_paired_error_probabilities: dict | None = None
+    """The correlated CZ error rates as a dictionary"""
+
+    def __post_init__(self):
+        if (
+            self.cz_paired_correlated_rates is None
+            and self.cz_paired_error_probabilities is None
+        ):
+            # NOTE: no input, set to default value; weird setattr for frozen dataclass
+            object.__setattr__(
+                self,
+                "cz_paired_error_probabilities",
+                _default_cz_paired_correlated_rates(),
+            )
+        elif (
+            self.cz_paired_correlated_rates is not None
+            and self.cz_paired_correlated_rates is None
+        ):
+
+            if self.cz_paired_correlated_rates.shape != (4, 4):
+                raise ValueError(
+                    "Expected a 4x4 array of probabilities for cz_paired_correlated_rates"
+                )
+
+            # NOTE: convert array to dict
+            object.__setattr__(
+                self,
+                "cz_paired_error_probabilities",
+                correlated_noise_array_to_dict(self.cz_paired_correlated_rates),
+            )
+        elif (
+            self.cz_paired_correlated_rates is not None
+            and self.cz_paired_correlated_rates is not None
+        ):
+            raise ValueError(
+                "Received both `cz_paired_correlated_rates` and `cz_paired_correlated_rates` as input. This is ambiguous, please only set one."
+            )
+
     @staticmethod
     def validate_moments(moments: Iterable[cirq.Moment]):
         allowed_target_gates: frozenset[cirq.GateFamily] = cirq.CZTargetGateset().gates
@@ -81,72 +149,33 @@ class GeminiNoiseModelABC(cirq.NoiseModel, MoveNoiseModelABC):
             self.cz_unpaired_gate_pz,
         )
 
+    @property
+    def two_qubit_pauli(self) -> cirq.AsymmetricDepolarizingChannel:
+        # NOTE: if this was None it would error when instantiating self
+        # quiet the linter for the copy below
+        error_probabilities = cast(dict, self.cz_paired_error_probabilities)
 
-@dataclass(frozen=True)
-class GeminiOneZoneNoiseModelABC(GeminiNoiseModelABC):
-    """Abstract base class for all one-zone Gemini noise models."""
-
-    parallelize_circuit: bool = False
-
-    def noisy_moments(
-        self, moments: Iterable[cirq.Moment], system_qubits: Sequence[cirq.Qid]
-    ) -> Sequence[cirq.OP_TREE]:
-        """Adds possibly stateful noise to a series of moments.
-
-        Args:
-            moments: The moments to add noise to.
-            system_qubits: A list of all qubits in the system.
-
-        Returns:
-            A sequence of OP_TREEEs, with the k'th tree corresponding to the
-            noisy operations for the k'th moment.
-        """
-
-        if self.check_input_circuit:
-            self.validate_moments(moments)
-
-        # Split into moments with only 1Q and 2Q gates
-        moments_1q = [
-            cirq.Moment([op for op in moment.operations if len(op.qubits) == 1])
-            for moment in moments
-        ]
-        moments_2q = [
-            cirq.Moment([op for op in moment.operations if len(op.qubits) == 2])
-            for moment in moments
-        ]
-
-        assert len(moments_1q) == len(moments_2q)
-
-        interleaved_moments = []
-        for idx, moment in enumerate(moments_1q):
-            interleaved_moments.append(moment)
-            interleaved_moments.append(moments_2q[idx])
-
-        interleaved_circuit = cirq.Circuit.from_moments(*interleaved_moments)
-
-        # Combine subsequent 1Q gates
-        compressed_circuit = cirq.merge_single_qubit_moments_to_phxz(
-            interleaved_circuit
-        )
-        if self.parallelize_circuit:
-            compressed_circuit = parallelize(compressed_circuit)
-
-        return self._noisy_moments_impl_moment(
-            compressed_circuit.moments, system_qubits
+        # NOTE: copy dict since cirq modifies it in-place somewhere
+        return cirq.AsymmetricDepolarizingChannel(
+            error_probabilities=error_probabilities.copy()
         )
 
 
 @dataclass(frozen=True)
-class GeminiOneZoneNoiseModel(GeminiOneZoneNoiseModelABC):
+class GeminiOneZoneNoiseModel(GeminiNoiseModelABC):
     """
     A Cirq-compatible noise model for a one-zone implementation of the Gemini architecture.
 
     This model introduces custom asymmetric depolarizing noise for both single- and two-qubit gates
     depending on whether operations are global, local, or part of a CZ interaction. Since the model assumes all
-    atoms are in the entangling zone, error are applied that stem from application of Rydberg error, even for
+    atoms are in the entangling zone, errors are applied that stem from application of Rydberg error, even for
     qubits not actively involved in a gate operation.
+
+    Note, that the noise applied to entangling pairs is correlated.
     """
 
+    parallelize_circuit: bool = False
+
     def _single_qubit_moment_noise_ops(
         self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]
     ) -> tuple[list, list]:
@@ -206,132 +235,6 @@ class GeminiOneZoneNoiseModel(GeminiOneZoneNoiseModelABC):
 
         return [gate_noise_op], []
 
-    def noisy_moment(self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]):
-        """
-        Applies a structured noise model to a given moment depending on the type of operations it contains.
-
-        For single-qubit moments:
-            - If all gates are identical and act on all qubits, global noise is applied.
-            - Otherwise, local depolarizing noise is applied per qubit.
-
-        For two-qubit moments:
-            - Applies move error to move control qubits to target qubits before the gate and again to move back after
-                the gate.
-            - Applies gate error to control and target qubits.
-            - Adds 1q asymmetric noise to qubits that do not participate in a gate.
-
-        Args:
-            moment: A cirq.Moment containing the original quantum operations.
-            system_qubits: All qubits in the system (used to determine idleness and global operations).
-
-        Returns:
-            A list of cirq.Moment objects:
-                [pre-gate move noise, original moment, post-gate move noise, gate noise moment]
-
-        Raises:
-            ValueError: If the moment contains multi-qubit gates involving >2 qubits, which are unsupported.
-        """
-        # Moment with original ops
-        original_moment = moment
-
-        # Check if the moment is empty
-        if len(moment.operations) == 0:
-            move_noise_ops = []
-            gate_noise_ops = []
-        # Check if the moment contains 1-qubit gates or 2-qubit gates
-        elif len(moment.operations[0].qubits) == 1:
-            gate_noise_ops, move_noise_ops = self._single_qubit_moment_noise_ops(
-                moment, system_qubits
-            )
-        elif len(moment.operations[0].qubits) == 2:
-            # Check if the moment only contains two qubit gates
-            assert np.all([len(op.qubits) == 2 for op in moment.operations])
-
-            control_qubits = [op.qubits[0] for op in moment.operations]
-            target_qubits = [op.qubits[1] for op in moment.operations]
-            gated_qubits = control_qubits + target_qubits
-            idle_atoms = list(set(system_qubits) - set(gated_qubits))
-
-            move_noise_ops = [
-                cirq.asymmetric_depolarize(*self.mover_pauli_rates).on_each(
-                    control_qubits
-                ),
-                cirq.asymmetric_depolarize(*self.sitter_pauli_rates).on_each(
-                    target_qubits + idle_atoms
-                ),
-            ]  # In this setting, we assume a 1 zone scheme where the controls move to the targets.
-
-            gate_noise_ops = [
-                cirq.asymmetric_depolarize(*self.cz_paired_pauli_rates).on_each(
-                    gated_qubits
-                ),
-                cirq.asymmetric_depolarize(*self.cz_unpaired_pauli_rates).on_each(
-                    idle_atoms
-                ),
-            ]  # In this 1 zone scheme, all unpaired atoms are in the entangling zone.
-        else:
-            raise ValueError(
-                "Moment contains operations with more than 2 qubits, which is not supported. "
-                "Correlated measurements should be added after the noise model is applied."
-            )
-
-        if move_noise_ops == []:
-            move_noise_moments = []
-        else:
-            move_noise_moments = [cirq.Moment(move_noise_ops)]
-        gate_noise_moment = cirq.Moment(gate_noise_ops)
-
-        return [
-            *move_noise_moments,
-            original_moment,
-            gate_noise_moment,
-            *move_noise_moments,
-        ]
-
-
-def _default_cz_paired_correlated_rates() -> np.ndarray:
-    return np.array(
-        [
-            [0.994000006, 0.000142857, 0.000142857, 0.001428570],
-            [0.000142857, 0.000142857, 0.000142857, 0.000142857],
-            [0.000142857, 0.000142857, 0.000142857, 0.000142857],
-            [0.001428570, 0.000142857, 0.000142857, 0.001428570],
-        ]
-    )
-
-
-@dataclass(frozen=True)
-class GeminiOneZoneNoiseModelCorrelated(GeminiOneZoneNoiseModel):
-    """
-    A Cirq noise model for implementing correlated two-qubit Pauli errors in a one-zone Gemini architecture.
-    """
-
-    cz_paired_correlated_rates: np.ndarray = field(
-        default_factory=_default_cz_paired_correlated_rates
-    )
-
-    def __post_init__(self):
-        if self.cz_paired_correlated_rates.shape != (4, 4):
-            raise ValueError(
-                "Expected a 4x4 array of probabilities for cz_paired_correlated_rates"
-            )
-
-    @property
-    def two_qubit_pauli(self) -> cirq.AsymmetricDepolarizingChannel:
-        paulis = ("I", "X", "Y", "Z")
-        error_probabilities = {}
-        for idx1, p1 in enumerate(paulis):
-            for idx2, p2 in enumerate(paulis):
-                probability = self.cz_paired_correlated_rates[idx1, idx2]
-
-                if probability > 0:
-                    key = p1 + p2
-                    error_probabilities[key] = probability
-
-        return cirq.AsymmetricDepolarizingChannel(
-            error_probabilities=error_probabilities
-        )
-
     def noisy_moment(self, moment, system_qubits):
         # Moment with original ops
         original_moment = moment
@@ -391,6 +294,53 @@ class GeminiOneZoneNoiseModelCorrelated(GeminiOneZoneNoiseModel):
             *move_noise_moments,
         ]
 
+    def noisy_moments(
+        self, moments: Iterable[cirq.Moment], system_qubits: Sequence[cirq.Qid]
+    ) -> Sequence[cirq.OP_TREE]:
+        """Adds possibly stateful noise to a series of moments.
+
+        Args:
+            moments: The moments to add noise to.
+            system_qubits: A list of all qubits in the system.
+
+        Returns:
+            A sequence of OP_TREEEs, with the k'th tree corresponding to the
+            noisy operations for the k'th moment.
+        """
+
+        if self.check_input_circuit:
+            self.validate_moments(moments)
+
+        # Split into moments with only 1Q and 2Q gates
+        moments_1q = [
+            cirq.Moment([op for op in moment.operations if len(op.qubits) == 1])
+            for moment in moments
+        ]
+        moments_2q = [
+            cirq.Moment([op for op in moment.operations if len(op.qubits) == 2])
+            for moment in moments
+        ]
+
+        assert len(moments_1q) == len(moments_2q)
+
+        interleaved_moments = []
+        for idx, moment in enumerate(moments_1q):
+            interleaved_moments.append(moment)
+            interleaved_moments.append(moments_2q[idx])
+
+        interleaved_circuit = cirq.Circuit.from_moments(*interleaved_moments)
+
+        # Combine subsequent 1Q gates
+        compressed_circuit = cirq.merge_single_qubit_moments_to_phxz(
+            interleaved_circuit
+        )
+        if self.parallelize_circuit:
+            compressed_circuit = parallelize(compressed_circuit)
+
+        return self._noisy_moments_impl_moment(
+            compressed_circuit.moments, system_qubits
+        )
+
 
 @dataclass(frozen=True)
 class GeminiOneZoneNoiseModelConflictGraphMoves(GeminiOneZoneNoiseModel):
@@ -452,14 +402,18 @@ class GeminiOneZoneNoiseModelConflictGraphMoves(GeminiOneZoneNoiseModel):
             gated_qubits = control_qubits + target_qubits
             idle_atoms = list(set(system_qubits) - set(gated_qubits))
 
+            # Add correlated noise channels for entangling pairs
+            two_qubit_pauli = self.two_qubit_pauli
             gate_noise_ops = [
-                cirq.asymmetric_depolarize(*self.cz_paired_pauli_rates).on_each(
-                    gated_qubits
-                ),
+                two_qubit_pauli.on(c, t) for c, t in zip(control_qubits, target_qubits)
+            ]
+
+            # In this 1 zone scheme, all unpaired atoms are in the entangling zone.
+            gate_noise_ops.append(
                 cirq.asymmetric_depolarize(*self.cz_unpaired_pauli_rates).on_each(
                     idle_atoms
                 ),
-            ]  # In this 1 zone scheme, all unpaired atoms are in the entangling zone.
+            )
         else:
             raise ValueError(
                 "Moment contains operations with more than 2 qubits, which is not supported."
@@ -530,10 +484,9 @@ class GeminiTwoZoneNoiseModel(GeminiNoiseModelABC):
                         moments[i],
                         np.array(self.local_pauli_rates),
                         np.array(self.global_pauli_rates),
-                        np.array(
-                            self.cz_paired_pauli_rates + self.cz_paired_pauli_rates
-                        ),
+                        self.two_qubit_pauli,
                         np.array(self.cz_unpaired_pauli_rates),
+                        nqubs,
                     ).moments
                     if len(moment) > 0
                 ]

bloqade/cirq_utils/noise/transform.py

@@ -1,6 +1,6 @@
 import cirq
 
-from .model import GeminiOneZoneNoiseModel, GeminiOneZoneNoiseModelABC
+from .model import GeminiOneZoneNoiseModel
 from ..parallelize import transpile, parallelize
 
 
@@ -36,7 +36,7 @@ def transform_circuit(
 
     # only parallelize here if we aren't parallelizing inside a one-zone model
     parallelize_circuit_here = parallelize_circuit and not isinstance(
-        model, GeminiOneZoneNoiseModelABC
+        model, GeminiOneZoneNoiseModel
     )
 
     system_qubits = sorted(circuit.all_qubits())

bloqade/pyqrack/squin/qubit.py

@@ -25,7 +25,7 @@ class PyQrackMethods(interp.MethodTable):
 
     @interp.impl(qubit.Apply)
     def apply(self, interp: PyQrackInterpreter, frame: interp.Frame, stmt: qubit.Apply):
-        qubits: ilist.IList[PyQrackQubit, Any] = frame.get(stmt.qubits)
+        qubits: list[PyQrackQubit] = [frame.get(qbit) for qbit in stmt.qubits]
         operator: OperatorRuntimeABC = frame.get(stmt.operator)
         operator.apply(*qubits)
 
@@ -34,7 +34,9 @@ class PyQrackMethods(interp.MethodTable):
         self, interp: PyQrackInterpreter, frame: interp.Frame, stmt: qubit.Broadcast
     ):
         operator: OperatorRuntimeABC = frame.get(stmt.operator)
-        qubits: ilist.IList[PyQrackQubit, Any] = frame.get(stmt.qubits)
+        qubits: list[ilist.IList[PyQrackQubit, Any]] = [
+            frame.get(qbit) for qbit in stmt.qubits
+        ]
         operator.broadcast_apply(qubits)
 
     def _measure_qubit(self, qbit: PyQrackQubit, interp: PyQrackInterpreter):

bloqade/pyqrack/squin/runtime.py

@@ -28,17 +28,25 @@ class OperatorRuntimeABC:
     ) -> None:
         raise RuntimeError(f"Can't apply controlled version of {self}")
 
-    def broadcast_apply(self, qubits: ilist.IList[PyQrackQubit, Any], **kwargs) -> None:
+    def broadcast_apply(
+        self, qubit_lists: list[ilist.IList[PyQrackQubit, Any]], **kwargs
+    ) -> None:
         n = self.n_sites
 
-        if len(qubits) % n != 0:
+        if n != len(qubit_lists):
             raise RuntimeError(
-                f"Cannot broadcast operator {self} that applies to {n} over {len(qubits)} qubits."
+                f"Cannot apply operator of size {n} to {len(qubit_lists)} qubits!"
             )
 
-        for qubit_index in range(0, len(qubits), n):
-            targets = qubits[qubit_index : qubit_index + n]
-            self.apply(*targets, **kwargs)
+        m = len(qubit_lists[0])
+        for qubit_list in qubit_lists:
+            if m != len(qubit_list):
+                raise RuntimeError(
+                    "Cannot broadcast operator on qubit lists of varying length!"
+                )
+
+        for qubits in zip(*qubit_lists):
+            self.apply(*qubits, **kwargs)
 
 
 @dataclass(frozen=True)