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

cirq/ops/linear_combinations_test.py

@@ -1156,6 +1156,22 @@ def test_pauli_sum_pow():
     for psum in [psum1, psum2, psum3, psum4]:
         assert cirq.approx_eq(psum**0, identity)
 
+    # tests for exponents greater than two for both even and odd
+    psum5 = cirq.Z(q0) * cirq.Z(q1) + cirq.Z(q2) + cirq.Z(q3)
+    correctresult = psum5.copy()
+    for e in range(1, 9):
+        assert correctresult == psum5**e
+        correctresult *= psum5
+
+    psum6 = cirq.X(q0) * cirq.Y(q1) + cirq.Z(q2) + cirq.X(q3)
+    assert psum6 * psum6 * psum6 * psum6 * psum6 * psum6 * psum6 * psum6 == psum6**8
+
+    # test to ensure pow doesn't make any change to the original value
+    psum7 = cirq.X(q0) * cirq.Y(q1) + cirq.Z(q2)
+    psum7copy = psum7.copy()
+    assert psum7**5 == psum7 * psum7 * psum7 * psum7 * psum7
+    assert psum7copy == psum7
+
 
 # Using the entries of table 1 of https://arxiv.org/abs/1804.09130 as golden values.
 @pytest.mark.parametrize(
@@ -1302,7 +1318,7 @@ def test_expectation_from_state_vector_two_qubit_states():
     psum1 = cirq.Z(q[0]) + 3.2 * cirq.Z(q[1])
     psum2 = -1 * cirq.X(q[0]) + 2 * cirq.X(q[1])
     wf1 = np.array([0, 1, 0, 0], dtype=complex)
-    for state in [wf1, wf1.reshape(2, 2)]:
+    for state in [wf1, wf1.reshape((2, 2))]:
         np.testing.assert_allclose(
             psum1.expectation_from_state_vector(state, qubit_map=q_map), -2.2, atol=1e-7
         )
@@ -1311,7 +1327,7 @@ def test_expectation_from_state_vector_two_qubit_states():
         )
 
     wf2 = np.array([1, 1, 1, 1], dtype=complex) / 2
-    for state in [wf2, wf2.reshape(2, 2)]:
+    for state in [wf2, wf2.reshape((2, 2))]:
         np.testing.assert_allclose(
             psum1.expectation_from_state_vector(state, qubit_map=q_map), 0, atol=1e-7
         )
@@ -1322,7 +1338,7 @@ def test_expectation_from_state_vector_two_qubit_states():
     psum3 = cirq.Z(q[0]) + cirq.X(q[1])
     wf3 = np.array([1, 1, 0, 0], dtype=complex) / np.sqrt(2)
     q_map_2 = {q0: 1, q1: 0}
-    for state in [wf3, wf3.reshape(2, 2)]:
+    for state in [wf3, wf3.reshape((2, 2))]:
         np.testing.assert_allclose(
             psum3.expectation_from_state_vector(state, qubit_map=q_map), 2, atol=1e-7
         )
@@ -1336,7 +1352,7 @@ def test_expectation_from_density_matrix_invalid_input():
     psum = cirq.X(q0) + 2 * cirq.Y(q1) + 3 * cirq.Z(q3)
     q_map = {q0: 0, q1: 1, q3: 2}
     wf = np.array([1, 0, 0, 0, 0, 0, 0, 0], dtype=np.complex64)
-    rho = np.kron(wf.conjugate().T, wf).reshape(8, 8)
+    rho = np.kron(wf.conjugate().T, wf).reshape((8, 8))
 
     im_psum = (1j + 1) * psum
     with pytest.raises(NotImplementedError, match='non-Hermitian'):
@@ -1443,24 +1459,24 @@ def test_expectation_from_density_matrix_two_qubit_states():
     psum1 = cirq.Z(q[0]) + 3.2 * cirq.Z(q[1])
     psum2 = -1 * cirq.X(q[0]) + 2 * cirq.X(q[1])
     wf1 = np.array([0, 1, 0, 0], dtype=complex)
-    rho1 = np.kron(wf1, wf1).reshape(4, 4)
-    for state in [rho1, rho1.reshape(2, 2, 2, 2)]:
+    rho1 = np.kron(wf1, wf1).reshape((4, 4))
+    for state in [rho1, rho1.reshape((2, 2, 2, 2))]:
         np.testing.assert_allclose(
             psum1.expectation_from_density_matrix(state, qubit_map=q_map), -2.2
         )
         np.testing.assert_allclose(psum2.expectation_from_density_matrix(state, qubit_map=q_map), 0)
 
     wf2 = np.array([1, 1, 1, 1], dtype=complex) / 2
-    rho2 = np.kron(wf2, wf2).reshape(4, 4)
-    for state in [rho2, rho2.reshape(2, 2, 2, 2)]:
+    rho2 = np.kron(wf2, wf2).reshape((4, 4))
+    for state in [rho2, rho2.reshape((2, 2, 2, 2))]:
         np.testing.assert_allclose(psum1.expectation_from_density_matrix(state, qubit_map=q_map), 0)
         np.testing.assert_allclose(psum2.expectation_from_density_matrix(state, qubit_map=q_map), 1)
 
     psum3 = cirq.Z(q[0]) + cirq.X(q[1])
     wf3 = np.array([1, 1, 0, 0], dtype=complex) / np.sqrt(2)
-    rho3 = np.kron(wf3, wf3).reshape(4, 4)
+    rho3 = np.kron(wf3, wf3).reshape((4, 4))
     q_map_2 = {q0: 1, q1: 0}
-    for state in [rho3, rho3.reshape(2, 2, 2, 2)]:
+    for state in [rho3, rho3.reshape((2, 2, 2, 2))]:
         np.testing.assert_allclose(psum3.expectation_from_density_matrix(state, qubit_map=q_map), 2)
         np.testing.assert_allclose(
             psum3.expectation_from_density_matrix(state, qubit_map=q_map_2), 0

cirq/ops/matrix_gates.py

@@ -53,7 +53,7 @@ class MatrixGate(raw_types.Gate):
         self,
         matrix: np.ndarray,
         *,
-        name: str = None,
+        name: Optional[str] = None,
         qid_shape: Optional[Iterable[int]] = None,
         unitary_check: bool = True,
         unitary_check_rtol: float = 1e-5,
@@ -114,11 +114,15 @@ class MatrixGate(raw_types.Gate):
         return MatrixGate(self._matrix, name=name, qid_shape=self._qid_shape, unitary_check=False)
 
     def _json_dict_(self) -> Dict[str, Any]:
-        return {'matrix': self._matrix.tolist(), 'qid_shape': self._qid_shape}
+        return {
+            'matrix': self._matrix.tolist(),
+            'qid_shape': self._qid_shape,
+            **({'name': self._name} if self._name is not None else {}),
+        }
 
     @classmethod
-    def _from_json_dict_(cls, matrix, qid_shape, **kwargs):
-        return cls(matrix=np.array(matrix), qid_shape=qid_shape)
+    def _from_json_dict_(cls, matrix, qid_shape, name=None, **kwargs):
+        return cls(matrix=np.array(matrix), qid_shape=qid_shape, name=name)
 
     def _qid_shape_(self) -> Tuple[int, ...]:
         return self._qid_shape

cirq/ops/matrix_gates_test.py

@@ -29,12 +29,12 @@ def test_single_qubit_init():
     m = np.array([[1, 1j], [1j, 1]]) * np.sqrt(0.5)
     x2 = cirq.MatrixGate(m)
     assert cirq.has_unitary(x2)
-    assert np.alltrue(cirq.unitary(x2) == m)
+    assert np.all(cirq.unitary(x2) == m)
     assert cirq.qid_shape(x2) == (2,)
 
     x2 = cirq.MatrixGate(PLUS_ONE, qid_shape=(3,))
     assert cirq.has_unitary(x2)
-    assert np.alltrue(cirq.unitary(x2) == PLUS_ONE)
+    assert np.all(cirq.unitary(x2) == PLUS_ONE)
     assert cirq.qid_shape(x2) == (3,)
 
     with pytest.raises(ValueError, match='Not a .*unitary matrix'):
@@ -97,7 +97,7 @@ def test_single_qubit_extrapolate():
 def test_two_qubit_init():
     x2 = cirq.MatrixGate(QFT2)
     assert cirq.has_unitary(x2)
-    assert np.alltrue(cirq.unitary(x2) == QFT2)
+    assert np.all(cirq.unitary(x2) == QFT2)
 
 
 def test_two_qubit_eq():
@@ -388,3 +388,25 @@ def test_matrixgate_unitary_tolerance():
     # very low atol -> the check never converges
     with pytest.raises(ValueError):
         _ = cirq.MatrixGate(np.array([[0.707, 0.707], [-0.707, 0.707]]), unitary_check_rtol=1e-10)
+
+
+def test_matrixgate_name_serialization():
+    # https://github.com/quantumlib/Cirq/issues/5999
+
+    # Test name serialization
+    gate1 = cirq.MatrixGate(np.eye(2), name='test_name')
+    gate_after_serialization1 = cirq.read_json(json_text=cirq.to_json(gate1))
+    assert gate1._name == 'test_name'
+    assert gate_after_serialization1._name == 'test_name'
+
+    # Test name backwards compatibility
+    gate2 = cirq.MatrixGate(np.eye(2))
+    gate_after_serialization2 = cirq.read_json(json_text=cirq.to_json(gate2))
+    assert gate2._name is None
+    assert gate_after_serialization2._name is None
+
+    # Test empty name
+    gate3 = cirq.MatrixGate(np.eye(2), name='')
+    gate_after_serialization3 = cirq.read_json(json_text=cirq.to_json(gate3))
+    assert gate3._name == ''
+    assert gate_after_serialization3._name == ''

cirq/ops/measure_util.py

@@ -46,18 +46,22 @@ def measure_single_paulistring(
 
     Raises:
         ValueError: if the observable is not an instance of PauliString or if the coefficient
-            is not +1.
+            is not +1 or -1.
     """
     if not isinstance(pauli_observable, pauli_string.PauliString):
         raise ValueError(
             f'Pauli observable {pauli_observable} should be an instance of cirq.PauliString.'
         )
-    if pauli_observable.coefficient != 1:
-        raise ValueError(f"Pauli observable {pauli_observable} must have a coefficient of +1.")
+    if abs(pauli_observable.coefficient) != 1:
+        raise ValueError(
+            f"Pauli observable {pauli_observable} must have a coefficient of +1 or -1."
+        )
 
     if key is None:
         key = _default_measurement_key(pauli_observable)
-    return PauliMeasurementGate(pauli_observable.values(), key).on(*pauli_observable.keys())
+    return PauliMeasurementGate(pauli_observable.dense(list(pauli_observable.keys())), key).on(
+        *pauli_observable.keys()
+    )
 
 
 def measure_paulistring_terms(
@@ -115,7 +119,8 @@ def measure(
 ) -> raw_types.Operation:
     """Returns a single MeasurementGate applied to all the given qubits.
 
-    The qubits are measured in the computational basis.
+    The qubits are measured in the computational basis. This can also be
+    used with the alias `cirq.M`.
 
     Args:
         *target: The qubits that the measurement gate should measure.
@@ -159,6 +164,9 @@ def measure(
     return MeasurementGate(len(targets), key, invert_mask, qid_shape, confusion_map).on(*targets)
 
 
+M = measure
+
+
 @overload
 def measure_each(
     *qubits: raw_types.Qid, key_func: Callable[[raw_types.Qid], str] = str

cirq/ops/measure_util_test.py

@@ -95,6 +95,12 @@ def test_measure_single_paulistring():
         ps.values(), key='a'
     ).on(*ps.keys())
 
+    # Test with negative coefficient
+    ps_neg = -cirq.Y(cirq.LineQubit(0)) * cirq.Y(cirq.LineQubit(1))
+    assert cirq.measure_single_paulistring(ps_neg, key='1').gate == cirq.PauliMeasurementGate(
+        cirq.DensePauliString('YY', coefficient=-1), key='1'
+    )
+
     # Empty application
     with pytest.raises(ValueError, match='should be an instance of cirq.PauliString'):
         _ = cirq.measure_single_paulistring(cirq.I(q[0]) * cirq.I(q[1]))
@@ -103,9 +109,9 @@ def test_measure_single_paulistring():
     with pytest.raises(ValueError, match='should be an instance of cirq.PauliString'):
         _ = cirq.measure_single_paulistring(q)
 
-    # Coefficient != +1
+    # Coefficient != +1 or -1
     with pytest.raises(ValueError, match='must have a coefficient'):
-        _ = cirq.measure_single_paulistring(-ps)
+        _ = cirq.measure_single_paulistring(-2 * ps)
 
 
 def test_measure_paulistring_terms():

cirq/ops/measurement_gate.py

@@ -50,7 +50,7 @@ class MeasurementGate(raw_types.Gate):
         num_qubits: Optional[int] = None,
         key: Union[str, 'cirq.MeasurementKey'] = '',
         invert_mask: Tuple[bool, ...] = (),
-        qid_shape: Tuple[int, ...] = None,
+        qid_shape: Optional[Tuple[int, ...]] = None,
         confusion_map: Optional[Dict[Tuple[int, ...], np.ndarray]] = None,
     ) -> None:
         """Inits MeasurementGate.

cirq/ops/measurement_gate_test.py

@@ -317,23 +317,28 @@ def test_op_repr():
             b,
             key='out',
             invert_mask=(False, True),
-            confusion_map={(0,): np.array([[0, 1], [1, 0]], dtype=np.int64)},
+            confusion_map={(0,): np.array([[0, 1], [1, 0]], dtype=np.dtype('int64'))},
         )
     ) == (
         "cirq.measure(cirq.LineQubit(0), cirq.LineQubit(1), "
         "key=cirq.MeasurementKey(name='out'), "
         "invert_mask=(False, True), "
-        "confusion_map={(0,): np.array([[0, 1], [1, 0]], dtype=np.int64)})"
+        "confusion_map={(0,): np.array([[0, 1], [1, 0]], dtype=np.dtype('int64'))})"
     )
 
 
 def test_repr():
     gate = cirq.MeasurementGate(
-        3, 'a', (True, False), (1, 2, 3), {(2,): np.array([[0, 1], [1, 0]], dtype=np.int64)}
+        3,
+        'a',
+        (True, False),
+        (1, 2, 3),
+        {(2,): np.array([[0, 1], [1, 0]], dtype=np.dtype('int64'))},
     )
     assert repr(gate) == (
         "cirq.MeasurementGate(3, cirq.MeasurementKey(name='a'), (True, False), "
-        "qid_shape=(1, 2, 3), confusion_map={(2,): np.array([[0, 1], [1, 0]], dtype=np.int64)})"
+        "qid_shape=(1, 2, 3), "
+        "confusion_map={(2,): np.array([[0, 1], [1, 0]], dtype=np.dtype('int64'))})"
     )
 
 

cirq/ops/mixed_unitary_channel_test.py

@@ -95,16 +95,16 @@ def test_matrix_mixture_str():
 
 def test_matrix_mixture_repr():
     mix = [
-        (0.5, np.array([[1, 0], [0, 1]], dtype=np.complex64)),
-        (0.5, np.array([[0, 1], [1, 0]], dtype=np.complex64)),
+        (0.5, np.array([[1, 0], [0, 1]], dtype=np.dtype('complex64'))),
+        (0.5, np.array([[0, 1], [1, 0]], dtype=np.dtype('complex64'))),
     ]
     half_flip = cirq.MixedUnitaryChannel(mix, key='flip')
     assert (
         repr(half_flip)
         == """\
 cirq.MixedUnitaryChannel(mixture=[\
-(0.5, np.array([[(1+0j), 0j], [0j, (1+0j)]], dtype=np.complex64)), \
-(0.5, np.array([[0j, (1+0j)], [(1+0j), 0j]], dtype=np.complex64))], \
+(0.5, np.array([[(1+0j), 0j], [0j, (1+0j)]], dtype=np.dtype('complex64'))), \
+(0.5, np.array([[0j, (1+0j)], [(1+0j), 0j]], dtype=np.dtype('complex64')))], \
 key='flip')"""
     )
 

cirq/ops/named_qubit.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 import functools
-from typing import Any, Dict, List, TYPE_CHECKING, TypeVar
+from typing import Any, Dict, List, TYPE_CHECKING
 
 from cirq import protocols
 from cirq.ops import raw_types
@@ -21,10 +21,8 @@ from cirq.ops import raw_types
 if TYPE_CHECKING:
     import cirq
 
-TSelf = TypeVar('TSelf', bound='_BaseNamedQid')
 
-
-@functools.total_ordering  # type: ignore
+@functools.total_ordering
 class _BaseNamedQid(raw_types.Qid):
     """The base class for `NamedQid` and `NamedQubit`."""
 

cirq/ops/parity_gates.py

@@ -15,6 +15,7 @@
 """Quantum gates that phase with respect to product-of-pauli observables."""
 
 from typing import Any, Dict, List, Optional, Tuple, Union, TYPE_CHECKING
+from typing_extensions import Self
 
 import numpy as np
 
@@ -295,6 +296,9 @@ class ZZPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate):
 
         return args.target_tensor
 
+    def _phase_by_(self, phase_turns: float, qubit_index: int) -> "ZZPowGate":
+        return self
+
     def __str__(self) -> str:
         if self._exponent == 1:
             return 'ZZ'
@@ -328,7 +332,7 @@ class MSGate(XXPowGate):
         XXPowGate.__init__(self, exponent=rads * 2 / np.pi, global_shift=-0.5)
         self.rads = rads
 
-    def _with_exponent(self: 'MSGate', exponent: value.TParamVal) -> 'MSGate':
+    def _with_exponent(self, exponent: value.TParamVal) -> Self:
         return type(self)(rads=exponent * np.pi / 2)
 
     def _circuit_diagram_info_(

cirq/ops/parity_gates_test.py

@@ -195,6 +195,12 @@ def test_zz_pow():
     assert (cirq.ZZ**-1) ** 0.5 == cirq.ZZ**-0.5
 
 
+def test_zz_phase_by():
+    assert cirq.phase_by(cirq.ZZ, 0.25, 0) == cirq.phase_by(cirq.ZZ, 0.25, 1) == cirq.ZZ
+    assert cirq.phase_by(cirq.ZZ**0.5, 0.25, 0) == cirq.ZZ**0.5
+    assert cirq.phase_by(cirq.ZZ**-0.5, 0.25, 1) == cirq.ZZ**-0.5
+
+
 def test_zz_str():
     assert str(cirq.ZZ) == 'ZZ'
     assert str(cirq.ZZ**0.5) == 'ZZ**0.5'

cirq/ops/pauli_gates.py

@@ -112,10 +112,10 @@ class _PauliX(Pauli, common_gates.XPowGate):
         Pauli.__init__(self, index=0, name='X')
         common_gates.XPowGate.__init__(self, exponent=1.0)
 
-    def __pow__(self: '_PauliX', exponent: 'cirq.TParamVal') -> common_gates.XPowGate:
+    def __pow__(self, exponent: 'cirq.TParamVal') -> common_gates.XPowGate:
         return common_gates.XPowGate(exponent=exponent) if exponent != 1 else _PauliX()
 
-    def _with_exponent(self: '_PauliX', exponent: 'cirq.TParamVal') -> common_gates.XPowGate:
+    def _with_exponent(self, exponent: 'cirq.TParamVal') -> common_gates.XPowGate:
         return self.__pow__(exponent)
 
     @classmethod
@@ -125,7 +125,7 @@ class _PauliX(Pauli, common_gates.XPowGate):
         return Pauli._XYZ[0]
 
     @property
-    def basis(self: '_PauliX') -> Dict[int, '_XEigenState']:
+    def basis(self) -> Dict[int, '_XEigenState']:
         from cirq.value.product_state import _XEigenState
 
         return {+1: _XEigenState(+1), -1: _XEigenState(-1)}
@@ -136,10 +136,10 @@ class _PauliY(Pauli, common_gates.YPowGate):
         Pauli.__init__(self, index=1, name='Y')
         common_gates.YPowGate.__init__(self, exponent=1.0)
 
-    def __pow__(self: '_PauliY', exponent: 'cirq.TParamVal') -> common_gates.YPowGate:
+    def __pow__(self, exponent: 'cirq.TParamVal') -> common_gates.YPowGate:
         return common_gates.YPowGate(exponent=exponent) if exponent != 1 else _PauliY()
 
-    def _with_exponent(self: '_PauliY', exponent: 'cirq.TParamVal') -> common_gates.YPowGate:
+    def _with_exponent(self, exponent: 'cirq.TParamVal') -> common_gates.YPowGate:
         return self.__pow__(exponent)
 
     @classmethod
@@ -149,7 +149,7 @@ class _PauliY(Pauli, common_gates.YPowGate):
         return Pauli._XYZ[1]
 
     @property
-    def basis(self: '_PauliY') -> Dict[int, '_YEigenState']:
+    def basis(self) -> Dict[int, '_YEigenState']:
         from cirq.value.product_state import _YEigenState
 
         return {+1: _YEigenState(+1), -1: _YEigenState(-1)}
@@ -160,10 +160,10 @@ class _PauliZ(Pauli, common_gates.ZPowGate):
         Pauli.__init__(self, index=2, name='Z')
         common_gates.ZPowGate.__init__(self, exponent=1.0)
 
-    def __pow__(self: '_PauliZ', exponent: 'cirq.TParamVal') -> common_gates.ZPowGate:
+    def __pow__(self, exponent: 'cirq.TParamVal') -> common_gates.ZPowGate:
         return common_gates.ZPowGate(exponent=exponent) if exponent != 1 else _PauliZ()
 
-    def _with_exponent(self: '_PauliZ', exponent: 'cirq.TParamVal') -> common_gates.ZPowGate:
+    def _with_exponent(self, exponent: 'cirq.TParamVal') -> common_gates.ZPowGate:
         return self.__pow__(exponent)
 
     @classmethod
@@ -173,7 +173,7 @@ class _PauliZ(Pauli, common_gates.ZPowGate):
         return Pauli._XYZ[2]
 
     @property
-    def basis(self: '_PauliZ') -> Dict[int, '_ZEigenState']:
+    def basis(self) -> Dict[int, '_ZEigenState']:
         from cirq.value.product_state import _ZEigenState
 
         return {+1: _ZEigenState(+1), -1: _ZEigenState(-1)}

cirq/ops/pauli_string.py

@@ -242,12 +242,14 @@ class PauliString(raw_types.Operation, Generic[TKey]):
     def get(self, key: Any, default: TDefault) -> Union[pauli_gates.Pauli, TDefault]:
         pass
 
-    def get(self, key: Any, default: TDefault = None) -> Union[pauli_gates.Pauli, TDefault, None]:
+    def get(
+        self, key: Any, default: Optional[TDefault] = None
+    ) -> Union[pauli_gates.Pauli, TDefault, None]:
         """Returns the `cirq.Pauli` operation acting on qubit `key` or `default` if none exists."""
         return self._qubit_pauli_map.get(key, default)
 
     @overload
-    def __mul__(  # type: ignore
+    def __mul__(
         self, other: 'cirq.PauliString[TKeyOther]'
     ) -> 'cirq.PauliString[Union[TKey, TKeyOther]]':
         pass

cirq/ops/pauli_string_raw_types.py

@@ -13,7 +13,8 @@
 # limitations under the License.
 
 import abc
-from typing import Any, Dict, Sequence, Tuple, TypeVar, TYPE_CHECKING
+from typing import Any, Dict, Sequence, Tuple, TYPE_CHECKING
+from typing_extensions import Self
 
 from cirq import protocols
 from cirq.ops import pauli_string as ps, raw_types
@@ -21,10 +22,6 @@ from cirq.ops import pauli_string as ps, raw_types
 if TYPE_CHECKING:
     import cirq
 
-TSelf_PauliStringGateOperation = TypeVar(
-    'TSelf_PauliStringGateOperation', bound='PauliStringGateOperation'
-)
-
 
 class PauliStringGateOperation(raw_types.Operation, metaclass=abc.ABCMeta):
     def __init__(self, pauli_string: ps.PauliString) -> None:
@@ -38,16 +35,12 @@ class PauliStringGateOperation(raw_types.Operation, metaclass=abc.ABCMeta):
         if len(qubits) != len(self.pauli_string):
             raise ValueError('Incorrect number of qubits for gate')
 
-    def with_qubits(
-        self: TSelf_PauliStringGateOperation, *new_qubits: 'cirq.Qid'
-    ) -> TSelf_PauliStringGateOperation:
+    def with_qubits(self, *new_qubits: 'cirq.Qid') -> Self:
         self.validate_args(new_qubits)
         return self.map_qubits(dict(zip(self.pauli_string.qubits, new_qubits)))
 
     @abc.abstractmethod
-    def map_qubits(
-        self: TSelf_PauliStringGateOperation, qubit_map: Dict[raw_types.Qid, raw_types.Qid]
-    ) -> TSelf_PauliStringGateOperation:
+    def map_qubits(self, qubit_map: Dict[raw_types.Qid, raw_types.Qid]) -> Self:
         """Return an equivalent operation on new qubits with its Pauli string
         mapped to new qubits.
 

cirq/ops/pauli_string_test.py

@@ -1030,17 +1030,17 @@ def test_expectation_from_state_vector_entangled_states():
     x0x1 = cirq.PauliString(x0x1_pauli_map)
     q_map = {q0: 0, q1: 1}
     wf1 = np.array([0, 1, 1, 0], dtype=complex) / np.sqrt(2)
-    for state in [wf1, wf1.reshape(2, 2)]:
+    for state in [wf1, wf1.reshape((2, 2))]:
         np.testing.assert_allclose(z0z1.expectation_from_state_vector(state, q_map), -1)
         np.testing.assert_allclose(x0x1.expectation_from_state_vector(state, q_map), 1)
 
     wf2 = np.array([1, 0, 0, 1], dtype=complex) / np.sqrt(2)
-    for state in [wf2, wf2.reshape(2, 2)]:
+    for state in [wf2, wf2.reshape((2, 2))]:
         np.testing.assert_allclose(z0z1.expectation_from_state_vector(state, q_map), 1)
         np.testing.assert_allclose(x0x1.expectation_from_state_vector(state, q_map), 1)
 
     wf3 = np.array([1, 1, 1, 1], dtype=complex) / 2
-    for state in [wf3, wf3.reshape(2, 2)]:
+    for state in [wf3, wf3.reshape((2, 2))]:
         np.testing.assert_allclose(z0z1.expectation_from_state_vector(state, q_map), 0)
         np.testing.assert_allclose(x0x1.expectation_from_state_vector(state, q_map), 1)
 
@@ -1049,7 +1049,7 @@ def test_expectation_from_state_vector_qubit_map():
     q0, q1, q2 = _make_qubits(3)
     z = cirq.PauliString({q0: cirq.Z})
     wf = np.array([0, 1, 0, 1, 0, 0, 0, 0], dtype=complex) / np.sqrt(2)
-    for state in [wf, wf.reshape(2, 2, 2)]:
+    for state in [wf, wf.reshape((2, 2, 2))]:
         np.testing.assert_allclose(
             z.expectation_from_state_vector(state, {q0: 0, q1: 1, q2: 2}), 1, atol=1e-8
         )
@@ -1124,7 +1124,7 @@ def test_expectation_from_density_matrix_invalid_input():
     q0, q1, q2, q3 = _make_qubits(4)
     ps = cirq.PauliString({q0: cirq.X, q1: cirq.Y})
     wf = cirq.testing.random_superposition(4)
-    rho = np.kron(wf.conjugate().T, wf).reshape(4, 4)
+    rho = np.kron(wf.conjugate().T, wf).reshape((4, 4))
     q_map = {q0: 0, q1: 1}
 
     im_ps = (1j + 1) * ps
@@ -1238,20 +1238,20 @@ def test_expectation_from_density_matrix_entangled_states():
     q_map = {q0: 0, q1: 1}
 
     wf1 = np.array([0, 1, 1, 0], dtype=complex) / np.sqrt(2)
-    rho1 = np.kron(wf1, wf1).reshape(4, 4)
-    for state in [rho1, rho1.reshape(2, 2, 2, 2)]:
+    rho1 = np.kron(wf1, wf1).reshape((4, 4))
+    for state in [rho1, rho1.reshape((2, 2, 2, 2))]:
         np.testing.assert_allclose(z0z1.expectation_from_density_matrix(state, q_map), -1)
         np.testing.assert_allclose(x0x1.expectation_from_density_matrix(state, q_map), 1)
 
     wf2 = np.array([1, 0, 0, 1], dtype=complex) / np.sqrt(2)
-    rho2 = np.kron(wf2, wf2).reshape(4, 4)
-    for state in [rho2, rho2.reshape(2, 2, 2, 2)]:
+    rho2 = np.kron(wf2, wf2).reshape((4, 4))
+    for state in [rho2, rho2.reshape((2, 2, 2, 2))]:
         np.testing.assert_allclose(z0z1.expectation_from_density_matrix(state, q_map), 1)
         np.testing.assert_allclose(x0x1.expectation_from_density_matrix(state, q_map), 1)
 
     wf3 = np.array([1, 1, 1, 1], dtype=complex) / 2
-    rho3 = np.kron(wf3, wf3).reshape(4, 4)
-    for state in [rho3, rho3.reshape(2, 2, 2, 2)]:
+    rho3 = np.kron(wf3, wf3).reshape((4, 4))
+    for state in [rho3, rho3.reshape((2, 2, 2, 2))]:
         np.testing.assert_allclose(z0z1.expectation_from_density_matrix(state, q_map), 0)
         np.testing.assert_allclose(x0x1.expectation_from_density_matrix(state, q_map), 1)
 
@@ -1260,9 +1260,9 @@ def test_expectation_from_density_matrix_qubit_map():
     q0, q1, q2 = _make_qubits(3)
     z = cirq.PauliString({q0: cirq.Z})
     wf = np.array([0, 1, 0, 1, 0, 0, 0, 0], dtype=complex) / np.sqrt(2)
-    rho = np.kron(wf, wf).reshape(8, 8)
+    rho = np.kron(wf, wf).reshape((8, 8))
 
-    for state in [rho, rho.reshape(2, 2, 2, 2, 2, 2)]:
+    for state in [rho, rho.reshape((2, 2, 2, 2, 2, 2))]:
         np.testing.assert_allclose(
             z.expectation_from_density_matrix(state, {q0: 0, q1: 1, q2: 2}), 1
         )

cirq/ops/pauli_sum_exponential.py

@@ -16,7 +16,7 @@ from typing import Any, Iterator, Tuple, Union, TYPE_CHECKING
 import numpy as np
 import sympy
 
-from cirq import linalg, protocols, value
+from cirq import linalg, protocols, value, _compat
 from cirq.ops import linear_combinations, pauli_string_phasor
 
 if TYPE_CHECKING:
@@ -78,6 +78,10 @@ class PauliSumExponential:
     def with_qubits(self, *new_qubits: 'cirq.Qid') -> 'PauliSumExponential':
         return PauliSumExponential(self._pauli_sum.with_qubits(*new_qubits), self._exponent)
 
+    @_compat.cached_method
+    def _is_parameterized_(self) -> bool:
+        return protocols.is_parameterized(self._exponent)
+
     def _resolve_parameters_(
         self, resolver: 'cirq.ParamResolver', recursive: bool
     ) -> 'PauliSumExponential':
@@ -109,6 +113,7 @@ class PauliSumExponential:
             ret = np.kron(ret, protocols.unitary(pauli_string_exp))
         return ret
 
+    @_compat.cached_method
     def _has_unitary_(self) -> bool:
         return linalg.is_unitary(self.matrix())