cirq-core 1.1.0.dev20221220224914__py3-none-any.whl → 1.2.0__py3-none-any.whl

cirq/linalg/transformations.py

@@ -29,6 +29,8 @@ from cirq.linalg import predicates
 # user provides a different np.array([]) value.
 RaiseValueErrorIfNotProvided: np.ndarray = np.array([])
 
+_NPY_MAXDIMS = 32  # Should be changed once numpy/numpy#5744 is resolved.
+
 
 def reflection_matrix_pow(reflection_matrix: np.ndarray, exponent: float):
     """Raises a matrix with two opposing eigenvalues to a power.
@@ -249,7 +251,7 @@ def targeted_conjugate_about(
     tensor: np.ndarray,
     target: np.ndarray,
     indices: Sequence[int],
-    conj_indices: Sequence[int] = None,
+    conj_indices: Optional[Sequence[int]] = None,
     buffer: Optional[np.ndarray] = None,
     out: Optional[np.ndarray] = None,
 ) -> np.ndarray:
@@ -399,13 +401,13 @@ def partial_trace(tensor: np.ndarray, keep_indices: Sequence[int]) -> np.ndarray
     ndim = tensor.ndim // 2
     if not all(tensor.shape[i] == tensor.shape[i + ndim] for i in range(ndim)):
         raise ValueError(
-            'Tensors must have shape (d_0,...,d_{{k-1}},d_0,...,'
-            'd_{{k-1}}) but had shape ({}).'.format(tensor.shape)
+            f'Tensors must have shape (d_0,...,d_{{k-1}},d_0,...,'
+            f'd_{{k-1}}) but had shape ({tensor.shape}).'
         )
     if not all(i < ndim for i in keep_indices):
         raise ValueError(
-            'keep_indices were {} but must be in first half, '
-            'i.e. have index less that {}.'.format(keep_indices, ndim)
+            f'keep_indices were {keep_indices} but must be in first half, '
+            f'i.e. have index less that {ndim}.'
         )
     keep_set = set(keep_indices)
     keep_map = dict(zip(keep_indices, sorted(keep_indices)))
@@ -530,8 +532,8 @@ def sub_state_vector(
 
     if not np.log2(state_vector.size).is_integer():
         raise ValueError(
-            "Input state_vector of size {} does not represent a "
-            "state over qubits.".format(state_vector.size)
+            f"Input state_vector of size {state_vector.size} does not represent a "
+            "state over qubits."
         )
 
     n_qubits = int(np.log2(state_vector.size))
@@ -572,8 +574,7 @@ def sub_state_vector(
         return default
 
     raise EntangledStateError(
-        "Input state vector could not be factored into pure state over "
-        "indices {}".format(keep_indices)
+        f"Input state vector could not be factored into pure state over indices {keep_indices}"
     )
 
 
@@ -746,3 +747,65 @@ def transpose_density_matrix_to_axis_order(t: np.ndarray, axes: Sequence[int]):
     """
     axes = list(axes) + [i + len(axes) for i in axes]
     return transpose_state_vector_to_axis_order(t, axes)
+
+
+def _volumes(shape: Sequence[int]) -> List[int]:
+    r"""Returns a list of the volume spanned by each dimension.
+
+    Given a shape=[d_0, d_1, .., d_n] the volume spanned by each dimension is
+        volume[i] = `\prod_{j=i+1}^n d_j`
+
+    Args:
+        shape: Sequence of the size of each dimension.
+
+    Returns:
+        Sequence of the volume spanned of each dimension.
+    """
+    volume = [0] * len(shape)
+    v = 1
+    for i in reversed(range(len(shape))):
+        volume[i] = v
+        v *= shape[i]
+    return volume
+
+
+def _coordinates_from_index(idx: int, volume: Sequence[int]) -> Sequence[int]:
+    ret = []
+    for v in volume:
+        ret.append(idx // v)
+        idx %= v
+    return tuple(ret)
+
+
+def _index_from_coordinates(s: Sequence[int], volume: Sequence[int]) -> int:
+    return np.dot(s, volume)
+
+
+def transpose_flattened_array(t: np.ndarray, shape: Sequence[int], axes: Sequence[int]):
+    """Transposes a flattened array.
+
+    Equivalent to np.transpose(t.reshape(shape), axes).reshape((-1,)).
+
+    Args:
+        t: flat array.
+        shape: the shape of `t` before flattening.
+        axes: permutation of range(len(shape)).
+
+    Returns:
+        Flattened transpose of `t`.
+    """
+    if len(t.shape) != 1:
+        t = t.reshape((-1,))
+    cur_volume = _volumes(shape)
+    new_volume = _volumes([shape[i] for i in axes])
+    ret = np.zeros_like(t)
+    for idx in range(t.shape[0]):
+        cell = _coordinates_from_index(idx, cur_volume)
+        new_cell = [cell[i] for i in axes]
+        ret[_index_from_coordinates(new_cell, new_volume)] = t[idx]
+    return ret
+
+
+def can_numpy_support_shape(shape: Sequence[int]) -> bool:
+    """Returns whether numpy supports the given shape or not numpy/numpy#5744."""
+    return len(shape) <= _NPY_MAXDIMS

cirq/linalg/transformations_test.py

@@ -17,6 +17,7 @@ import pytest
 
 import cirq
 import cirq.testing
+from cirq import linalg
 
 
 def test_reflection_matrix_pow_consistent_results():
@@ -352,20 +353,20 @@ def test_sub_state_vector():
     a = np.arange(4) / np.linalg.norm(np.arange(4))
     b = (np.arange(8) + 3) / np.linalg.norm(np.arange(8) + 3)
     c = (np.arange(16) + 1) / np.linalg.norm(np.arange(16) + 1)
-    state = np.kron(np.kron(a, b), c).reshape(2, 2, 2, 2, 2, 2, 2, 2, 2)
+    state = np.kron(np.kron(a, b), c).reshape((2, 2, 2, 2, 2, 2, 2, 2, 2))
 
     assert cirq.equal_up_to_global_phase(cirq.sub_state_vector(a, [0, 1], atol=1e-8), a)
     assert cirq.equal_up_to_global_phase(cirq.sub_state_vector(b, [0, 1, 2], atol=1e-8), b)
     assert cirq.equal_up_to_global_phase(cirq.sub_state_vector(c, [0, 1, 2, 3], atol=1e-8), c)
 
     assert cirq.equal_up_to_global_phase(
-        cirq.sub_state_vector(state, [0, 1], atol=1e-15), a.reshape(2, 2)
+        cirq.sub_state_vector(state, [0, 1], atol=1e-15), a.reshape((2, 2))
     )
     assert cirq.equal_up_to_global_phase(
-        cirq.sub_state_vector(state, [2, 3, 4], atol=1e-15), b.reshape(2, 2, 2)
+        cirq.sub_state_vector(state, [2, 3, 4], atol=1e-15), b.reshape((2, 2, 2))
     )
     assert cirq.equal_up_to_global_phase(
-        cirq.sub_state_vector(state, [5, 6, 7, 8], atol=1e-15), c.reshape(2, 2, 2, 2)
+        cirq.sub_state_vector(state, [5, 6, 7, 8], atol=1e-15), c.reshape((2, 2, 2, 2))
     )
 
     # Output state vector conforms to the shape of the input state vector.
@@ -485,15 +486,15 @@ def test_partial_trace_of_state_vector_as_mixture_pure_result():
 
     assert mixtures_equal(
         cirq.partial_trace_of_state_vector_as_mixture(state, [0, 1], atol=1e-8),
-        ((1.0, a.reshape(2, 2)),),
+        ((1.0, a.reshape((2, 2))),),
     )
     assert mixtures_equal(
         cirq.partial_trace_of_state_vector_as_mixture(state, [2, 3, 4], atol=1e-8),
-        ((1.0, b.reshape(2, 2, 2)),),
+        ((1.0, b.reshape((2, 2, 2))),),
     )
     assert mixtures_equal(
         cirq.partial_trace_of_state_vector_as_mixture(state, [5, 6, 7, 8], atol=1e-8),
-        ((1.0, c.reshape(2, 2, 2, 2)),),
+        ((1.0, c.reshape((2, 2, 2, 2))),),
     )
     assert mixtures_equal(
         cirq.partial_trace_of_state_vector_as_mixture(state, [0, 1, 2, 3, 4], atol=1e-8),
@@ -632,3 +633,18 @@ def test_factor_state_vector(state_1: int, state_2: int):
         # All phase goes into a1, and b1 is just the dephased state vector
         assert np.allclose(a1, a * phase)
         assert np.allclose(b1, b)
+
+
+@pytest.mark.parametrize('num_dimensions', [*range(1, 7)])
+def test_transpose_flattened_array(num_dimensions):
+    np.random.seed(0)
+    for _ in range(10):
+        shape = np.random.randint(1, 5, (num_dimensions,)).tolist()
+        axes = np.random.permutation(num_dimensions).tolist()
+        volume = np.prod(shape)
+        A = np.random.permutation(volume)
+        want = np.transpose(A.reshape(shape), axes)
+        got = linalg.transpose_flattened_array(A, shape, axes).reshape(want.shape)
+        assert np.array_equal(want, got)
+        got = linalg.transpose_flattened_array(A.reshape(shape), shape, axes).reshape(want.shape)
+        assert np.array_equal(want, got)

cirq/ops/__init__.py

@@ -41,6 +41,7 @@ from cirq.ops.common_channels import (
     phase_flip,
     PhaseDampingChannel,
     PhaseFlipChannel,
+    R,
     reset,
     reset_each,
     ResetChannel,
@@ -119,6 +120,8 @@ from cirq.ops.projector import ProjectorString
 
 from cirq.ops.controlled_operation import ControlledOperation
 
+from cirq.ops.qubit_manager import BorrowableQubit, CleanQubit, QubitManager, SimpleQubitManager
+
 from cirq.ops.qubit_order import QubitOrder
 
 from cirq.ops.qubit_order_or_list import QubitOrderOrList
@@ -126,6 +129,7 @@ from cirq.ops.qubit_order_or_list import QubitOrderOrList
 from cirq.ops.matrix_gates import MatrixGate
 
 from cirq.ops.measure_util import (
+    M,
     measure,
     measure_each,
     measure_paulistring_terms,

cirq/ops/arithmetic_operation.py

@@ -15,7 +15,8 @@
 
 import abc
 import itertools
-from typing import Union, Iterable, List, Sequence, cast, Tuple, TypeVar, TYPE_CHECKING
+from typing import Union, Iterable, List, Sequence, cast, Tuple, TYPE_CHECKING
+from typing_extensions import Self
 
 import numpy as np
 
@@ -25,9 +26,6 @@ if TYPE_CHECKING:
     import cirq
 
 
-TSelfGate = TypeVar('TSelfGate', bound='ArithmeticGate')
-
-
 class ArithmeticGate(Gate, metaclass=abc.ABCMeta):
     r"""A helper gate for implementing reversible classical arithmetic.
 
@@ -55,7 +53,7 @@ class ArithmeticGate(Gate, metaclass=abc.ABCMeta):
     ...
     ...     def with_registers(
     ...         self, *new_registers: 'Union[int, Sequence[int]]'
-    ...     ) -> 'TSelfGate':
+    ...     ) -> 'Add':
     ...         return Add(*new_registers)
     ...
     ...     def apply(self, *register_values: int) -> 'Union[int, Iterable[int]]':
@@ -105,7 +103,7 @@ class ArithmeticGate(Gate, metaclass=abc.ABCMeta):
         raise NotImplementedError()
 
     @abc.abstractmethod
-    def with_registers(self: TSelfGate, *new_registers: Union[int, Sequence[int]]) -> TSelfGate:
+    def with_registers(self, *new_registers: Union[int, Sequence[int]]) -> Self:
         """Returns the same fate targeting different registers.
 
         Args:

cirq/ops/classically_controlled_operation.py

@@ -28,7 +28,7 @@ from typing import (
 import sympy
 
 from cirq import protocols, value
-from cirq.ops import raw_types
+from cirq.ops import op_tree, raw_types
 
 if TYPE_CHECKING:
     import cirq
@@ -105,11 +105,18 @@ class ClassicallyControlledOperation(raw_types.Operation):
         )
 
     def _decompose_(self):
-        result = protocols.decompose_once(self._sub_operation, NotImplemented)
+        return self._decompose_with_context_()
+
+    def _decompose_with_context_(self, context: Optional['cirq.DecompositionContext'] = None):
+        result = protocols.decompose_once(
+            self._sub_operation, NotImplemented, flatten=False, context=context
+        )
         if result is NotImplemented:
             return NotImplemented
 
-        return [ClassicallyControlledOperation(op, self._conditions) for op in result]
+        return op_tree.transform_op_tree(
+            result, lambda op: ClassicallyControlledOperation(op, self._conditions)
+        )
 
     def _value_equality_values_(self):
         return (frozenset(self._conditions), self._sub_operation)

cirq/ops/clifford_gate.py

@@ -75,12 +75,6 @@ def _to_clifford_tableau(
     return clifford_tableau
 
 
-def _pretend_initialized() -> 'SingleQubitCliffordGate':
-    # HACK: This is a workaround to fool mypy and pylint into correctly handling
-    # class fields that can't be initialized until after the class is defined.
-    pass
-
-
 def _validate_map_input(
     required_transform_count: int,
     pauli_map_to: Optional[Dict[Pauli, Tuple[Pauli, bool]]],
@@ -97,6 +91,7 @@ def _validate_map_input(
             ' of x_to, y_to, and z_to but both were given'
         )
     if len(pauli_map_to) != required_transform_count:
+        # pylint: disable=consider-using-f-string
         raise ValueError(
             'Method takes {} transform{} but {} {} given'.format(
                 required_transform_count,
@@ -440,7 +435,6 @@ class CliffordGate(raw_types.Gate, CommonCliffordGates):
     def _act_on_(
         self, sim_state: 'cirq.SimulationStateBase', qubits: Sequence['cirq.Qid']
     ) -> Union[NotImplementedType, bool]:
-
         # Note the computation complexity difference between _decompose_ and _act_on_.
         # Suppose this Gate has `m` qubits, args has `n` qubits, and the decomposition of
         # this operation into `k` operations:

cirq/ops/common_channels.py

@@ -775,10 +775,16 @@ class ResetChannel(raw_types.Gate):
 
 
 def reset(qubit: 'cirq.Qid') -> raw_types.Operation:
-    """Returns a `cirq.ResetChannel` on the given qubit."""
+    """Returns a `cirq.ResetChannel` on the given qubit.
+
+    This can also be used with the alias `cirq.R`.
+    """
     return ResetChannel(qubit.dimension).on(qubit)
 
 
+R = reset
+
+
 def reset_each(*qubits: 'cirq.Qid') -> List[raw_types.Operation]:
     """Returns a list of `cirq.ResetChannel` instances on the given qubits."""
     return [ResetChannel(q.dimension).on(q) for q in qubits]
@@ -1010,15 +1016,15 @@ def _phase_flip(p: float) -> PhaseFlipChannel:
 
     $$
     \begin{aligned}
-    M_0 =& \sqrt{p} \begin{bmatrix}
+    M_0 =& \sqrt{1 - p} \begin{bmatrix}
                         1 & 0  \\
                         0 & 1
-                   \end{bmatrix}
+                    \end{bmatrix}
     \\
-    M_1 =& \sqrt{1-p} \begin{bmatrix}
+    M_1 =& \sqrt{p} \begin{bmatrix}
                         1 & 0 \\
                         0 & -1
-                     \end{bmatrix}
+                    \end{bmatrix}
     \end{aligned}
     $$
 
@@ -1046,15 +1052,15 @@ def phase_flip(p: Optional[float] = None) -> Union[common_gates.ZPowGate, PhaseF
 
     $$
     \begin{aligned}
-    M_0 =& \sqrt{p} \begin{bmatrix}
+    M_0 =& \sqrt{1 - p} \begin{bmatrix}
                         1 & 0  \\
                         0 & 1
-                   \end{bmatrix}
+                    \end{bmatrix}
     \\
-    M_1 =& \sqrt{1-p} \begin{bmatrix}
+    M_1 =& \sqrt{p} \begin{bmatrix}
                         1 & 0 \\
                         0 & -1
-                     \end{bmatrix}
+                    \end{bmatrix}
     \end{aligned}
     $$
 
@@ -1162,14 +1168,14 @@ def _bit_flip(p: float) -> BitFlipChannel:
 
     $$
     \begin{aligned}
-    M_0 =& \sqrt{p} \begin{bmatrix}
+    M_0 =& \sqrt{1-p} \begin{bmatrix}
                         1 & 0 \\
                         0 & 1
                    \end{bmatrix}
     \\
-    M_1 =& \sqrt{1-p} \begin{bmatrix}
+    M_1 =& \sqrt{p} \begin{bmatrix}
                         0 & 1 \\
-                        1 & -0
+                        1 & 0
                      \end{bmatrix}
     \end{aligned}
     $$
@@ -1198,14 +1204,14 @@ def bit_flip(p: Optional[float] = None) -> Union[common_gates.XPowGate, BitFlipC
 
     $$
     \begin{aligned}
-    M_0 =& \sqrt{p} \begin{bmatrix}
+    M_0 =& \sqrt{1-p} \begin{bmatrix}
                         1 & 0 \\
                         0 & 1
                    \end{bmatrix}
     \\
-    M_1 =& \sqrt{1-p} \begin{bmatrix}
+    M_1 =& \sqrt{p} \begin{bmatrix}
                         0 & 1 \\
-                        1 & -0
+                        1 & 0
                      \end{bmatrix}
     \end{aligned}
     $$

cirq/ops/common_gate_families.py

@@ -37,9 +37,8 @@ class AnyUnitaryGateFamily(gateset.GateFamily):
 
         self._num_qubits = num_qubits
         name = f'{str(num_qubits) if num_qubits else "Any"}-Qubit UnitaryGateFamily'
-        description = 'Accepts any {}unitary gate'.format(
-            f'{num_qubits}-qubit ' if num_qubits else ''
-        )
+        kind = f'{num_qubits}-qubit ' if num_qubits else ''
+        description = f'Accepts any {kind}unitary gate'
         super().__init__(raw_types.Gate, name=name, description=description)
 
     def _predicate(self, g: raw_types.Gate) -> bool:

cirq/ops/common_gates.py

@@ -11,6 +11,7 @@
 # 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.
+
 """Quantum gates that are commonly used in the literature.
 
 This module creates Gate instances for the following gates:
@@ -120,6 +121,10 @@ class XPowGate(eigen_gate.EigenGate):
         super().__init__(exponent=exponent, global_shift=global_shift)
         self._dimension = dimension
 
+    @property
+    def dimension(self) -> value.TParamVal:
+        return self._dimension
+
     def _num_qubits_(self) -> int:
         return 1
 
@@ -183,7 +188,7 @@ class XPowGate(eigen_gate.EigenGate):
 
     def controlled(
         self,
-        num_controls: int = None,
+        num_controls: Optional[int] = None,
         control_values: Optional[
             Union[cv.AbstractControlValues, Sequence[Union[int, Collection[int]]]]
         ] = None,
@@ -316,6 +321,18 @@ class XPowGate(eigen_gate.EigenGate):
         all_args = ', '.join(args)
         return f'cirq.XPowGate({all_args})'
 
+    def _json_dict_(self) -> Dict[str, Any]:
+        d = protocols.obj_to_dict_helper(self, ['exponent', 'global_shift'])
+        if self.dimension != 2:
+            d['dimension'] = self.dimension
+        return d
+
+    def _value_equality_values_(self):
+        return (*super()._value_equality_values_(), self._dimension)
+
+    def _value_equality_approximate_values_(self):
+        return (*super()._value_equality_approximate_values_(), self._dimension)
+
 
 class Rx(XPowGate):
     r"""A gate with matrix $e^{-i X t/2}$ that rotates around the X axis of the Bloch sphere by $t$.
@@ -341,7 +358,7 @@ class Rx(XPowGate):
         self._rads = rads
         super().__init__(exponent=rads / _pi(rads), global_shift=-0.5)
 
-    def _with_exponent(self: 'Rx', exponent: value.TParamVal) -> 'Rx':
+    def _with_exponent(self, exponent: value.TParamVal) -> 'Rx':
         return Rx(rads=exponent * _pi(exponent))
 
     def _circuit_diagram_info_(
@@ -496,8 +513,10 @@ class YPowGate(eigen_gate.EigenGate):
             if self._exponent == 1:
                 return 'cirq.Y'
             return f'(cirq.Y**{proper_repr(self._exponent)})'
-        return 'cirq.YPowGate(exponent={}, global_shift={!r})'.format(
-            proper_repr(self._exponent), self._global_shift
+        return (
+            'cirq.YPowGate('
+            f'exponent={proper_repr(self._exponent)}, '
+            f'global_shift={self._global_shift!r})'
         )
 
 
@@ -525,7 +544,7 @@ class Ry(YPowGate):
         self._rads = rads
         super().__init__(exponent=rads / _pi(rads), global_shift=-0.5)
 
-    def _with_exponent(self: 'Ry', exponent: value.TParamVal) -> 'Ry':
+    def _with_exponent(self, exponent: value.TParamVal) -> 'Ry':
         return Ry(rads=exponent * _pi(exponent))
 
     def _circuit_diagram_info_(
@@ -608,6 +627,10 @@ class ZPowGate(eigen_gate.EigenGate):
         super().__init__(exponent=exponent, global_shift=global_shift)
         self._dimension = dimension
 
+    @property
+    def dimension(self) -> value.TParamVal:
+        return self._dimension
+
     def _num_qubits_(self) -> int:
         return 1
 
@@ -647,7 +670,7 @@ class ZPowGate(eigen_gate.EigenGate):
 
     def controlled(
         self,
-        num_controls: int = None,
+        num_controls: Optional[int] = None,
         control_values: Optional[
             Union[cv.AbstractControlValues, Sequence[Union[int, Collection[int]]]]
         ] = None,
@@ -834,6 +857,18 @@ class ZPowGate(eigen_gate.EigenGate):
             return NotImplemented
         return True
 
+    def _json_dict_(self) -> Dict[str, Any]:
+        d = protocols.obj_to_dict_helper(self, ['exponent', 'global_shift'])
+        if self.dimension != 2:
+            d['dimension'] = self.dimension
+        return d
+
+    def _value_equality_values_(self):
+        return (*super()._value_equality_values_(), self._dimension)
+
+    def _value_equality_approximate_values_(self):
+        return (*super()._value_equality_approximate_values_(), self._dimension)
+
 
 class Rz(ZPowGate):
     r"""A gate with matrix $e^{-i Z t/2}$ that rotates around the Z axis of the Bloch sphere by $t$.
@@ -859,7 +894,7 @@ class Rz(ZPowGate):
         self._rads = rads
         super().__init__(exponent=rads / _pi(rads), global_shift=-0.5)
 
-    def _with_exponent(self: 'Rz', exponent: value.TParamVal) -> 'Rz':
+    def _with_exponent(self, exponent: value.TParamVal) -> 'Rz':
         return Rz(rads=exponent * _pi(exponent))
 
     def _circuit_diagram_info_(
@@ -1090,7 +1125,7 @@ class CZPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate):
 
     def controlled(
         self,
-        num_controls: int = None,
+        num_controls: Optional[int] = None,
         control_values: Optional[
             Union[cv.AbstractControlValues, Sequence[Union[int, Collection[int]]]]
         ] = None,
@@ -1189,8 +1224,10 @@ class CZPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate):
             if self._exponent == 1:
                 return 'cirq.CZ'
             return f'(cirq.CZ**{proper_repr(self._exponent)})'
-        return 'cirq.CZPowGate(exponent={}, global_shift={!r})'.format(
-            proper_repr(self._exponent), self._global_shift
+        return (
+            'cirq.CZPowGate('
+            f'exponent={proper_repr(self._exponent)}, '
+            f'global_shift={self._global_shift!r})'
         )
 
 
@@ -1296,7 +1333,7 @@ class CXPowGate(eigen_gate.EigenGate):
 
     def controlled(
         self,
-        num_controls: int = None,
+        num_controls: Optional[int] = None,
         control_values: Optional[
             Union[cv.AbstractControlValues, Sequence[Union[int, Collection[int]]]]
         ] = None,

cirq/ops/common_gates_test.py

@@ -1100,6 +1100,7 @@ def test_approx_eq():
 
 def test_xpow_dim_3():
     x = cirq.XPowGate(dimension=3)
+    assert cirq.X != x
     # fmt: off
     expected = [
         [0, 0, 1],
@@ -1127,6 +1128,7 @@ def test_xpow_dim_3():
 
 def test_xpow_dim_4():
     x = cirq.XPowGate(dimension=4)
+    assert cirq.X != x
     # fmt: off
     expected = [
         [0, 0, 0, 1],
@@ -1159,6 +1161,7 @@ def test_zpow_dim_3():
     L = np.exp(2 * np.pi * 1j / 3)
     L2 = L**2
     z = cirq.ZPowGate(dimension=3)
+    assert cirq.Z != z
     # fmt: off
     expected = [
         [1, 0, 0],
@@ -1209,6 +1212,7 @@ def test_zpow_dim_3():
 
 def test_zpow_dim_4():
     z = cirq.ZPowGate(dimension=4)
+    assert cirq.Z != z
     # fmt: off
     expected = [
         [1, 0, 0, 0],