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

cirq/contrib/qcircuit/qcircuit_test.py

@@ -33,17 +33,13 @@ def assert_has_qcircuit_diagram(actual: cirq.Circuit, desired: str, **kwargs) ->
         "Circuit's qcircuit diagram differs from the desired diagram.\n"
         '\n'
         'Diagram of actual circuit:\n'
-        '{}\n'
+        f'{actual_diagram}\n'
         '\n'
         'Desired qcircuit diagram:\n'
-        '{}\n'
+        f'{desired_diagram}\n'
         '\n'
         'Highlighted differences:\n'
-        '{}\n'.format(
-            actual_diagram,
-            desired_diagram,
-            ct.highlight_text_differences(actual_diagram, desired_diagram),
-        )
+        f'{ct.highlight_text_differences(actual_diagram, desired_diagram)}\n'
     )
 
 

cirq/contrib/quantum_volume/quantum_volume.py

@@ -200,7 +200,7 @@ def compile_circuit(
     *,
     device_graph: nx.Graph,
     routing_attempts: int,
-    compiler: Callable[[cirq.Circuit], cirq.Circuit] = None,
+    compiler: Optional[Callable[[cirq.Circuit], cirq.Circuit]] = None,
     routing_algo_name: Optional[str] = None,
     router: Optional[Callable[..., ccr.SwapNetwork]] = None,
     add_readout_error_correction=False,
@@ -357,7 +357,7 @@ def execute_circuits(
     samplers: List[cirq.Sampler],
     circuits: List[Tuple[cirq.Circuit, List[int]]],
     routing_attempts: int,
-    compiler: Callable[[cirq.Circuit], cirq.Circuit] = None,
+    compiler: Optional[Callable[[cirq.Circuit], cirq.Circuit]] = None,
     repetitions: int = 10_000,
     add_readout_error_correction=False,
 ) -> List[QuantumVolumeResult]:
@@ -429,7 +429,7 @@ def calculate_quantum_volume(
     device_graph: nx.Graph,
     samplers: List[cirq.Sampler],
     random_state: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None,
-    compiler: Callable[[cirq.Circuit], cirq.Circuit] = None,
+    compiler: Optional[Callable[[cirq.Circuit], cirq.Circuit]] = None,
     repetitions=10_000,
     routing_attempts=30,
     add_readout_error_correction=False,

cirq/contrib/quimb/mps_simulator.py

@@ -569,7 +569,7 @@ class MPSState(SimulationState[_MPSHandler]):
         simulation_options: MPSOptions = MPSOptions(),
         grouping: Optional[Dict['cirq.Qid', int]] = None,
         initial_state: int = 0,
-        classical_data: 'cirq.ClassicalDataStore' = None,
+        classical_data: Optional['cirq.ClassicalDataStore'] = None,
     ):
         """Creates and MPSState
 

cirq/contrib/quimb/state_vector.py

@@ -177,6 +177,8 @@ def tensor_expectation_value(
     if ram_gb > max_ram_gb:
         raise MemoryError(f"We estimate that this contraction will take too much RAM! {ram_gb} GB")
     e_val = tn.contract(inplace=True)
+    if isinstance(e_val, qtn.TensorNetwork):
+        e_val = e_val.item()
     assert e_val.imag < tol
     assert cast(complex, pauli_string.coefficient).imag < tol
     return e_val.real * pauli_string.coefficient

cirq/contrib/quirk/quirk_gate.py

@@ -111,6 +111,7 @@ def single_qubit_matrix_gate(matrix: Optional[np.ndarray]) -> Optional[QuirkOp]:
     if matrix is None or matrix.shape[0] != 2:
         return None
 
+    # pylint: disable=consider-using-f-string
     matrix = matrix.round(6)
     matrix_repr = '{{%s+%si,%s+%si},{%s+%si,%s+%si}}' % (
         np.real(matrix[0, 0]),

cirq/contrib/svg/svg.py

@@ -16,13 +16,10 @@ def fixup_text(text: str):
         # https://github.com/quantumlib/Cirq/issues/4499
         # TODO: Visualize Custom MatrixGate
         return '?'
-    if '[<virtual>]' in text:
-        # https://github.com/quantumlib/Cirq/issues/2905
-        # TODO: escape angle brackets when you actually want to display tags
-        return text.replace('[<virtual>]', '')  # coverage: ignore
-    if '[cirq.VirtualTag()]' in text:
-        # https://github.com/quantumlib/Cirq/issues/2905
-        return text.replace('[cirq.VirtualTag()]', '')
+    # https://github.com/quantumlib/Cirq/issues/2905
+    text = text.replace('[<virtual>]', '')
+    text = text.replace('[cirq.VirtualTag()]', '')
+    text = text.replace('<', '&lt;').replace('>', '&gt;')
     return text
 
 

cirq/contrib/svg/svg_test.py

@@ -1,6 +1,7 @@
 # pylint: disable=wrong-or-nonexistent-copyright-notice
-import pytest
+import IPython.display
 import numpy as np
+import pytest
 
 import cirq
 from cirq.contrib.svg import circuit_to_svg
@@ -20,6 +21,7 @@ def test_svg():
             cirq.MatrixGate(np.eye(2)).on(a),
         )
     )
+    assert '?' in svg_text
     assert '<svg' in svg_text
     assert '</svg>' in svg_text
 
@@ -57,3 +59,29 @@ def test_empty_moments():
     svg_2 = circuit_to_svg(cirq.Circuit(cirq.Moment()))
     assert '<svg' in svg_2
     assert '</svg>' in svg_2
+
+
+@pytest.mark.parametrize(
+    'symbol,svg_symbol',
+    [
+        ('<a', '&lt;a'),
+        ('<=b', '&lt;=b'),
+        ('>c', '&gt;c'),
+        ('>=d', '&gt;=d'),
+        ('>e<', '&gt;e&lt;'),
+        ('A[<virtual>]B[cirq.VirtualTag()]C>D<E', 'ABC&gt;D&lt;E'),
+    ],
+)
+def test_gate_with_less_greater_str(symbol, svg_symbol):
+    class CustomGate(cirq.Gate):
+        def _num_qubits_(self) -> int:
+            return 1
+
+        def _circuit_diagram_info_(self, _) -> cirq.CircuitDiagramInfo:
+            return cirq.CircuitDiagramInfo(wire_symbols=[symbol])
+
+    circuit = cirq.Circuit(CustomGate().on(cirq.LineQubit(0)))
+    svg = circuit_to_svg(circuit)
+
+    _ = IPython.display.SVG(svg)
+    assert svg_symbol in svg

cirq/devices/grid_qubit.py

@@ -12,10 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import functools
-from typing import Any, Dict, Iterable, List, Optional, Tuple, Set, TypeVar, TYPE_CHECKING
-
 import abc
+import functools
+from typing import Any, Dict, Iterable, List, Optional, Tuple, Set, TYPE_CHECKING, Union
+from typing_extensions import Self
 
 import numpy as np
 
@@ -24,10 +24,8 @@ from cirq import _compat, ops, protocols
 if TYPE_CHECKING:
     import cirq
 
-TSelf = TypeVar('TSelf', bound='_BaseGridQid')
-
 
-@functools.total_ordering  # type: ignore
+@functools.total_ordering
 class _BaseGridQid(ops.Qid):
     """The Base class for `GridQid` and `GridQubit`."""
 
@@ -47,13 +45,13 @@ class _BaseGridQid(ops.Qid):
         return self._col
 
     def with_dimension(self, dimension: int) -> 'GridQid':
-        return GridQid(self.row, self.col, dimension=dimension)
+        return GridQid(self._row, self._col, dimension=dimension)
 
     def is_adjacent(self, other: 'cirq.Qid') -> bool:
         """Determines if two qubits are adjacent qubits."""
         return (
             isinstance(other, GridQubit)
-            and abs(self.row - other.row) + abs(self.col - other.col) == 1
+            and abs(self._row - other._row) + abs(self._col - other._col) == 1
         )
 
     def neighbors(self, qids: Optional[Iterable[ops.Qid]] = None) -> Set['_BaseGridQid']:
@@ -69,20 +67,20 @@ class _BaseGridQid(ops.Qid):
         return neighbors
 
     @abc.abstractmethod
-    def _with_row_col(self: TSelf, row: int, col: int) -> TSelf:
+    def _with_row_col(self, row: int, col: int) -> Self:
         """Returns a qid with the same type but a different coordinate."""
 
     def __complex__(self) -> complex:
-        return self.col + 1j * self.row
+        return self._col + 1j * self._row
 
-    def __add__(self: TSelf, other: Tuple[int, int]) -> 'TSelf':
+    def __add__(self, other: Union[Tuple[int, int], Self]) -> Self:
         if isinstance(other, _BaseGridQid):
             if self.dimension != other.dimension:
                 raise TypeError(
                     "Can only add GridQids with identical dimension. "
                     f"Got {self.dimension} and {other.dimension}"
                 )
-            return self._with_row_col(row=self.row + other.row, col=self.col + other.col)
+            return self._with_row_col(row=self._row + other._row, col=self._col + other._col)
         if not (
             isinstance(other, (tuple, np.ndarray))
             and len(other) == 2
@@ -92,16 +90,16 @@ class _BaseGridQid(ops.Qid):
                 'Can only add integer tuples of length 2 to '
                 f'{type(self).__name__}. Instead was {other}'
             )
-        return self._with_row_col(row=self.row + other[0], col=self.col + other[1])
+        return self._with_row_col(row=self._row + other[0], col=self._col + other[1])
 
-    def __sub__(self: TSelf, other: Tuple[int, int]) -> 'TSelf':
+    def __sub__(self, other: Union[Tuple[int, int], Self]) -> Self:
         if isinstance(other, _BaseGridQid):
             if self.dimension != other.dimension:
                 raise TypeError(
                     "Can only subtract GridQids with identical dimension. "
                     f"Got {self.dimension} and {other.dimension}"
                 )
-            return self._with_row_col(row=self.row - other.row, col=self.col - other.col)
+            return self._with_row_col(row=self._row - other._row, col=self._col - other._col)
         if not (
             isinstance(other, (tuple, np.ndarray))
             and len(other) == 2
@@ -111,16 +109,16 @@ class _BaseGridQid(ops.Qid):
                 "Can only subtract integer tuples of length 2 to "
                 f"{type(self).__name__}. Instead was {other}"
             )
-        return self._with_row_col(row=self.row - other[0], col=self.col - other[1])
+        return self._with_row_col(row=self._row - other[0], col=self._col - other[1])
 
-    def __radd__(self: TSelf, other: Tuple[int, int]) -> 'TSelf':
+    def __radd__(self, other: Tuple[int, int]) -> Self:
         return self + other
 
-    def __rsub__(self: TSelf, other: Tuple[int, int]) -> 'TSelf':
+    def __rsub__(self, other: Tuple[int, int]) -> Self:
         return -self + other
 
-    def __neg__(self: TSelf) -> 'TSelf':
-        return self._with_row_col(row=-self.row, col=-self.col)
+    def __neg__(self) -> Self:
+        return self._with_row_col(row=-self._row, col=-self._col)
 
 
 class GridQid(_BaseGridQid):
@@ -257,16 +255,16 @@ class GridQid(_BaseGridQid):
         return [GridQid(*c, dimension=dimension) for c in coords]
 
     def __repr__(self) -> str:
-        return f"cirq.GridQid({self.row}, {self.col}, dimension={self.dimension})"
+        return f"cirq.GridQid({self._row}, {self._col}, dimension={self.dimension})"
 
     def __str__(self) -> str:
-        return f"q({self.row}, {self.col}) (d={self.dimension})"
+        return f"q({self._row}, {self._col}) (d={self.dimension})"
 
     def _circuit_diagram_info_(
         self, args: 'cirq.CircuitDiagramInfoArgs'
     ) -> 'cirq.CircuitDiagramInfo':
         return protocols.CircuitDiagramInfo(
-            wire_symbols=(f"({self.row}, {self.col}) (d={self.dimension})",)
+            wire_symbols=(f"({self._row}, {self._col}) (d={self.dimension})",)
         )
 
     def _json_dict_(self) -> Dict[str, Any]:
@@ -307,13 +305,13 @@ class GridQubit(_BaseGridQid):
     def __eq__(self, other):
         # Explicitly implemented for performance (vs delegating to Qid).
         if isinstance(other, GridQubit):
-            return self.row == other.row and self.col == other.col
+            return self._row == other._row and self._col == other._col
         return NotImplemented
 
     def __ne__(self, other):
         # Explicitly implemented for performance (vs delegating to Qid).
         if isinstance(other, GridQubit):
-            return self.row != other.row or self.col != other.col
+            return self._row != other._row or self._col != other._col
         return NotImplemented
 
     @property
@@ -414,15 +412,15 @@ class GridQubit(_BaseGridQid):
         return [GridQubit(*c) for c in coords]
 
     def __repr__(self) -> str:
-        return f"cirq.GridQubit({self.row}, {self.col})"
+        return f"cirq.GridQubit({self._row}, {self._col})"
 
     def __str__(self) -> str:
-        return f"q({self.row}, {self.col})"
+        return f"q({self._row}, {self._col})"
 
     def _circuit_diagram_info_(
         self, args: 'cirq.CircuitDiagramInfoArgs'
     ) -> 'cirq.CircuitDiagramInfo':
-        return protocols.CircuitDiagramInfo(wire_symbols=(f"({self.row}, {self.col})",))
+        return protocols.CircuitDiagramInfo(wire_symbols=(f"({self._row}, {self._col})",))
 
     def _json_dict_(self) -> Dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ['row', 'col'])

cirq/devices/grid_qubit_test.py

@@ -335,23 +335,39 @@ def test_to_json():
 
 
 def test_immutable():
-    with pytest.raises(AttributeError, match="can't set attribute"):
+    # Match one of two strings. The second one is message returned since python 3.11.
+    with pytest.raises(
+        AttributeError,
+        match="(can't set attribute)|(property 'col' of 'GridQubit' object has no setter)",
+    ):
         q = cirq.GridQubit(1, 2)
         q.col = 3
 
-    with pytest.raises(AttributeError, match="can't set attribute"):
+    with pytest.raises(
+        AttributeError,
+        match="(can't set attribute)|(property 'row' of 'GridQubit' object has no setter)",
+    ):
         q = cirq.GridQubit(1, 2)
         q.row = 3
 
-    with pytest.raises(AttributeError, match="can't set attribute"):
+    with pytest.raises(
+        AttributeError,
+        match="(can't set attribute)|(property 'col' of 'GridQid' object has no setter)",
+    ):
         q = cirq.GridQid(1, 2, dimension=3)
         q.col = 3
 
-    with pytest.raises(AttributeError, match="can't set attribute"):
+    with pytest.raises(
+        AttributeError,
+        match="(can't set attribute)|(property 'row' of 'GridQid' object has no setter)",
+    ):
         q = cirq.GridQid(1, 2, dimension=3)
         q.row = 3
 
-    with pytest.raises(AttributeError, match="can't set attribute"):
+    with pytest.raises(
+        AttributeError,
+        match="(can't set attribute)|(property 'dimension' of 'GridQid' object has no setter)",
+    ):
         q = cirq.GridQid(1, 2, dimension=3)
         q.dimension = 3
 

cirq/devices/line_qubit.py

@@ -12,20 +12,18 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import functools
-from typing import Any, Dict, Iterable, List, Optional, Sequence, Set, TypeVar, TYPE_CHECKING
-
 import abc
+import functools
+from typing import Any, Dict, Iterable, List, Optional, Sequence, Set, TYPE_CHECKING, Union
+from typing_extensions import Self
 
 from cirq import ops, protocols
 
 if TYPE_CHECKING:
     import cirq
 
-TSelf = TypeVar('TSelf', bound='_BaseLineQid')
-
 
-@functools.total_ordering  # type: ignore
+@functools.total_ordering
 class _BaseLineQid(ops.Qid):
     """The base class for `LineQid` and `LineQubit`."""
 
@@ -66,10 +64,10 @@ class _BaseLineQid(ops.Qid):
         return neighbors
 
     @abc.abstractmethod
-    def _with_x(self: TSelf, x: int) -> TSelf:
+    def _with_x(self, x: int) -> Self:
         """Returns a qubit with the same type but a different value of `x`."""
 
-    def __add__(self: TSelf, other: int) -> TSelf:
+    def __add__(self, other: Union[int, Self]) -> Self:
         if isinstance(other, _BaseLineQid):
             if self.dimension != other.dimension:
                 raise TypeError(
@@ -81,7 +79,7 @@ class _BaseLineQid(ops.Qid):
             raise TypeError(f"Can only add ints and {type(self).__name__}. Instead was {other}")
         return self._with_x(self.x + other)
 
-    def __sub__(self: TSelf, other: int) -> TSelf:
+    def __sub__(self, other: Union[int, Self]) -> Self:
         if isinstance(other, _BaseLineQid):
             if self.dimension != other.dimension:
                 raise TypeError(
@@ -95,13 +93,13 @@ class _BaseLineQid(ops.Qid):
             )
         return self._with_x(self.x - other)
 
-    def __radd__(self: TSelf, other: int) -> TSelf:
+    def __radd__(self, other: int) -> Self:
         return self + other
 
-    def __rsub__(self: TSelf, other: int) -> TSelf:
+    def __rsub__(self, other: int) -> Self:
         return -self + other
 
-    def __neg__(self: TSelf) -> TSelf:
+    def __neg__(self) -> Self:
         return self._with_x(-self.x)
 
     def __complex__(self) -> complex:

cirq/devices/line_qubit_test.py

@@ -242,11 +242,18 @@ def test_for_gate():
 
 
 def test_immutable():
-    with pytest.raises(AttributeError, match="can't set attribute"):
+    # Match one of two strings. The second one is message returned since python 3.11.
+    with pytest.raises(
+        AttributeError,
+        match="(can't set attribute)|(property 'x' of 'LineQubit' object has no setter)",
+    ):
         q = cirq.LineQubit(5)
         q.x = 6
 
-    with pytest.raises(AttributeError, match="can't set attribute"):
+    with pytest.raises(
+        AttributeError,
+        match="(can't set attribute)|(property 'x' of 'LineQid' object has no setter)",
+    ):
         q = cirq.LineQid(5, dimension=4)
         q.x = 6
 

cirq/devices/named_topologies.py

@@ -345,7 +345,7 @@ def draw_placements(
     small_graph: nx.Graph,
     small_to_big_mappings: Sequence[Dict],
     max_plots: int = 20,
-    axes: Sequence[plt.Axes] = None,
+    axes: Optional[Sequence[plt.Axes]] = None,
     tilted: bool = True,
     bad_placement_callback: Optional[Callable[[plt.Axes, int], None]] = None,
 ):

cirq/devices/noise_model.py

@@ -73,7 +73,7 @@ class NoiseModel(metaclass=value.ABCMetaImplementAnyOneOf):
 
         raise TypeError(
             'Expected a NOISE_MODEL_LIKE (None, a cirq.NoiseModel, '
-            'or a single qubit gate). Got {!r}'.format(noise)
+            f'or a single qubit gate). Got {noise!r}'
         )
 
     def is_virtual_moment(self, moment: 'cirq.Moment') -> bool:
@@ -125,6 +125,7 @@ class NoiseModel(metaclass=value.ABCMetaImplementAnyOneOf):
             A sequence of OP_TREEs, with the k'th tree corresponding to the
             noisy operations for the k'th moment.
         """
+        raise NotImplementedError
 
     def _noisy_moment_impl_moments(
         self, moment: 'cirq.Moment', system_qubits: Sequence['cirq.Qid']
@@ -150,6 +151,7 @@ class NoiseModel(metaclass=value.ABCMetaImplementAnyOneOf):
         Returns:
             An OP_TREE corresponding to the noisy operations for the moment.
         """
+        raise NotImplementedError
 
     def _noisy_operation_impl_moments(self, operation: 'cirq.Operation') -> 'cirq.OP_TREE':
         return self.noisy_moments([moment_module.Moment([operation])], operation.qubits)
@@ -169,6 +171,7 @@ class NoiseModel(metaclass=value.ABCMetaImplementAnyOneOf):
             An OP_TREE corresponding to the noisy operations implementing the
             noisy version of the given operation.
         """
+        raise NotImplementedError
 
 
 @value.value_equality

cirq/devices/superconducting_qubits_noise_properties.py

@@ -27,9 +27,7 @@ if TYPE_CHECKING:
 
 
 # TODO: missing per-device defaults
-# Type-ignored because mypy cannot handle abstract dataclasses:
-# https://github.com/python/mypy/issues/5374
-@dataclass  # type: ignore
+@dataclass
 class SuperconductingQubitsNoiseProperties(devices.NoiseProperties, abc.ABC):
     """Noise-defining properties for a superconducting-qubit-based device.
 

cirq/experiments/n_qubit_tomography.py

@@ -134,7 +134,7 @@ def state_tomography(
     qubits: Sequence['cirq.Qid'],
     circuit: 'cirq.Circuit',
     repetitions: int = 1000,
-    prerotations: Sequence[Tuple[float, float]] = None,
+    prerotations: Optional[Sequence[Tuple[float, float]]] = None,
 ) -> TomographyResult:
     """This performs n qubit tomography on a cirq circuit
 

cirq/experiments/qubit_characterizations.py

@@ -542,8 +542,8 @@ def _matrix_bar_plot(
     mat: np.ndarray,
     z_label: str,
     ax: plt.Axes,
-    kets: Sequence[str] = None,
-    title: str = None,
+    kets: Optional[Sequence[str]] = None,
+    title: Optional[str] = None,
     ylim: Tuple[int, int] = (-1, 1),
     **bar3d_kwargs: Any,
 ) -> None:

cirq/experiments/single_qubit_readout_calibration.py

@@ -111,7 +111,7 @@ def estimate_parallel_single_qubit_readout_errors(
     trials: int = 20,
     repetitions: int = 1000,
     trials_per_batch: Optional[int] = None,
-    bit_strings: np.ndarray = None,
+    bit_strings: Optional[np.ndarray] = None,
 ) -> SingleQubitReadoutCalibrationResult:
     """Estimate single qubit readout error using parallel operations.
 

cirq/experiments/t2_decay_experiment.py

@@ -45,7 +45,7 @@ def t2_decay(
     min_delay: 'cirq.DURATION_LIKE' = None,
     repetitions: int = 1000,
     delay_sweep: Optional[study.Sweep] = None,
-    num_pulses: List[int] = None,
+    num_pulses: Optional[List[int]] = None,
 ) -> Union['cirq.experiments.T2DecayResult', List['cirq.experiments.T2DecayResult']]:
     """Runs a t2 transverse relaxation experiment.
 

cirq/experiments/xeb_simulation_test.py

@@ -59,7 +59,7 @@ def test_simulate_circuit_length_validation():
         )
         for _ in range(2)
     ]
-    cycle_depths = np.arange(3, 50, 9)
+    cycle_depths = np.arange(3, 50, 9, dtype=np.int64)
     with pytest.raises(ValueError, match='.*not long enough.*'):
         _ = simulate_2q_xeb_circuits(circuits=circuits, cycle_depths=cycle_depths)
 
@@ -127,7 +127,7 @@ def test_incremental_simulate(multiprocess):
         )
         for _ in range(20)
     ]
-    cycle_depths = np.arange(3, 100, 9)
+    cycle_depths = np.arange(3, 100, 9, dtype=np.int64)
 
     if multiprocess:
         pool = multiprocessing.Pool()

cirq/interop/quirk/cells/testing.py

@@ -22,7 +22,7 @@ from cirq import quirk_url_to_circuit
 
 def assert_url_to_circuit_returns(
     json_text: str,
-    circuit: 'cirq.Circuit' = None,
+    circuit: Optional['cirq.Circuit'] = None,
     *,
     unitary: Optional[np.ndarray] = None,
     diagram: Optional[str] = None,

cirq/json_resolver_cache.py

@@ -241,6 +241,7 @@ def _class_resolver_dictionary() -> Dict[str, ObjectFactory]:
         'YYPowGate': cirq.YYPowGate,
         '_ZEigenState': cirq.value.product_state._ZEigenState,
         'Zip': cirq.Zip,
+        'ZipLongest': cirq.ZipLongest,
         'ZPowGate': cirq.ZPowGate,
         'ZZPowGate': cirq.ZZPowGate,
         # Old types, only supported for backwards-compatibility

cirq/linalg/__init__.py

@@ -81,4 +81,6 @@ from cirq.linalg.transformations import (
     targeted_conjugate_about,
     targeted_left_multiply,
     to_special,
+    transpose_flattened_array,
+    can_numpy_support_shape,
 )

cirq/linalg/decompositions_test.py

@@ -367,12 +367,12 @@ def test_kak_repr():
 cirq.KakDecomposition(
     interaction_coefficients=(0.5, 0.25, 0),
     single_qubit_operations_before=(
-        np.array([[0j, (1+0j)], [(1+0j), 0j]], dtype=np.complex128),
-        np.array([[0j, -1j], [1j, 0j]], dtype=np.complex128),
+        np.array([[0j, (1+0j)], [(1+0j), 0j]], dtype=np.dtype('complex128')),
+        np.array([[0j, -1j], [1j, 0j]], dtype=np.dtype('complex128')),
     ),
     single_qubit_operations_after=(
-        np.array([[1.0, 0.0], [0.0, 1.0]], dtype=np.float64),
-        np.array([[(1+0j), 0j], [0j, (-1+0j)]], dtype=np.complex128),
+        np.array([[1.0, 0.0], [0.0, 1.0]], dtype=np.dtype('float64')),
+        np.array([[(1+0j), 0j], [0j, (-1+0j)]], dtype=np.dtype('complex128')),
     ),
     global_phase=1)
 """.strip()

cirq/linalg/diagonalize_test.py

@@ -60,8 +60,9 @@ def random_bi_diagonalizable_pair(
 
 
 def _get_assert_diagonalized_by_str(m, p, d):
-    return 'm.round(3) : {}, p.round(3) : {}, np.abs(p.T @ m @ p).round(2): {}'.format(
-        np.round(m, 3), np.round(p, 3), np.abs(d).round(2)
+    return (
+        f'm.round(3) : {np.round(m, 3)}, p.round(3) : {np.round(p, 3)}, '
+        f'np.abs(p.T @ m @ p).round(2): {np.abs(d).round(2)}'
     )
 
 
@@ -75,10 +76,8 @@ def assert_diagonalized_by(m, p, atol: float = 1e-8):
 
 def _get_assert_bidiagonalized_by_str(m, p, q, d):
     return (
-        'm.round(3) : {}, p.round(3) : {}, q.round(3): {}, '
-        'np.abs(p.T @ m @ p).round(2): {}'.format(
-            np.round(m, 3), np.round(p, 3), np.round(q, 3), np.abs(d).round(2)
-        )
+        f'm.round(3) : {np.round(m, 3)}, p.round(3) : {np.round(p, 3)}, '
+        f'q.round(3): {np.round(q, 3)}, np.abs(p.T @ m @ p).round(2): {np.abs(d).round(2)}'
     )