Guard confusion_map usage

cirq-core/cirq/ops/measurement_gate.py

@@ -312,7 +312,19 @@ def _act_on_(self, sim_state: 'cirq.SimulationStateBase', qubits: Sequence['cirq
 
         if not isinstance(sim_state, SimulationState):
             return NotImplemented
-        sim_state.measure(qubits, self.key, self.full_invert_mask(), self.confusion_map)
+        try:
+            sim_state.measure(
+                qubits, self.key, self.full_invert_mask(), confusion_map=self.confusion_map
+            )
+        except TypeError as e:
+            # Ensure that the error was due to confusion_map.
+            if not any("unexpected keyword argument 'confusion_map'" in arg for arg in e.args):
+                raise
+            _compat._warn_or_error(
+                "Starting in v0.16, SimulationState subclasses will be required to accept "
+                "a 'confusion_map' argument. See SimulationState.measure for details."
+            )
+            sim_state.measure(qubits, self.key, self.full_invert_mask())
         return True
 
 

cirq-core/cirq/ops/measurement_gate_test.py

@@ -12,11 +12,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import cast
+from typing import Any, Sequence, Union, cast
 import numpy as np
 import pytest
 
 import cirq
+from cirq.type_workarounds import NotImplementedType
 
 
 @pytest.mark.parametrize(
@@ -529,3 +530,38 @@ def test_act_on_qutrit():
     )
     cirq.act_on(m, args)
     assert args.log_of_measurement_results == {'out': [0, 0]}
+
+
+def test_act_on_no_confusion_map_deprecated():
+    class OldSimState(cirq.StateVectorSimulationState):
+        def __init__(self, *args, **kwargs):
+            super().__init__(*args, **kwargs)
+            self.measured = False
+
+        def _act_on_fallback_(
+            self, action: Any, qubits: Sequence['cirq.Qid'], allow_decompose: bool = True
+        ) -> Union[bool, NotImplementedType]:
+            return NotImplemented  # coverage: ignore
+
+        def measure(self, qubits: Sequence['cirq.Qid'], key: str, invert_mask: Sequence[bool]):
+            self.measured = True
+
+    qubits = cirq.LineQubit.range(2)
+    old_state = OldSimState(qubits=qubits)
+    m = cirq.measure(*qubits, key='test')
+    with cirq.testing.assert_deprecated('confusion_map', deadline='v0.16'):
+        cirq.act_on(m, old_state)
+    assert old_state.measured
+
+    # Verify that the check doesn't prevent other errors from being raised
+    sv_state = cirq.StateVectorSimulationState(
+        available_buffer=np.empty(shape=(2, 2)),
+        qubits=qubits,
+        prng=np.random.RandomState(),
+        dtype=np.complex64,
+    )
+    m1 = cirq.measure(qubits[0], key='test')
+    m2 = cirq.measure(*qubits, key='test')
+    cirq.act_on(m1, sv_state)
+    with pytest.raises(ValueError, match='does not match'):
+        cirq.act_on(m2, sv_state)

cirq-core/cirq/sim/simulation_state.py

@@ -105,7 +105,7 @@ def measure(
         qubits: Sequence['cirq.Qid'],
         key: str,
         invert_mask: Sequence[bool],
-        confusion_map: Dict[Tuple[int, ...], np.ndarray],
+        confusion_map: Optional[Dict[Tuple[int, ...], np.ndarray]] = None,
     ):
         """Measures the qubits and records to `log_of_measurement_results`.
 
@@ -123,7 +123,8 @@ def measure(
             ValueError: If a measurement key has already been logged to a key.
         """
         bits = self._perform_measurement(qubits)
-        confused = self._confuse_result(bits, qubits, confusion_map)
+        if confusion_map is not None:
+            confused = self._confuse_result(bits, qubits, confusion_map)
         corrected = [bit ^ (bit < 2 and mask) for bit, mask in zip(confused, invert_mask)]
         self._classical_data.record_measurement(
             value.MeasurementKey.parse_serialized(key), corrected, qubits