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

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,53 @@ 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):
+        is_ambiguous = (
+            self.cz_paired_correlated_rates is not None
+            and self.cz_paired_error_probabilities is not None
+        )
+        if is_ambiguous:
+            raise ValueError(
+                "Received both `cz_paired_correlated_rates` and `cz_paired_error_probabilities` as input. This is ambiguous, please only set one."
+            )
+
+        use_default = (
+            self.cz_paired_correlated_rates is None
+            and self.cz_paired_error_probabilities is None
+        )
+        if use_default:
+            # NOTE: no input, set to default value; weird setattr for frozen dataclass
+            object.__setattr__(
+                self,
+                "cz_paired_error_probabilities",
+                _default_cz_paired_correlated_rates(),
+            )
+            return
+
+        if self.cz_paired_correlated_rates is not 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),
+            )
+            return
+
+        assert (
+            self.cz_paired_error_probabilities is not None
+        ), "This error should not happen! Please report this issue."
+
     @staticmethod
     def validate_moments(moments: Iterable[cirq.Moment]):
         allowed_target_gates: frozenset[cirq.GateFamily] = cirq.CZTargetGateset().gates
@@ -81,72 +155,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 +241,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 +300,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):
@@ -407,9 +363,10 @@ class GeminiOneZoneNoiseModelConflictGraphMoves(GeminiOneZoneNoiseModel):
     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."
+        assert np.all([isinstance(q, cirq.GridQubit) for q in system_qubits]), (
+            "Found a qubit that is not a GridQubit. In order for the conflict graph to know the qubit geometry, "
+            "all qubits in the circuit must be defined as cirq.GridQubit objects."
+        )
         # Check if the moment is empty
         if len(moment.operations) == 0:
             move_moments = []
@@ -452,14 +409,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 +491,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/cirq_utils/parallelize.py

@@ -136,7 +136,7 @@ def auto_similarity(
     return cirq.Circuit(flattened_circuit), weights
 
 
-def no_similarity(circuit: cirq.Circuit) -> cirq.Circuit:
+def remove_tags(circuit: cirq.Circuit) -> cirq.Circuit:
     """
     Removes all tags from the circuit
 
@@ -146,10 +146,11 @@ def no_similarity(circuit: cirq.Circuit) -> cirq.Circuit:
     Returns:
     [0] - cirq.Circuit - the circuit with all tags removed.
     """
-    new_moments = []
-    for moment in circuit.moments:
-        new_moments.append([gate.untagged for gate in moment.operations])
-    return cirq.Circuit(new_moments)
+
+    def remove_tag(op: cirq.Operation, _):
+        return op.untagged
+
+    return cirq.map_operations(circuit, remove_tag)
 
 
 def to_dag_circuit(circuit: cirq.Circuit, can_reorder=None) -> nx.DiGraph:
@@ -399,4 +400,6 @@ def parallelize(
     )
     # Convert the epochs to a cirq circuit.
     moments = map(cirq.Moment, epochs)
-    return cirq.Circuit(moments)
+    circuit = cirq.Circuit(moments)
+
+    return remove_tags(circuit)

bloqade/gemini/__init__.py

@@ -0,0 +1 @@
+from .groups import logical as logical

bloqade/gemini/analysis/__init__.py

@@ -0,0 +1,3 @@
+from .logical_validation.analysis import (
+    GeminiLogicalValidationAnalysis as GeminiLogicalValidationAnalysis,
+)

bloqade/gemini/analysis/logical_validation/__init__.py

@@ -0,0 +1 @@
+from . import impls as impls, analysis as analysis  # NOTE: register methods

bloqade/gemini/analysis/logical_validation/analysis.py

@@ -0,0 +1,17 @@
+from kirin import ir
+
+from bloqade import squin
+from bloqade.validation.analysis import ValidationFrame, ValidationAnalysis
+
+
+class GeminiLogicalValidationAnalysis(ValidationAnalysis):
+    keys = ["gemini.validate.logical"]
+
+    first_gate = True
+
+    def eval_fallback(self, frame: ValidationFrame, node: ir.Statement):
+        if isinstance(node, squin.gate.stmts.Gate):
+            # NOTE: to validate that only the first encountered gate can be non-Clifford, we need to track this here
+            self.first_gate = False
+
+        return super().eval_fallback(frame, node)

bloqade/gemini/analysis/logical_validation/impls.py

@@ -0,0 +1,101 @@
+from kirin import ir, interp as _interp
+from kirin.analysis import const
+from kirin.dialects import scf, func
+
+from bloqade.squin import gate
+from bloqade.validation.analysis import ValidationFrame
+from bloqade.validation.analysis.lattice import Error
+
+from .analysis import GeminiLogicalValidationAnalysis
+
+
+@scf.dialect.register(key="gemini.validate.logical")
+class __ScfGeminiLogicalValidation(_interp.MethodTable):
+
+    @_interp.impl(scf.IfElse)
+    def if_else(
+        self,
+        interp: GeminiLogicalValidationAnalysis,
+        frame: ValidationFrame,
+        stmt: scf.IfElse,
+    ):
+        frame.errors.append(
+            ir.ValidationError(
+                stmt, "If statements are not supported in logical Gemini programs!"
+            )
+        )
+        return (
+            Error(
+                message="If statements are not supported in logical Gemini programs!"
+            ),
+        )
+
+    @_interp.impl(scf.For)
+    def for_loop(
+        self,
+        interp: GeminiLogicalValidationAnalysis,
+        frame: ValidationFrame,
+        stmt: scf.For,
+    ):
+        if isinstance(stmt.iterable.hints.get("const"), const.Value):
+            return (interp.lattice.top(),)
+
+        frame.errors.append(
+            ir.ValidationError(
+                stmt,
+                "Non-constant iterable in for loop is not supported in Gemini logical programs!",
+            )
+        )
+
+        return (
+            Error(
+                message="Non-constant iterable in for loop is not supported in Gemini logical programs!"
+            ),
+        )
+
+
+@func.dialect.register(key="gemini.validate.logical")
+class __FuncGeminiLogicalValidation(_interp.MethodTable):
+    @_interp.impl(func.Invoke)
+    def invoke(
+        self,
+        interp: GeminiLogicalValidationAnalysis,
+        frame: ValidationFrame,
+        stmt: func.Invoke,
+    ):
+        frame.errors.append(
+            ir.ValidationError(
+                stmt,
+                "Function invocations not supported in logical Gemini program!",
+                help="Make sure to decorate your function with `@logical(inline = True)` or `@logical(aggressive_unroll = True)` to inline function calls",
+            )
+        )
+
+        return tuple(
+            Error(
+                message="Function invocations not supported in logical Gemini program!"
+            )
+            for _ in stmt.results
+        )
+
+
+@gate.dialect.register(key="gemini.validate.logical")
+class __GateGeminiLogicalValidation(_interp.MethodTable):
+    @_interp.impl(gate.stmts.U3)
+    def u3(
+        self,
+        interp: GeminiLogicalValidationAnalysis,
+        frame: ValidationFrame,
+        stmt: gate.stmts.U3,
+    ):
+        if interp.first_gate:
+            interp.first_gate = False
+            return ()
+
+        frame.errors.append(
+            ir.ValidationError(
+                stmt,
+                "U3 gate can only be used for initial state preparation, i.e. as the first gate!",
+            )
+        )
+        return ()