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

cirq/__init__.py

@@ -509,6 +509,7 @@ from cirq.study import (
     flatten_with_sweep as flatten_with_sweep,
     ResultDict as ResultDict,
     Linspace as Linspace,
+    list_of_dicts_to_zip as list_of_dicts_to_zip,
     ListSweep as ListSweep,
     ParamDictType as ParamDictType,
     ParamMappingType as ParamMappingType,

cirq/_compat.py

@@ -20,15 +20,16 @@ import contextlib
 import contextvars
 import dataclasses
 import functools
-import importlib
+import importlib.util
 import inspect
 import os
 import re
 import sys
 import traceback
 import warnings
+from collections.abc import Callable, Iterator
 from types import ModuleType
-from typing import Any, Callable, Iterator, overload, TypeVar
+from typing import Any, overload, TypeVar
 
 import numpy as np
 import pandas as pd

cirq/_compat_test.py

@@ -25,9 +25,10 @@ import sys
 import traceback
 import types
 import warnings
+from collections.abc import Callable
 from importlib.machinery import ModuleSpec
 from types import ModuleType
-from typing import Any, Callable
+from typing import Any
 from unittest import mock
 
 import duet
@@ -159,7 +160,7 @@ def test_deprecated_with_name():
 
 
 def test_deprecated_with_property():
-    class AClass(object):
+    class AClass:
         def __init__(self, a):
             self.a = a
 
@@ -554,11 +555,11 @@ def _import_deprecated_same_name_in_earlier_subtree():
 
 
 def _import_top_level_deprecated():
-    import time
+    import numpy.random
 
-    from cirq.testing._compat_test_data.fake_freezegun import api  # type: ignore
+    from cirq.testing._compat_test_data.fake_numpy import random  # type: ignore
 
-    assert api.real_time == time.time
+    assert random.normal is numpy.random.normal
 
 
 def _repeated_import_path():
@@ -611,9 +612,9 @@ _fake_ops_deprecation_msg = [
 
 
 # see cirq_compat_test_data/__init__.py for the setup code
-_fake_freezegun_deprecation_msg = [
-    f'{old_parent}.fake_freezegun was used but is deprecated',
-    'Use freezegun instead',
+_fake_numpy_deprecation_msg = [
+    f'{old_parent}.fake_numpy was used but is deprecated',
+    'Use numpy instead',
 ] + _deprecation_origin
 
 # see cirq_compat_test_data/__init__.py for the setup code
@@ -686,7 +687,7 @@ def run_in_subprocess(test_func, *args):
         (_import_parent_use_constant_from_deprecated_module_attribute, [_fake_a_deprecation_msg]),
         (_import_deprecated_sub_use_constant, [_fake_a_deprecation_msg]),
         (_import_deprecated_same_name_in_earlier_subtree, [_fake_a_deprecation_msg]),
-        (_import_top_level_deprecated, [_fake_freezegun_deprecation_msg]),
+        (_import_top_level_deprecated, [_fake_numpy_deprecation_msg]),
         (_from_deprecated_import_sub_of_sub, [_fake_a_deprecation_msg]),
         (_repeated_import_path, [_repeated_child_deprecation_msg]),
         (_type_repr_in_deprecated_module, [_fake_a_deprecation_msg]),
@@ -746,7 +747,7 @@ def test_metadata_search_path():
     run_in_subprocess(_test_metadata_search_path_inner)
 
 
-def _test_metadata_search_path_inner():  # pragma: no cover
+def _test_metadata_search_path_inner():
     # initialize the DeprecatedModuleFinders
     assert importlib.metadata.metadata('numpy')
 
@@ -855,13 +856,13 @@ def test_new_module_is_top_level():
 
 
 def _test_new_module_is_top_level_inner():
-    # sets up the DeprecationFinders
-    import time
+    from numpy.random import normal
 
-    # imports a top level module that was also deprecated
-    from freezegun import api
+    # sets up the DeprecationFinders
+    import cirq.testing._compat_test_data  # noqa: F401
 
-    assert api.real_time == time.time
+    # imports a top level new module replacing deprecated module
+    assert normal is importlib.import_module('numpy').random.normal
 
 
 def test_import_deprecated_with_no_attribute():

cirq/_doc.py

@@ -15,12 +15,13 @@
 
 from __future__ import annotations
 
-from typing import Any
+from typing import TypeVar
 
+T = TypeVar('T')
 RECORDED_CONST_DOCS: dict[int, str] = {}
 
 
-def document(value: Any, doc_string: str = ''):
+def document(value: T, doc_string: str = '') -> T:
     """Stores documentation details about the given value.
 
     This method is used to associate a docstring with global constants. It is
@@ -64,7 +65,7 @@ def document(value: Any, doc_string: str = ''):
 _DOC_PRIVATE = "_tf_docs_doc_private"
 
 
-def doc_private(obj):
+def doc_private(obj: T) -> T:
     """A decorator: Generates docs for private methods/functions.
 
     For example:

cirq/_import.py

@@ -16,12 +16,13 @@ from __future__ import annotations
 
 import importlib
 import sys
+from collections.abc import Callable
 from contextlib import contextmanager
 from importlib import abc
 from importlib.abc import Loader
 from importlib.machinery import ModuleSpec
 from types import ModuleType
-from typing import Any, Callable, cast
+from typing import Any, cast
 
 
 class InstrumentedFinder(abc.MetaPathFinder):

cirq/_version.py

@@ -28,4 +28,4 @@ if sys.version_info < (3, 11, 0):  # pragma: no cover
         'of Cirq (e.g. "python -m pip install cirq==1.5.0")'
     )
 
-__version__ = "1.7.0.dev20250825174419"
+__version__ = "1.7.0.dev20251203004401"

cirq/_version_test.py

@@ -3,4 +3,4 @@ import cirq
 
 
 def test_version() -> None:
-    assert cirq.__version__ == "1.7.0.dev20250825174419"
+    assert cirq.__version__ == "1.7.0.dev20251203004401"

cirq/circuits/_bucket_priority_queue.py

@@ -14,7 +14,8 @@
 
 from __future__ import annotations
 
-from typing import Any, Generic, Iterable, Iterator, TypeVar
+from collections.abc import Iterable, Iterator
+from typing import Any, Generic, TypeVar
 
 TItem = TypeVar('TItem')
 

cirq/circuits/circuit.py

@@ -27,24 +27,18 @@ import html
 import itertools
 import math
 from collections import defaultdict
-from types import NotImplementedType
-from typing import (
-    AbstractSet,
-    Any,
+from collections.abc import (
     Callable,
-    cast,
     Hashable,
     Iterable,
     Iterator,
     Mapping,
     MutableSequence,
-    overload,
-    Self,
     Sequence,
-    TYPE_CHECKING,
-    TypeVar,
-    Union,
+    Set,
 )
+from types import NotImplementedType
+from typing import Any, cast, overload, Self, TYPE_CHECKING, TypeVar, Union
 
 import networkx
 import numpy as np
@@ -1341,7 +1335,7 @@ class AbstractCircuit(abc.ABC):
             protocols.is_parameterized(tag) for tag in self.tags
         )
 
-    def _parameter_names_(self) -> AbstractSet[str]:
+    def _parameter_names_(self) -> Set[str]:
         op_params = {name for op in self.all_operations() for name in protocols.parameter_names(op)}
         tag_params = {name for tag in self.tags for name in protocols.parameter_names(tag)}
         return op_params | tag_params
@@ -1666,8 +1660,14 @@ class AbstractCircuit(abc.ABC):
         )
 
     def _control_keys_(self) -> frozenset[cirq.MeasurementKey]:
-        controls = frozenset(k for op in self.all_operations() for k in protocols.control_keys(op))
-        return controls - protocols.measurement_key_objs(self)
+        measures: set[cirq.MeasurementKey] = set()
+        controls: set[cirq.MeasurementKey] = set()
+        for op in self.all_operations():
+            # Only require keys that haven't already been measured earlier
+            controls.update(k for k in protocols.control_keys(op) if k not in measures)
+            # Record any measurement keys produced by this op
+            measures.update(protocols.measurement_key_objs(op))
+        return frozenset(controls)
 
 
 def _overlap_collision_time(
@@ -1839,7 +1839,7 @@ class Circuit(AbstractCircuit):
         self._frozen: cirq.FrozenCircuit | None = None
         self._is_measurement: bool | None = None
         self._is_parameterized: bool | None = None
-        self._parameter_names: AbstractSet[str] | None = None
+        self._parameter_names: Set[str] | None = None
         if not contents:
             return
         flattened_contents = tuple(ops.flatten_to_ops_or_moments(contents))
@@ -1948,7 +1948,7 @@ class Circuit(AbstractCircuit):
             self._is_parameterized = super()._is_parameterized_()
         return self._is_parameterized
 
-    def _parameter_names_(self) -> AbstractSet[str]:
+    def _parameter_names_(self) -> Set[str]:
         if self._parameter_names is None:
             self._parameter_names = super()._parameter_names_()
         return self._parameter_names
@@ -3002,13 +3002,15 @@ def get_earliest_accommodating_moment_index(
     mop_index = last_conflict + 1
 
     # Update our dicts with data from this `mop` placement. Note `mop_index` will always be greater
-    # than the existing value for all of these, by construction.
+    # than the existing value for qubits and measurement keys, by construction.
     for qubit in mop_qubits:
         qubit_indices[qubit] = mop_index
     for key in mop_mkeys:
         mkey_indices[key] = mop_index
+    # For control keys, keep the maximum moment index seen so far because ops with the same control
+    # keys can commute past each other.
     for key in mop_ckeys:
-        ckey_indices[key] = mop_index
+        ckey_indices[key] = max(mop_index, ckey_indices.get(key, -1))
 
     return mop_index
 

cirq/circuits/circuit_operation.py

@@ -22,8 +22,9 @@ component operations in order, including any nested CircuitOperations.
 from __future__ import annotations
 
 import math
+from collections.abc import Callable, Iterator, Mapping, Sequence
 from functools import cached_property
-from typing import Any, Callable, cast, Iterator, Mapping, Sequence, TYPE_CHECKING, TypeAlias
+from typing import Any, cast, TYPE_CHECKING, TypeAlias
 
 import numpy as np
 import sympy

cirq/circuits/circuit_operation_test.py

@@ -1253,22 +1253,27 @@ def test_repeat_until_protocols() -> None:
     # Ensure the _repeat_until has been mapped, the measurement has been mapped to the same key,
     # and the control keys of the subcircuit is empty (because the control key of the condition is
     # bound to the measurement).
+    assert scoped._mapped_repeat_until is not None
     assert scoped._mapped_repeat_until.keys == (cirq.MeasurementKey('a', ('0',)),)
     assert cirq.measurement_key_objs(scoped) == {cirq.MeasurementKey('a', ('0',))}
     assert not cirq.control_keys(scoped)
     mapped = cirq.with_measurement_key_mapping(scoped, {'a': 'b'})
+    assert mapped._mapped_repeat_until is not None
     assert mapped._mapped_repeat_until.keys == (cirq.MeasurementKey('b', ('0',)),)
     assert cirq.measurement_key_objs(mapped) == {cirq.MeasurementKey('b', ('0',))}
     assert not cirq.control_keys(mapped)
     prefixed = cirq.with_key_path_prefix(mapped, ('1',))
+    assert prefixed._mapped_repeat_until is not None
     assert prefixed._mapped_repeat_until.keys == (cirq.MeasurementKey('b', ('1', '0')),)
     assert cirq.measurement_key_objs(prefixed) == {cirq.MeasurementKey('b', ('1', '0'))}
     assert not cirq.control_keys(prefixed)
     setpath = cirq.with_key_path(prefixed, ('2',))
+    assert setpath._mapped_repeat_until is not None
     assert setpath._mapped_repeat_until.keys == (cirq.MeasurementKey('b', ('2',)),)
     assert cirq.measurement_key_objs(setpath) == {cirq.MeasurementKey('b', ('2',))}
     assert not cirq.control_keys(setpath)
     resolved = cirq.resolve_parameters(setpath, {'p': 1})
+    assert resolved._mapped_repeat_until is not None
     assert resolved._mapped_repeat_until.keys == (cirq.MeasurementKey('b', ('2',)),)
     assert cirq.measurement_key_objs(resolved) == {cirq.MeasurementKey('b', ('2',))}
     assert not cirq.control_keys(resolved)
@@ -1324,3 +1329,17 @@ def test_has_unitary_protocol_returns_true_if_all_params_resolve() -> None:
     exp = sympy.Symbol('exp')
     op = cirq.CircuitOperation(cirq.FrozenCircuit(cirq.X(q) ** exp), param_resolver={exp: 0.5})
     assert protocols.has_unitary(op)
+
+
+def test_control_keys_respects_internal_measurement_order() -> None:
+    q = cirq.LineQubit(0)
+
+    # Control BEFORE measurement inside the subcircuit: external key required
+    fc_before = cirq.FrozenCircuit(cirq.X(q).with_classical_controls('a'), cirq.measure(q, key='a'))
+    op_before = cirq.CircuitOperation(fc_before)
+    assert cirq.control_keys(op_before) == {cirq.MeasurementKey('a')}
+
+    # Measurement BEFORE control inside the subcircuit: no external key required
+    fc_after = cirq.FrozenCircuit(cirq.measure(q, key='a'), cirq.X(q).with_classical_controls('a'))
+    op_after = cirq.CircuitOperation(fc_after)
+    assert cirq.control_keys(op_after) == set()

cirq/circuits/circuit_test.py

@@ -18,8 +18,8 @@ import itertools
 import os
 import time
 from collections import defaultdict
+from collections.abc import Iterator, Sequence
 from random import randint, random, randrange, sample
-from typing import Iterator, Sequence
 
 import numpy as np
 import pytest
@@ -208,6 +208,24 @@ def test_append_control_key() -> None:
     assert len(c) == 1
 
 
+def test_append_control_key_before_measure() -> None:
+    c = cirq.Circuit()
+    q1, q2 = cirq.LineQubit.range(2)
+    c.append(cirq.X(q1))
+    c.append(cirq.X(q1))
+    c.append(cirq.X(q1).with_classical_controls('a'))
+    c.append(cirq.X(q2).with_classical_controls('a'))
+    c.append(cirq.measure(q2, key='a'))
+    assert c == cirq.Circuit(
+        [
+            cirq.Moment(cirq.X(q1), cirq.X(q2).with_classical_controls('a')),
+            cirq.Moment(cirq.X(q1)),
+            cirq.Moment(cirq.X(q1).with_classical_controls('a')),
+            cirq.Moment(cirq.measure(q2, key='a')),
+        ]
+    )
+
+
 def test_append_multiple() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
@@ -338,20 +356,21 @@ def test_add_op_tree(circuit_cls) -> None:
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_radd_op_tree(circuit_cls) -> None:
+@pytest.mark.parametrize('gate', [cirq.X, cirq.H])
+def test_radd_op_tree(circuit_cls, gate) -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
 
     c = circuit_cls()
-    assert [cirq.X(a), cirq.Y(b)] + c == circuit_cls([cirq.Moment([cirq.X(a), cirq.Y(b)])])
+    assert [gate(a), cirq.Y(b)] + c == circuit_cls([cirq.Moment([gate(a), cirq.Y(b)])])
 
-    assert cirq.X(a) + c == circuit_cls(cirq.X(a))
-    assert [cirq.X(a)] + c == circuit_cls(cirq.X(a))
-    assert [[[cirq.X(a)], []]] + c == circuit_cls(cirq.X(a))
-    assert (cirq.X(a),) + c == circuit_cls(cirq.X(a))
-    assert (cirq.X(a) for _ in range(1)) + c == circuit_cls(cirq.X(a))
+    assert gate(a) + c == circuit_cls(gate(a))
+    assert [gate(a)] + c == circuit_cls(gate(a))
+    assert [[[gate(a)], []]] + c == circuit_cls(gate(a))
+    assert (gate(a),) + c == circuit_cls(gate(a))
+    assert (gate(a) for _ in range(1)) + c == circuit_cls(gate(a))
     with pytest.raises(AttributeError):
-        _ = cirq.X + c
+        _ = gate + c
     with pytest.raises(TypeError):
         _ = 0 + c
 
@@ -362,9 +381,9 @@ def test_radd_op_tree(circuit_cls) -> None:
     else:
         d = cirq.Circuit()
         d.append(cirq.Y(b))
-    assert [cirq.X(a)] + d == circuit_cls([cirq.Moment([cirq.X(a)]), cirq.Moment([cirq.Y(b)])])
-    assert cirq.Moment([cirq.X(a)]) + d == circuit_cls(
-        [cirq.Moment([cirq.X(a)]), cirq.Moment([cirq.Y(b)])]
+    assert [gate(a)] + d == circuit_cls([cirq.Moment([gate(a)]), cirq.Moment([cirq.Y(b)])])
+    assert cirq.Moment([gate(a)]) + d == circuit_cls(
+        [cirq.Moment([gate(a)]), cirq.Moment([cirq.Y(b)])]
     )
 
 

cirq/circuits/frozen_circuit.py

@@ -16,9 +16,10 @@
 
 from __future__ import annotations
 
+from collections.abc import Hashable, Iterable, Iterator, Sequence, Set
 from functools import cached_property
 from types import NotImplementedType
-from typing import AbstractSet, Hashable, Iterable, Iterator, Sequence, TYPE_CHECKING
+from typing import TYPE_CHECKING
 
 from cirq import _compat, protocols
 from cirq.circuits import AbstractCircuit, Alignment, Circuit
@@ -172,7 +173,7 @@ class FrozenCircuit(AbstractCircuit, protocols.SerializableByKey):
         return super()._is_parameterized_()
 
     @_compat.cached_method
-    def _parameter_names_(self) -> AbstractSet[str]:
+    def _parameter_names_(self) -> Set[str]:
         return super()._parameter_names_()
 
     def _measurement_key_names_(self) -> frozenset[str]:

cirq/circuits/moment.py

@@ -17,22 +17,10 @@
 from __future__ import annotations
 
 import itertools
+from collections.abc import Callable, Hashable, Iterable, Iterator, Mapping, Sequence, Set
 from functools import cached_property
 from types import NotImplementedType
-from typing import (
-    AbstractSet,
-    Any,
-    Callable,
-    cast,
-    Hashable,
-    Iterable,
-    Iterator,
-    Mapping,
-    overload,
-    Self,
-    Sequence,
-    TYPE_CHECKING,
-)
+from typing import Any, cast, overload, Self, TYPE_CHECKING
 
 import numpy as np
 
@@ -307,7 +295,7 @@ class Moment:
         return any(protocols.is_parameterized(op) for op in self)
 
     @_compat.cached_method()
-    def _parameter_names_(self) -> AbstractSet[str]:
+    def _parameter_names_(self) -> Set[str]:
         return {name for op in self for name in protocols.parameter_names(op)}
 
     def _resolve_parameters_(self, resolver: cirq.ParamResolver, recursive: bool) -> cirq.Moment:

cirq/circuits/optimization_pass.py

@@ -18,7 +18,8 @@ from __future__ import annotations
 
 import abc
 from collections import defaultdict
-from typing import Callable, cast, Iterable, Sequence, TYPE_CHECKING
+from collections.abc import Callable, Iterable, Sequence
+from typing import cast, TYPE_CHECKING
 
 from cirq import ops
 

cirq/circuits/qasm_output.py

@@ -17,11 +17,14 @@
 from __future__ import annotations
 
 import re
-from typing import Callable, Iterator, Sequence, TYPE_CHECKING
+from collections.abc import Callable, Iterator, Sequence, Set
+from typing import TYPE_CHECKING
 
 import numpy as np
+import sympy
 
 from cirq import linalg, ops, protocols, value
+from cirq._compat import proper_repr
 
 if TYPE_CHECKING:
     import cirq
@@ -29,7 +32,7 @@ if TYPE_CHECKING:
 
 @value.value_equality(approximate=True)
 class QasmUGate(ops.Gate):
-    def __init__(self, theta, phi, lmda) -> None:
+    def __init__(self, theta: cirq.TParamVal, phi: cirq.TParamVal, lmda: cirq.TParamVal) -> None:
         """A QASM gate representing any single qubit unitary with a series of
         three rotations, Z, Y, and Z.
 
@@ -40,9 +43,9 @@ class QasmUGate(ops.Gate):
             phi: Half turns to rotate about Z (applied last).
             lmda: Half turns to rotate about Z (applied first).
         """
-        self.lmda = lmda % 2
         self.theta = theta % 2
         self.phi = phi % 2
+        self.lmda = lmda % 2
 
     def _num_qubits_(self) -> int:
         return 1
@@ -53,7 +56,28 @@ class QasmUGate(ops.Gate):
         return QasmUGate(rotation / np.pi, post_phase / np.pi, pre_phase / np.pi)
 
     def _has_unitary_(self):
-        return True
+        return not self._is_parameterized_()
+
+    def _is_parameterized_(self) -> bool:
+        return (
+            protocols.is_parameterized(self.theta)
+            or protocols.is_parameterized(self.phi)
+            or protocols.is_parameterized(self.lmda)
+        )
+
+    def _parameter_names_(self) -> Set[str]:
+        return (
+            protocols.parameter_names(self.theta)
+            | protocols.parameter_names(self.phi)
+            | protocols.parameter_names(self.lmda)
+        )
+
+    def _resolve_parameters_(self, resolver: cirq.ParamResolver, recursive: bool) -> QasmUGate:
+        return QasmUGate(
+            protocols.resolve_parameters(self.theta, resolver, recursive),
+            protocols.resolve_parameters(self.phi, resolver, recursive),
+            protocols.resolve_parameters(self.lmda, resolver, recursive),
+        )
 
     def _qasm_(self, qubits: tuple[cirq.Qid, ...], args: cirq.QasmArgs) -> str:
         args.validate_version('2.0', '3.0')
@@ -68,17 +92,22 @@ class QasmUGate(ops.Gate):
     def __repr__(self) -> str:
         return (
             f'cirq.circuits.qasm_output.QasmUGate('
-            f'theta={self.theta!r}, '
-            f'phi={self.phi!r}, '
-            f'lmda={self.lmda})'
+            f'theta={proper_repr(self.theta)}, '
+            f'phi={proper_repr(self.phi)}, '
+            f'lmda={proper_repr(self.lmda)})'
         )
 
     def _decompose_(self, qubits):
+        def mul_pi(x):
+            return x * (sympy.pi if protocols.is_parameterized(x) else np.pi)
+
         q = qubits[0]
+        phase_correction_half_turns = (self.phi + self.lmda) / 2
         return [
-            ops.rz(self.lmda * np.pi).on(q),
-            ops.ry(self.theta * np.pi).on(q),
-            ops.rz(self.phi * np.pi).on(q),
+            ops.rz(mul_pi(self.lmda)).on(q),
+            ops.ry(mul_pi(self.theta)).on(q),
+            ops.rz(mul_pi(self.phi)).on(q),
+            ops.global_phase_operation(1j ** (2 * phase_correction_half_turns)),
         ]
 
     def _value_equality_values_(self):

cirq/circuits/qasm_output_test.py

@@ -19,6 +19,7 @@ import re
 
 import numpy as np
 import pytest
+import sympy
 
 import cirq
 from cirq.circuits.qasm_output import QasmTwoQubitGate, QasmUGate
@@ -29,6 +30,17 @@ def _make_qubits(n):
     return [cirq.NamedQubit(f'q{i}') for i in range(n)]
 
 
+def _qiskit_ugate_unitary(gate: QasmUGate) -> np.ndarray:
+    # Ref: https://quantum.cloud.ibm.com/docs/en/api/qiskit/qiskit.circuit.library.U3Gate#u3gate
+    th, ph, lm = np.pi * np.array([gate.theta, gate.phi, gate.lmda])
+    return np.array(
+        [
+            [np.cos(th / 2), -np.exp(1j * lm) * np.sin(th / 2)],
+            [np.exp(1j * ph) * np.sin(th / 2), np.exp(1j * (ph + lm)) * np.cos(th / 2)],
+        ]
+    )
+
+
 def test_u_gate_repr() -> None:
     gate = QasmUGate(0.1, 0.2, 0.3)
     assert repr(gate) == 'cirq.circuits.qasm_output.QasmUGate(theta=0.1, phi=0.2, lmda=0.3)'
@@ -43,6 +55,42 @@ def test_u_gate_eq() -> None:
     cirq.approx_eq(gate4, gate3, atol=1e-16)
 
 
+@pytest.mark.parametrize("_", range(10))
+def test_u_gate_from_qiskit_ugate_unitary(_) -> None:
+    # QasmUGate at (theta, phi, lmda) is the same as QasmUGate at
+    # (2 - theta, phi + 1, lmda + 1) and a global phase factor of -1.
+    # QasmUGate.from_matrix resolves theta at [0, 1] and ignores possible global
+    # phase.  To avoid phase discrepancy we limit theta to the [0, 1] interval.
+    theta = np.random.uniform(0, 1)
+    phi = np.random.uniform(0, 2)
+    lmda = np.random.uniform(0, 2)
+    u = _qiskit_ugate_unitary(QasmUGate(theta, phi, lmda))
+    g = QasmUGate.from_matrix(u)
+    np.testing.assert_allclose(cirq.unitary(g), u, atol=1e-7)
+
+
+def test_u_gate_params() -> None:
+    q = cirq.LineQubit(0)
+    a, b, c = sympy.symbols('a b c')
+    u_gate = QasmUGate(a, b, c)
+    assert u_gate == QasmUGate(a, b + 2, c - 2)
+    assert u_gate != QasmUGate(a, b + 1, c - 1)
+    assert cirq.is_parameterized(u_gate)
+    assert cirq.parameter_names(u_gate) == {'a', 'b', 'c'}
+    assert not cirq.has_unitary(u_gate)
+    cirq.testing.assert_equivalent_repr(u_gate)
+    cirq.testing.assert_implements_consistent_protocols(u_gate)
+    u_gate_caps = cirq.resolve_parameters(u_gate, {'a': 'A', 'b': 'B', 'c': 'C'})
+    assert u_gate_caps == QasmUGate(*sympy.symbols('A B C'))
+    resolver = {'A': 0.1, 'B': 2.2, 'C': -1.7}
+    resolved = cirq.resolve_parameters(u_gate_caps, resolver)
+    assert cirq.approx_eq(resolved, QasmUGate(0.1, 0.2, 0.3))
+    resolved_then_decomposed = cirq.decompose_once_with_qubits(resolved, [q])
+    decomposed = cirq.decompose_once_with_qubits(u_gate_caps, [q])
+    decomposed_then_resolved = [cirq.resolve_parameters(g, resolver) for g in decomposed]
+    assert resolved_then_decomposed == decomposed_then_resolved
+
+
 def test_qasm_two_qubit_gate_repr() -> None:
     cirq.testing.assert_equivalent_repr(
         QasmTwoQubitGate.from_matrix(cirq.testing.random_unitary(4))
@@ -53,13 +101,14 @@ def test_qasm_u_qubit_gate_unitary() -> None:
     u = cirq.testing.random_unitary(2)
     g = QasmUGate.from_matrix(u)
     cirq.testing.assert_allclose_up_to_global_phase(cirq.unitary(g), u, atol=1e-7)
-
     cirq.testing.assert_implements_consistent_protocols(g)
+    np.testing.assert_allclose(cirq.unitary(g), _qiskit_ugate_unitary(g), atol=1e-7)
 
     u = cirq.unitary(cirq.Y)
     g = QasmUGate.from_matrix(u)
     cirq.testing.assert_allclose_up_to_global_phase(cirq.unitary(g), u, atol=1e-7)
     cirq.testing.assert_implements_consistent_protocols(g)
+    np.testing.assert_allclose(cirq.unitary(g), _qiskit_ugate_unitary(g), atol=1e-7)
 
 
 def test_qasm_two_qubit_gate_unitary() -> None:
@@ -200,7 +249,7 @@ ry(pi*-0.25) q[0];
     )
 
 
-def test_qasm_global_pahse() -> None:
+def test_qasm_global_phase() -> None:
     output = cirq.QasmOutput((cirq.global_phase_operation(np.exp(1j * 5))), ())
     assert (
         str(output)

cirq/circuits/text_diagram_drawer.py

@@ -14,7 +14,8 @@
 
 from __future__ import annotations
 
-from typing import Any, Callable, cast, Iterable, Mapping, NamedTuple, Self, Sequence, TYPE_CHECKING
+from collections.abc import Callable, Iterable, Mapping, Sequence
+from typing import Any, cast, NamedTuple, Self, TYPE_CHECKING
 
 import numpy as np