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

bloqade/cirq_utils/noise/model.py

@@ -0,0 +1,544 @@
+from typing import Iterable, Sequence
+from dataclasses import field, dataclass
+
+import cirq
+import numpy as np
+
+from bloqade.qasm2.dialects.noise import MoveNoiseModelABC
+
+from . import _two_zone_utils
+from ..parallelize import parallelize
+from .conflict_graph import OneZoneConflictGraph
+
+
+@dataclass(frozen=True)
+class GeminiNoiseModelABC(cirq.NoiseModel, MoveNoiseModelABC):
+    """Abstract base class for all Gemini noise models."""
+
+    check_input_circuit: bool = True
+    """Determine whether or not to verify that the circuit only contains native gates.
+
+    **Caution**: Disabling this for circuits containing non-native gates may lead to incorrect results!
+
+    """
+
+    @staticmethod
+    def validate_moments(moments: Iterable[cirq.Moment]):
+        allowed_target_gates: frozenset[cirq.GateFamily] = cirq.CZTargetGateset().gates
+
+        for moment in moments:
+            for operation in moment:
+                if not isinstance(operation, cirq.Operation):
+                    continue
+
+                gate = operation.gate
+                for allowed_family in allowed_target_gates:
+                    if gate in allowed_family:
+                        break
+                else:
+                    raise ValueError(
+                        f"Noise model only supported for circuits containing native gates part of the CZTargetGateSet, but encountered {operation} in moment {moment}! "
+                        "To solve this error you can either use the `bloqade.cirq_utils.noise.transform` method setting `to_target_gateset = True` "
+                        "or use the `bloqade.cirq_utils.transpile` method to convert the circuit before applying the noise model."
+                    )
+
+    def parallel_cz_errors(
+        self, ctrls: list[int], qargs: list[int], rest: list[int]
+    ) -> dict[tuple[float, float, float, float], list[int]]:
+        raise NotImplementedError(
+            "This noise model doesn't support rewrites on bloqade kernels, but should be used with cirq."
+        )
+
+    @property
+    def mover_pauli_rates(self) -> tuple[float, float, float]:
+        return (self.mover_px, self.mover_py, self.mover_pz)
+
+    @property
+    def sitter_pauli_rates(self) -> tuple[float, float, float]:
+        return (self.sitter_px, self.sitter_py, self.sitter_pz)
+
+    @property
+    def global_pauli_rates(self) -> tuple[float, float, float]:
+        return (self.global_px, self.global_py, self.global_pz)
+
+    @property
+    def local_pauli_rates(self) -> tuple[float, float, float]:
+        return (self.local_px, self.local_py, self.local_pz)
+
+    @property
+    def cz_paired_pauli_rates(self) -> tuple[float, float, float]:
+        return (
+            self.cz_paired_gate_px,
+            self.cz_paired_gate_py,
+            self.cz_paired_gate_pz,
+        )
+
+    @property
+    def cz_unpaired_pauli_rates(self) -> tuple[float, float, float]:
+        return (
+            self.cz_unpaired_gate_px,
+            self.cz_unpaired_gate_py,
+            self.cz_unpaired_gate_pz,
+        )
+
+
+@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
+        )
+
+
+@dataclass(frozen=True)
+class GeminiOneZoneNoiseModel(GeminiOneZoneNoiseModelABC):
+    """
+    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
+    qubits not actively involved in a gate operation.
+    """
+
+    def _single_qubit_moment_noise_ops(
+        self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]
+    ) -> tuple[list, list]:
+        """
+        Helper function to determine the noise operations for a single qubit moment.
+
+        :param moment: The current cirq.Moment being evaluated.
+        :param system_qubits: All qubits in the circuit.
+        :return: A tuple containing gate noise operations and move noise operations for the given moment.
+        """
+        # Check if the moment only contains single qubit gates
+        assert np.all([len(op.qubits) == 1 for op in moment.operations])
+        # Check if single qubit gate is global or local
+        gate_params = [
+            [op.gate.axis_phase_exponent, op.gate.x_exponent, op.gate.z_exponent]
+            for op in moment.operations
+        ]
+        gate_params = np.array(gate_params)
+
+        test_params = [
+            [
+                moment.operations[0].gate.axis_phase_exponent,
+                moment.operations[0].gate.x_exponent,
+                moment.operations[0].gate.z_exponent,
+            ]
+            for _ in moment.operations
+        ]
+        test_params = np.array(test_params)
+
+        gated_qubits = [
+            op.qubits[0]
+            for op in moment.operations
+            if not (
+                np.isclose(op.gate.x_exponent, 0) and np.isclose(op.gate.z_exponent, 0)
+            )
+        ]
+
+        is_global = np.all(np.isclose(gate_params, test_params)) and set(
+            gated_qubits
+        ) == set(system_qubits)
+
+        if is_global:
+            p_x = self.global_px
+            p_y = self.global_py
+            p_z = self.global_pz
+        else:
+            p_x = self.local_px
+            p_y = self.local_py
+            p_z = self.local_pz
+
+        if p_x == p_y == p_z:
+            gate_noise_op = cirq.depolarize(p_x + p_y + p_z).on_each(gated_qubits)
+        else:
+            gate_noise_op = cirq.asymmetric_depolarize(
+                p_x=p_x, p_y=p_y, p_z=p_z
+            ).on_each(gated_qubits)
+
+        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
+
+        # 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:
+            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.
+
+            # Add correlated noise channels for entangling pairs
+            two_qubit_pauli = self.two_qubit_pauli
+            gate_noise_ops = [
+                two_qubit_pauli.on_each([c, t])
+                for c, t in zip(control_qubits, target_qubits)
+            ]
+
+            # In this 1 zone scheme, all unpaired atoms are in the entangling zone.
+            idle_depolarize = cirq.asymmetric_depolarize(
+                *self.cz_unpaired_pauli_rates
+            ).on_each(idle_atoms)
+
+            gate_noise_ops.append(idle_depolarize)
+        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,
+        ]
+
+
+@dataclass(frozen=True)
+class GeminiOneZoneNoiseModelConflictGraphMoves(GeminiOneZoneNoiseModel):
+    """
+    A Cirq noise model that uses a conflict graph to schedule moves in a one-zone Gemini architecture.
+
+    Assumes that the qubits are cirq.GridQubits, such that the assignment of row, column coordinates define the initial
+    geometry. An SLM site at the two qubit interaction distance is also assumed next to each cirq.GridQubit to allow
+    for multiple moves before a single Rydberg pulse is applied for a parallel CZ.
+    """
+
+    max_parallel_movers: int = 10000
+
+    def noisy_moment(self, moment, system_qubits):
+        # Moment with original ops
+        original_moment = moment
+        assert np.all(
+            [isinstance(q, cirq.GridQubit) for q in system_qubits]
+        ), "Found a qubit that is not a GridQubit."
+        # Check if the moment is empty
+        if len(moment.operations) == 0:
+            move_moments = []
+            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, _ = self._single_qubit_moment_noise_ops(
+                moment, system_qubits
+            )
+            move_moments = []
+        elif len(moment.operations[0].qubits) == 2:
+            cg = OneZoneConflictGraph(moment)
+            schedule = cg.get_move_schedule(mover_limit=self.max_parallel_movers)
+            move_moments = []
+            for move_moment_idx, movers in schedule.items():
+                control_qubits = list(movers)
+                target_qubits = list(
+                    set(
+                        [op.qubits[0] for op in moment.operations]
+                        + [op.qubits[1] for op in moment.operations]
+                    )
+                    - movers
+                )
+                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
+                    ),
+                ]
+
+                move_moments.append(cirq.Moment(move_noise_ops))
+
+            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))
+
+            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."
+            )
+
+        gate_noise_moment = cirq.Moment(gate_noise_ops)
+
+        return [
+            *move_moments,
+            original_moment,
+            gate_noise_moment,
+            *(move_moments[::-1]),
+        ]
+
+
+@dataclass(frozen=True)
+class GeminiTwoZoneNoiseModel(GeminiNoiseModelABC):
+    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)
+
+        moments = list(moments)
+
+        if len(moments) == 0:
+            return []
+
+        nqubs = len(system_qubits)
+        noisy_moment_list = []
+
+        prev_moment: cirq.Moment | None = None
+
+        # TODO: clean up error getters so they return a list moments rather than circuits
+        for i in range(len(moments)):
+            noisy_moment_list.extend(
+                [
+                    moment
+                    for moment in _two_zone_utils.get_move_error_channel_two_zoned(
+                        moments[i],
+                        prev_moment,
+                        np.array(self.mover_pauli_rates),
+                        np.array(self.sitter_pauli_rates),
+                        nqubs,
+                    ).moments
+                    if len(moment) > 0
+                ]
+            )
+
+            noisy_moment_list.append(moments[i])
+
+            noisy_moment_list.extend(
+                [
+                    moment
+                    for moment in _two_zone_utils.get_gate_error_channel(
+                        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
+                        ),
+                        np.array(self.cz_unpaired_pauli_rates),
+                    ).moments
+                    if len(moment) > 0
+                ]
+            )
+
+            prev_moment = moments[i]
+
+        return noisy_moment_list

bloqade/cirq_utils/noise/transform.py

@@ -0,0 +1,57 @@
+import cirq
+
+from .model import GeminiOneZoneNoiseModel, GeminiOneZoneNoiseModelABC
+from ..parallelize import transpile, parallelize
+
+
+def transform_circuit(
+    circuit: cirq.Circuit,
+    to_native_gateset: bool = True,
+    model: cirq.NoiseModel | None = None,
+    parallelize_circuit: bool = False,
+) -> cirq.Circuit:
+    """Transform an input circuit into one with the native gateset with noise operations added.
+
+    Noise operations will be added to all qubits in circuit.all_qubits(), regardless of whether the output of the
+    circuit optimizers contain all the qubits.
+
+    Args:
+        circuit (cirq.Circuit): The input circuit.
+
+    Keyword Arguments:
+        to_native_gateset (bool): Whether or not to convert the input circuit to one using the native set of gates (`cirq.CZTargetGateset`)
+            only. Defaults to `True`. Note, that if you use an input circuit that has gates different from this gateset and don't convert it,
+            may lead to incorrect results and errors.
+        model (cirq.NoiseModel): The cirq noise model to apply to the circuit. Usually, you want to use one of the ones supplied in this submodule,
+            such as `GeminiOneZoneNoiseModel`.
+        parallelize_circuit (bool): Whether or not to parallelize the circuit as much as possible after it's been converted to the native gateset.
+            Defaults to `False`.
+
+    Returns:
+        cirq.Circuit:
+            The resulting noisy circuit.
+    """
+    if model is None:
+        model = GeminiOneZoneNoiseModel(parallelize_circuit=parallelize_circuit)
+
+    # only parallelize here if we aren't parallelizing inside a one-zone model
+    parallelize_circuit_here = parallelize_circuit and not isinstance(
+        model, GeminiOneZoneNoiseModelABC
+    )
+
+    system_qubits = sorted(circuit.all_qubits())
+    # Transform to CZ + PhasedXZ gateset.
+    if to_native_gateset and not parallelize_circuit_here:
+        native_circuit = transpile(circuit)
+    elif parallelize_circuit_here:
+        native_circuit = parallelize(circuit)
+    else:
+        native_circuit = circuit
+
+    # Add noise
+    noisy_circuit = cirq.Circuit()
+    for op_tree in model.noisy_moments(native_circuit, system_qubits):
+        # Keep moments aligned
+        noisy_circuit += cirq.Circuit(op_tree)
+
+    return noisy_circuit

bloqade/cirq_utils/parallelize.py

@@ -39,6 +39,8 @@ def transpile(circuit: cirq.Circuit) -> cirq.Circuit:
     """
     # Convert to CZ target gate set.
     circuit2 = cirq.optimize_for_target_gateset(circuit, gateset=cirq.CZTargetGateset())
+    circuit2 = cirq.drop_empty_moments(circuit2)
+
     missing_qubits = circuit.all_qubits() - circuit2.all_qubits()
 
     for qubit in missing_qubits:
@@ -374,9 +376,9 @@ def parallelize(
     """
     hyperparameters = _get_hyperparameters(hyperparameters)
 
+    # Transpile the circuit to a native CZ gate set.
+    transpiled_circuit = transpile(circuit)
     if auto_tag:
-        # Transpile the circuit to a native CZ gate set.
-        transpiled_circuit = transpile(circuit)
         # Annotate the circuit with topological information
         # to improve parallelization
         transpiled_circuit, group_weights = auto_similarity(

bloqade/qasm2/_qasm_loading.py

@@ -82,7 +82,7 @@ def loads(
         body=body,
     )
 
-    return ir.Method(
+    mt = ir.Method(
         mod=None,
         py_func=None,
         sym_name=kernel_name,
@@ -91,6 +91,9 @@ def loads(
         code=code,
     )
 
+    mt.verify()
+    return mt
+
 
 def loadfile(
     qasm_file: str | pathlib.Path,

bloqade/qasm2/parse/lowering.py

@@ -202,7 +202,13 @@ class QASM2(lowering.LoweringABC[ast.Node]):
 
             then_body = if_frame.curr_region
 
-        state.current_frame.push(scf.IfElse(cond, then_body=then_body))
+        # NOTE: create empty else body
+        else_body = ir.Block(stmts=[scf.Yield()])
+        else_body.args.append_from(types.Bool)
+
+        state.current_frame.push(
+            scf.IfElse(cond, then_body=then_body, else_body=else_body)
+        )
 
     def branch_next_if_not_terminated(self, frame: lowering.Frame):
         """Branch to the next block if the current block is not terminated.
@@ -381,6 +387,8 @@ class QASM2(lowering.LoweringABC[ast.Node]):
             QubitType for _ in node.qparams
         ]
 
+        self_name = node.name + "_self"
+
         with state.frame(
             stmts=node.body,
             finalize_next=False,
@@ -390,7 +398,7 @@ class QASM2(lowering.LoweringABC[ast.Node]):
                 types.Generic(
                     ir.Method, types.Tuple.where(tuple(arg_types)), types.NoneType
                 ),
-                name=node.name + "_self",
+                name=self_name,
             )
 
             for arg_type, arg_name in zip(arg_types, arg_names):
@@ -422,7 +430,7 @@ class QASM2(lowering.LoweringABC[ast.Node]):
             py_func=None,
             sym_name=node.name,
             dialects=self.dialects,
-            arg_names=[*node.cparams, *node.qparams],
+            arg_names=[self_name, *node.cparams, *node.qparams],
             code=gate_func,
         )
         state.current_frame.globals[node.name] = mt