cirq-core 1.4.1__py3-none-any.whl → 1.5.0__py3-none-any.whl

cirq/ops/clifford_gate.py

@@ -12,18 +12,18 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Any, Dict, List, Optional, Sequence, Tuple, TYPE_CHECKING, Union
-
 import functools
 from dataclasses import dataclass
+from types import NotImplementedType
+from typing import Any, Dict, List, Optional, Sequence, Tuple, TYPE_CHECKING, Union
+
 import numpy as np
 
-from cirq import protocols, value, linalg, qis
-from cirq._import import LazyLoader
+from cirq import linalg, protocols, qis, value
 from cirq._compat import cached_method
-from cirq.ops import common_gates, named_qubit, raw_types, pauli_gates, phased_x_z_gate
+from cirq._import import LazyLoader
+from cirq.ops import common_gates, named_qubit, pauli_gates, phased_x_z_gate, raw_types
 from cirq.ops.pauli_gates import Pauli
-from cirq.type_workarounds import NotImplementedType
 
 if TYPE_CHECKING:
     import cirq
@@ -130,22 +130,10 @@ def _pad_tableau(
     return padded_tableau
 
 
-def _gate_tableau(num_qubits: int, gate: raw_types.Gate) -> 'cirq.CliffordTableau':
-    qubits = devices.LineQubit.range(num_qubits)
-    t = qis.CliffordTableau(num_qubits=num_qubits)
-    args = sim.CliffordTableauSimulationState(
-        tableau=t, qubits=qubits, prng=np.random.RandomState()
-    )
-    protocols.act_on(gate, args, qubits, allow_decompose=False)
-    return args.tableau
-
-
 class CommonCliffordGateMetaClass(value.ABCMetaImplementAnyOneOf):
     """A metaclass used to lazy initialize several common Clifford Gate as class attributes."""
 
     # These are class properties so we define them as properties on a metaclass.
-    # Note that in python 3.9+ @classmethod can be used with @property, so these
-    # can be moved to CommonCliffordGates.
 
     @property
     def all_single_qubit_cliffords(cls) -> Sequence['cirq.SingleQubitCliffordGate']:
@@ -322,7 +310,7 @@ class CommonCliffordGates(metaclass=CommonCliffordGateMetaClass):
             ValueError: When one or more operations do not have stabilizer effect.
         """
         for op in operations:
-            if op.gate and op.gate._has_stabilizer_effect_():
+            if op.gate and protocols.has_stabilizer_effect(op.gate):
                 continue
             raise ValueError(
                 "Clifford Gate can only be constructed from the "
@@ -377,7 +365,10 @@ class CliffordGate(raw_types.Gate, CommonCliffordGates):
         #  ZI  [ 0  0 | 1  0  | 1 ]
         #  IZ  [ 1  0 | 1  1  | 0 ]
         # Take the third row as example: this means the ZI gate after the this gate,
-        # more precisely the conjugate transformation of ZI by this gate, becomes -ZI.
+        # more precisely the conjugate transformation of ZI by this gate, becomes -ZI:
+        #   ---(CliffordGate^-1)---ZI---CliffordGate---
+        # = unitary(CliffordGate)@unitary(ZI)@unitary(CliffordGate).conj().T
+        # = -ZI.
         # (Note the real clifford tableau has to satify the Symplectic property.
         # here is just for illustration)
         object.__setattr__(self, '_clifford_tableau', _clifford_tableau.copy())
@@ -402,7 +393,7 @@ class CliffordGate(raw_types.Gate, CommonCliffordGates):
 
     def __pow__(self, exponent: float) -> 'CliffordGate':
         if exponent != int(exponent):
-            return NotImplemented
+            return NotImplemented  # pragma: no cover
         exponent = int(exponent)
 
         if exponent == -1:
@@ -433,19 +424,19 @@ class CliffordGate(raw_types.Gate, CommonCliffordGates):
         return CliffordGate.from_clifford_tableau(base_tableau)
 
     def __repr__(self) -> str:
-        return f"Clifford Gate with Tableau:\n {self.clifford_tableau._str_full_()}"
+        return f"Clifford Gate with Tableau:\n{self.clifford_tableau._str_full_()}"
 
     def _commutes_(
         self, other: Any, *, atol: float = 1e-8
     ) -> Union[bool, NotImplementedType, None]:
-        # Note even if we assume two gates define the tabluea based on the same qubit order,
+        # Note even if we assume two gates define the tableau based on the same qubit order,
         # the following approach cannot judge it:
         # self.clifford_tableau.then(other.clifford_tableau) == other.clifford_tableau.then(
         #     self.clifford_tableau
         # )
         # For example: X.then(Z) and Z.then(X) both return same tableau
         # it is because Clifford tableau ignores the global phase information.
-        return NotImplemented
+        return NotImplemented  # pragma: no cover
 
     def _decompose_(self, qubits: Sequence['cirq.Qid']) -> 'cirq.OP_TREE':
         return transformers.analytical_decompositions.decompose_clifford_tableau_to_operations(
@@ -474,7 +465,7 @@ class CliffordGate(raw_types.Gate, CommonCliffordGates):
             # is aimed to fix that.
             return NotImplemented
 
-        return NotImplemented
+        return NotImplemented  # pragma: no cover
 
 
 @dataclass(frozen=True, init=False, eq=False, repr=False)
@@ -742,17 +733,23 @@ class SingleQubitCliffordGate(CliffordGate):
             z = -0.5 if x_to_flip else 0.5
         return phased_x_z_gate.PhasedXZGate(x_exponent=x, z_exponent=z, axis_phase_exponent=a)
 
-    def __pow__(self, exponent: Union[float, int]) -> 'SingleQubitCliffordGate':
-        # First to check if we can get the sqrt and negative sqrt Clifford.
-        if self._get_sqrt_map().get(exponent, None):
-            pow_gate = self._get_sqrt_map()[exponent].get(self, None)
+    def __pow__(self, exponent: float) -> 'SingleQubitCliffordGate':
+        if int(exponent) == exponent:
+            # The single qubit Clifford gates are a group of size 24
+            exp = int(exponent) % 24
+            ret_gate = super().__pow__(exp if exp != 23 else -1)
+            return SingleQubitCliffordGate.from_clifford_tableau(ret_gate.clifford_tableau)
+        elif int(2 * exponent) == 2 * exponent:
+            # If exponent = k/2 for integer k, then we compute the k-th power of the square root
+            if exponent < 0:
+                sqrt_exp = -0.5
+            else:
+                sqrt_exp = 0.5
+            pow_gate = self._get_sqrt_map()[sqrt_exp].get(self, None)
             if pow_gate:
-                return pow_gate
-        # If not, we try the Clifford Tableau based method.
-        ret_gate = super().__pow__(exponent)
-        if ret_gate is NotImplemented:
-            return NotImplemented
-        return SingleQubitCliffordGate.from_clifford_tableau(ret_gate.clifford_tableau)
+                return pow_gate ** (abs(2 * exponent))
+
+        return NotImplemented
 
     def _act_on_(
         self,
@@ -897,7 +894,12 @@ class SingleQubitCliffordGate(CliffordGate):
         return self.merged_with(after).merged_with(self**-1)
 
     def __repr__(self) -> str:
-        return f'cirq.CliffordGate.from_clifford_tableau({self.clifford_tableau!r})'
+        return (
+            f'cirq.ops.SingleQubitCliffordGate(_clifford_tableau=cirq.CliffordTableau(1, '
+            f'rs=np.array({self._clifford_tableau.rs.tolist()!r}), '
+            f'xs=np.array({self._clifford_tableau.xs.tolist()!r}), '
+            f'zs=np.array({self._clifford_tableau.zs.tolist()!r})))'
+        )
 
     def _circuit_diagram_info_(
         self, args: 'cirq.CircuitDiagramInfoArgs'

cirq/ops/clifford_gate_test.py

@@ -21,7 +21,7 @@ import pytest
 
 import cirq
 from cirq.protocols.act_on_protocol_test import ExampleSimulationState
-from cirq.testing import EqualsTester, assert_allclose_up_to_global_phase
+from cirq.testing import assert_allclose_up_to_global_phase, EqualsTester
 
 _bools = (False, True)
 _paulis = (cirq.X, cirq.Y, cirq.Z)
@@ -219,6 +219,8 @@ def test_pow():
     assert cirq.SingleQubitCliffordGate.Y_nsqrt == cirq.SingleQubitCliffordGate.Y**-0.5
     assert cirq.SingleQubitCliffordGate.Z_nsqrt == cirq.SingleQubitCliffordGate.Z**-0.5
     assert cirq.SingleQubitCliffordGate.X_sqrt**-1 == cirq.SingleQubitCliffordGate.X_nsqrt
+    assert cirq.SingleQubitCliffordGate.X_sqrt**3 == cirq.SingleQubitCliffordGate.X**1.5
+    assert cirq.SingleQubitCliffordGate.Z**2.0 == cirq.SingleQubitCliffordGate.I
     assert cirq.inverse(cirq.SingleQubitCliffordGate.X_nsqrt) == (
         cirq.SingleQubitCliffordGate.X_sqrt
     )
@@ -919,3 +921,75 @@ def test_all_single_qubit_clifford_unitaries():
     assert cirq.equal_up_to_global_phase(cs[21], (i - 1j * (-x + y - z)) / 2)
     assert cirq.equal_up_to_global_phase(cs[22], (i - 1j * (-x - y + z)) / 2)
     assert cirq.equal_up_to_global_phase(cs[23], (i - 1j * (-x - y - z)) / 2)
+
+
+def test_clifford_gate_repr():
+    q0, q1, q2 = cirq.LineQubit.range(3)
+    assert (
+        repr(cirq.ops.CliffordGate.from_op_list([cirq.ops.X(q0), cirq.CZ(q1, q2)], [q0, q1, q2]))
+        == """Clifford Gate with Tableau:
+stable   | destable
+---------+----------
+- Z0     | + X0
++   Z1   | +   X1Z2
++     Z2 | +   Z1X2
+"""
+    )
+    assert (
+        repr(cirq.ops.CliffordGate.CNOT)
+        == """Clifford Gate with Tableau:
+stable | destable
+-------+----------
++ Z0   | + X0X1
++ Z0Z1 | +   X1
+"""
+    )
+
+
+def test_single_qubit_clifford_gate_repr():
+    # Common gates
+    assert repr(cirq.ops.SingleQubitCliffordGate.X) == (
+        'cirq.ops.SingleQubitCliffordGate(_clifford_tableau=cirq.CliffordTableau(1, '
+        'rs=np.array([False, True]), xs=np.array([[True], [False]]), '
+        'zs=np.array([[False], [True]])))'
+    )
+    assert repr(cirq.ops.SingleQubitCliffordGate.Y) == (
+        'cirq.ops.SingleQubitCliffordGate(_clifford_tableau=cirq.CliffordTableau(1, '
+        'rs=np.array([True, True]), xs=np.array([[True], [False]]), '
+        'zs=np.array([[False], [True]])))'
+    )
+    assert repr(cirq.ops.SingleQubitCliffordGate.Z) == (
+        'cirq.ops.SingleQubitCliffordGate(_clifford_tableau=cirq.CliffordTableau(1, '
+        'rs=np.array([True, False]), xs=np.array([[True], [False]]), '
+        'zs=np.array([[False], [True]])))'
+    )
+    assert repr(cirq.ops.SingleQubitCliffordGate.I) == (
+        'cirq.ops.SingleQubitCliffordGate(_clifford_tableau=cirq.CliffordTableau(1, '
+        'rs=np.array([False, False]), xs=np.array([[True], [False]]), '
+        'zs=np.array([[False], [True]])))'
+    )
+    assert repr(cirq.ops.SingleQubitCliffordGate.X_sqrt) == (
+        'cirq.ops.SingleQubitCliffordGate(_clifford_tableau=cirq.CliffordTableau(1, '
+        'rs=np.array([False, True]), xs=np.array([[True], [True]]), '
+        'zs=np.array([[False], [True]])))'
+    )
+
+    assert repr(cirq.ops.SingleQubitCliffordGate.X) == (
+        'cirq.ops.SingleQubitCliffordGate(_clifford_tableau=cirq.CliffordTableau(1, '
+        'rs=np.array([False, True]), xs=np.array([[True], [False]]), '
+        'zs=np.array([[False], [True]])))'
+    )
+
+    # Other gates
+    qa = cirq.NamedQubit('a')
+    gate = cirq.ops.SingleQubitCliffordGate.from_clifford_tableau(
+        cirq.ops.CliffordGate.from_op_list(
+            [cirq.ops.PhasedXZGate(axis_phase_exponent=0.25, x_exponent=-1, z_exponent=0).on(qa)],
+            [qa],
+        ).clifford_tableau
+    )
+    assert repr(gate) == (
+        'cirq.ops.SingleQubitCliffordGate(_clifford_tableau=cirq.CliffordTableau(1, '
+        'rs=np.array([False, True]), xs=np.array([[True], [False]]), '
+        'zs=np.array([[True], [True]])))'
+    )

cirq/ops/common_channels.py

@@ -15,19 +15,19 @@
 """Quantum channels that are commonly used in the literature."""
 
 import itertools
-from typing import Any, Dict, Iterable, List, Optional, Sequence, Tuple, Union, TYPE_CHECKING
+from typing import Any, Dict, Iterable, List, Optional, Sequence, Tuple, TYPE_CHECKING, Union
 
 import numpy as np
 
 from cirq import protocols, value
 from cirq.linalg import transformations
-from cirq.ops import raw_types, common_gates, pauli_gates, identity
+from cirq.ops import common_gates, identity, pauli_gates, raw_types
 
 if TYPE_CHECKING:
     import cirq
 
 
-@value.value_equality
+@value.value_equality(approximate=True)
 class AsymmetricDepolarizingChannel(raw_types.Gate):
     r"""A channel that depolarizes asymmetrically along different directions.
 
@@ -131,7 +131,7 @@ class AsymmetricDepolarizingChannel(raw_types.Gate):
         return True
 
     def _value_equality_values_(self):
-        return self._num_qubits, hash(tuple(sorted(self._error_probabilities.items())))
+        return self._num_qubits, tuple(sorted(self._error_probabilities.items()))
 
     def __repr__(self) -> str:
         return 'cirq.asymmetric_depolarize(' + f"error_probabilities={self._error_probabilities})"
@@ -196,11 +196,6 @@ class AsymmetricDepolarizingChannel(raw_types.Gate):
     def _json_dict_(self) -> Dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ['error_probabilities'])
 
-    def _approx_eq_(self, other: Any, atol: float) -> bool:
-        self_keys, self_values = zip(*sorted(self.error_probabilities.items()))
-        other_keys, other_values = zip(*sorted(other.error_probabilities.items()))
-        return self_keys == other_keys and protocols.approx_eq(self_values, other_values, atol=atol)
-
 
 def asymmetric_depolarize(
     p_x: Optional[float] = None,
@@ -246,7 +241,7 @@ def asymmetric_depolarize(
     return AsymmetricDepolarizingChannel(p_x, p_y, p_z, error_probabilities, tol)
 
 
-@value.value_equality
+@value.value_equality(approximate=True)
 class DepolarizingChannel(raw_types.Gate):
     r"""A channel that depolarizes one or several qubits.
 
@@ -306,7 +301,7 @@ class DepolarizingChannel(raw_types.Gate):
         return True
 
     def _value_equality_values_(self):
-        return self._p
+        return self._p, self._n_qubits
 
     def __repr__(self) -> str:
         if self._n_qubits == 1:
@@ -333,7 +328,7 @@ class DepolarizingChannel(raw_types.Gate):
         """The probability that one of the Pauli gates is applied.
 
         Each of the Pauli gates is applied independently with probability
-        $p / (4^n_qubits - 1)$.
+        $p / (4^n - 1)$, where $n$ is `n_qubits`.
         """
         return self._p
 
@@ -347,9 +342,6 @@ class DepolarizingChannel(raw_types.Gate):
             return protocols.obj_to_dict_helper(self, ['p'])
         return protocols.obj_to_dict_helper(self, ['p', 'n_qubits'])
 
-    def _approx_eq_(self, other: Any, atol: float) -> bool:
-        return np.isclose(self.p, other.p, atol=atol).item() and self.n_qubits == other.n_qubits
-
 
 def depolarize(p: float, n_qubits: int = 1) -> DepolarizingChannel:
     r"""Returns a DepolarizingChannel with given probability of error.
@@ -372,7 +364,7 @@ def depolarize(p: float, n_qubits: int = 1) -> DepolarizingChannel:
     Args:
         p: The probability that one of the Pauli gates is applied. Each of
             the Pauli gates is applied independently with probability
-            $p / (4^n - 1)$.
+            $p / (4^n - 1)$, where $n$ is n_qubits.
         n_qubits: The number of qubits.
 
     Raises:
@@ -381,7 +373,7 @@ def depolarize(p: float, n_qubits: int = 1) -> DepolarizingChannel:
     return DepolarizingChannel(p, n_qubits)
 
 
-@value.value_equality
+@value.value_equality(approximate=True)
 class GeneralizedAmplitudeDampingChannel(raw_types.Gate):
     r"""Dampen qubit amplitudes through non ideal dissipation.
 
@@ -489,12 +481,6 @@ class GeneralizedAmplitudeDampingChannel(raw_types.Gate):
     def _json_dict_(self) -> Dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ['p', 'gamma'])
 
-    def _approx_eq_(self, other: Any, atol: float) -> bool:
-        return (
-            np.isclose(self.gamma, other.gamma, atol=atol).item()
-            and np.isclose(self.p, other.p, atol=atol).item()
-        )
-
 
 def generalized_amplitude_damp(p: float, gamma: float) -> GeneralizedAmplitudeDampingChannel:
     r"""Returns a GeneralizedAmplitudeDampingChannel with probabilities gamma and p.
@@ -542,7 +528,7 @@ def generalized_amplitude_damp(p: float, gamma: float) -> GeneralizedAmplitudeDa
     return GeneralizedAmplitudeDampingChannel(p, gamma)
 
 
-@value.value_equality
+@value.value_equality(approximate=True)
 class AmplitudeDampingChannel(raw_types.Gate):
     r"""Dampen qubit amplitudes through dissipation.
 
@@ -619,9 +605,6 @@ class AmplitudeDampingChannel(raw_types.Gate):
     def _json_dict_(self) -> Dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ['gamma'])
 
-    def _approx_eq_(self, other: Any, atol: float) -> bool:
-        return np.isclose(self.gamma, other.gamma, atol=atol).item()
-
 
 def amplitude_damp(gamma: float) -> AmplitudeDampingChannel:
     r"""Returns an AmplitudeDampingChannel with the given probability gamma.
@@ -702,7 +685,7 @@ class ResetChannel(raw_types.Gate):
         return True
 
     def _qasm_(self, args: 'cirq.QasmArgs', qubits: Tuple['cirq.Qid', ...]) -> Optional[str]:
-        args.validate_version('2.0')
+        args.validate_version('2.0', '3.0')
         return args.format('reset {0};\n', qubits[0])
 
     def _qid_shape_(self):
@@ -787,7 +770,7 @@ def reset_each(*qubits: 'cirq.Qid') -> List[raw_types.Operation]:
     return [ResetChannel(q.dimension).on(q) for q in qubits]
 
 
-@value.value_equality
+@value.value_equality(approximate=True)
 class PhaseDampingChannel(raw_types.Gate):
     r"""Dampen qubit phase.
 
@@ -881,9 +864,6 @@ class PhaseDampingChannel(raw_types.Gate):
     def _json_dict_(self) -> Dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ['gamma'])
 
-    def _approx_eq_(self, other: Any, atol: float) -> bool:
-        return np.isclose(self._gamma, other._gamma, atol=atol).item()
-
 
 def phase_damp(gamma: float) -> PhaseDampingChannel:
     r"""Creates a PhaseDampingChannel with damping constant gamma.
@@ -919,7 +899,7 @@ def phase_damp(gamma: float) -> PhaseDampingChannel:
     return PhaseDampingChannel(gamma)
 
 
-@value.value_equality
+@value.value_equality(approximate=True)
 class PhaseFlipChannel(raw_types.Gate):
     r"""Probabilistically flip the sign of the phase of a qubit.
 
@@ -991,9 +971,6 @@ class PhaseFlipChannel(raw_types.Gate):
     def _json_dict_(self) -> Dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ['p'])
 
-    def _approx_eq_(self, other: Any, atol: float) -> bool:
-        return np.isclose(self.p, other.p, atol=atol).item()
-
 
 def _phase_flip_Z() -> common_gates.ZPowGate:
     """Returns a cirq.Z which corresponds to a guaranteed phase flip."""
@@ -1073,7 +1050,7 @@ def phase_flip(p: Optional[float] = None) -> Union[common_gates.ZPowGate, PhaseF
     return _phase_flip(p)
 
 
-@value.value_equality
+@value.value_equality(approximate=True)
 class BitFlipChannel(raw_types.Gate):
     r"""Probabilistically flip a qubit from 1 to 0 state or vice versa.
 
@@ -1112,15 +1089,12 @@ class BitFlipChannel(raw_types.Gate):
             ValueError: if p is not a valid probability.
         """
         self._p = value.validate_probability(p, 'p')
-        self._delegate = AsymmetricDepolarizingChannel(p, 0.0, 0.0)
 
     def _num_qubits_(self) -> int:
         return 1
 
-    def _mixture_(self) -> Sequence[Tuple[float, np.ndarray]]:
-        mixture = self._delegate._mixture_()
-        # just return identity and x term
-        return (mixture[0], mixture[1])
+    def _mixture_(self) -> Sequence[Tuple[float, Any]]:
+        return ((1 - self._p, identity.I), (self._p, pauli_gates.X))
 
     def _has_mixture_(self) -> bool:
         return True
@@ -1148,9 +1122,6 @@ class BitFlipChannel(raw_types.Gate):
     def _json_dict_(self) -> Dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ['p'])
 
-    def _approx_eq_(self, other: Any, atol: float) -> bool:
-        return np.isclose(self._p, other._p, atol=atol).item()
-
 
 def _bit_flip(p: float) -> BitFlipChannel:
     r"""Construct a BitFlipChannel that flips a qubit state with probability of a flip given by p.

cirq/ops/common_channels_test.py

@@ -92,6 +92,7 @@ def test_asymmetric_depolarizing_channel_eq():
     c = cirq.asymmetric_depolarize(0.0, 0.0, 0.0)
 
     assert cirq.approx_eq(a, b, atol=1e-2)
+    assert not cirq.approx_eq(a, cirq.X)
 
     et = cirq.testing.EqualsTester()
     et.make_equality_group(lambda: c)
@@ -276,6 +277,7 @@ def test_depolarizing_channel_eq():
     c = cirq.depolarize(0.0)
 
     assert cirq.approx_eq(a, b, atol=1e-2)
+    assert not cirq.approx_eq(a, cirq.X)
 
     et = cirq.testing.EqualsTester()
 
@@ -283,6 +285,7 @@ def test_depolarizing_channel_eq():
     et.add_equality_group(cirq.depolarize(0.1))
     et.add_equality_group(cirq.depolarize(0.9))
     et.add_equality_group(cirq.depolarize(1.0))
+    et.add_equality_group(cirq.depolarize(1.0, n_qubits=2))
 
 
 def test_depolarizing_channel_invalid_probability():
@@ -349,6 +352,7 @@ def test_generalized_amplitude_damping_channel_eq():
     b = cirq.generalized_amplitude_damp(0.01, 0.0099999)
 
     assert cirq.approx_eq(a, b, atol=1e-2)
+    assert not cirq.approx_eq(a, cirq.X)
 
     et = cirq.testing.EqualsTester()
     c = cirq.generalized_amplitude_damp(0.0, 0.0)
@@ -411,6 +415,7 @@ def test_amplitude_damping_channel_eq():
     c = cirq.amplitude_damp(0.0)
 
     assert cirq.approx_eq(a, b, atol=1e-2)
+    assert not cirq.approx_eq(a, cirq.X)
 
     et = cirq.testing.EqualsTester()
     et.make_equality_group(lambda: c)
@@ -562,6 +567,7 @@ def test_phase_damping_channel_eq():
     c = cirq.phase_damp(0.0)
 
     assert cirq.approx_eq(a, b, atol=1e-2)
+    assert not cirq.approx_eq(a, cirq.X)
 
     et = cirq.testing.EqualsTester()
     et.make_equality_group(lambda: c)
@@ -636,6 +642,7 @@ def test_phase_flip_channel_eq():
     c = cirq.phase_flip(0.0)
 
     assert cirq.approx_eq(a, b, atol=1e-2)
+    assert not cirq.approx_eq(a, cirq.X)
 
     et = cirq.testing.EqualsTester()
     et.make_equality_group(lambda: c)
@@ -701,6 +708,7 @@ def test_bit_flip_channel_eq():
     c = cirq.bit_flip(0.0)
 
     assert cirq.approx_eq(a, b, atol=1e-2)
+    assert not cirq.approx_eq(a, cirq.X)
 
     et = cirq.testing.EqualsTester()
     et.make_equality_group(lambda: c)
@@ -834,6 +842,8 @@ def test_multi_asymmetric_depolarizing_eq():
 
     assert cirq.approx_eq(a, b, atol=1e-3)
 
+    assert not cirq.approx_eq(a, cirq.X)
+
 
 def test_multi_asymmetric_depolarizing_channel_str():
     assert str(cirq.asymmetric_depolarize(error_probabilities={'II': 0.8, 'XX': 0.2})) == (

cirq/ops/common_gate_families.py

@@ -16,8 +16,8 @@
 
 from typing import Any, cast, Optional, Type, Union
 
-from cirq.ops import gateset, raw_types, parallel_gate, eigen_gate
 from cirq import protocols
+from cirq.ops import eigen_gate, gateset, parallel_gate, raw_types
 
 
 class AnyUnitaryGateFamily(gateset.GateFamily):

cirq/ops/common_gate_families_test.py

@@ -14,6 +14,7 @@
 
 import pytest
 import sympy
+
 import cirq
 from cirq.ops.gateset_test import CustomX, CustomXPowGate