cirq-core 1.4.0.dev20240529225110__py3-none-any.whl → 1.5.0__py3-none-any.whl

cirq/ops/dense_pauli_string.py

@@ -14,6 +14,7 @@
 
 import abc
 import numbers
+from types import NotImplementedType
 from typing import (
     AbstractSet,
     Any,
@@ -30,15 +31,14 @@ from typing import (
     TYPE_CHECKING,
     Union,
 )
-from typing_extensions import Self
 
 import numpy as np
 import sympy
+from typing_extensions import Self
 
-from cirq import protocols, linalg, value
+from cirq import linalg, protocols, value
 from cirq._compat import proper_repr
-from cirq.ops import raw_types, identity, pauli_gates, global_phase_op, pauli_string
-from cirq.type_workarounds import NotImplementedType
+from cirq.ops import global_phase_op, identity, pauli_gates, pauli_string, raw_types
 
 if TYPE_CHECKING:
     import cirq
@@ -116,7 +116,7 @@ class BaseDensePauliString(raw_types.Gate, metaclass=abc.ABCMeta):
         return self._pauli_mask
 
     @property
-    def coefficient(self) -> Union[sympy.Expr, complex]:
+    def coefficient(self) -> 'cirq.TParamValComplex':
         """A complex coefficient or symbol."""
         return self._coefficient
 
@@ -203,7 +203,7 @@ class BaseDensePauliString(raw_types.Gate, metaclass=abc.ABCMeta):
     def __pos__(self):
         return self
 
-    def __pow__(self, power: Union[int, float]) -> Union[NotImplementedType, Self]:
+    def __pow__(self, power: float) -> Union[NotImplementedType, Self]:
         concrete_class = type(self)
         if isinstance(power, int):
             i_group = [1, +1j, -1, -1j]
@@ -359,7 +359,7 @@ class BaseDensePauliString(raw_types.Gate, metaclass=abc.ABCMeta):
             coef = '+'
         elif self.coefficient == -1:
             coef = '-'
-        elif isinstance(self.coefficient, (complex, sympy.Symbol)):
+        elif isinstance(self.coefficient, (numbers.Complex, sympy.Symbol)):
             coef = f'{self.coefficient}*'
         else:
             coef = f'({self.coefficient})*'
@@ -403,7 +403,7 @@ class BaseDensePauliString(raw_types.Gate, metaclass=abc.ABCMeta):
     @abc.abstractmethod
     def copy(
         self,
-        coefficient: Optional[Union[sympy.Expr, int, float, complex]] = None,
+        coefficient: Optional['cirq.TParamValComplex'] = None,
         pauli_mask: Union[None, str, Iterable[int], np.ndarray] = None,
     ) -> Self:
         """Returns a copy with possibly modified contents.
@@ -459,7 +459,7 @@ class DensePauliString(BaseDensePauliString):
 
     def copy(
         self,
-        coefficient: Optional[Union[sympy.Expr, int, float, complex]] = None,
+        coefficient: Optional['cirq.TParamValComplex'] = None,
         pauli_mask: Union[None, str, Iterable[int], np.ndarray] = None,
     ) -> 'DensePauliString':
         if pauli_mask is None and (coefficient is None or coefficient == self.coefficient):
@@ -559,7 +559,7 @@ class MutableDensePauliString(BaseDensePauliString):
 
     def copy(
         self,
-        coefficient: Optional[Union[sympy.Expr, int, float, complex]] = None,
+        coefficient: Optional['cirq.TParamValComplex'] = None,
         pauli_mask: Union[None, str, Iterable[int], np.ndarray] = None,
     ) -> 'MutableDensePauliString':
         return MutableDensePauliString(
@@ -627,7 +627,7 @@ def _attempt_value_to_pauli_index(v: 'cirq.Operation') -> Optional[Tuple[int, in
         return None
 
     if not isinstance(v.gate, pauli_gates.Pauli):
-        return None
+        return None  # pragma: no cover
 
     q = v.qubits[0]
     from cirq import devices

cirq/ops/diagonal_gate.py

@@ -36,7 +36,7 @@ import sympy
 
 from cirq import protocols, value
 from cirq._compat import proper_repr
-from cirq.ops import common_gates, raw_types, global_phase_op
+from cirq.ops import common_gates, global_phase_op, raw_types
 
 if TYPE_CHECKING:
     import cirq
@@ -166,7 +166,7 @@ class DiagonalGate(raw_types.Gate):
         self, index: int, bit_flip: int, theta: 'cirq.TParamVal', qubits: Sequence['cirq.Qid']
     ) -> Iterator[Union['cirq.ZPowGate', 'cirq.CXPowGate']]:
         if index == 0:
-            return []
+            return
         largest_digit = self._num_qubits_() - (len(bin(index)) - 2)
         yield common_gates.rz(2 * theta)(qubits[largest_digit])
         _flip_bit = self._num_qubits_() - bit_flip - 1

cirq/ops/diagonal_gate_test.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 
 from typing import List
+
 import numpy as np
 import pytest
 import sympy

cirq/ops/eigen_gate.py

@@ -15,6 +15,7 @@ import abc
 import fractions
 import math
 import numbers
+from types import NotImplementedType
 from typing import (
     AbstractSet,
     Any,
@@ -32,10 +33,8 @@ from typing import (
 import numpy as np
 import sympy
 
-from cirq import value, protocols
-from cirq.linalg import tolerance
+from cirq import protocols, value
 from cirq.ops import raw_types
-from cirq.type_workarounds import NotImplementedType
 
 if TYPE_CHECKING:
     import cirq
@@ -122,7 +121,6 @@ class EigenGate(raw_types.Gate):
             exponent = exponent.real
         self._exponent = exponent
         self._global_shift = global_shift
-        self._canonical_exponent_cached = None
 
     @property
     def exponent(self) -> value.TParamVal:
@@ -302,29 +300,22 @@ class EigenGate(raw_types.Gate):
     def __pow__(self, exponent: Union[float, sympy.Symbol]) -> 'EigenGate':
         new_exponent = protocols.mul(self._exponent, exponent, NotImplemented)
         if new_exponent is NotImplemented:
-            return NotImplemented
+            return NotImplemented  # pragma: no cover
         return self._with_exponent(exponent=new_exponent)
 
-    @property
-    def _canonical_exponent(self):
-        if self._canonical_exponent_cached is None:
-            period = self._period()
-            if not period or protocols.is_parameterized(self._exponent):
-                self._canonical_exponent_cached = self._exponent
-            else:
-                self._canonical_exponent_cached = self._exponent % period
-        return self._canonical_exponent_cached
-
     def _value_equality_values_(self):
-        return self._canonical_exponent, self._global_shift
+        """The phases by which we multiply the eigenspaces.
 
-    def _value_equality_approximate_values_(self):
-        period = self._period()
-        if not period or protocols.is_parameterized(self._exponent):
-            exponent = self._exponent
-        else:
-            exponent = value.PeriodicValue(self._exponent, period)
-        return exponent, self._global_shift
+        The default implementation assumes that the eigenspaces are constant
+        for the class, and the eigenphases are the only distinguishing
+        characteristics. For gates whose eigenspaces can change, such as
+        `PhasedISwapPowGate`, this must be overridden to provide the additional
+        fields that affect the eigenspaces.
+        """
+        symbolic = lambda x: isinstance(x, sympy.Expr) and x.free_symbols
+        f = lambda x: x if symbolic(x) else float(x)
+        shifts = (f(self._exponent) * f(self._global_shift + e) for e in self._eigen_shifts())
+        return tuple(s if symbolic(s) else value.PeriodicValue(f(s), 2) for s in shifts)
 
     def _trace_distance_bound_(self) -> Optional[float]:
         if protocols.is_parameterized(self._exponent):
@@ -355,7 +346,7 @@ class EigenGate(raw_types.Gate):
 
     def _resolve_parameters_(self, resolver: 'cirq.ParamResolver', recursive: bool) -> 'EigenGate':
         exponent = resolver.value_of(self._exponent, recursive)
-        if isinstance(exponent, (complex, numbers.Complex)):
+        if isinstance(exponent, numbers.Complex):
             if isinstance(exponent, numbers.Real):
                 exponent = float(exponent)
             else:
@@ -374,20 +365,9 @@ class EigenGate(raw_types.Gate):
             return False
         self_without_phase = self._with_exponent(self.exponent)
         self_without_phase._global_shift = 0
-        self_without_exp_or_phase = self_without_phase._with_exponent(0)
-        self_without_exp_or_phase._global_shift = 0
         other_without_phase = other._with_exponent(other.exponent)
         other_without_phase._global_shift = 0
-        other_without_exp_or_phase = other_without_phase._with_exponent(0)
-        other_without_exp_or_phase._global_shift = 0
-        if not protocols.approx_eq(
-            self_without_exp_or_phase, other_without_exp_or_phase, atol=atol
-        ):
-            return False
-
-        period = self_without_phase._period()
-        exponents_diff = exponents[0] - exponents[1]
-        return tolerance.near_zero_mod(exponents_diff, period, atol=atol)
+        return protocols.approx_eq(self_without_phase, other_without_phase, atol=atol)
 
     def _json_dict_(self) -> Dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ['exponent', 'global_shift'])

cirq/ops/eigen_gate_test.py

@@ -13,7 +13,6 @@
 # limitations under the License.
 
 from typing import List, Tuple
-import re
 
 import numpy as np
 import pytest
@@ -50,7 +49,7 @@ class CExpZinGate(cirq.EigenGate, cirq.testing.TwoQubitGate):
         ]
 
 
-class ZGateDef(cirq.EigenGate, cirq.testing.TwoQubitGate):
+class ZGateDef(cirq.EigenGate, cirq.testing.SingleQubitGate):
     @property
     def exponent(self):
         return self._exponent
@@ -97,7 +96,6 @@ def test_eq():
     eq.make_equality_group(lambda: CExpZinGate(quarter_turns=0.1))
     eq.add_equality_group(CExpZinGate(0), CExpZinGate(4), CExpZinGate(-4))
 
-    # Equates by canonicalized period.
     eq.add_equality_group(CExpZinGate(1.5), CExpZinGate(41.5))
     eq.add_equality_group(CExpZinGate(3.5), CExpZinGate(-0.5))
 
@@ -109,6 +107,64 @@ def test_eq():
     eq.add_equality_group(ZGateDef(exponent=0.5, global_shift=0.5))
     eq.add_equality_group(ZGateDef(exponent=1.0, global_shift=0.5))
 
+    # All variants of (0,0) == (0*a,0*a) == (0, 2) == (2, 2)
+    a, b = sympy.symbols('a, b')
+    eq.add_equality_group(
+        WeightedZPowGate(0),
+        WeightedZPowGate(0) ** 1.1,
+        WeightedZPowGate(0) ** a,
+        (WeightedZPowGate(0) ** a) ** 1.2,
+        WeightedZPowGate(0) ** (a + 1.3),
+        WeightedZPowGate(0) ** b,
+        WeightedZPowGate(1) ** 2,
+        WeightedZPowGate(0, global_shift=1) ** 2,
+        WeightedZPowGate(1, global_shift=1) ** 2,
+        WeightedZPowGate(2),
+        WeightedZPowGate(0, global_shift=2),
+        WeightedZPowGate(2, global_shift=2),
+    )
+    # WeightedZPowGate(2) is identity, but non-integer exponent would make it different, similar to
+    # how we treat (X**2)**0.5==X. So these are in their own equality group. (0, 2*a)
+    eq.add_equality_group(
+        WeightedZPowGate(2) ** a,
+        (WeightedZPowGate(1) ** 2) ** a,
+        (WeightedZPowGate(1) ** a) ** 2,
+        WeightedZPowGate(1) ** (a * 2),
+        WeightedZPowGate(1) ** (a + a),
+    )
+    # Similarly, these are identity without the exponent, but global_shift affects both phases
+    # instead of just the one, so will have a different effect from the above depending on the
+    # exponent. (2*a, 0)
+    eq.add_equality_group(
+        WeightedZPowGate(0, global_shift=2) ** a,
+        (WeightedZPowGate(0, global_shift=1) ** 2) ** a,
+        (WeightedZPowGate(0, global_shift=1) ** a) ** 2,
+        WeightedZPowGate(0, global_shift=1) ** (a * 2),
+        WeightedZPowGate(0, global_shift=1) ** (a + a),
+    )
+    # Symbolic exponents that cancel (0, 1) == (0, a/a)
+    eq.add_equality_group(
+        WeightedZPowGate(1),
+        WeightedZPowGate(a) ** (1 / a),
+        WeightedZPowGate(b) ** (1 / b),
+        WeightedZPowGate(1 / a) ** a,
+        WeightedZPowGate(1 / b) ** b,
+    )
+    # Symbol in one phase and constant off by period in another (0, a) == (2, a)
+    eq.add_equality_group(
+        WeightedZPowGate(a),
+        WeightedZPowGate(a - 2, global_shift=2),
+        WeightedZPowGate(1 - 2 / a, global_shift=2 / a) ** a,
+    )
+    # Different symbol, different equality group (0, b)
+    eq.add_equality_group(WeightedZPowGate(b))
+    # Various number types
+    eq.add_equality_group(
+        WeightedZPowGate(np.int64(3), global_shift=sympy.Number(5)) ** 7.0,
+        WeightedZPowGate(sympy.Number(3), global_shift=5.0) ** np.int64(7),
+        WeightedZPowGate(3.0, global_shift=np.int64(5)) ** sympy.Number(7),
+    )
+
 
 def test_approx_eq():
     assert cirq.approx_eq(CExpZinGate(1.5), CExpZinGate(1.5), atol=0.1)
@@ -118,8 +174,7 @@ def test_approx_eq():
     assert cirq.approx_eq(ZGateDef(exponent=1.5), ZGateDef(exponent=1.5), atol=0.1)
     assert not cirq.approx_eq(CExpZinGate(1.5), ZGateDef(exponent=1.5), atol=0.1)
     with pytest.raises(
-        TypeError,
-        match=re.escape("unsupported operand type(s) for -: 'Symbol' and 'PeriodicValue'"),
+        TypeError, match="unsupported operand type\\(s\\) for -: '.*' and 'PeriodicValue'"
     ):
         cirq.approx_eq(ZGateDef(exponent=1.5), ZGateDef(exponent=sympy.Symbol('a')), atol=0.1)
     assert cirq.approx_eq(CExpZinGate(sympy.Symbol('a')), CExpZinGate(sympy.Symbol('a')), atol=0.1)
@@ -333,11 +388,6 @@ class WeightedZPowGate(cirq.EigenGate, cirq.testing.SingleQubitGate):
         self.weight = weight
         super().__init__(**kwargs)
 
-    def _value_equality_values_(self):
-        return self.weight, self._canonical_exponent, self._global_shift
-
-    _value_equality_approximate_values_ = _value_equality_values_
-
     def _eigen_components(self) -> List[Tuple[float, np.ndarray]]:
         return [(0, np.diag([1, 0])), (self.weight, np.diag([0, 1]))]
 

cirq/ops/fourier_transform.py

@@ -18,7 +18,7 @@ import numpy as np
 import sympy
 
 import cirq
-from cirq import value, _compat
+from cirq import _compat, value
 from cirq.ops import raw_types
 
 
@@ -170,8 +170,6 @@ class PhaseGradientGate(raw_types.Gate):
         self, resolver: 'cirq.ParamResolver', recursive: bool
     ) -> 'PhaseGradientGate':
         new_exponent = cirq.resolve_parameters(self.exponent, resolver, recursive)
-        if new_exponent is self.exponent:
-            return self
         return PhaseGradientGate(num_qubits=self._num_qubits, exponent=new_exponent)
 
     def __str__(self) -> str:

cirq/ops/fourier_transform_test.py

@@ -13,7 +13,8 @@
 # limitations under the License.
 
 import numpy as np
-import pytest, sympy
+import pytest
+import sympy
 
 import cirq
 

cirq/ops/fsim_gate.py

@@ -23,7 +23,7 @@ applies more generally to fermions, thus the name of the gate.
 
 import cmath
 import math
-from typing import AbstractSet, Any, Dict, Optional, Tuple
+from typing import AbstractSet, Any, Dict, Iterator, Optional, Tuple
 
 import numpy as np
 import sympy
@@ -187,7 +187,7 @@ class FSimGate(gate_features.InterchangeableQubitsGate, raw_types.Gate):
             out[ii] *= cmath.exp(-1j * self.phi)
         return out
 
-    def _decompose_(self, qubits) -> 'cirq.OP_TREE':
+    def _decompose_(self, qubits) -> Iterator['cirq.OP_TREE']:
         a, b = qubits
         xx = cirq.XXPowGate(exponent=self.theta / np.pi, global_shift=-0.5)
         yy = cirq.YYPowGate(exponent=self.theta / np.pi, global_shift=-0.5)
@@ -347,6 +347,45 @@ class PhasedFSimGate(gate_features.InterchangeableQubitsGate, raw_types.Gate):
         chi = (b0 - b1 - a0 + a1) / 2.0
         return PhasedFSimGate(theta, zeta, chi, gamma, phi)
 
+    @staticmethod
+    def from_matrix(u: np.ndarray) -> Optional['PhasedFSimGate']:
+        """Contruct a PhasedFSimGate from unitary.
+
+        Args:
+            u: A unitary matrix representing a PhasedFSimGate.
+
+        Returns:
+            - Either PhasedFSimGate with the given unitary or None if
+                the matrix is not unitary or if doesn't represent a PhasedFSimGate.
+        """
+
+        gamma = np.angle(u[1, 1] * u[2, 2] - u[1, 2] * u[2, 1]) / -2
+        phi = -np.angle(u[3, 3]) - 2 * gamma
+        phased_cos_theta_2 = u[1, 1] * u[2, 2]
+        if phased_cos_theta_2 == 0:
+            # The zeta phase is multiplied with cos(theta),
+            # so if cos(theta) is zero then any value is possible.
+            zeta = 0
+        else:
+            zeta = np.angle(u[2, 2] / u[1, 1]) / 2
+
+        phased_sin_theta_2 = u[1, 2] * u[2, 1]
+        if phased_sin_theta_2 == 0:
+            # The chi phase is multiplied with sin(theta),
+            # so if sin(theta) is zero then any value is possible.
+            chi = 0
+        else:
+            chi = np.angle(u[1, 2] / u[2, 1]) / 2
+
+        theta = np.angle(
+            np.exp(1j * (gamma + zeta)) * u[1, 1] - np.exp(1j * (gamma - chi)) * u[1, 2]
+        )
+
+        gate = PhasedFSimGate(theta=theta, phi=phi, chi=chi, zeta=zeta, gamma=gamma)
+        if np.allclose(u, protocols.unitary(gate)):
+            return gate
+        return None
+
     @property
     def rz_angles_before(self) -> Tuple['cirq.TParamVal', 'cirq.TParamVal']:
         """Returns 2-tuple of phase angles applied to qubits before FSimGate."""
@@ -452,7 +491,7 @@ class PhasedFSimGate(gate_features.InterchangeableQubitsGate, raw_types.Gate):
             out[ii] *= f * f
         return out
 
-    def _decompose_(self, qubits) -> 'cirq.OP_TREE':
+    def _decompose_(self, qubits) -> Iterator['cirq.OP_TREE']:
         """Decomposes self into Z rotations and FSimGate.
 
         Note that Z rotations returned by this method have unusual global phase

cirq/ops/fsim_gate_test.py

@@ -797,3 +797,24 @@ def test_phased_fsim_json_dict():
     assert cirq.PhasedFSimGate(
         theta=0.12, zeta=0.34, chi=0.56, gamma=0.78, phi=0.9
     )._json_dict_() == {'theta': 0.12, 'zeta': 0.34, 'chi': 0.56, 'gamma': 0.78, 'phi': 0.9}
+
+
+@pytest.mark.parametrize(
+    'gate',
+    [
+        cirq.CZ,
+        cirq.SQRT_ISWAP,
+        cirq.SQRT_ISWAP_INV,
+        cirq.ISWAP,
+        cirq.ISWAP_INV,
+        cirq.cphase(0.1),
+        cirq.CZ**0.2,
+    ],
+)
+def test_phase_fsim_from_matrix(gate):
+    u = cirq.unitary(gate)
+    np.testing.assert_allclose(cirq.unitary(cirq.PhasedFSimGate.from_matrix(u)), u, atol=1e-8)
+
+
+def test_phase_fsim_from_matrix_not_fsim_returns_none():
+    assert cirq.PhasedFSimGate.from_matrix(np.ones((4, 4))) is None

cirq/ops/gate_operation.py

@@ -16,29 +16,29 @@
 
 import re
 import warnings
+from types import NotImplementedType
 from typing import (
     AbstractSet,
     Any,
-    Mapping,
     cast,
     Collection,
     Dict,
     FrozenSet,
+    List,
+    Mapping,
     Optional,
     Sequence,
     Tuple,
-    TypeVar,
     TYPE_CHECKING,
+    TypeVar,
     Union,
-    List,
 )
-from typing_extensions import Self
 
 import numpy as np
+from typing_extensions import Self
 
 from cirq import ops, protocols, value
-from cirq.ops import raw_types, gate_features, control_values as cv
-from cirq.type_workarounds import NotImplementedType
+from cirq.ops import control_values as cv, gate_features, raw_types
 
 if TYPE_CHECKING:
     import cirq
@@ -302,7 +302,7 @@ class GateOperation(raw_types.Operation):
     def _decompose_into_clifford_(self):
         sub = getattr(self.gate, '_decompose_into_clifford_with_qubits_', None)
         if sub is None:
-            return NotImplemented
+            return NotImplemented  # pragma: no cover
         return sub(self.qubits)
 
     def _trace_distance_bound_(self) -> float:
@@ -360,7 +360,7 @@ class GateOperation(raw_types.Operation):
         return protocols.qasm(self.gate, args=args, qubits=self.qubits, default=None)
 
     def _equal_up_to_global_phase_(
-        self, other: Any, atol: Union[int, float] = 1e-8
+        self, other: Any, atol: float = 1e-8
     ) -> Union[NotImplementedType, bool]:
         if not isinstance(other, type(self)):
             return NotImplemented

cirq/ops/gate_operation_test.py

@@ -454,6 +454,7 @@ def test_is_parameterized():
             return True
 
     q = cirq.LineQubit(0)
+    assert No1().num_qubits() == 1
     assert not cirq.is_parameterized(No1().on(q))
     assert not cirq.is_parameterized(No2().on(q))
     assert cirq.is_parameterized(Yes().on(q))
@@ -490,7 +491,9 @@ def test_gate_to_operation_to_gate_round_trips():
     gate_subclasses = {
         g
         for g in all_subclasses(cirq.Gate)
-        if "cirq." in g.__module__ and "contrib" not in g.__module__ and "test" not in g.__module__
+        if g.__module__.startswith("cirq.")
+        and "contrib" not in g.__module__
+        and "test" not in g.__module__
     }
 
     test_module_spec = cirq.testing.json.spec_for("cirq.protocols")
@@ -506,7 +509,6 @@ def test_gate_to_operation_to_gate_round_trips():
         cirq.transformers.measurement_transformers._ConfusionChannel,
         cirq.transformers.measurement_transformers._ModAdd,
         cirq.transformers.routing.visualize_routed_circuit._SwapPrintGate,
-        cirq.ops.raw_types._InverseCompositeGate,
         cirq.circuits.qasm_output.QasmTwoQubitGate,
         cirq.ops.MSGate,
         # Interop gates

cirq/ops/gateset_test.py

@@ -12,13 +12,15 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Tuple, List, cast
 import re
+from typing import cast, List, Tuple
+
+import numpy as np
 import pytest
 import sympy
+
 import cirq
 from cirq._compat import proper_repr
-import numpy as np
 
 
 class CustomXPowGate(cirq.EigenGate):
@@ -441,3 +443,10 @@ def test_gateset_contains_with_tags():
     # Both tags to accept and tags to ignore
     assert op in cirq.Gateset(gf_accept, gf_ignore)
     assert op_with_tag in cirq.Gateset(gf_accept, gf_ignore)
+
+
+def test_gateset_contains_op_with_no_gate():
+    gf = cirq.GateFamily(cirq.ZPowGate)
+    op = cirq.X(cirq.q(1)).with_classical_controls('a')
+    assert op.gate is None
+    assert op not in gf

cirq/ops/global_phase_op.py

@@ -13,22 +13,23 @@
 # limitations under the License.
 """A no-qubit global phase operation."""
 
-from typing import AbstractSet, Any, cast, Dict, Sequence, Tuple, Union, Optional, Collection
+from types import NotImplementedType
+from typing import AbstractSet, Any, cast, Collection, Dict, Optional, Sequence, Tuple, Union
 
 import numpy as np
 import sympy
 
 import cirq
-from cirq import value, protocols
-from cirq.ops import raw_types, controlled_gate, control_values as cv
-from cirq.type_workarounds import NotImplementedType
+from cirq import protocols, value
+from cirq._compat import proper_repr
+from cirq.ops import control_values as cv, controlled_gate, raw_types
 
 
 @value.value_equality(approximate=True)
 class GlobalPhaseGate(raw_types.Gate):
     def __init__(self, coefficient: 'cirq.TParamValComplex', atol: float = 1e-8) -> None:
         if not isinstance(coefficient, sympy.Basic):
-            if abs(1 - abs(coefficient)) > atol:  # type: ignore[operator]
+            if abs(1 - abs(coefficient)) > atol:
                 raise ValueError(f'Coefficient is not unitary: {coefficient!r}')
         self._coefficient = coefficient
 
@@ -68,10 +69,10 @@ class GlobalPhaseGate(raw_types.Gate):
         return str(self.coefficient)
 
     def __repr__(self) -> str:
-        return f'cirq.GlobalPhaseGate({self.coefficient!r})'
+        return f'cirq.GlobalPhaseGate({proper_repr(self.coefficient)})'
 
     def _op_repr_(self, qubits: Sequence['cirq.Qid']) -> str:
-        return f'cirq.global_phase_operation({self.coefficient!r})'
+        return f'cirq.global_phase_operation({proper_repr(self.coefficient)})'
 
     def _json_dict_(self) -> Dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ['coefficient'])

cirq/ops/global_phase_op_test.py

@@ -33,7 +33,7 @@ def test_init():
 
 
 def test_protocols():
-    for p in [1, 1j, -1]:
+    for p in [1, 1j, -1, sympy.Symbol('s')]:
         cirq.testing.assert_implements_consistent_protocols(cirq.global_phase_operation(p))
 
     np.testing.assert_allclose(

cirq/ops/greedy_qubit_manager_test.py

@@ -90,6 +90,11 @@ ancilla_1: ───X───X───
     )
 
 
+def test_empty_qubits():
+    qm = cirq.GreedyQubitManager(prefix="anc")
+    assert qm.qalloc(0) == []
+
+
 def test_greedy_qubit_manager_preserves_order():
     qm = cirq.GreedyQubitManager(prefix="anc")
     ancillae = [cirq.q(f"anc_{i}") for i in range(100)]