cirq-core 1.7.0.dev20250911180440__py3-none-any.whl → 1.7.0.dev20250917002151__py3-none-any.whl

cirq/sim/clifford/clifford_simulator_test.py

@@ -15,6 +15,7 @@
 from __future__ import annotations
 
 import itertools
+import random
 
 import numpy as np
 import pytest
@@ -24,7 +25,7 @@ import cirq
 import cirq.testing
 
 
-def test_simulate_no_circuit():
+def test_simulate_no_circuit() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     simulator = cirq.CliffordSimulator()
     circuit = cirq.Circuit()
@@ -33,7 +34,7 @@ def test_simulate_no_circuit():
     assert len(result.measurements) == 0
 
 
-def test_run_no_repetitions():
+def test_run_no_repetitions() -> None:
     q0 = cirq.LineQubit(0)
     simulator = cirq.CliffordSimulator()
     circuit = cirq.Circuit(cirq.H(q0), cirq.measure(q0))
@@ -41,7 +42,7 @@ def test_run_no_repetitions():
     assert sum(result.measurements['q(0)']) == 0
 
 
-def test_run_hadamard():
+def test_run_hadamard() -> None:
     q0 = cirq.LineQubit(0)
     simulator = cirq.CliffordSimulator()
     circuit = cirq.Circuit(cirq.H(q0), cirq.measure(q0))
@@ -50,7 +51,7 @@ def test_run_hadamard():
     assert sum(result.measurements['q(0)'])[0] > 20
 
 
-def test_run_GHZ():
+def test_run_GHZ() -> None:
     (q0, q1) = (cirq.LineQubit(0), cirq.LineQubit(1))
     simulator = cirq.CliffordSimulator()
     circuit = cirq.Circuit(cirq.H(q0), cirq.H(q1), cirq.measure(q0))
@@ -59,7 +60,7 @@ def test_run_GHZ():
     assert sum(result.measurements['q(0)'])[0] > 20
 
 
-def test_run_correlations():
+def test_run_correlations() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     simulator = cirq.CliffordSimulator()
     circuit = cirq.Circuit(cirq.H(q0), cirq.CNOT(q0, q1), cirq.measure(q0, q1))
@@ -69,7 +70,7 @@ def test_run_correlations():
         assert bits[0] == bits[1]
 
 
-def test_run_parameters_not_resolved():
+def test_run_parameters_not_resolved() -> None:
     a = cirq.LineQubit(0)
     simulator = cirq.CliffordSimulator()
     circuit = cirq.Circuit(cirq.XPowGate(exponent=sympy.Symbol('a'))(a), cirq.measure(a))
@@ -77,7 +78,7 @@ def test_run_parameters_not_resolved():
         _ = simulator.run_sweep(circuit, cirq.ParamResolver({}))
 
 
-def test_simulate_parameters_not_resolved():
+def test_simulate_parameters_not_resolved() -> None:
     a = cirq.LineQubit(0)
     simulator = cirq.CliffordSimulator()
     circuit = cirq.Circuit(cirq.XPowGate(exponent=sympy.Symbol('a'))(a), cirq.measure(a))
@@ -85,7 +86,7 @@ def test_simulate_parameters_not_resolved():
         _ = simulator.simulate_sweep(circuit, cirq.ParamResolver({}))
 
 
-def test_simulate():
+def test_simulate() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     simulator = cirq.CliffordSimulator()
     circuit = cirq.Circuit(cirq.H(q0), cirq.H(q1))
@@ -94,7 +95,7 @@ def test_simulate():
     assert len(result.measurements) == 0
 
 
-def test_simulate_initial_state():
+def test_simulate_initial_state() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     simulator = cirq.CliffordSimulator()
     for b0 in [0, 1]:
@@ -119,7 +120,7 @@ def test_simulate_initial_state():
                 )
 
 
-def test_simulation_state():
+def test_simulation_state() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     simulator = cirq.CliffordSimulator()
     for b0 in [0, 1]:
@@ -140,7 +141,7 @@ def test_simulation_state():
             )
 
 
-def test_simulate_qubit_order():
+def test_simulate_qubit_order() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     simulator = cirq.CliffordSimulator()
     for b0 in [0, 1]:
@@ -160,7 +161,7 @@ def test_simulate_qubit_order():
             )
 
 
-def test_run_measure_multiple_qubits():
+def test_run_measure_multiple_qubits() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     simulator = cirq.CliffordSimulator()
     for b0 in [0, 1]:
@@ -175,7 +176,7 @@ def test_run_measure_multiple_qubits():
             np.testing.assert_equal(result.measurements, {'q(0),q(1)': [[b0, b1]] * 3})
 
 
-def test_simulate_moment_steps():
+def test_simulate_moment_steps() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     circuit = cirq.Circuit(cirq.H(q0), cirq.H(q1), cirq.H(q0), cirq.H(q1))
     simulator = cirq.CliffordSimulator()
@@ -186,7 +187,7 @@ def test_simulate_moment_steps():
             np.testing.assert_almost_equal(step.state.to_numpy(), np.array([1, 0, 0, 0]))
 
 
-def test_simulate_moment_steps_sample():
+def test_simulate_moment_steps_sample() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     circuit = cirq.Circuit(cirq.H(q0), cirq.CNOT(q0, q1))
     simulator = cirq.CliffordSimulator()
@@ -206,7 +207,7 @@ def test_simulate_moment_steps_sample():
 
 
 @pytest.mark.parametrize('split', [True, False])
-def test_simulate_moment_steps_intermediate_measurement(split):
+def test_simulate_moment_steps_intermediate_measurement(split) -> None:
     q0 = cirq.LineQubit(0)
     circuit = cirq.Circuit(cirq.H(q0), cirq.measure(q0), cirq.H(q0))
     simulator = cirq.CliffordSimulator(split_untangled_states=split)
@@ -221,7 +222,7 @@ def test_simulate_moment_steps_intermediate_measurement(split):
             np.testing.assert_almost_equal(step.state.to_numpy(), expected)
 
 
-def test_clifford_state_initial_state():
+def test_clifford_state_initial_state() -> None:
     q0 = cirq.LineQubit(0)
     with pytest.raises(ValueError, match='Out of range'):
         _ = cirq.CliffordState(qubit_map={q0: 0}, initial_state=2)
@@ -231,7 +232,7 @@ def test_clifford_state_initial_state():
     assert state.copy() == state
 
 
-def test_clifford_trial_result_repr():
+def test_clifford_trial_result_repr() -> None:
     q0 = cirq.LineQubit(0)
     final_simulator_state = cirq.StabilizerChFormSimulationState(qubits=[q0])
     assert (
@@ -251,7 +252,7 @@ def test_clifford_trial_result_repr():
     )
 
 
-def test_clifford_trial_result_str():
+def test_clifford_trial_result_str() -> None:
     q0 = cirq.LineQubit(0)
     final_simulator_state = cirq.StabilizerChFormSimulationState(qubits=[q0])
     assert (
@@ -267,7 +268,7 @@ def test_clifford_trial_result_str():
     )
 
 
-def test_clifford_trial_result_repr_pretty():
+def test_clifford_trial_result_repr_pretty() -> None:
     q0 = cirq.LineQubit(0)
     final_simulator_state = cirq.StabilizerChFormSimulationState(qubits=[q0])
     result = cirq.CliffordTrialResult(
@@ -280,7 +281,7 @@ def test_clifford_trial_result_repr_pretty():
     cirq.testing.assert_repr_pretty(result, "cirq.CliffordTrialResult(...)", cycle=True)
 
 
-def test_clifford_step_result_str():
+def test_clifford_step_result_str() -> None:
     q0 = cirq.LineQubit(0)
     result = next(
         cirq.CliffordSimulator().simulate_moment_steps(cirq.Circuit(cirq.measure(q0, key='m')))
@@ -288,7 +289,7 @@ def test_clifford_step_result_str():
     assert str(result) == "m=0\n|0⟩"
 
 
-def test_clifford_step_result_repr_pretty():
+def test_clifford_step_result_repr_pretty() -> None:
     q0 = cirq.LineQubit(0)
     result = next(
         cirq.CliffordSimulator().simulate_moment_steps(cirq.Circuit(cirq.measure(q0, key='m')))
@@ -297,40 +298,40 @@ def test_clifford_step_result_repr_pretty():
     cirq.testing.assert_repr_pretty(result, "cirq.CliffordSimulatorStateResult(...)", cycle=True)
 
 
-def test_clifford_step_result_no_measurements_str():
+def test_clifford_step_result_no_measurements_str() -> None:
     q0 = cirq.LineQubit(0)
     result = next(cirq.CliffordSimulator().simulate_moment_steps(cirq.Circuit(cirq.I(q0))))
     assert str(result) == "|0⟩"
 
 
-def test_clifford_state_str():
+def test_clifford_state_str() -> None:
     (q0, q1) = (cirq.LineQubit(0), cirq.LineQubit(1))
     state = cirq.CliffordState(qubit_map={q0: 0, q1: 1})
 
     assert str(state) == "|00⟩"
 
 
-def test_clifford_state_state_vector():
+def test_clifford_state_state_vector() -> None:
     (q0, q1) = (cirq.LineQubit(0), cirq.LineQubit(1))
     state = cirq.CliffordState(qubit_map={q0: 0, q1: 1})
 
     np.testing.assert_equal(state.state_vector(), [1.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j])
 
 
-def test_stabilizerStateChForm_H():
+def test_stabilizerStateChForm_H() -> None:
     (q0, q1) = (cirq.LineQubit(0), cirq.LineQubit(1))
     state = cirq.CliffordState(qubit_map={q0: 0, q1: 1})
     with pytest.raises(ValueError, match="|y> is equal to |z>"):
         state.ch_form._H_decompose(0, 1, 1, 0)
 
 
-def test_clifford_stabilizerStateChForm_repr():
+def test_clifford_stabilizerStateChForm_repr() -> None:
     (q0, q1) = (cirq.LineQubit(0), cirq.LineQubit(1))
     state = cirq.CliffordState(qubit_map={q0: 0, q1: 1})
     assert repr(state) == 'StabilizerStateChForm(num_qubits=2)'
 
 
-def test_clifford_circuit_SHSYSHS():
+def test_clifford_circuit_SHSYSHS() -> None:
     q0 = cirq.LineQubit(0)
     circuit = cirq.Circuit(
         cirq.S(q0),
@@ -355,7 +356,7 @@ def test_clifford_circuit_SHSYSHS():
 
 
 @pytest.mark.parametrize('split', [True, False])
-def test_clifford_circuit(split):
+def test_clifford_circuit(split) -> None:
     (q0, q1) = (cirq.LineQubit(0), cirq.LineQubit(1))
     circuit = cirq.Circuit()
 
@@ -363,15 +364,15 @@ def test_clifford_circuit(split):
         x = np.random.randint(7)
 
         if x == 0:
-            circuit.append(cirq.X(np.random.choice((q0, q1))))
+            circuit.append(cirq.X(random.choice((q0, q1))))
         elif x == 1:
-            circuit.append(cirq.Z(np.random.choice((q0, q1))))
+            circuit.append(cirq.Z(random.choice((q0, q1))))
         elif x == 2:
-            circuit.append(cirq.Y(np.random.choice((q0, q1))))
+            circuit.append(cirq.Y(random.choice((q0, q1))))
         elif x == 3:
-            circuit.append(cirq.S(np.random.choice((q0, q1))))
+            circuit.append(cirq.S(random.choice((q0, q1))))
         elif x == 4:
-            circuit.append(cirq.H(np.random.choice((q0, q1))))
+            circuit.append(cirq.H(random.choice((q0, q1))))
         elif x == 5:
             circuit.append(cirq.CNOT(q0, q1))
         elif x == 6:
@@ -388,7 +389,7 @@ def test_clifford_circuit(split):
 
 @pytest.mark.parametrize("qubits", [cirq.LineQubit.range(2), cirq.LineQubit.range(4)])
 @pytest.mark.parametrize('split', [True, False])
-def test_clifford_circuit_2(qubits, split):
+def test_clifford_circuit_2(qubits, split) -> None:
     circuit = cirq.Circuit()
 
     np.random.seed(2)
@@ -419,7 +420,7 @@ def test_clifford_circuit_2(qubits, split):
 
 
 @pytest.mark.parametrize('split', [True, False])
-def test_clifford_circuit_3(split):
+def test_clifford_circuit_3(split) -> None:
     # This test tests the simulator on arbitrary 1-qubit Clifford gates.
     (q0, q1) = (cirq.LineQubit(0), cirq.LineQubit(1))
     circuit = cirq.Circuit()
@@ -435,7 +436,7 @@ def test_clifford_circuit_3(split):
         if np.random.randint(5) == 0:
             circuit.append(cirq.CNOT(q0, q1))
         else:
-            circuit.append(random_clifford_gate()(np.random.choice((q0, q1))))
+            circuit.append(random_clifford_gate()(random.choice((q0, q1))))
 
     clifford_simulator = cirq.CliffordSimulator(split_untangled_states=split)
     state_vector_simulator = cirq.Simulator()
@@ -447,7 +448,7 @@ def test_clifford_circuit_3(split):
     )
 
 
-def test_non_clifford_circuit():
+def test_non_clifford_circuit() -> None:
     q0 = cirq.LineQubit(0)
     circuit = cirq.Circuit()
     circuit.append(cirq.T(q0))
@@ -455,7 +456,7 @@ def test_non_clifford_circuit():
         cirq.CliffordSimulator().simulate(circuit)
 
 
-def test_swap():
+def test_swap() -> None:
     a, b = cirq.LineQubit.range(2)
     circuit = cirq.Circuit(
         cirq.X(a),
@@ -472,7 +473,7 @@ def test_swap():
         cirq.CliffordSimulator().simulate((cirq.Circuit(cirq.SWAP(a, b) ** 3.5)))
 
 
-def test_sample_seed():
+def test_sample_seed() -> None:
     q = cirq.NamedQubit('q')
     circuit = cirq.Circuit(cirq.H(q), cirq.measure(q))
     simulator = cirq.CliffordSimulator(seed=1234)
@@ -482,7 +483,7 @@ def test_sample_seed():
     assert result_string == '11010001111100100000'
 
 
-def test_is_supported_operation():
+def test_is_supported_operation() -> None:
     class MultiQubitOp(cirq.Operation):
         """Multi-qubit operation with unitary.
 
@@ -514,7 +515,7 @@ def test_is_supported_operation():
     assert not cirq.CliffordSimulator.is_supported_operation(MultiQubitOp())
 
 
-def test_simulate_pauli_string():
+def test_simulate_pauli_string() -> None:
     q = cirq.NamedQubit('q')
     circuit = cirq.Circuit([cirq.PauliString({q: 'X'}), cirq.PauliString({q: 'Z'})])
     simulator = cirq.CliffordSimulator()
@@ -524,7 +525,7 @@ def test_simulate_pauli_string():
     assert np.allclose(result, [0, -1])
 
 
-def test_simulate_global_phase_operation():
+def test_simulate_global_phase_operation() -> None:
     q1, q2 = cirq.LineQubit.range(2)
     circuit = cirq.Circuit([cirq.I(q1), cirq.I(q2), cirq.global_phase_operation(-1j)])
     simulator = cirq.CliffordSimulator()
@@ -534,7 +535,7 @@ def test_simulate_global_phase_operation():
     assert np.allclose(result, [-1j, 0, 0, 0])
 
 
-def test_json_roundtrip():
+def test_json_roundtrip() -> None:
     (q0, q1, q2) = (cirq.LineQubit(0), cirq.LineQubit(1), cirq.LineQubit(2))
     state = cirq.CliffordState(qubit_map={q0: 0, q1: 1, q2: 2})
 
@@ -557,19 +558,19 @@ def test_json_roundtrip():
     assert np.allclose(state.ch_form.state_vector(), state_roundtrip.ch_form.state_vector())
 
 
-def test_invalid_apply_measurement():
+def test_invalid_apply_measurement() -> None:
     q0 = cirq.LineQubit(0)
     state = cirq.CliffordState(qubit_map={q0: 0})
-    measurements = {}
+    measurements: dict[str, list[int]] = {}
     with pytest.raises(TypeError, match='only supports cirq.MeasurementGate'):
         state.apply_measurement(cirq.H(q0), measurements, np.random.RandomState())
     assert measurements == {}
 
 
-def test_valid_apply_measurement():
+def test_valid_apply_measurement() -> None:
     q0 = cirq.LineQubit(0)
     state = cirq.CliffordState(qubit_map={q0: 0}, initial_state=1)
-    measurements = {}
+    measurements: dict[str, list[int]] = {}
     state.apply_measurement(
         cirq.measure(q0), measurements, np.random.RandomState(), collapse_state_vector=False
     )
@@ -579,7 +580,7 @@ def test_valid_apply_measurement():
 
 
 @pytest.mark.parametrize('split', [True, False])
-def test_reset(split):
+def test_reset(split) -> None:
     q = cirq.LineQubit(0)
     c = cirq.Circuit(cirq.X(q), cirq.reset(q), cirq.measure(q, key="out"))
     sim = cirq.CliffordSimulator(split_untangled_states=split)
@@ -590,7 +591,7 @@ def test_reset(split):
     assert sim.sample(c)["out"][0] == 0
 
 
-def test_state_copy():
+def test_state_copy() -> None:
     sim = cirq.CliffordSimulator()
 
     q = cirq.LineQubit(0)

cirq/sim/clifford/stabilizer_state_ch_form.py

@@ -150,7 +150,7 @@ class StabilizerStateChForm(qis.StabilizerState):
         self.F[:, r] ^= self.F[:, q]
         self.M[:, q] ^= self.M[:, r]
 
-    def update_sum(self, t, u, delta=0, alpha=0):
+    def update_sum(self, t, u, delta=0, alpha=0) -> None:
         """Implements the transformation (Proposition 4 in Bravyi et al)
 
         ``i^alpha U_H (|t> + i^delta |u>) = omega W_C W_H |s'>``
@@ -255,7 +255,7 @@ class StabilizerStateChForm(qis.StabilizerState):
         self.project_Z(q, x_i)
         return x_i
 
-    def project_Z(self, q, z):
+    def project_Z(self, q, z) -> None:
         """Applies a Z projector on the q'th qubit.
 
         Returns: a normalized state with Z_q |psi> = z |psi>
@@ -295,7 +295,7 @@ class StabilizerStateChForm(qis.StabilizerState):
         copy.omega = self.omega
         return copy
 
-    def apply_x(self, axis: int, exponent: float = 1, global_shift: float = 0):
+    def apply_x(self, axis: int, exponent: float = 1, global_shift: float = 0) -> None:
         if exponent % 2 != 0:
             if exponent % 0.5 != 0.0:
                 raise ValueError('X exponent must be half integer')  # pragma: no cover
@@ -304,7 +304,7 @@ class StabilizerStateChForm(qis.StabilizerState):
             self.apply_h(axis)
         self.omega *= _phase(exponent, global_shift)
 
-    def apply_y(self, axis: int, exponent: float = 1, global_shift: float = 0):
+    def apply_y(self, axis: int, exponent: float = 1, global_shift: float = 0) -> None:
         if exponent % 0.5 != 0.0:
             raise ValueError('Y exponent must be half integer')  # pragma: no cover
         shift = _phase(exponent, global_shift)
@@ -325,7 +325,7 @@ class StabilizerStateChForm(qis.StabilizerState):
             self.apply_z(axis)
             self.omega *= shift * (1 - 1j) / (2**0.5)
 
-    def apply_z(self, axis: int, exponent: float = 1, global_shift: float = 0):
+    def apply_z(self, axis: int, exponent: float = 1, global_shift: float = 0) -> None:
         if exponent % 2 != 0:
             if exponent % 0.5 != 0.0:
                 raise ValueError('Z exponent must be half integer')  # pragma: no cover
@@ -337,7 +337,7 @@ class StabilizerStateChForm(qis.StabilizerState):
                 self.gamma[axis] = (self.gamma[axis] - 1) % 4
         self.omega *= _phase(exponent, global_shift)
 
-    def apply_h(self, axis: int, exponent: float = 1, global_shift: float = 0):
+    def apply_h(self, axis: int, exponent: float = 1, global_shift: float = 0) -> None:
         if exponent % 2 != 0:
             if exponent % 1 != 0:
                 raise ValueError('H exponent must be integer')  # pragma: no cover
@@ -357,7 +357,7 @@ class StabilizerStateChForm(qis.StabilizerState):
 
     def apply_cz(
         self, control_axis: int, target_axis: int, exponent: float = 1, global_shift: float = 0
-    ):
+    ) -> None:
         if exponent % 2 != 0:
             if exponent % 1 != 0:
                 raise ValueError('CZ exponent must be integer')  # pragma: no cover
@@ -369,7 +369,7 @@ class StabilizerStateChForm(qis.StabilizerState):
 
     def apply_cx(
         self, control_axis: int, target_axis: int, exponent: float = 1, global_shift: float = 0
-    ):
+    ) -> None:
         if exponent % 2 != 0:
             if exponent % 1 != 0:
                 raise ValueError('CX exponent must be integer')  # pragma: no cover
@@ -385,7 +385,7 @@ class StabilizerStateChForm(qis.StabilizerState):
             self.M[control_axis, :] ^= self.M[target_axis, :]
         self.omega *= _phase(exponent, global_shift)
 
-    def apply_global_phase(self, coefficient: value.Scalar):
+    def apply_global_phase(self, coefficient: value.Scalar) -> None:
         self.omega *= coefficient
 
     def measure(

cirq/sim/density_matrix_simulation_state.py

@@ -16,7 +16,7 @@
 
 from __future__ import annotations
 
-from typing import Any, Callable, Sequence, TYPE_CHECKING
+from typing import Any, Callable, Self, Sequence, TYPE_CHECKING
 
 import numpy as np
 
@@ -284,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]) -> Self:
         ret = super().add_qubits(qubits)
         return (
             self.kronecker_product(type(self)(qubits=qubits), inplace=True)
@@ -292,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]) -> Self:
         ret = super().remove_qubits(qubits)
         if ret is not NotImplemented:
             return ret
@@ -332,15 +332,15 @@ class DensityMatrixSimulationState(SimulationState[_BufferedDensityMatrix]):
         )
 
     @property
-    def target_tensor(self):
+    def target_tensor(self) -> np.ndarray:
         return self._state._density_matrix
 
     @property
-    def available_buffer(self):
+    def available_buffer(self) -> list[np.ndarray]:
         return self._state._buffer
 
     @property
-    def qid_shape(self):
+    def qid_shape(self) -> tuple[int, ...]:
         return self._state._qid_shape
 
 

cirq/sim/density_matrix_simulator.py

@@ -258,7 +258,7 @@ class DensityMatrixStepResult(simulator_base.StepResultBase['cirq.DensityMatrixS
         self._dtype = dtype
         self._density_matrix: np.ndarray | None = None
 
-    def density_matrix(self, copy=True):
+    def density_matrix(self, copy=True) -> np.ndarray:
         """Returns the density matrix at this step in the simulation.
 
         The density matrix that is stored in this result is returned in the