cirq-core 1.7.0.dev20250915211227__py3-none-any.whl → 1.7.0.dev20250917023732__py3-none-any.whl

cirq/sim/classical_simulator_test.py

@@ -23,7 +23,7 @@ import sympy
 import cirq
 
 
-def test_x_gate():
+def test_x_gate() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     circuit = cirq.Circuit()
     circuit.append(cirq.X(q0))
@@ -31,30 +31,33 @@ def test_x_gate():
     circuit.append(cirq.X(q1))
     circuit.append(cirq.measure((q0, q1), key='key'))
     expected_results = {'key': np.array([[[1, 0]]], dtype=np.uint8)}
+    sim: cirq.ClassicalStateSimulator
     sim = cirq.ClassicalStateSimulator()
     results = sim.run(circuit, param_resolver=None, repetitions=1).records
     np.testing.assert_equal(results, expected_results)
 
 
-def test_CNOT():
+def test_CNOT() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     circuit = cirq.Circuit()
     circuit.append(cirq.X(q0))
     circuit.append(cirq.CNOT(q0, q1))
     circuit.append(cirq.measure(q1, key='key'))
     expected_results = {'key': np.array([[[1]]], dtype=np.uint8)}
+    sim: cirq.ClassicalStateSimulator
     sim = cirq.ClassicalStateSimulator()
     results = sim.run(circuit, param_resolver=None, repetitions=1).records
     np.testing.assert_equal(results, expected_results)
 
 
-def test_Swap():
+def test_Swap() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     circuit = cirq.Circuit()
     circuit.append(cirq.X(q0))
     circuit.append(cirq.SWAP(q0, q1))
     circuit.append(cirq.measure((q0, q1), key='key'))
     expected_results = {'key': np.array([[[0, 1]]], dtype=np.uint8)}
+    sim: cirq.ClassicalStateSimulator
     sim = cirq.ClassicalStateSimulator()
     results = sim.run(circuit, param_resolver=None, repetitions=1).records
     np.testing.assert_equal(results, expected_results)
@@ -67,10 +70,11 @@ def test_Swap():
         for n in np.random.randint(3, 8, size=10)
     ],
 )
-def test_qubit_permutation_gate(n, perm, state):
+def test_qubit_permutation_gate(n, perm, state) -> None:
     qubits = cirq.LineQubit.range(n)
     perm_gate = cirq.QubitPermutationGate(perm)
     circuit = cirq.Circuit(perm_gate(*qubits), cirq.measure(*qubits, key='key'))
+    sim: cirq.ClassicalStateSimulator
     sim = cirq.ClassicalStateSimulator()
     result = sim.simulate(circuit, initial_state=state)
     expected = [0] * n
@@ -79,7 +83,7 @@ def test_qubit_permutation_gate(n, perm, state):
     np.testing.assert_equal(result.measurements['key'], expected)
 
 
-def test_CCNOT():
+def test_CCNOT() -> None:
     q0, q1, q2 = cirq.LineQubit.range(3)
     circuit = cirq.Circuit()
     circuit.append(cirq.CCNOT(q0, q1, q2))
@@ -97,13 +101,14 @@ def test_CCNOT():
     expected_results = {
         'key': np.array([[[0, 0, 0], [1, 0, 0], [0, 1, 0], [1, 1, 1]]], dtype=np.uint8)
     }
+    sim: cirq.ClassicalStateSimulator
     sim = cirq.ClassicalStateSimulator()
     results = sim.run(circuit, param_resolver=None, repetitions=1).records
     np.testing.assert_equal(results, expected_results)
 
 
 @pytest.mark.parametrize(['initial_state'], [(list(x),) for x in product([0, 1], repeat=4)])
-def test_CCCX(initial_state):
+def test_CCCX(initial_state) -> None:
     CCCX = cirq.CCNOT.controlled()
     qubits = cirq.LineQubit.range(4)
 
@@ -114,13 +119,14 @@ def test_CCCX(initial_state):
     final_state = initial_state.copy()
     final_state[-1] ^= all(final_state[:-1])
 
+    sim: cirq.ClassicalStateSimulator
     sim = cirq.ClassicalStateSimulator()
     results = sim.simulate(circuit, initial_state=initial_state).measurements['key']
     np.testing.assert_equal(results, final_state)
 
 
 @pytest.mark.parametrize(['initial_state'], [(list(x),) for x in product([0, 1], repeat=3)])
-def test_CSWAP(initial_state):
+def test_CSWAP(initial_state) -> None:
     CSWAP = cirq.SWAP.controlled()
     qubits = cirq.LineQubit.range(3)
     circuit = cirq.Circuit()
@@ -134,46 +140,50 @@ def test_CSWAP(initial_state):
         b, c = c, b
     final_state = [a, b, c]
 
+    sim: cirq.ClassicalStateSimulator
     sim = cirq.ClassicalStateSimulator()
     results = sim.simulate(circuit, initial_state=initial_state).measurements['key']
     np.testing.assert_equal(results, final_state)
 
 
-def test_measurement_gate():
+def test_measurement_gate() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     circuit = cirq.Circuit()
     circuit.append(cirq.measure((q0, q1), key='key'))
     expected_results = {'key': np.array([[[0, 0]]], dtype=np.uint8)}
+    sim: cirq.ClassicalStateSimulator
     sim = cirq.ClassicalStateSimulator()
     results = sim.run(circuit, param_resolver=None, repetitions=1).records
     np.testing.assert_equal(results, expected_results)
 
 
-def test_qubit_order():
+def test_qubit_order() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     circuit = cirq.Circuit()
     circuit.append(cirq.CNOT(q0, q1))
     circuit.append(cirq.X(q0))
     circuit.append(cirq.measure((q0, q1), key='key'))
     expected_results = {'key': np.array([[[1, 0]]], dtype=np.uint8)}
+    sim: cirq.ClassicalStateSimulator
     sim = cirq.ClassicalStateSimulator()
     results = sim.run(circuit, param_resolver=None, repetitions=1).records
     np.testing.assert_equal(results, expected_results)
 
 
-def test_same_key_instances():
+def test_same_key_instances() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     circuit = cirq.Circuit()
     circuit.append(cirq.measure((q0, q1), key='key'))
     circuit.append(cirq.X(q0))
     circuit.append(cirq.measure((q0, q1), key='key'))
     expected_results = {'key': np.array([[[0, 0], [1, 0]]], dtype=np.uint8)}
+    sim: cirq.ClassicalStateSimulator
     sim = cirq.ClassicalStateSimulator()
     results = sim.run(circuit, param_resolver=None, repetitions=1).records
     np.testing.assert_equal(results, expected_results)
 
 
-def test_same_key_instances_order():
+def test_same_key_instances_order() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     circuit = cirq.Circuit()
     circuit.append(cirq.X(q0))
@@ -181,12 +191,13 @@ def test_same_key_instances_order():
     circuit.append(cirq.X(q0))
     circuit.append(cirq.measure((q1, q0), key='key'))
     expected_results = {'key': np.array([[[1, 0], [0, 0]]], dtype=np.uint8)}
+    sim: cirq.ClassicalStateSimulator
     sim = cirq.ClassicalStateSimulator()
     results = sim.run(circuit, param_resolver=None, repetitions=1).records
     np.testing.assert_equal(results, expected_results)
 
 
-def test_repetitions():
+def test_repetitions() -> None:
     q0 = cirq.LineQubit.range(1)
     circuit = cirq.Circuit()
     circuit.append(cirq.measure(q0, key='key'))
@@ -195,12 +206,13 @@ def test_repetitions():
             [[[0]], [[0]], [[0]], [[0]], [[0]], [[0]], [[0]], [[0]], [[0]], [[0]]], dtype=np.uint8
         )
     }
+    sim: cirq.ClassicalStateSimulator
     sim = cirq.ClassicalStateSimulator()
     results = sim.run(circuit, param_resolver=None, repetitions=10).records
     np.testing.assert_equal(results, expected_results)
 
 
-def test_multiple_gates():
+def test_multiple_gates() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     circuit = cirq.Circuit()
     circuit.append(cirq.X(q0))
@@ -210,12 +222,13 @@ def test_multiple_gates():
     circuit.append(cirq.X(q1))
     circuit.append(cirq.measure((q0, q1), key='key'))
     expected_results = {'key': np.array([[[1, 0]]], dtype=np.uint8)}
+    sim: cirq.ClassicalStateSimulator
     sim = cirq.ClassicalStateSimulator()
     results = sim.run(circuit, param_resolver=None, repetitions=1).records
     np.testing.assert_equal(results, expected_results)
 
 
-def test_multiple_gates_order():
+def test_multiple_gates_order() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     circuit = cirq.Circuit()
     circuit.append(cirq.X(q0))
@@ -223,20 +236,22 @@ def test_multiple_gates_order():
     circuit.append(cirq.CNOT(q1, q0))
     circuit.append(cirq.measure((q0, q1), key='key'))
     expected_results = {'key': np.array([[[0, 1]]], dtype=np.uint8)}
+    sim: cirq.ClassicalStateSimulator
     sim = cirq.ClassicalStateSimulator()
     results = sim.run(circuit, param_resolver=None, repetitions=1).records
     np.testing.assert_equal(results, expected_results)
 
 
-def test_tuple_initial_state():
+def test_tuple_initial_state() -> None:
     q0, q1, q2 = cirq.LineQubit.range(3)
     circuit = cirq.Circuit(cirq.X(q0), cirq.measure(q0, q1, q2, key='key'))
+    sim: cirq.ClassicalStateSimulator
     sim = cirq.ClassicalStateSimulator()
     result = sim.simulate(circuit, initial_state=(0, 1, 0))
     np.testing.assert_equal(result.measurements['key'], [1, 1, 0])
 
 
-def test_param_resolver():
+def test_param_resolver() -> None:
     gate = cirq.CNOT ** sympy.Symbol('t')
     q0, q1 = cirq.LineQubit.range(2)
     circuit = cirq.Circuit()
@@ -244,6 +259,7 @@ def test_param_resolver():
     circuit.append(gate(q0, q1))
     circuit.append(cirq.measure((q1), key='key'))
     resolver = cirq.ParamResolver({'t': 0})
+    sim: cirq.ClassicalStateSimulator
     sim = cirq.ClassicalStateSimulator()
     results_with_parameter_zero = sim.run(circuit, param_resolver=resolver, repetitions=1).records
     resolver = cirq.ParamResolver({'t': 1})
@@ -252,33 +268,37 @@ def test_param_resolver():
     np.testing.assert_equal(results_with_parameter_one, {'key': np.array([[[1]]], dtype=np.uint8)})
 
 
-def test_unknown_gates():
+def test_unknown_gates() -> None:
     gate = cirq.Y
     q = cirq.LineQubit(0)
     circuit = cirq.Circuit(gate(q), cirq.measure((q), key='key'))
+    sim: cirq.ClassicalStateSimulator
     sim = cirq.ClassicalStateSimulator()
     with pytest.raises(ValueError):
         _ = sim.run(circuit).records
 
 
-def test_incompatible_measurements():
+def test_incompatible_measurements() -> None:
     qs = cirq.LineQubit.range(2)
     c = cirq.Circuit(cirq.measure(qs, key='key'), cirq.measure(qs[0], key='key'))
+    sim: cirq.ClassicalStateSimulator
     sim = cirq.ClassicalStateSimulator()
     with pytest.raises(ValueError):
         _ = sim.run(c)
 
 
-def test_compatible_measurement():
+def test_compatible_measurement() -> None:
     qs = cirq.LineQubit.range(2)
     c = cirq.Circuit(cirq.measure(qs, key='key'), cirq.X.on_each(qs), cirq.measure(qs, key='key'))
+    sim: cirq.ClassicalStateSimulator
     sim = cirq.ClassicalStateSimulator()
     res = sim.run(c, repetitions=3).records
     np.testing.assert_equal(res['key'], np.array([[[0, 0], [1, 1]]] * 3, dtype=np.uint8))
 
 
-def test_simulate_sweeps_param_resolver():
+def test_simulate_sweeps_param_resolver() -> None:
     q0, q1 = cirq.LineQubit.range(2)
+    simulator: cirq.ClassicalStateSimulator
     simulator = cirq.ClassicalStateSimulator()
     for b0 in [0, 1]:
         for b1 in [0, 1]:
@@ -295,18 +315,22 @@ def test_simulate_sweeps_param_resolver():
             assert results[1].params == params[1]
 
 
-def test_create_partial_simulation_state_from_int_with_no_qubits():
+def test_create_partial_simulation_state_from_int_with_no_qubits() -> None:
+    sim: cirq.ClassicalStateSimulator
     sim = cirq.ClassicalStateSimulator()
     initial_state = 5
     qs = None
     classical_data = cirq.value.ClassicalDataDictionaryStore()
     with pytest.raises(ValueError):
         sim._create_partial_simulation_state(
-            initial_state=initial_state, qubits=qs, classical_data=classical_data
+            initial_state=initial_state,
+            qubits=qs,  # type: ignore[arg-type]
+            classical_data=classical_data,
         )
 
 
-def test_create_partial_simulation_state_from_invalid_state():
+def test_create_partial_simulation_state_from_invalid_state() -> None:
+    sim: cirq.ClassicalStateSimulator
     sim = cirq.ClassicalStateSimulator()
     initial_state = None
     qs = cirq.LineQubit.range(2)
@@ -317,7 +341,8 @@ def test_create_partial_simulation_state_from_invalid_state():
         )
 
 
-def test_create_partial_simulation_state_from_int():
+def test_create_partial_simulation_state_from_int() -> None:
+    sim: cirq.ClassicalStateSimulator
     sim = cirq.ClassicalStateSimulator()
     initial_state = 15
     qs = cirq.LineQubit.range(4)
@@ -329,7 +354,8 @@ def test_create_partial_simulation_state_from_int():
     assert result == expected_result
 
 
-def test_create_valid_partial_simulation_state_from_list():
+def test_create_valid_partial_simulation_state_from_list() -> None:
+    sim: cirq.ClassicalStateSimulator
     sim = cirq.ClassicalStateSimulator()
     initial_state = [1, 1, 1, 1]
     qs = cirq.LineQubit.range(4)
@@ -341,7 +367,8 @@ def test_create_valid_partial_simulation_state_from_list():
     assert result == expected_result
 
 
-def test_create_valid_partial_simulation_state_from_np():
+def test_create_valid_partial_simulation_state_from_np() -> None:
+    sim: cirq.ClassicalStateSimulator
     sim = cirq.ClassicalStateSimulator()
     initial_state = np.array([1, 1])
     qs = cirq.LineQubit.range(2)
@@ -355,10 +382,11 @@ def test_create_valid_partial_simulation_state_from_np():
     np.testing.assert_equal(result, expected_result)
 
 
-def test_create_invalid_partial_simulation_state_from_np():
+def test_create_invalid_partial_simulation_state_from_np() -> None:
     initial_state = np.array([[1, 1], [1, 1]])
     qs = cirq.LineQubit.range(2)
     classical_data = cirq.value.ClassicalDataDictionaryStore()
+    sim: cirq.ClassicalStateSimulator
     sim = cirq.ClassicalStateSimulator()
 
     with pytest.raises(ValueError):
@@ -367,7 +395,7 @@ def test_create_invalid_partial_simulation_state_from_np():
         )
 
 
-def test_noise_model():
+def test_noise_model() -> None:
     noise_model = cirq.NoiseModel.from_noise_model_like(cirq.depolarize(p=0.01))
     with pytest.raises(ValueError):
         cirq.ClassicalStateSimulator(noise=noise_model)

cirq/sim/clifford/clifford_simulator.py

@@ -161,7 +161,7 @@ class CliffordSimulatorStepResult(
             sim_state: The qubit:SimulationState lookup for this step.
         """
         super().__init__(sim_state)
-        self._clifford_state = None
+        self._clifford_state: CliffordState | None = None
 
     def __str__(self) -> str:
         def bitstring(vals):
@@ -183,7 +183,7 @@ class CliffordSimulatorStepResult(
         p.text("cirq.CliffordSimulatorStateResult(...)" if cycle else self.__str__())
 
     @property
-    def state(self):
+    def state(self) -> CliffordState:
         if self._clifford_state is None:
             clifford_state = CliffordState(self._qubit_mapping)
             clifford_state.ch_form = self._merged_sim_state.state.copy()
@@ -240,10 +240,10 @@ class CliffordState:
     def to_numpy(self) -> np.ndarray:
         return self.ch_form.to_state_vector()
 
-    def state_vector(self):
+    def state_vector(self) -> np.ndarray:
         return self.ch_form.state_vector()
 
-    def apply_unitary(self, op: cirq.Operation):
+    def apply_unitary(self, op: cirq.Operation) -> None:
         ch_form_args = clifford.StabilizerChFormSimulationState(
             prng=np.random.RandomState(), qubits=self.qubit_map.keys(), initial_state=self.ch_form
         )
@@ -259,7 +259,7 @@ class CliffordState:
         measurements: dict[str, list[int]],
         prng: np.random.RandomState,
         collapse_state_vector=True,
-    ):
+    ) -> None:
         if not isinstance(op.gate, cirq.MeasurementGate):
             raise TypeError(
                 f'apply_measurement only supports cirq.MeasurementGate operations. '