cirq-core 1.4.0.dev20240529225110__py3-none-any.whl → 1.5.0__py3-none-any.whl

cirq/sim/clifford/clifford_simulator_test.py

@@ -1,4 +1,16 @@
-# pylint: disable=wrong-or-nonexistent-copyright-notice
+# Copyright 2025 The Cirq Developers
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# 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.
 import itertools
 
 import numpy as np
@@ -91,12 +103,17 @@ def test_simulate_initial_state():
                 circuit.append(cirq.X(q1))
             circuit.append(cirq.measure(q0, q1))
 
-            result = simulator.simulate(circuit, initial_state=1)
-            expected_state = np.zeros(shape=(2, 2))
-            expected_state[b0][1 - b1] = 1.0
-            np.testing.assert_almost_equal(
-                result.final_state.to_numpy(), np.reshape(expected_state, 4)
-            )
+            for initial_state in [
+                cirq.StabilizerChFormSimulationState(
+                    qubits=cirq.LineQubit.range(2), initial_state=1
+                )
+            ]:
+                result = simulator.simulate(circuit, initial_state=initial_state)
+                expected_state = np.zeros(shape=(2, 2))
+                expected_state[b0][1 - b1] = 1.0
+                np.testing.assert_almost_equal(
+                    result.final_state.to_numpy(), np.reshape(expected_state, 4)
+                )
 
 
 def test_simulation_state():
@@ -208,6 +225,8 @@ def test_clifford_state_initial_state():
     state = cirq.CliffordState(qubit_map={q0: 0}, initial_state=1)
     np.testing.assert_allclose(state.state_vector(), [0, 1])
 
+    assert state.copy() == state
+
 
 def test_clifford_trial_result_repr():
     q0 = cirq.LineQubit(0)
@@ -476,10 +495,10 @@ def test_is_supported_operation():
             raise NotImplementedError()
 
         def _has_unitary_(self):
-            return True
+            return True  # pragma: no cover
 
         def _unitary_(self):
-            assert False
+            assert False  # pragma: no cover
 
     q1, q2 = cirq.LineQubit.range(2)
     assert cirq.CliffordSimulator.is_supported_operation(cirq.X(q1))
@@ -548,6 +567,10 @@ def test_valid_apply_measurement():
     q0 = cirq.LineQubit(0)
     state = cirq.CliffordState(qubit_map={q0: 0}, initial_state=1)
     measurements = {}
+    _ = state.apply_measurement(
+        cirq.measure(q0), measurements, np.random.RandomState(), collapse_state_vector=False
+    )
+    assert measurements == {'q(0)': [1]}
     state.apply_measurement(cirq.measure(q0), measurements, np.random.RandomState())
     assert measurements == {'q(0)': [1]}
 

cirq/sim/clifford/clifford_tableau_simulation_state.py

@@ -12,7 +12,7 @@
 # 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."""
+for Clifford Simulator."""
 
 from typing import Optional, Sequence, TYPE_CHECKING
 

cirq/sim/clifford/stabilizer_simulation_state.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 
 import abc
+from types import NotImplementedType
 from typing import Any, cast, Generic, Optional, Sequence, TYPE_CHECKING, TypeVar, Union
 
 import numpy as np
@@ -23,7 +24,6 @@ from cirq.ops import common_gates, global_phase_op, matrix_gates, swap_gates
 from cirq.ops.clifford_gate import SingleQubitCliffordGate
 from cirq.protocols import has_unitary, num_qubits, unitary
 from cirq.sim.simulation_state import SimulationState
-from cirq.type_workarounds import NotImplementedType
 
 if TYPE_CHECKING:
     import cirq

cirq/sim/clifford/stabilizer_state_ch_form.py

@@ -12,7 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Any, Dict, List, Sequence, Union
+from typing import Any, Dict, List, Sequence
+
 import numpy as np
 
 import cirq
@@ -20,7 +21,7 @@ from cirq import protocols, qis, value
 from cirq.value import big_endian_int_to_digits, random_state
 
 
-@value.value_equality
+@value.value_equality(unhashable=True)
 class StabilizerStateChForm(qis.StabilizerState):
     r"""A representation of stabilizer states using the CH form,
 
@@ -101,7 +102,7 @@ class StabilizerStateChForm(qis.StabilizerState):
         """Return the CH form representation of the state."""
         return f'StabilizerStateChForm(num_qubits={self.n!r})'
 
-    def inner_product_of_state_and_x(self, x: int) -> Union[float, complex]:
+    def inner_product_of_state_and_x(self, x: int) -> complex:
         """Returns the amplitude of x'th element of
         the state vector, i.e. <x|psi>"""
         if type(x) == int:

cirq/sim/density_matrix_simulator.py

@@ -18,7 +18,7 @@ import numpy as np
 
 from cirq import ops, protocols, study, value
 from cirq._compat import proper_repr
-from cirq.sim import simulator, density_matrix_simulation_state, simulator_base
+from cirq.sim import density_matrix_simulation_state, simulator, simulator_base
 
 if TYPE_CHECKING:
     import cirq
@@ -168,7 +168,8 @@ class DensityMatrixSimulator(
             DensityMatrixSimulationState for the circuit.
         """
         if isinstance(initial_state, density_matrix_simulation_state.DensityMatrixSimulationState):
-            return initial_state
+            # Instances of SimulationStateBase usually returned before this point
+            return initial_state  # pragma: no cover
 
         return density_matrix_simulation_state.DensityMatrixSimulationState(
             qubits=qubits,

cirq/sim/density_matrix_simulator_test.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 import itertools
 import random
-from typing import Type
+from typing import Type, Union
 from unittest import mock
 
 import numpy as np
@@ -402,10 +402,10 @@ def test_run_param_resolver(dtype: Type[np.complexfloating], split: bool):
                 cirq.measure(q1),
             )
             param_resolver = {'b0': b0, 'b1': b1}
-            result = simulator.run(circuit, param_resolver=param_resolver)  # type: ignore
+            result = simulator.run(circuit, param_resolver=param_resolver)
             np.testing.assert_equal(result.measurements, {'q(0)': [[b0]], 'q(1)': [[b1]]})
             # pylint: disable=line-too-long
-            np.testing.assert_equal(result.params, cirq.ParamResolver(param_resolver))  # type: ignore
+            np.testing.assert_equal(result.params, cirq.ParamResolver(param_resolver))
 
 
 @pytest.mark.parametrize('dtype', [np.complex64, np.complex128])
@@ -584,7 +584,15 @@ def test_simulate_qudit_increments(dtype: Type[np.complexfloating], split: bool)
 
 @pytest.mark.parametrize('dtype', [np.complex64, np.complex128])
 @pytest.mark.parametrize('split', [True, False])
-def test_simulate_initial_state(dtype: Type[np.complexfloating], split: bool):
+@pytest.mark.parametrize(
+    'initial_state',
+    [1, cirq.DensityMatrixSimulationState(initial_state=1, qubits=cirq.LineQubit.range(2))],
+)
+def test_simulate_initial_state(
+    dtype: Type[np.complexfloating],
+    split: bool,
+    initial_state: Union[int, cirq.DensityMatrixSimulationState],
+):
     q0, q1 = cirq.LineQubit.range(2)
     simulator = cirq.DensityMatrixSimulator(dtype=dtype, split_untangled_states=split)
     for b0 in [0, 1]:

cirq/sim/density_matrix_utils.py

@@ -14,7 +14,7 @@
 
 """Code to handle density matrices."""
 
-from typing import List, Optional, TYPE_CHECKING, Tuple, Sequence
+from typing import List, Optional, Sequence, Tuple, TYPE_CHECKING
 
 import numpy as np
 

cirq/sim/mux.py

@@ -21,9 +21,9 @@ from typing import List, Optional, Sequence, Type, TYPE_CHECKING, Union
 
 import numpy as np
 
-from cirq import circuits, protocols, study, devices, ops, value
+from cirq import circuits, devices, ops, protocols, study, value
 from cirq._doc import document
-from cirq.sim import sparse_simulator, density_matrix_simulator
+from cirq.sim import density_matrix_simulator, sparse_simulator
 from cirq.sim.clifford import clifford_simulator
 from cirq.transformers import measurement_transformers
 

cirq/sim/simulation_state.py

@@ -24,16 +24,15 @@ from typing import (
     Optional,
     Sequence,
     Set,
-    TypeVar,
-    TYPE_CHECKING,
     Tuple,
+    TYPE_CHECKING,
+    TypeVar,
 )
-from typing_extensions import Self
 
 import numpy as np
+from typing_extensions import Self
 
 from cirq import ops, protocols, value
-
 from cirq.sim.simulation_state_base import SimulationStateBase
 
 TState = TypeVar('TState', bound='cirq.QuantumStateRepresentation')
@@ -337,7 +336,7 @@ def strat_act_on_from_apply_decompose(
         curr_ancilla = tuple(q for q in operation.qubits if q not in args.qubits)
         args = args.add_qubits(curr_ancilla)
         if args is NotImplemented:
-            return NotImplemented
+            return NotImplemented  # pragma: no cover
         all_ancilla.update(curr_ancilla)
         protocols.act_on(operation, args)
     args = args.remove_qubits(tuple(all_ancilla))

cirq/sim/simulation_state_base.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 """An interface for quantum states as targets for operations."""
 import abc
+from types import NotImplementedType
 from typing import (
     Any,
     Dict,
@@ -27,12 +28,11 @@ from typing import (
     TypeVar,
     Union,
 )
-from typing_extensions import Self
 
 import numpy as np
+from typing_extensions import Self
 
 from cirq import protocols, value
-from cirq.type_workarounds import NotImplementedType
 
 if TYPE_CHECKING:
     import cirq

cirq/sim/simulation_state_test.py

@@ -66,7 +66,7 @@ class DelegatingAncillaZ(cirq.Gate):
 
 class Composite(cirq.Gate):
     def num_qubits(self) -> int:
-        return 1
+        return 1  # pragma: no cover
 
     def _decompose_(self, qubits):
         yield cirq.X(*qubits)

cirq/sim/simulation_utils.py

@@ -56,4 +56,6 @@ def state_probabilities_by_indices(
         probs = np.sum(probs, axis=-1)
 
     # To deal with rounding issues, ensure that the probabilities sum to 1.
-    return probs / np.sum(probs)
+    probs = np.clip(probs, 0, None)
+    probs /= probs.sum()
+    return probs

cirq/sim/simulation_utils_test.py

@@ -11,12 +11,11 @@
 # 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.
-import pytest
-
 import numpy as np
+import pytest
 
-from cirq.sim import simulation_utils
 from cirq import testing
+from cirq.sim import simulation_utils
 
 
 @pytest.mark.parametrize('n,m', [(n, m) for n in range(1, 4) for m in range(1, n + 1)])

cirq/sim/simulator.py

@@ -912,7 +912,7 @@ class SimulationTrialResult(Generic[TSimulatorState]):
     def __str__(self) -> str:
         def bitstring(vals):
             separator = ' ' if np.max(vals) >= 10 else ''
-            return separator.join(str(int(v)) for v in vals)
+            return separator.join(str(v.item()) for v in vals)
 
         results = sorted([(key, bitstring(val)) for key, val in self.measurements.items()])
         if not results:
@@ -973,9 +973,10 @@ def split_into_matching_protocol_then_general(
     qubit A will cause later operations on A to be part of the non-matching
     suffix, but later operations on other qubits will continue to be put into
     the matching part (as long as those qubits have had no non-matching operation
-    up to that point).
+    up to that point). Measurement keys are handled equivalently.
     """
     blocked_qubits: Set[cirq.Qid] = set()
+    blocked_keys: Set[cirq.MeasurementKey] = set()
     matching_prefix = circuits.Circuit()
     general_suffix = circuits.Circuit()
     for moment in circuit:
@@ -983,12 +984,12 @@ def split_into_matching_protocol_then_general(
         general_part = []
         for op in moment:
             qs = set(op.qubits)
-            if not predicate(op) or not qs.isdisjoint(blocked_qubits):
-                blocked_qubits |= qs
-
-            if qs.isdisjoint(blocked_qubits):
+            keys = protocols.measurement_keys_touched(op)
+            if predicate(op) and qs.isdisjoint(blocked_qubits) and keys.isdisjoint(blocked_keys):
                 matching_part.append(op)
             else:
+                blocked_qubits |= qs
+                blocked_keys |= keys
                 general_part.append(op)
         if matching_part:
             matching_prefix.append(circuits.Moment(matching_part))

cirq/sim/simulator_base.py

@@ -20,15 +20,15 @@ from typing import (
     Any,
     cast,
     Dict,
-    Iterator,
     Generic,
+    Iterator,
     List,
     Optional,
     Sequence,
     Tuple,
     Type,
-    TypeVar,
     TYPE_CHECKING,
+    TypeVar,
 )
 
 import numpy as np
@@ -38,13 +38,13 @@ from cirq.sim.simulation_product_state import SimulationProductState
 from cirq.sim.simulation_state import TSimulationState
 from cirq.sim.simulation_state_base import SimulationStateBase
 from cirq.sim.simulator import (
-    TSimulationTrialResult,
+    check_all_resolved,
     SimulatesIntermediateState,
     SimulatesSamples,
-    StepResult,
     SimulationTrialResult,
-    check_all_resolved,
     split_into_matching_protocol_then_general,
+    StepResult,
+    TSimulationTrialResult,
 )
 
 if TYPE_CHECKING:

cirq/sim/simulator_test.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 """Tests for simulator.py"""
 import abc
-from typing import Generic, Dict, Any, List, Sequence, Union
+from typing import Any, Dict, Generic, List, Sequence, Union
 from unittest import mock
 
 import duet
@@ -24,13 +24,13 @@ import cirq
 from cirq import study
 from cirq.sim.simulation_state import TSimulationState
 from cirq.sim.simulator import (
-    TStepResult,
     SimulatesAmplitudes,
     SimulatesExpectationValues,
     SimulatesFinalState,
     SimulatesIntermediateState,
     SimulatesSamples,
     SimulationTrialResult,
+    TStepResult,
 )
 
 
@@ -50,7 +50,7 @@ class FakeStepResult(cirq.StepResult):
         self._final_state = final_state
 
     def _simulator_state(self):
-        return self._final_state
+        return self._final_state  # pragma: no cover
 
     def state_vector(self):
         pass
@@ -399,6 +399,17 @@ def test_sample_repeated_measurement_keys():
     assert len(result.records['b'][0]) == 2
 
 
+def test_classical_controls_go_to_suffix_if_corresponding_measurement_does():
+    subcircuit = cirq.CircuitOperation(cirq.FrozenCircuit()).with_classical_controls('a')
+    m = cirq.measure(cirq.LineQubit(0), key='a')
+    circuit = cirq.Circuit(m, subcircuit)
+    prefix, suffix = cirq.sim.simulator.split_into_matching_protocol_then_general(
+        circuit, lambda op: op != m  # any op but m goes into prefix
+    )
+    assert not prefix
+    assert suffix == circuit
+
+
 def test_simulate_with_invert_mask():
     q0, q1, q2, q3, q4 = cirq.LineQid.for_qid_shape((2, 3, 3, 3, 4))
     c = cirq.Circuit(

cirq/sim/sparse_simulator.py

@@ -14,12 +14,12 @@
 
 """A simulator that uses numpy's einsum for sparse matrix operations."""
 
-from typing import Any, Iterator, List, TYPE_CHECKING, Union, Sequence, Type, Optional
+from typing import Any, Iterator, List, Optional, Sequence, Type, TYPE_CHECKING, Union
 
 import numpy as np
 
 from cirq import ops
-from cirq.sim import simulator, state_vector, state_vector_simulator, state_vector_simulation_state
+from cirq.sim import simulator, state_vector, state_vector_simulation_state, state_vector_simulator
 
 if TYPE_CHECKING:
     import cirq
@@ -171,7 +171,8 @@ class Simulator(
             StateVectorSimulationState for the circuit.
         """
         if isinstance(initial_state, state_vector_simulation_state.StateVectorSimulationState):
-            return initial_state
+            # Instances of SimulationStateBase usually returned before this point
+            return initial_state  # pragma: no cover
 
         return state_vector_simulation_state.StateVectorSimulationState(
             qubits=qubits,

cirq/sim/sparse_simulator_test.py

@@ -13,9 +13,9 @@
 # limitations under the License.
 import itertools
 import random
-from typing import Type
-
+from typing import Type, Union
 from unittest import mock
+
 import numpy as np
 import pytest
 import sympy
@@ -115,7 +115,7 @@ def test_run_repetitions_terminal_measurement_stochastic():
     q = cirq.LineQubit(0)
     c = cirq.Circuit(cirq.H(q), cirq.measure(q, key='q'))
     results = cirq.Simulator().run(c, repetitions=10000)
-    assert 1000 <= sum(v[0] for v in results.measurements['q']) < 9000
+    assert 1000 <= np.count_nonzero(results.measurements['q']) < 9000
 
 
 @pytest.mark.parametrize('dtype', [np.complex64, np.complex128])
@@ -255,7 +255,7 @@ def test_run_mixture(dtype: Type[np.complexfloating], split: bool):
     simulator = cirq.Simulator(dtype=dtype, split_untangled_states=split)
     circuit = cirq.Circuit(cirq.bit_flip(0.5)(q0), cirq.measure(q0))
     result = simulator.run(circuit, repetitions=100)
-    assert 20 < sum(result.measurements['q(0)'])[0] < 80
+    assert 20 < np.count_nonzero(result.measurements['q(0)']) < 80
 
 
 @pytest.mark.parametrize('dtype', [np.complex64, np.complex128])
@@ -265,8 +265,8 @@ def test_run_mixture_with_gates(dtype: Type[np.complexfloating], split: bool):
     simulator = cirq.Simulator(dtype=dtype, split_untangled_states=split, seed=23)
     circuit = cirq.Circuit(cirq.H(q0), cirq.phase_flip(0.5)(q0), cirq.H(q0), cirq.measure(q0))
     result = simulator.run(circuit, repetitions=100)
-    assert sum(result.measurements['q(0)'])[0] < 80
-    assert sum(result.measurements['q(0)'])[0] > 20
+    assert np.count_nonzero(result.measurements['q(0)']) < 80
+    assert np.count_nonzero(result.measurements['q(0)']) > 20
 
 
 @pytest.mark.parametrize('dtype', [np.complex64, np.complex128])
@@ -446,7 +446,15 @@ def test_simulate_bit_flips(dtype: Type[np.complexfloating], split: bool):
 
 @pytest.mark.parametrize('dtype', [np.complex64, np.complex128])
 @pytest.mark.parametrize('split', [True, False])
-def test_simulate_initial_state(dtype: Type[np.complexfloating], split: bool):
+@pytest.mark.parametrize(
+    'initial_state',
+    [1, cirq.StateVectorSimulationState(initial_state=1, qubits=cirq.LineQubit.range(2))],
+)
+def test_simulate_initial_state(
+    dtype: Type[np.complexfloating],
+    split: bool,
+    initial_state: Union[int, cirq.StateVectorSimulationState],
+):
     q0, q1 = cirq.LineQubit.range(2)
     simulator = cirq.Simulator(dtype=dtype, split_untangled_states=split)
     for b0 in [0, 1]:
@@ -498,11 +506,11 @@ def test_simulate_param_resolver(dtype: Type[np.complexfloating], split: bool):
                 (cirq.X ** sympy.Symbol('b0'))(q0), (cirq.X ** sympy.Symbol('b1'))(q1)
             )
             resolver = {'b0': b0, 'b1': b1}
-            result = simulator.simulate(circuit, param_resolver=resolver)  # type: ignore
+            result = simulator.simulate(circuit, param_resolver=resolver)
             expected_state = np.zeros(shape=(2, 2))
             expected_state[b0][b1] = 1.0
             np.testing.assert_equal(result.final_state_vector, np.reshape(expected_state, 4))
-            assert result.params == cirq.ParamResolver(resolver)  # type: ignore
+            assert result.params == cirq.ParamResolver(resolver)
             assert len(result.measurements) == 0
 
 

cirq/sim/state_vector.py

@@ -14,12 +14,12 @@
 """Helpers for handling quantum state vectors."""
 
 import abc
-from typing import List, Mapping, Optional, Tuple, TYPE_CHECKING, Sequence
+from typing import List, Mapping, Optional, Sequence, Tuple, TYPE_CHECKING
 
 import numpy as np
 
 from cirq import linalg, qis, value
-from cirq.sim import simulator, simulation_utils
+from cirq.sim import simulation_utils, simulator
 
 if TYPE_CHECKING:
     import cirq

cirq/sim/state_vector_simulation_state_test.py

@@ -63,7 +63,7 @@ def test_shallow_copy_buffers():
 def test_decomposed_fallback():
     class Composite(cirq.Gate):
         def num_qubits(self) -> int:
-            return 1
+            return 1  # pragma: no cover
 
         def _decompose_(self, qubits):
             yield cirq.X(*qubits)

cirq/sim/state_vector_simulator.py

@@ -14,15 +14,15 @@
 """Abstract classes for simulations which keep track of state vector."""
 
 import abc
-from functools import cached_property
-from typing import Any, Dict, Iterator, Sequence, Type, TYPE_CHECKING, Generic, TypeVar
 import warnings
+from functools import cached_property
+from typing import Any, Dict, Generic, Iterator, Sequence, Type, TYPE_CHECKING, TypeVar
 
 import numpy as np
 
-from cirq import _compat, ops, value, qis
-from cirq.sim import simulator, state_vector, simulator_base
+from cirq import _compat, ops, qis, value
 from cirq.protocols import qid_shape
+from cirq.sim import simulator, simulator_base, state_vector
 
 if TYPE_CHECKING:
     import cirq