cirq-core 1.7.0.dev20250825174419__py3-none-any.whl → 1.7.0.dev20251203004401__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,36 +31,59 @@ 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)
 
 
-def test_CCNOT():
+@pytest.mark.parametrize(
+    "n,perm,state",
+    [
+        (n, np.random.permutation(n).tolist(), np.random.choice(2, size=n))
+        for n in np.random.randint(3, 8, size=10)
+    ],
+)
+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
+    for i in range(n):
+        expected[perm[i]] = state[i]
+    np.testing.assert_equal(result.measurements['key'], expected)
+
+
+def test_CCNOT() -> None:
     q0, q1, q2 = cirq.LineQubit.range(3)
     circuit = cirq.Circuit()
     circuit.append(cirq.CCNOT(q0, q1, q2))
@@ -78,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)
 
@@ -95,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()
@@ -115,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))
@@ -162,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'))
@@ -176,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))
@@ -191,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))
@@ -204,12 +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_param_resolver():
+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() -> None:
     gate = cirq.CNOT ** sympy.Symbol('t')
     q0, q1 = cirq.LineQubit.range(2)
     circuit = cirq.Circuit()
@@ -217,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})
@@ -225,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]:
@@ -268,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)
@@ -290,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)
@@ -302,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)
@@ -314,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)
@@ -328,19 +382,20 @@ 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()
-    sim_state = sim._create_partial_simulation_state(
-        initial_state=initial_state, qubits=qs, classical_data=classical_data
-    )
+
     with pytest.raises(ValueError):
-        sim_state._act_on_fallback_(action=cirq.CX, qubits=qs)
+        sim._create_partial_simulation_state(
+            initial_state=initial_state, qubits=qs, classical_data=classical_data
+        )
 
 
-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

@@ -32,7 +32,8 @@ The quantum state is specified in two forms:
 
 from __future__ import annotations
 
-from typing import Any, Sequence
+from collections.abc import Sequence
+from typing import Any
 
 import numpy as np
 
@@ -161,7 +162,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 +184,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 +241,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 +260,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. '