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

cirq/ops/phased_iswap_gate.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 """ISWAPPowGate conjugated by tensor product Rz(phi) and Rz(-phi)."""
 
-from typing import AbstractSet, Any, cast, Dict, List, Optional, Sequence, Tuple, Union
+from typing import AbstractSet, Any, cast, Dict, Iterator, List, Optional, Sequence, Tuple, Union
 
 import numpy as np
 import sympy
@@ -93,15 +93,14 @@ class PhasedISwapPowGate(eigen_gate.EigenGate):
         }
 
     def _value_equality_values_cls_(self):
-        if self.phase_exponent == 0:
-            return swap_gates.ISwapPowGate
         return PhasedISwapPowGate
 
     def _value_equality_values_(self):
-        if self.phase_exponent == 0:
-            return self._iswap._value_equality_values_()
         return (self.phase_exponent, *self._iswap._value_equality_values_())
 
+    def _value_equality_approximate_values_(self):
+        return (self.phase_exponent, *self._iswap._value_equality_approximate_values_())
+
     def _is_parameterized_(self) -> bool:
         return protocols.is_parameterized(self._iswap) or protocols.is_parameterized(
             self._phase_exponent
@@ -157,7 +156,7 @@ class PhasedISwapPowGate(eigen_gate.EigenGate):
         )
         return args.available_buffer
 
-    def _decompose_(self, qubits: Sequence['cirq.Qid']) -> 'cirq.OP_TREE':
+    def _decompose_(self, qubits: Sequence['cirq.Qid']) -> Iterator['cirq.OP_TREE']:
         if len(qubits) != 2:
             raise ValueError(f'Expected two qubits, got {len(qubits)}')
         a, b = qubits
@@ -253,4 +252,4 @@ def givens(angle_rads: value.TParamVal) -> PhasedISwapPowGate:
         A phased iswap gate for the given rotation.
     """
     pi = sympy.pi if protocols.is_parameterized(angle_rads) else np.pi
-    return PhasedISwapPowGate() ** (2 * angle_rads / pi)
+    return cast(PhasedISwapPowGate, PhasedISwapPowGate() ** (2 * angle_rads / pi))

cirq/ops/phased_iswap_gate_test.py

@@ -34,11 +34,10 @@ def test_phased_iswap_init():
 
 def test_phased_iswap_equality():
     eq = cirq.testing.EqualsTester()
-    eq.add_equality_group(cirq.PhasedISwapPowGate(phase_exponent=0, exponent=0.4), cirq.ISWAP**0.4)
-    eq.add_equality_group(
-        cirq.PhasedISwapPowGate(phase_exponent=0, exponent=0.4, global_shift=0.3),
-        cirq.ISwapPowGate(global_shift=0.3) ** 0.4,
-    )
+    eq.add_equality_group(cirq.PhasedISwapPowGate(phase_exponent=0, exponent=0.4))
+    eq.add_equality_group(cirq.ISWAP**0.4)
+    eq.add_equality_group(cirq.PhasedISwapPowGate(phase_exponent=0, exponent=0.4, global_shift=0.3))
+    eq.add_equality_group(cirq.ISwapPowGate(global_shift=0.3) ** 0.4)
 
 
 def test_repr():
@@ -204,3 +203,20 @@ def test_givens_rotation_equivalent_circuit():
 @pytest.mark.parametrize('angle_rads', (-np.pi / 5, 0.4, 2, np.pi))
 def test_givens_rotation_has_consistent_protocols(angle_rads):
     cirq.testing.assert_implements_consistent_protocols(cirq.givens(angle_rads))
+
+
+def test_approx_eq():
+    gate0 = cirq.PhasedISwapPowGate(phase_exponent=0)
+    gate1 = cirq.PhasedISwapPowGate(phase_exponent=1e-12)
+    gate2 = cirq.PhasedISwapPowGate(phase_exponent=2e-12)
+    gate3 = cirq.PhasedISwapPowGate(phase_exponent=0.345)
+    gate4 = cirq.ISwapPowGate()
+
+    assert cirq.approx_eq(gate1, gate2)
+    assert cirq.approx_eq(gate1, gate0)
+    assert not cirq.approx_eq(gate1, gate3)
+    assert not cirq.approx_eq(gate0, gate4)
+
+    assert cirq.equal_up_to_global_phase(gate1, gate2)
+    assert cirq.equal_up_to_global_phase(gate1, gate0)
+    assert not cirq.equal_up_to_global_phase(gate1, gate3)

cirq/ops/phased_x_gate.py

@@ -12,21 +12,22 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """An `XPowGate` conjugated by `ZPowGate`s."""
-from typing import AbstractSet, Any, cast, Dict, Optional, Sequence, Tuple, Union
 
 import math
 import numbers
+from types import NotImplementedType
+from typing import AbstractSet, Any, cast, Dict, Optional, Sequence, Tuple, Union
+
 import numpy as np
 import sympy
 
 import cirq
-from cirq import value, protocols
+from cirq import protocols, value
 from cirq._compat import proper_repr
-from cirq.ops import common_gates, raw_types
-from cirq.type_workarounds import NotImplementedType
+from cirq.ops import raw_types
 
 
-@value.value_equality(manual_cls=True, approximate=True)
+@value.value_equality(approximate=True)
 class PhasedXPowGate(raw_types.Gate):
     r"""A gate equivalent to $Z^{-p} X^t Z^{p}$ (in time order).
 
@@ -67,7 +68,7 @@ class PhasedXPowGate(raw_types.Gate):
         if cirq.is_parameterized(self):
             return None
 
-        args.validate_version('2.0')
+        args.validate_version('2.0', '3.0')
 
         e = cast(float, value.canonicalize_half_turns(self._exponent))
         p = cast(float, self.phase_exponent)
@@ -115,7 +116,7 @@ class PhasedXPowGate(raw_types.Gate):
     def __pow__(self, exponent: Union[float, sympy.Expr]) -> 'PhasedXPowGate':
         new_exponent = protocols.mul(self._exponent, exponent, NotImplemented)
         if new_exponent is NotImplemented:
-            return NotImplemented
+            return NotImplemented  # pragma: no cover
         return PhasedXPowGate(
             phase_exponent=self._phase_exponent,
             exponent=new_exponent,
@@ -130,7 +131,7 @@ class PhasedXPowGate(raw_types.Gate):
     def _has_unitary_(self):
         return not self._is_parameterized_()
 
-    def _unitary_(self) -> Union[np.ndarray, NotImplementedType]:
+    def _unitary_(self) -> Optional[Union[np.ndarray, NotImplementedType]]:
         """See `cirq.SupportsUnitary`."""
         if self._is_parameterized_():
             return None
@@ -174,12 +175,12 @@ class PhasedXPowGate(raw_types.Gate):
         """See `cirq.SupportsParameterization`."""
         phase_exponent = resolver.value_of(self._phase_exponent, recursive)
         exponent = resolver.value_of(self._exponent, recursive)
-        if isinstance(phase_exponent, (complex, numbers.Complex)):
+        if isinstance(phase_exponent, numbers.Complex):
             if isinstance(phase_exponent, numbers.Real):
                 phase_exponent = float(phase_exponent)
             else:
                 raise ValueError(f'PhasedXPowGate does not support complex value {phase_exponent}')
-        if isinstance(exponent, (complex, numbers.Complex)):
+        if isinstance(exponent, numbers.Complex):
             if isinstance(exponent, numbers.Real):
                 exponent = float(exponent)
             else:
@@ -240,22 +241,7 @@ class PhasedXPowGate(raw_types.Gate):
 
         return self._exponent % period
 
-    def _value_equality_values_cls_(self):
-        if self.phase_exponent == 0:
-            return common_gates.XPowGate
-        if self.phase_exponent == 0.5:
-            return common_gates.YPowGate
-        return PhasedXPowGate
-
     def _value_equality_values_(self):
-        if self.phase_exponent == 0:
-            return common_gates.XPowGate(
-                exponent=self._exponent, global_shift=self._global_shift
-            )._value_equality_values_()
-        if self.phase_exponent == 0.5:
-            return common_gates.YPowGate(
-                exponent=self._exponent, global_shift=self._global_shift
-            )._value_equality_values_()
         return self.phase_exponent, self._canonical_exponent, self._global_shift
 
     def _json_dict_(self) -> Dict[str, Any]:

cirq/ops/phased_x_gate_test.py

@@ -79,16 +79,17 @@ def test_eq():
         cirq.PhasedXPowGate(exponent=1, phase_exponent=0),
         cirq.PhasedXPowGate(exponent=1, phase_exponent=2),
         cirq.PhasedXPowGate(exponent=1, phase_exponent=-2),
-        cirq.X,
     )
+    eq.add_equality_group(cirq.X)
     eq.add_equality_group(cirq.PhasedXPowGate(exponent=1, phase_exponent=2, global_shift=0.1))
 
     eq.add_equality_group(
         cirq.PhasedXPowGate(phase_exponent=0.5, exponent=1),
         cirq.PhasedXPowGate(phase_exponent=2.5, exponent=3),
-        cirq.Y,
     )
-    eq.add_equality_group(cirq.PhasedXPowGate(phase_exponent=0.5, exponent=0.25), cirq.Y**0.25)
+    eq.add_equality_group(cirq.Y)
+    eq.add_equality_group(cirq.PhasedXPowGate(phase_exponent=0.5, exponent=0.25))
+    eq.add_equality_group(cirq.Y**0.25)
 
     eq.add_equality_group(cirq.PhasedXPowGate(phase_exponent=0.25, exponent=0.25, global_shift=0.1))
     eq.add_equality_group(cirq.PhasedXPowGate(phase_exponent=2.25, exponent=0.25, global_shift=0.2))
@@ -266,3 +267,18 @@ def test_exponent_consistency(exponent, phase_exponent):
     u = cirq.protocols.unitary(g)
     u2 = cirq.protocols.unitary(g2)
     assert np.all(u == u2)
+
+
+def test_approx_eq_for_close_phase_exponents():
+    gate1 = cirq.PhasedXPowGate(phase_exponent=0)
+    gate2 = cirq.PhasedXPowGate(phase_exponent=1e-12)
+    gate3 = cirq.PhasedXPowGate(phase_exponent=2e-12)
+    gate4 = cirq.PhasedXPowGate(phase_exponent=0.345)
+
+    assert cirq.approx_eq(gate2, gate3)
+    assert cirq.approx_eq(gate2, gate1)
+    assert not cirq.approx_eq(gate2, gate4)
+
+    assert cirq.equal_up_to_global_phase(gate2, gate3)
+    assert cirq.equal_up_to_global_phase(gate2, gate1)
+    assert not cirq.equal_up_to_global_phase(gate2, gate4)

cirq/ops/phased_x_z_gate.py

@@ -11,15 +11,16 @@
 # 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 typing import AbstractSet, Any, Dict, Optional, Sequence, Tuple, TYPE_CHECKING, Union
+
 import numbers
+from typing import AbstractSet, Any, Dict, Iterator, Optional, Sequence, Tuple, TYPE_CHECKING, Union
 
 import numpy as np
 import sympy
 
-from cirq import value, ops, protocols, linalg
-from cirq.ops import raw_types
+from cirq import linalg, ops, protocols, value
 from cirq._compat import proper_repr
+from cirq.ops import raw_types
 
 if TYPE_CHECKING:
     import cirq
@@ -69,9 +70,9 @@ class PhasedXZGate(raw_types.Gate):
 
     @classmethod
     def from_zyz_angles(cls, z0_rad: float, y_rad: float, z1_rad: float) -> 'cirq.PhasedXZGate':
-        """Create a PhasedXZGate from ZYZ angles.
+        r"""Create a PhasedXZGate from ZYZ angles.
 
-        The returned gate is equivalent to $Rz(z0_rad) Ry(y_rad) Rz(z1_rad)$ (in time order).
+        The returned gate is equivalent to $Rz(z0\_rad) Ry(y\_rad) Rz(z1\_rad)$ (in time order).
         """
         return cls.from_zyz_exponents(z0=z0_rad / np.pi, y=y_rad / np.pi, z1=z1_rad / np.pi)
 
@@ -79,7 +80,7 @@ class PhasedXZGate(raw_types.Gate):
     def from_zyz_exponents(cls, z0: float, y: float, z1: float) -> 'cirq.PhasedXZGate':
         """Create a PhasedXZGate from ZYZ exponents.
 
-        The returned gate is equivalent to $Z^z0 Y^y Z^z1$ (in time order).
+        The returned gate is equivalent to $Z^{z0} Y^y Z^{z1}$ (in time order).
         """
         return PhasedXZGate(axis_phase_exponent=-z0 + 0.5, x_exponent=y, z_exponent=z0 + z1)
 
@@ -188,13 +189,13 @@ class PhasedXZGate(raw_types.Gate):
         z_post = protocols.unitary(ops.Z ** (self._axis_phase_exponent + self._z_exponent))
         return z_post @ x @ z_pre
 
-    def _decompose_(self, qubits: Sequence['cirq.Qid']) -> 'cirq.OP_TREE':
+    def _decompose_(self, qubits: Sequence['cirq.Qid']) -> Iterator['cirq.OP_TREE']:
         q = qubits[0]
         yield ops.Z(q) ** -self._axis_phase_exponent
         yield ops.X(q) ** self._x_exponent
         yield ops.Z(q) ** (self._axis_phase_exponent + self._z_exponent)
 
-    def __pow__(self, exponent: Union[float, int]) -> 'PhasedXZGate':
+    def __pow__(self, exponent: float) -> 'PhasedXZGate':
         if exponent == 1:
             return self
         if exponent == -1:
@@ -228,17 +229,17 @@ class PhasedXZGate(raw_types.Gate):
         z_exponent = resolver.value_of(self._z_exponent, recursive)
         x_exponent = resolver.value_of(self._x_exponent, recursive)
         axis_phase_exponent = resolver.value_of(self._axis_phase_exponent, recursive)
-        if isinstance(z_exponent, (complex, numbers.Complex)):
+        if isinstance(z_exponent, numbers.Complex):
             if isinstance(z_exponent, numbers.Real):
                 z_exponent = float(z_exponent)
             else:
                 raise ValueError(f'Complex exponent {z_exponent} not allowed in cirq.PhasedXZGate')
-        if isinstance(x_exponent, (complex, numbers.Complex)):
+        if isinstance(x_exponent, numbers.Complex):
             if isinstance(x_exponent, numbers.Real):
                 x_exponent = float(x_exponent)
             else:
                 raise ValueError(f'Complex exponent {x_exponent} not allowed in cirq.PhasedXZGate')
-        if isinstance(axis_phase_exponent, (complex, numbers.Complex)):
+        if isinstance(axis_phase_exponent, numbers.Complex):
             if isinstance(axis_phase_exponent, numbers.Real):
                 axis_phase_exponent = float(axis_phase_exponent)
             else:

cirq/ops/projector.py

@@ -1,6 +1,7 @@
 # pylint: disable=wrong-or-nonexistent-copyright-notice
 import itertools
-from typing import Any, Dict, Iterable, List, Mapping, Optional, Union
+import math
+from typing import Any, Dict, Iterable, List, Mapping, Optional
 
 import numpy as np
 from scipy.sparse import csr_matrix
@@ -20,9 +21,7 @@ def _check_qids_dimension(qids):
 class ProjectorString:
     """Mapping of `cirq.Qid` to measurement values (with a coefficient) representing a projector."""
 
-    def __init__(
-        self, projector_dict: Dict[raw_types.Qid, int], coefficient: Union[int, float, complex] = 1
-    ):
+    def __init__(self, projector_dict: Dict[raw_types.Qid, int], coefficient: complex = 1):
         """Constructor for ProjectorString
 
         Args:
@@ -61,7 +60,7 @@ class ProjectorString:
             for qid in projector_qids
         ]
 
-        total_d = np.prod([qid.dimension for qid in projector_qids], dtype=np.int64)
+        total_d = math.prod(qid.dimension for qid in projector_qids)
 
         ones_idx = []
         for idx in itertools.product(*idx_to_keep):

cirq/ops/qubit_manager.py

@@ -14,7 +14,8 @@
 
 import abc
 import dataclasses
-from typing import Iterable, List, TYPE_CHECKING, Tuple
+from typing import Iterable, List, Tuple, TYPE_CHECKING
+
 from cirq.ops import raw_types
 
 if TYPE_CHECKING:

cirq/ops/qubit_manager_test.py

@@ -12,9 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import pytest
+
 import cirq
 from cirq.ops import qubit_manager as cqi
-import pytest
 
 
 def test_clean_qubits():

cirq/ops/qubit_order.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 
 
-from typing import Any, Callable, Iterable, Optional, Tuple, TypeVar, TYPE_CHECKING
+from typing import Any, Callable, Iterable, Optional, Tuple, TYPE_CHECKING, TypeVar
 
 from cirq.ops import raw_types
 

cirq/ops/random_gate_channel.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 
 import numbers
-from typing import AbstractSet, Tuple, TYPE_CHECKING, Dict, Any, cast, SupportsFloat, Optional
+from typing import AbstractSet, Any, cast, Dict, Optional, SupportsFloat, Tuple, TYPE_CHECKING
 
 import numpy as np
 

cirq/ops/random_gate_channel_test.py

@@ -150,12 +150,6 @@ def test_mixture():
     assert {p for p, _ in m} == {7 / 8, 1 / 32, 3 / 32}
 
 
-def assert_channel_sums_to_identity(val):
-    m = cirq.kraus(val)
-    s = sum(np.conj(e.T) @ e for e in m)
-    np.testing.assert_allclose(s, np.eye(np.prod(cirq.qid_shape(val), dtype=np.int64)), atol=1e-8)
-
-
 def test_channel():
     class NoDetailsGate(cirq.Gate):
         def num_qubits(self) -> int: