cirq-core 1.7.0.dev20250924231107__py3-none-any.whl → 1.7.0.dev20251203004401__py3-none-any.whl

cirq/testing/consistent_controlled_gate_op.py

@@ -14,7 +14,7 @@
 
 from __future__ import annotations
 
-from typing import Collection, Sequence
+from collections.abc import Collection, Sequence
 
 import numpy as np
 

cirq/testing/consistent_controlled_gate_op_test.py

@@ -14,7 +14,8 @@
 
 from __future__ import annotations
 
-from typing import Collection, Sequence, TYPE_CHECKING
+from collections.abc import Collection, Sequence
+from typing import TYPE_CHECKING
 
 import numpy as np
 import pytest

cirq/testing/consistent_protocols.py

@@ -15,7 +15,8 @@
 from __future__ import annotations
 
 import itertools
-from typing import Any, Sequence
+from collections.abc import Sequence
+from typing import Any
 
 import numpy as np
 import sympy

cirq/testing/consistent_protocols_test.py

@@ -14,8 +14,8 @@
 
 from __future__ import annotations
 
+from collections.abc import Sequence, Set
 from types import NotImplementedType
-from typing import AbstractSet, Sequence
 
 import numpy as np
 import pytest
@@ -100,7 +100,7 @@ class GoodGate(cirq.testing.SingleQubitGate):
     def _is_parameterized_(self) -> bool:
         return cirq.is_parameterized(self.exponent) or cirq.is_parameterized(self.phase_exponent)
 
-    def _parameter_names_(self) -> AbstractSet[str]:
+    def _parameter_names_(self) -> Set[str]:
         return cirq.parameter_names(self.exponent) | cirq.parameter_names(self.phase_exponent)
 
     def _resolve_parameters_(self, resolver, recursive) -> GoodGate:
@@ -124,7 +124,7 @@ class BadGateIsParameterized(GoodGate):
 
 
 class BadGateParameterNames(GoodGate):
-    def _parameter_names_(self) -> AbstractSet[str]:
+    def _parameter_names_(self) -> Set[str]:
         return super()._parameter_names_() | {'not_a_param'}
 
 

cirq/testing/consistent_qasm.py

@@ -15,7 +15,8 @@
 from __future__ import annotations
 
 import warnings
-from typing import Any, Sequence
+from collections.abc import Sequence
+from typing import Any
 
 import numpy as np
 

cirq/testing/consistent_resolve_parameters.py

@@ -21,7 +21,7 @@ import sympy
 import cirq
 
 
-def assert_consistent_resolve_parameters(val: Any):
+def assert_consistent_resolve_parameters(val: Any) -> None:
     names = cirq.parameter_names(val)
     symbols = cirq.parameter_symbols(val)
 

cirq/testing/consistent_unitary.py

@@ -21,7 +21,7 @@ import numpy as np
 import cirq
 
 
-def assert_unitary_is_consistent(val: Any, ignoring_global_phase: bool = False):
+def assert_unitary_is_consistent(val: Any, ignoring_global_phase: bool = False) -> None:
     if not isinstance(val, (cirq.Operation, cirq.Gate)):
         return
 

cirq/testing/consistent_unitary_test.py

@@ -95,4 +95,4 @@ def test_failed_decomposition() -> None:
     with pytest.raises(ValueError):
         cirq.testing.assert_unitary_is_consistent(FailsOnDecompostion())
 
-    _ = cirq.testing.assert_unitary_is_consistent(cirq.Circuit())
+    cirq.testing.assert_unitary_is_consistent(cirq.Circuit())

cirq/testing/deprecation.py

@@ -17,7 +17,7 @@ from __future__ import annotations
 import contextlib
 import logging
 import os
-from typing import Iterator
+from collections.abc import Iterator
 
 from cirq._compat import ALLOW_DEPRECATION_IN_TEST
 

cirq/testing/devices.py

@@ -15,7 +15,8 @@
 """Provides test devices that can validate circuits."""
 from __future__ import annotations
 
-from typing import AbstractSet, cast
+from collections.abc import Set
+from typing import cast
 
 from cirq import devices, ops
 
@@ -38,7 +39,7 @@ class ValidatingTestDevice(devices.Device):
 
     def __init__(
         self,
-        qubits: AbstractSet[ops.Qid],
+        qubits: Set[ops.Qid],
         name: str = "ValidatingTestDevice",
         allowed_gates: tuple[type, ...] = (ops.Gate,),
         allowed_qubit_types: tuple[type, ...] = (devices.GridQubit,),

cirq/testing/equals_tester.py

@@ -24,7 +24,8 @@ from __future__ import annotations
 
 import collections
 import itertools
-from typing import Any, Callable
+from collections.abc import Callable
+from typing import Any
 
 
 class EqualsTester:
@@ -93,7 +94,7 @@ class EqualsTester:
                 "Common problem: returning NotImplementedError instead of NotImplemented. "
             )
 
-    def add_equality_group(self, *group_items: Any):
+    def add_equality_group(self, *group_items: Any) -> None:
         """Tries to add a disjoint equivalence group to the equality tester.
 
         This methods asserts that items within the group must all be equal to
@@ -114,7 +115,7 @@ class EqualsTester:
         # Remember this group, to enable disjoint checks vs later groups.
         self._groups.append(group_items)
 
-    def make_equality_group(self, *factories: Callable[[], Any]):
+    def make_equality_group(self, *factories: Callable[[], Any]) -> None:
         """Tries to add a disjoint equivalence group to the equality tester.
 
         Uses the factory methods to produce two different objects with the same

cirq/testing/equivalent_basis_map.py

@@ -14,7 +14,7 @@
 
 from __future__ import annotations
 
-from typing import Sequence
+from collections.abc import Sequence
 
 import numpy as np
 
@@ -22,7 +22,9 @@ import cirq
 from cirq import circuits
 
 
-def assert_equivalent_computational_basis_map(maps: dict[int, int], circuit: circuits.Circuit):
+def assert_equivalent_computational_basis_map(
+    maps: dict[int, int], circuit: circuits.Circuit
+) -> None:
     """Ensure equivalence of basis state mapping.
 
     Args:

cirq/testing/json.py

@@ -18,9 +18,10 @@ import dataclasses
 import inspect
 import io
 import pathlib
+from collections.abc import Iterator
 from dataclasses import dataclass
 from types import ModuleType
-from typing import Iterator, TYPE_CHECKING
+from typing import TYPE_CHECKING
 
 import numpy as np
 import pandas as pd
@@ -149,7 +150,7 @@ def spec_for(module_name: str) -> ModuleJsonTestSpec:
     return getattr(test_module, "TestSpec")
 
 
-def assert_json_roundtrip_works(obj, text_should_be=None, resolvers=None):
+def assert_json_roundtrip_works(obj, text_should_be=None, resolvers=None) -> None:
     """Tests that the given object can serialized and de-serialized
 
     Args:

cirq/testing/logs.py

@@ -18,7 +18,7 @@ from __future__ import annotations
 
 import contextlib
 import logging
-from typing import Iterator
+from collections.abc import Iterator
 
 
 @contextlib.contextmanager

cirq/testing/op_tree.py

@@ -17,7 +17,7 @@ from __future__ import annotations
 from cirq import ops
 
 
-def assert_equivalent_op_tree(x: ops.OP_TREE, y: ops.OP_TREE):
+def assert_equivalent_op_tree(x: ops.OP_TREE, y: ops.OP_TREE) -> None:
     """Ensures that the two OP_TREEs are equivalent.
 
     Args:

cirq/testing/order_tester.py

@@ -78,7 +78,7 @@ class OrderTester:
                 f"That rule is being violated by this value: {item!r}"
             ) from ex
 
-    def add_ascending(self, *items: Any):
+    def add_ascending(self, *items: Any) -> None:
         """Tries to add a sequence of ascending items to the order tester.
 
         This methods asserts that items must all be ascending
@@ -98,7 +98,7 @@ class OrderTester:
         for item in items:
             self.add_ascending_equivalence_group(item)
 
-    def add_ascending_equivalence_group(self, *group_items: Any):
+    def add_ascending_equivalence_group(self, *group_items: Any) -> None:
         """Tries to add an ascending equivalence group to the order tester.
 
         Asserts that the group items are equal to each other, but strictly

cirq/testing/pytest_utils.py

@@ -18,7 +18,8 @@ from __future__ import annotations
 
 import functools
 import warnings
-from typing import Any, Callable
+from collections.abc import Callable
+from typing import Any
 
 
 def retry_once_after_timeout(testfunc: Callable) -> Callable:

cirq/testing/random_circuit.py

@@ -14,7 +14,8 @@
 
 from __future__ import annotations
 
-from typing import Sequence, TYPE_CHECKING
+from collections.abc import Sequence
+from typing import TYPE_CHECKING
 
 from cirq import circuits, ops, value
 from cirq._doc import document

cirq/testing/random_circuit_test.py

@@ -15,7 +15,8 @@
 from __future__ import annotations
 
 import random
-from typing import cast, Sequence
+from collections.abc import Sequence
+from typing import cast
 
 import numpy as np
 import pytest

cirq/testing/repr_pretty_tester.py

@@ -34,11 +34,11 @@ class FakePrinter:
     def __init__(self):
         self.text_pretty = ""
 
-    def text(self, to_print):
+    def text(self, to_print) -> None:
         self.text_pretty += to_print
 
 
-def assert_repr_pretty(val: Any, text: str, cycle: bool = False):
+def assert_repr_pretty(val: Any, text: str, cycle: bool = False) -> None:
     """Assert that the given object has a `_repr_pretty_` method that produces the given text.
 
     Args:
@@ -57,7 +57,7 @@ def assert_repr_pretty(val: Any, text: str, cycle: bool = False):
     assert p.text_pretty == text, f"{p.text_pretty} != {text}"
 
 
-def assert_repr_pretty_contains(val: Any, substr: str, cycle: bool = False):
+def assert_repr_pretty_contains(val: Any, substr: str, cycle: bool = False) -> None:
     """Assert that the given object has a `_repr_pretty_` output that contains the given text.
 
     Args:

cirq/transformers/__init__.py

@@ -150,6 +150,7 @@ from cirq.transformers.gauge_compiling import (
     SpinInversionGaugeTransformer as SpinInversionGaugeTransformer,
     SqrtCZGaugeTransformer as SqrtCZGaugeTransformer,
     SqrtISWAPGaugeTransformer as SqrtISWAPGaugeTransformer,
+    CPhaseGaugeTransformerMM as CPhaseGaugeTransformerMM,
 )
 
 from cirq.transformers.randomized_measurements import (

cirq/transformers/_connected_component.py

@@ -0,0 +1,231 @@
+# Copyright 2025 The Cirq Developers
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Defines a connected component of operations, to be used in merge transformers."""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Sequence
+from typing import cast, TYPE_CHECKING
+
+from scipy.cluster.hierarchy import DisjointSet
+
+from cirq import ops, protocols
+
+if TYPE_CHECKING:
+    import cirq
+
+
+class Component:
+    """Internal representation for a connected component of operations."""
+
+    # Circuit moment containing the component
+    moment_id: int
+    # Union of all op qubits in the component
+    qubits: frozenset[cirq.Qid]
+    # Union of all measurement keys in the component
+    mkeys: frozenset[cirq.MeasurementKey]
+    # Union of all control keys in the component
+    ckeys: frozenset[cirq.MeasurementKey]
+    # Initial operation in the component
+    op: cirq.Operation
+
+    # True if the component can be merged with other components
+    is_mergeable: bool
+
+    def __init__(self, op: cirq.Operation, moment_id: int, is_mergeable=True):
+        """Initializes a singleton component."""
+        self.op = op
+        self.is_mergeable = is_mergeable
+        self.moment_id = moment_id
+        self.qubits = frozenset(op.qubits)
+        self.mkeys = protocols.measurement_key_objs(op)
+        self.ckeys = protocols.control_keys(op)
+
+
+class ComponentWithOps(Component):
+    """Component that keeps track of operations."""
+
+    # List of all operations in the component
+    ops: list[cirq.Operation]
+
+    def __init__(self, op: cirq.Operation, moment_id: int, is_mergeable=True):
+        super().__init__(op, moment_id, is_mergeable)
+        self.ops = [op]
+
+
+class ComponentWithCircuitOp(Component):
+    """Component that keeps track of operations as a CircuitOperation."""
+
+    # CircuitOperation containing all the operations in the component,
+    # or a single Operation if the component is a singleton
+    circuit_op: cirq.Operation
+
+    def __init__(self, op: cirq.Operation, moment_id: int, is_mergeable=True):
+        super().__init__(op, moment_id, is_mergeable)
+        self.circuit_op = op
+
+
+class ComponentSet:
+    """Represents a set of mergeable components of operations."""
+
+    _comp_type: type[Component]
+
+    _disjoint_set: DisjointSet
+
+    # Callable to decide if a component is mergeable
+    _is_mergeable: Callable[[cirq.Operation], bool]
+
+    # List of components in creation order
+    _components: list[Component]
+
+    def __init__(self, is_mergeable: Callable[[cirq.Operation], bool]):
+        self._is_mergeable = is_mergeable
+        self._disjoint_set = DisjointSet()
+        self._components = []
+        self._comp_type = Component
+
+    def new_component(self, op: cirq.Operation, moment_id: int, is_mergeable=True) -> Component:
+        """Creates a new component and adds it to the set."""
+        c = self._comp_type(op, moment_id, is_mergeable and self._is_mergeable(op))
+        self._disjoint_set.add(c)
+        self._components.append(c)
+        return c
+
+    def components(self) -> list[Component]:
+        """Returns the initial components in creation order."""
+        return self._components
+
+    def find(self, x: Component) -> Component:
+        """Finds the representative for a merged component."""
+        return self._disjoint_set[x]
+
+    def merge(self, x: Component, y: Component, merge_left=True) -> Component | None:
+        """Attempts to merge two components.
+
+        If merge_left is True, y is merged into x, and the representative will keep
+        y's moment. If merge_left is False, x is merged into y, and the representative
+        will keep y's moment.
+
+        Args:
+            x: First component to merge.
+            y: Second component to merge.
+            merge_left: True to keep x's moment for the merged component, False to
+                keep y's moment for the merged component.
+
+        Returns:
+            None, if the components can't be merged.
+            Otherwise the new component representative.
+        """
+        x = self._disjoint_set[x]
+        y = self._disjoint_set[y]
+
+        if not x.is_mergeable or not y.is_mergeable:
+            return None
+
+        if not self._disjoint_set.merge(x, y):
+            return x
+
+        root = self._disjoint_set[x]
+        root.moment_id = x.moment_id if merge_left else y.moment_id
+        root.qubits = x.qubits.union(y.qubits)
+        root.mkeys = x.mkeys.union(y.mkeys)
+        root.ckeys = x.ckeys.union(y.ckeys)
+
+        return root
+
+
+class ComponentWithOpsSet(ComponentSet):
+    """Represents a set of mergeable components, where each component tracks operations."""
+
+    # Callable that returns if two components can be merged based on their operations
+    _can_merge: Callable[[Sequence[cirq.Operation], Sequence[cirq.Operation]], bool]
+
+    def __init__(
+        self,
+        is_mergeable: Callable[[cirq.Operation], bool],
+        can_merge: Callable[[Sequence[cirq.Operation], Sequence[cirq.Operation]], bool],
+    ):
+        super().__init__(is_mergeable)
+        self._can_merge = can_merge
+        self._comp_type = ComponentWithOps
+
+    def merge(self, x: Component, y: Component, merge_left=True) -> Component | None:
+        """Attempts to merge two components.
+
+        Returns:
+            None if can_merge is False or the merge doesn't succeed, otherwise the
+                new representative. The representative will have ops = x.ops + y.ops.
+        """
+        x = cast(ComponentWithOps, self._disjoint_set[x])
+        y = cast(ComponentWithOps, self._disjoint_set[y])
+
+        if x is y:
+            return x
+
+        if not x.is_mergeable or not y.is_mergeable or not self._can_merge(x.ops, y.ops):
+            return None
+
+        root = cast(ComponentWithOps, super().merge(x, y, merge_left))
+        root.ops = x.ops + y.ops
+        # Clear the ops list in the non-representative component to avoid duplication
+        other = y if x is root else x
+        other.ops = []
+        return root
+
+
+class ComponentWithCircuitOpSet(ComponentSet):
+    """Represents a set of mergeable components, with operations as a CircuitOperation."""
+
+    # Callable that merges CircuitOperations from two components
+    _merge_func: Callable[[ops.Operation, ops.Operation], ops.Operation | None]
+
+    def __init__(
+        self,
+        is_mergeable: Callable[[cirq.Operation], bool],
+        merge_func: Callable[[ops.Operation, ops.Operation], ops.Operation | None],
+    ):
+        super().__init__(is_mergeable)
+        self._merge_func = merge_func
+        self._comp_type = ComponentWithCircuitOp
+
+    def merge(self, x: Component, y: Component, merge_left=True) -> Component | None:
+        """Attempts to merge two components.
+
+        Returns:
+            None if merge_func returns None or the merge doesn't succeed,
+                otherwise the new representative.
+        """
+        x = cast(ComponentWithCircuitOp, self._disjoint_set[x])
+        y = cast(ComponentWithCircuitOp, self._disjoint_set[y])
+
+        if x is y:
+            return x
+
+        if not x.is_mergeable or not y.is_mergeable:
+            return None
+
+        new_op = self._merge_func(x.circuit_op, y.circuit_op)
+        if not new_op:
+            return None
+
+        root = cast(ComponentWithCircuitOp, super().merge(x, y, merge_left))
+
+        root.circuit_op = new_op
+        # The merge_func can be arbitrary, so we need to recompute the component properties
+        root.qubits = frozenset(new_op.qubits)
+        root.mkeys = protocols.measurement_key_objs(new_op)
+        root.ckeys = protocols.control_keys(new_op)
+
+        return root