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

cirq/testing/consistent_qasm_test.py

@@ -32,10 +32,10 @@ class Fixed(cirq.Operation):
         return self.unitary
 
     @property
-    def qubits(self):
-        return cirq.LineQubit.range(self.unitary.shape[0].bit_length() - 1)
+    def qubits(self) -> tuple[cirq.Qid, ...]:
+        return tuple(cirq.LineQubit.range(self.unitary.shape[0].bit_length() - 1))
 
-    def with_qubits(self, *new_qubits):
+    def with_qubits(self, *new_qubits) -> Fixed:
         raise NotImplementedError()
 
     def _qasm_(self, args: cirq.QasmArgs):

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/lin_alg_utils.py

@@ -28,7 +28,7 @@ if TYPE_CHECKING:
 
 def random_superposition(
     dim: int, *, random_state: cirq.RANDOM_STATE_OR_SEED_LIKE = None
-) -> np.ndarray:
+) -> np.ndarray[tuple[int], np.dtype[np.complex128]]:
     """Returns a random unit-length vector from the uniform distribution.
 
     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

cirq/transformers/_connected_component_test.py

@@ -0,0 +1,200 @@
+# 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.
+
+from __future__ import annotations
+
+import pytest
+
+import cirq
+from cirq.transformers._connected_component import (
+    ComponentSet,
+    ComponentWithCircuitOpSet,
+    ComponentWithOpsSet,
+)
+
+
+def _always_mergeable(_: cirq.Operation) -> bool:
+    return True
+
+
+def _never_mergeable(_: cirq.Operation) -> bool:
+    return False
+
+
+def _always_can_merge(_ops1: list[cirq.Operation], _ops2: list[cirq.Operation]) -> bool:
+    return True
+
+
+def _never_can_merge(_ops1: list[cirq.Operation], _ops2: list[cirq.Operation]) -> bool:
+    return False
+
+
+def _merge_as_first_operation(op1: cirq.Operation, _op2: cirq.Operation) -> cirq.Operation:
+    return op1
+
+
+def _merge_never_successful(op1: cirq.Operation, _op2: cirq.Operation) -> None:
+    return None
+
+
+def test_find_returns_itself_for_singleton():
+    cset = ComponentSet(_always_mergeable)
+
+    q = cirq.NamedQubit('x')
+    c = cset.new_component(op=cirq.X(q), moment_id=0)
+    assert cset.find(c) is c
+
+
+def test_merge_components():
+    cset = ComponentSet(_always_mergeable)
+
+    q = cirq.NamedQubit('x')
+    c = [cset.new_component(op=cirq.X(q), moment_id=i) for i in range(5)]
+    cset.merge(c[1], c[0])
+    cset.merge(c[2], c[1])
+    cset.merge(c[4], c[3])
+    cset.merge(c[3], c[0])
+
+    for i in range(5):
+        assert cset.find(c[i]) is cset.find(c[0])
+
+
+def test_merge_same_component():
+    cset = ComponentSet(_always_mergeable)
+
+    q = cirq.NamedQubit('x')
+    c = [cset.new_component(op=cirq.X(q), moment_id=i) for i in range(3)]
+    cset.merge(c[1], c[0])
+    cset.merge(c[2], c[1])
+
+    root = cset.find(c[0])
+
+    assert cset.merge(c[0], c[2]) is root
+
+
+def test_merge_returns_None_if_one_component_is_not_mergeable():
+    cset = ComponentSet(_always_mergeable)
+
+    q = cirq.NamedQubit('x')
+    c0 = cset.new_component(op=cirq.X(q), moment_id=0, is_mergeable=True)
+    c1 = cset.new_component(op=cirq.X(q), moment_id=1, is_mergeable=False)
+    assert cset.merge(c0, c1) is None
+
+
+def test_cset_merge_returns_None_if_is_mergeable_is_false():
+    q = cirq.NamedQubit('x')
+    cset = ComponentSet(is_mergeable=_never_mergeable)
+
+    c0 = cset.new_component(op=cirq.X(q), moment_id=0, is_mergeable=True)
+    c1 = cset.new_component(op=cirq.X(q), moment_id=1, is_mergeable=True)
+    assert cset.merge(c0, c1) is None
+
+
+@pytest.mark.parametrize("merge_left,expected_moment_id", [(True, 0), (False, 1)])
+def test_merge_qubits_with_merge_left(merge_left: bool, expected_moment_id: int) -> None:
+    cset = ComponentSet(_always_mergeable)
+
+    q0 = cirq.NamedQubit('x')
+    q1 = cirq.NamedQubit('y')
+    c0 = cset.new_component(op=cirq.X(q0), moment_id=0)
+    c1 = cset.new_component(op=cirq.X(q1), moment_id=1)
+    c2 = cset.new_component(op=cirq.X(q1), moment_id=2)
+    cset.merge(c1, c2)
+    cset.merge(c0, c1, merge_left=merge_left)
+    assert cset.find(c1).qubits == frozenset([q0, q1])
+    assert cset.find(c1).moment_id == expected_moment_id
+
+
+def test_component_with_ops_merge():
+    cset = ComponentWithOpsSet(_always_mergeable, _always_can_merge)
+
+    q = cirq.LineQubit.range(3)
+    ops = [cirq.X(q[i]) for i in range(3)]
+    c = [cset.new_component(op=ops[i], moment_id=i) for i in range(3)]
+    cset.merge(c[0], c[1])
+    cset.merge(c[1], c[2])
+    assert cset.find(c[0]).ops == ops
+    # check merge of indirectly merged components does not make a difference
+    assert cset.merge(c[0], c[2]).ops == ops
+
+
+def test_component_with_ops_merge_when_merge_fails():
+    cset = ComponentWithOpsSet(_always_mergeable, _never_can_merge)
+
+    q = cirq.LineQubit.range(3)
+    ops = [cirq.X(q[i]) for i in range(3)]
+    c = [cset.new_component(op=ops[i], moment_id=i) for i in range(3)]
+
+    cset.merge(c[0], c[1])
+    cset.merge(c[1], c[2])
+    # No merge happened
+    for i in range(3):
+        assert cset.find(c[i]) is c[i]
+
+
+def test_component_with_ops_merge_when_is_mergeable_is_false():
+    cset = ComponentWithOpsSet(_never_mergeable, _always_can_merge)
+
+    q = cirq.LineQubit.range(3)
+    ops = [cirq.X(q[i]) for i in range(3)]
+    c = [cset.new_component(op=ops[i], moment_id=i) for i in range(3)]
+
+    cset.merge(c[0], c[1])
+    cset.merge(c[1], c[2])
+    # No merge happened
+    for i in range(3):
+        assert cset.find(c[i]) is c[i]
+
+
+def test_component_with_circuit_op_merge():
+    cset = ComponentWithCircuitOpSet(_always_mergeable, _merge_as_first_operation)
+
+    q = cirq.LineQubit.range(3)
+    ops = [cirq.X(q[i]) for i in range(3)]
+    c = [cset.new_component(op=ops[i], moment_id=i) for i in range(3)]
+
+    cset.merge(c[0], c[1])
+    cset.merge(c[1], c[2])
+    for i in range(3):
+        assert cset.find(c[i]).circuit_op == ops[0]
+    # check merge of indirectly merged components does not make a difference
+    assert cset.merge(c[0], c[2]) is cset.find(c[1])
+
+
+def test_component_with_circuit_op_merge_func_is_none():
+    cset = ComponentWithCircuitOpSet(_always_mergeable, _merge_never_successful)
+
+    q = cirq.LineQubit.range(3)
+    ops = [cirq.X(q[i]) for i in range(3)]
+    c = [cset.new_component(op=ops[i], moment_id=i) for i in range(3)]
+
+    cset.merge(c[0], c[1])
+    cset.merge(c[1], c[2])
+    # No merge happened
+    for i in range(3):
+        assert cset.find(c[i]) is c[i]
+
+
+def test_component_with_circuit_op_merge_when_is_mergeable_is_false():
+    cset = ComponentWithCircuitOpSet(_never_mergeable, _merge_as_first_operation)
+
+    q = cirq.LineQubit.range(3)
+    ops = [cirq.X(q[i]) for i in range(3)]
+    c = [cset.new_component(op=ops[i], moment_id=i) for i in range(3)]
+
+    cset.merge(c[0], c[1])
+    cset.merge(c[1], c[2])
+    # No merge happened
+    for i in range(3):
+        assert cset.find(c[i]) is c[i]