cirq-core 1.5.0.dev20250409222543__py3-none-any.whl → 1.6.0__py3-none-any.whl

cirq/sim/clifford/clifford_simulator_test.py

@@ -11,6 +11,9 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+
+from __future__ import annotations
+
 import itertools
 
 import numpy as np
@@ -273,7 +276,7 @@ def test_clifford_trial_result_repr_pretty():
         final_simulator_state=final_simulator_state,
     )
 
-    cirq.testing.assert_repr_pretty(result, "measurements: m=1\n" "output state: |0⟩")
+    cirq.testing.assert_repr_pretty(result, "measurements: m=1\noutput state: |0⟩")
     cirq.testing.assert_repr_pretty(result, "cirq.CliffordTrialResult(...)", cycle=True)
 
 
@@ -282,7 +285,7 @@ def test_clifford_step_result_str():
     result = next(
         cirq.CliffordSimulator().simulate_moment_steps(cirq.Circuit(cirq.measure(q0, key='m')))
     )
-    assert str(result) == "m=0\n" "|0⟩"
+    assert str(result) == "m=0\n|0⟩"
 
 
 def test_clifford_step_result_repr_pretty():
@@ -290,7 +293,7 @@ def test_clifford_step_result_repr_pretty():
     result = next(
         cirq.CliffordSimulator().simulate_moment_steps(cirq.Circuit(cirq.measure(q0, key='m')))
     )
-    cirq.testing.assert_repr_pretty(result, "m=0\n" "|0⟩")
+    cirq.testing.assert_repr_pretty(result, "m=0\n|0⟩")
     cirq.testing.assert_repr_pretty(result, "cirq.CliffordSimulatorStateResult(...)", cycle=True)
 
 
@@ -567,7 +570,7 @@ def test_valid_apply_measurement():
     q0 = cirq.LineQubit(0)
     state = cirq.CliffordState(qubit_map={q0: 0}, initial_state=1)
     measurements = {}
-    _ = state.apply_measurement(
+    state.apply_measurement(
         cirq.measure(q0), measurements, np.random.RandomState(), collapse_state_vector=False
     )
     assert measurements == {'q(0)': [1]}

cirq/sim/clifford/clifford_tableau_simulation_state.py

@@ -11,17 +11,20 @@
 # 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.
+
 """A protocol for implementing high performance clifford tableau evolutions
 for Clifford Simulator."""
 
-from typing import Optional, Sequence, TYPE_CHECKING
+from __future__ import annotations
 
-import numpy as np
+from typing import Sequence, TYPE_CHECKING
 
 from cirq.qis import clifford_tableau
 from cirq.sim.clifford.stabilizer_simulation_state import StabilizerSimulationState
 
 if TYPE_CHECKING:
+    import numpy as np
+
     import cirq
 
 
@@ -30,10 +33,10 @@ class CliffordTableauSimulationState(StabilizerSimulationState[clifford_tableau.
 
     def __init__(
         self,
-        tableau: 'cirq.CliffordTableau',
-        prng: Optional[np.random.RandomState] = None,
-        qubits: Optional[Sequence['cirq.Qid']] = None,
-        classical_data: Optional['cirq.ClassicalDataStore'] = None,
+        tableau: cirq.CliffordTableau,
+        prng: np.random.RandomState | None = None,
+        qubits: Sequence[cirq.Qid] | None = None,
+        classical_data: cirq.ClassicalDataStore | None = None,
     ):
         """Inits CliffordTableauSimulationState.
 
@@ -51,5 +54,5 @@ class CliffordTableauSimulationState(StabilizerSimulationState[clifford_tableau.
         super().__init__(state=tableau, prng=prng, qubits=qubits, classical_data=classical_data)
 
     @property
-    def tableau(self) -> 'cirq.CliffordTableau':
+    def tableau(self) -> cirq.CliffordTableau:
         return self.state

cirq/sim/clifford/clifford_tableau_simulation_state_test.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Tuple
+from __future__ import annotations
 
 import numpy as np
 import pytest
@@ -20,13 +20,13 @@ import pytest
 import cirq
 
 
-def test_unitary_fallback():
+def test_unitary_fallback() -> None:
     class UnitaryXGate(cirq.testing.SingleQubitGate):
         def _unitary_(self):
             return np.array([[0, 1], [1, 0]])
 
     class UnitaryYGate(cirq.Gate):
-        def _qid_shape_(self) -> Tuple[int, ...]:
+        def _qid_shape_(self) -> tuple[int, ...]:
             return (2,)
 
         def _unitary_(self):
@@ -57,7 +57,7 @@ def test_unitary_fallback():
     assert args.tableau == expected_args.tableau
 
 
-def test_cannot_act():
+def test_cannot_act() -> None:
     class NoDetails:
         pass
 
@@ -77,7 +77,7 @@ def test_cannot_act():
         cirq.act_on(NoDetailsSingleQubitGate(), args, [cirq.LineQubit(1)])
 
 
-def test_copy():
+def test_copy() -> None:
     args = cirq.CliffordTableauSimulationState(
         tableau=cirq.CliffordTableau(num_qubits=3),
         qubits=cirq.LineQubit.range(3),

cirq/sim/clifford/stabilizer_ch_form_simulation_state.py

@@ -12,15 +12,17 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Optional, Sequence, TYPE_CHECKING, Union
+from __future__ import annotations
 
-import numpy as np
+from typing import Sequence, TYPE_CHECKING
 
 from cirq._compat import proper_repr
 from cirq.sim.clifford import stabilizer_state_ch_form
 from cirq.sim.clifford.stabilizer_simulation_state import StabilizerSimulationState
 
 if TYPE_CHECKING:
+    import numpy as np
+
     import cirq
 
 
@@ -32,10 +34,10 @@ class StabilizerChFormSimulationState(
     def __init__(
         self,
         *,
-        prng: Optional[np.random.RandomState] = None,
-        qubits: Optional[Sequence['cirq.Qid']] = None,
-        initial_state: Union[int, 'cirq.StabilizerStateChForm'] = 0,
-        classical_data: Optional['cirq.ClassicalDataStore'] = None,
+        prng: np.random.RandomState | None = None,
+        qubits: Sequence[cirq.Qid] | None = None,
+        initial_state: int | cirq.StabilizerStateChForm = 0,
+        classical_data: cirq.ClassicalDataStore | None = None,
     ):
         """Initializes with the given state and the axes for the operation.
 

cirq/sim/clifford/stabilizer_ch_form_simulation_state_test.py

@@ -12,20 +12,22 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import numpy as np
 import pytest
 
 import cirq
 
 
-def test_init_state():
+def test_init_state() -> None:
     args = cirq.StabilizerChFormSimulationState(qubits=cirq.LineQubit.range(1), initial_state=1)
     np.testing.assert_allclose(args.state.state_vector(), [0, 1])
     with pytest.raises(ValueError, match='Must specify qubits'):
         _ = cirq.StabilizerChFormSimulationState(initial_state=1)
 
 
-def test_cannot_act():
+def test_cannot_act() -> None:
     class NoDetails(cirq.testing.SingleQubitGate):
         pass
 
@@ -35,7 +37,7 @@ def test_cannot_act():
         cirq.act_on(NoDetails(), args, qubits=())
 
 
-def test_gate_with_act_on():
+def test_gate_with_act_on() -> None:
     class CustomGate(cirq.testing.SingleQubitGate):
         def _act_on_(self, sim_state, qubits):
             if isinstance(sim_state, cirq.StabilizerChFormSimulationState):
@@ -53,7 +55,7 @@ def test_gate_with_act_on():
     np.testing.assert_allclose(state.gamma, [0, 1, 0])
 
 
-def test_unitary_fallback_y():
+def test_unitary_fallback_y() -> None:
     class UnitaryYGate(cirq.Gate):
         def num_qubits(self) -> int:
             return 1
@@ -72,7 +74,7 @@ def test_unitary_fallback_y():
     np.testing.assert_allclose(args.state.state_vector(), expected_args.state.state_vector())
 
 
-def test_unitary_fallback_h():
+def test_unitary_fallback_h() -> None:
     class UnitaryHGate(cirq.Gate):
         def num_qubits(self) -> int:
             return 1
@@ -91,7 +93,7 @@ def test_unitary_fallback_h():
     np.testing.assert_allclose(args.state.state_vector(), expected_args.state.state_vector())
 
 
-def test_copy():
+def test_copy() -> None:
     args = cirq.StabilizerChFormSimulationState(
         qubits=cirq.LineQubit.range(3), prng=np.random.RandomState()
     )

cirq/sim/clifford/stabilizer_sampler.py

@@ -12,7 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Dict, List, Sequence
+from __future__ import annotations
+
+from typing import Sequence
 
 import numpy as np
 
@@ -26,7 +28,7 @@ from cirq.work import sampler
 class StabilizerSampler(sampler.Sampler):
     """An efficient sampler for stabilizer circuits."""
 
-    def __init__(self, *, seed: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None):
+    def __init__(self, *, seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None):
         """Inits StabilizerSampler.
 
         Args:
@@ -36,18 +38,18 @@ class StabilizerSampler(sampler.Sampler):
         self._prng = value.parse_random_state(seed)
 
     def run_sweep(
-        self, program: 'cirq.AbstractCircuit', params: 'cirq.Sweepable', repetitions: int = 1
-    ) -> Sequence['cirq.Result']:
-        results: List[cirq.Result] = []
+        self, program: cirq.AbstractCircuit, params: cirq.Sweepable, repetitions: int = 1
+    ) -> Sequence[cirq.Result]:
+        results: list[cirq.Result] = []
         for param_resolver in cirq.to_resolvers(params):
             resolved_circuit = cirq.resolve_parameters(program, param_resolver)
             measurements = self._run(resolved_circuit, repetitions=repetitions)
             results.append(cirq.ResultDict(params=param_resolver, measurements=measurements))
         return results
 
-    def _run(self, circuit: 'cirq.AbstractCircuit', repetitions: int) -> Dict[str, np.ndarray]:
+    def _run(self, circuit: cirq.AbstractCircuit, repetitions: int) -> dict[str, np.ndarray]:
 
-        measurements: Dict[str, List[np.ndarray]] = {
+        measurements: dict[str, list[np.ndarray]] = {
             key: [] for key in protocols.measurement_key_names(circuit)
         }
         qubits = circuit.all_qubits()

cirq/sim/clifford/stabilizer_sampler_test.py

@@ -12,12 +12,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import numpy as np
 
 import cirq
 
 
-def test_produces_samples():
+def test_produces_samples() -> None:
     a, b = cirq.LineQubit.range(2)
     c = cirq.Circuit(cirq.H(a), cirq.CNOT(a, b), cirq.measure(a, key='a'), cirq.measure(b, key='b'))
 
@@ -26,7 +28,7 @@ def test_produces_samples():
     assert np.all(result['a'] ^ result['b'] == 0)
 
 
-def test_reset():
+def test_reset() -> None:
     q = cirq.LineQubit(0)
     sampler = cirq.StabilizerSampler()
     c = cirq.Circuit(cirq.X(q), cirq.reset(q), cirq.measure(q))

cirq/sim/clifford/stabilizer_simulation_state.py

@@ -12,11 +12,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import abc
 from types import NotImplementedType
-from typing import Any, cast, Generic, Optional, Sequence, TYPE_CHECKING, TypeVar, Union
+from typing import Any, cast, Generic, Sequence, TYPE_CHECKING, TypeVar
 
-import numpy as np
 import sympy
 
 from cirq import linalg, ops, protocols
@@ -26,6 +27,8 @@ from cirq.protocols import has_unitary, num_qubits, unitary
 from cirq.sim.simulation_state import SimulationState
 
 if TYPE_CHECKING:
+    import numpy as np
+
     import cirq
 
 
@@ -41,9 +44,9 @@ class StabilizerSimulationState(
         self,
         *,
         state: TStabilizerState,
-        prng: Optional[np.random.RandomState] = None,
-        qubits: Optional[Sequence['cirq.Qid']] = None,
-        classical_data: Optional['cirq.ClassicalDataStore'] = None,
+        prng: np.random.RandomState | None = None,
+        qubits: Sequence[cirq.Qid] | None = None,
+        classical_data: cirq.ClassicalDataStore | None = None,
     ):
         """Initializes the StabilizerSimulationState.
 
@@ -65,8 +68,8 @@ class StabilizerSimulationState(
         return self._state
 
     def _act_on_fallback_(
-        self, action: Any, qubits: Sequence['cirq.Qid'], allow_decompose: bool = True
-    ) -> Union[bool, NotImplementedType]:
+        self, action: Any, qubits: Sequence[cirq.Qid], allow_decompose: bool = True
+    ) -> bool | NotImplementedType:
         strats = [self._strat_apply_gate, self._strat_apply_mixture]
         if allow_decompose:
             strats.append(self._strat_decompose)
@@ -89,7 +92,7 @@ class StabilizerSimulationState(
         self._state.apply_cx(target_axis, control_axis, exponent, global_shift)
         self._state.apply_cx(control_axis, target_axis)
 
-    def _strat_apply_gate(self, val: Any, qubits: Sequence['cirq.Qid']) -> bool:
+    def _strat_apply_gate(self, val: Any, qubits: Sequence[cirq.Qid]) -> bool:
         if not protocols.has_stabilizer_effect(val):
             return NotImplemented
         gate = val.gate if isinstance(val, ops.Operation) else val
@@ -117,7 +120,7 @@ class StabilizerSimulationState(
             return NotImplemented
         return True
 
-    def _strat_apply_mixture(self, val: Any, qubits: Sequence['cirq.Qid']) -> bool:
+    def _strat_apply_mixture(self, val: Any, qubits: Sequence[cirq.Qid]) -> bool:
         mixture = protocols.mixture(val, None)
         if mixture is None:
             return NotImplemented
@@ -129,9 +132,7 @@ class StabilizerSimulationState(
             matrix_gates.MatrixGate(unitaries[index]), qubits
         )
 
-    def _strat_act_from_single_qubit_decompose(
-        self, val: Any, qubits: Sequence['cirq.Qid']
-    ) -> bool:
+    def _strat_act_from_single_qubit_decompose(self, val: Any, qubits: Sequence[cirq.Qid]) -> bool:
         if num_qubits(val) == 1:
             if not has_unitary(val):
                 return NotImplemented
@@ -148,7 +149,7 @@ class StabilizerSimulationState(
 
         return NotImplemented
 
-    def _strat_decompose(self, val: Any, qubits: Sequence['cirq.Qid']) -> bool:
+    def _strat_decompose(self, val: Any, qubits: Sequence[cirq.Qid]) -> bool:
         gate = val.gate if isinstance(val, ops.Operation) else val
         operations = protocols.decompose_once_with_qubits(gate, qubits, None)
         if operations is None or not all(protocols.has_stabilizer_effect(op) for op in operations):

cirq/sim/clifford/stabilizer_simulation_state_test.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import unittest.mock as mock
 
 import numpy as np
@@ -20,7 +22,7 @@ import sympy
 import cirq
 
 
-def test_apply_gate():
+def test_apply_gate() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     state = mock.Mock()
     args = cirq.StabilizerSimulationState(state=state, qubits=[q0, q1])
@@ -89,7 +91,7 @@ def test_apply_gate():
     state.apply_x.assert_not_called()
 
 
-def test_apply_mixture():
+def test_apply_mixture() -> None:
     q0 = cirq.LineQubit(0)
     state = mock.Mock()
     args = cirq.StabilizerSimulationState(state=state, qubits=[q0])
@@ -100,7 +102,7 @@ def test_apply_mixture():
     assert 10 < state.apply_x.call_count < 90
 
 
-def test_act_from_single_qubit_decompose():
+def test_act_from_single_qubit_decompose() -> None:
     q0 = cirq.LineQubit(0)
     state = mock.Mock()
     args = cirq.StabilizerSimulationState(state=state, qubits=[q0])
@@ -113,7 +115,7 @@ def test_act_from_single_qubit_decompose():
     state.apply_x.assert_called_with(0, 1.0, 0.0)
 
 
-def test_decompose():
+def test_decompose() -> None:
     class XContainer(cirq.Gate):
         def _decompose_(self, qs):
             return [cirq.X(*qs)]

cirq/sim/clifford/stabilizer_state_ch_form.py

@@ -12,7 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Any, Dict, List, Sequence
+from __future__ import annotations
+
+from typing import Any, Sequence
 
 import numpy as np
 
@@ -61,7 +63,7 @@ class StabilizerStateChForm(qis.StabilizerState):
             if val:
                 self.apply_x(i)
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ['n', 'G', 'F', 'M', 'gamma', 'v', 's', 'omega'])
 
     @classmethod
@@ -81,7 +83,7 @@ class StabilizerStateChForm(qis.StabilizerState):
     def _value_equality_values_(self) -> Any:
         return (self.n, self.G, self.F, self.M, self.gamma, self.v, self.s, self.omega)
 
-    def copy(self, deep_copy_buffers: bool = True) -> 'cirq.StabilizerStateChForm':
+    def copy(self, deep_copy_buffers: bool = True) -> cirq.StabilizerStateChForm:
         copy = StabilizerStateChForm(self.n)
 
         copy.G = self.G.copy()
@@ -267,7 +269,7 @@ class StabilizerStateChForm(qis.StabilizerState):
 
         self.update_sum(t, u, delta=delta)
 
-    def kron(self, other: 'cirq.StabilizerStateChForm') -> 'cirq.StabilizerStateChForm':
+    def kron(self, other: cirq.StabilizerStateChForm) -> cirq.StabilizerStateChForm:
         n = self.n + other.n
         copy = StabilizerStateChForm(n)
         copy.G[: self.n, : self.n] = self.G
@@ -282,14 +284,14 @@ class StabilizerStateChForm(qis.StabilizerState):
         copy.omega = self.omega * other.omega
         return copy
 
-    def reindex(self, axes: Sequence[int]) -> 'cirq.StabilizerStateChForm':
+    def reindex(self, axes: Sequence[int]) -> cirq.StabilizerStateChForm:
         copy = StabilizerStateChForm(self.n)
         copy.G = self.G[axes][:, axes]
         copy.F = self.F[axes][:, axes]
-        copy.M = self.M[axes][:, axes]
-        copy.gamma = self.gamma[axes]
-        copy.v = self.v[axes]
-        copy.s = self.s[axes]
+        copy.M = self.M[axes][:, axes]  # type: ignore[assignment]
+        copy.gamma = self.gamma[axes]  # type: ignore[assignment]
+        copy.v = self.v[axes]  # type: ignore[assignment]
+        copy.s = self.s[axes]  # type: ignore[assignment]
         copy.omega = self.omega
         return copy
 
@@ -387,8 +389,8 @@ class StabilizerStateChForm(qis.StabilizerState):
         self.omega *= coefficient
 
     def measure(
-        self, axes: Sequence[int], seed: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None
-    ) -> List[int]:
+        self, axes: Sequence[int], seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None
+    ) -> list[int]:
         return [self._measure(axis, random_state.parse_random_state(seed)) for axis in axes]
 
 

cirq/sim/clifford/stabilizer_state_ch_form_test.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import numpy as np
 import pytest
 
@@ -22,7 +24,7 @@ import cirq.testing
 # Github issue: https://github.com/quantumlib/Cirq/issues/3021
 
 
-def test_initial_state():
+def test_initial_state() -> None:
     with pytest.raises(ValueError, match='Out of range'):
         _ = cirq.StabilizerStateChForm(initial_state=-31, num_qubits=5)
     with pytest.raises(ValueError, match='Out of range'):
@@ -33,7 +35,7 @@ def test_initial_state():
     np.testing.assert_allclose(state.state_vector(), expected_state_vector)
 
 
-def test_run():
+def test_run() -> None:
     (q0, q1, q2) = (cirq.LineQubit(0), cirq.LineQubit(1), cirq.LineQubit(2))
 
     """

cirq/sim/density_matrix_simulation_state.py

@@ -14,7 +14,9 @@
 
 """Objects and methods for acting efficiently on a density matrix."""
 
-from typing import Any, Callable, List, Optional, Sequence, Tuple, Type, TYPE_CHECKING, Union
+from __future__ import annotations
+
+from typing import Any, Callable, Sequence, TYPE_CHECKING
 
 import numpy as np
 
@@ -30,7 +32,7 @@ if TYPE_CHECKING:
 class _BufferedDensityMatrix(qis.QuantumStateRepresentation):
     """Contains the density matrix and buffers for efficient state evolution."""
 
-    def __init__(self, density_matrix: np.ndarray, buffer: Optional[List[np.ndarray]] = None):
+    def __init__(self, density_matrix: np.ndarray, buffer: list[np.ndarray] | None = None):
         """Initializes the object with the inputs.
 
         This initializer creates the buffer if necessary.
@@ -55,10 +57,10 @@ class _BufferedDensityMatrix(qis.QuantumStateRepresentation):
     def create(
         cls,
         *,
-        initial_state: Union[np.ndarray, 'cirq.STATE_VECTOR_LIKE'] = 0,
-        qid_shape: Optional[Tuple[int, ...]] = None,
-        dtype: Optional[Type[np.complexfloating]] = None,
-        buffer: Optional[List[np.ndarray]] = None,
+        initial_state: np.ndarray | cirq.STATE_VECTOR_LIKE = 0,
+        qid_shape: tuple[int, ...] | None = None,
+        dtype: type[np.complexfloating] | None = None,
+        buffer: list[np.ndarray] | None = None,
     ):
         """Creates a buffered density matrix with the requested state.
 
@@ -91,7 +93,7 @@ class _BufferedDensityMatrix(qis.QuantumStateRepresentation):
         density_matrix = density_matrix.astype(dtype, copy=False)
         return cls(density_matrix, buffer)
 
-    def copy(self, deep_copy_buffers: bool = True) -> '_BufferedDensityMatrix':
+    def copy(self, deep_copy_buffers: bool = True) -> _BufferedDensityMatrix:
         """Copies the object.
 
         Args:
@@ -104,7 +106,7 @@ class _BufferedDensityMatrix(qis.QuantumStateRepresentation):
             buffer=[b.copy() for b in self._buffer] if deep_copy_buffers else self._buffer,
         )
 
-    def kron(self, other: '_BufferedDensityMatrix') -> '_BufferedDensityMatrix':
+    def kron(self, other: _BufferedDensityMatrix) -> _BufferedDensityMatrix:
         """Creates the Kronecker product with the other density matrix.
 
         Args:
@@ -119,7 +121,7 @@ class _BufferedDensityMatrix(qis.QuantumStateRepresentation):
 
     def factor(
         self, axes: Sequence[int], *, validate=True, atol=1e-07
-    ) -> Tuple['_BufferedDensityMatrix', '_BufferedDensityMatrix']:
+    ) -> tuple[_BufferedDensityMatrix, _BufferedDensityMatrix]:
         """Factors out the desired axes.
 
         Args:
@@ -141,7 +143,7 @@ class _BufferedDensityMatrix(qis.QuantumStateRepresentation):
         remainder = _BufferedDensityMatrix(density_matrix=remainder_tensor)
         return extracted, remainder
 
-    def reindex(self, axes: Sequence[int]) -> '_BufferedDensityMatrix':
+    def reindex(self, axes: Sequence[int]) -> _BufferedDensityMatrix:
         """Transposes the axes of a density matrix to a specified order.
 
         Args:
@@ -185,8 +187,8 @@ class _BufferedDensityMatrix(qis.QuantumStateRepresentation):
         return True
 
     def measure(
-        self, axes: Sequence[int], seed: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None
-    ) -> List[int]:
+        self, axes: Sequence[int], seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None
+    ) -> list[int]:
         """Measures the density matrix.
 
         Args:
@@ -205,10 +207,7 @@ class _BufferedDensityMatrix(qis.QuantumStateRepresentation):
         return bits
 
     def sample(
-        self,
-        axes: Sequence[int],
-        repetitions: int = 1,
-        seed: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None,
+        self, axes: Sequence[int], repetitions: int = 1, seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None
     ) -> np.ndarray:
         """Samples the density matrix.
 
@@ -246,12 +245,12 @@ class DensityMatrixSimulationState(SimulationState[_BufferedDensityMatrix]):
     def __init__(
         self,
         *,
-        available_buffer: Optional[List[np.ndarray]] = None,
-        prng: Optional[np.random.RandomState] = None,
-        qubits: Optional[Sequence['cirq.Qid']] = None,
-        initial_state: Union[np.ndarray, 'cirq.STATE_VECTOR_LIKE'] = 0,
-        dtype: Type[np.complexfloating] = np.complex64,
-        classical_data: Optional['cirq.ClassicalDataStore'] = None,
+        available_buffer: list[np.ndarray] | None = None,
+        prng: np.random.RandomState | None = None,
+        qubits: Sequence[cirq.Qid] | None = None,
+        initial_state: np.ndarray | cirq.STATE_VECTOR_LIKE = 0,
+        dtype: type[np.complexfloating] = np.complex64,
+        classical_data: cirq.ClassicalDataStore | None = None,
     ):
         """Inits DensityMatrixSimulationState.
 
@@ -285,7 +284,7 @@ class DensityMatrixSimulationState(SimulationState[_BufferedDensityMatrix]):
         )
         super().__init__(state=state, prng=prng, qubits=qubits, classical_data=classical_data)
 
-    def add_qubits(self, qubits: Sequence['cirq.Qid']):
+    def add_qubits(self, qubits: Sequence[cirq.Qid]):
         ret = super().add_qubits(qubits)
         return (
             self.kronecker_product(type(self)(qubits=qubits), inplace=True)
@@ -293,7 +292,7 @@ class DensityMatrixSimulationState(SimulationState[_BufferedDensityMatrix]):
             else ret
         )
 
-    def remove_qubits(self, qubits: Sequence['cirq.Qid']):
+    def remove_qubits(self, qubits: Sequence[cirq.Qid]):
         ret = super().remove_qubits(qubits)
         if ret is not NotImplemented:
             return ret
@@ -302,9 +301,9 @@ class DensityMatrixSimulationState(SimulationState[_BufferedDensityMatrix]):
         return remainder
 
     def _act_on_fallback_(
-        self, action: Any, qubits: Sequence['cirq.Qid'], allow_decompose: bool = True
+        self, action: Any, qubits: Sequence[cirq.Qid], allow_decompose: bool = True
     ) -> bool:
-        strats: List[Callable[[Any, Any, Sequence['cirq.Qid']], bool]] = [
+        strats: list[Callable[[Any, Any, Sequence[cirq.Qid]], bool]] = [
             _strat_apply_channel_to_state
         ]
         if allow_decompose:
@@ -346,7 +345,7 @@ class DensityMatrixSimulationState(SimulationState[_BufferedDensityMatrix]):
 
 
 def _strat_apply_channel_to_state(
-    action: Any, args: 'cirq.DensityMatrixSimulationState', qubits: Sequence['cirq.Qid']
+    action: Any, args: cirq.DensityMatrixSimulationState, qubits: Sequence[cirq.Qid]
 ) -> bool:
     """Apply channel to state."""
     if not args._state.apply_channel(action, args.get_axes(qubits)):