QVM - deprecate default gate_times_ns in noise_properties_from_calibration (#7399)

* `noise_properties_from_calibration` - show deprecation warning when
  called without `gate_times_ns` and introduce literal "legacy" as
  an alias for the old gate times default.

* `load_device_noise_properties` - update to use legacy gate times for
  old virtual processors and make tests more comprehensive.

Related to b/395705720

Author: pavoljuhas

cirq-google/cirq_google/engine/calibration_to_noise_properties.py

@@ -19,7 +19,8 @@
 calibration using the following pipeline:
 
     >>> cal = cirq_google.engine.load_median_device_calibration("rainbow")
-    >>> noise_props = cirq_google.engine.noise_properties_from_calibration(cal)
+    >>> noise_props = cirq_google.engine.noise_properties_from_calibration(
+    ...     cal, gate_times_ns="legacy")
     >>> noise_model = cirq_google.NoiseModelFromGoogleNoiseProperties(noise_props)
     >>> simulator = cirq.Simulator(noise=noise_model)
     >>> circuit = cirq.Circuit(cirq.X(cirq.GridQubit(5, 2)))
@@ -28,9 +29,9 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+from typing import Literal, TYPE_CHECKING
 
-from cirq import ops
+from cirq import _compat, ops
 from cirq.devices import noise_utils
 from cirq_google import engine, ops as cg_ops
 from cirq_google.devices import google_noise_properties
@@ -91,8 +92,9 @@ def _unpack_2q_from_calibration(
 
 def noise_properties_from_calibration(
     calibration: engine.Calibration,
+    *,
+    gate_times_ns: dict[type[cirq.Gate], float] | Literal['legacy'] | None = None,
     zphase_data: util.ZPhaseDataType | None = None,
-    gate_times_ns: dict[type[cirq.Gate], float] | None = None,
 ) -> google_noise_properties.GoogleNoiseProperties:
     """Translates between `cirq_google.Calibration` and NoiseProperties.
 
@@ -103,26 +105,42 @@ def noise_properties_from_calibration(
     To manually override noise properties, call `with_params` on the output:
 
         >>> cal = cirq_google.engine.load_median_device_calibration("rainbow")
+        >>> noise_props = cirq_google.engine.noise_properties_from_calibration(
+        ...     cal, gate_times_ns="legacy")
         >>> # noise_props with all gate durations set to 37ns.
-        >>> noise_props = cirq_google.engine.noise_properties_from_calibration(cal).with_params(
-        ...     gate_times_ns=37)
+        >>> noise_props_37ns = noise_props.with_params(gate_times_ns=37)
 
     See `cirq_google.GoogleNoiseProperties` for details.
 
     Args:
         calibration: a Calibration object with hardware metrics.
+        gate_times_ns: Map of gate durations in nanoseconds or "legacy"
+            to use the Sycamore gate times listed in `known_devices.py`.
+            Note this argument has changed from optional to mandatory and
+            the "legacy" value was added as an alias for the old default.
         zphase_data: Optional data for Z phases not captured by Calibration -
             specifically, zeta and gamma. These values require Floquet
             calibration and can be provided here if available.
-        gate_times_ns: Map of gate durations in nanoseconds. If not provided,
-            defaults to the Sycamore gate times listed in `known_devices.py`.
 
     Returns:
         A `cirq_google.GoogleNoiseProperties` which represents the error
         present in the given Calibration object.
     """
     if gate_times_ns is None:
+        _compat._warn_or_error(
+            'Function noise_properties_from_calibration was called without the '
+            'gate_times_ns argument.\n'
+            'This argument will become mandatory in cirq_google v1.7.\n'
+            'To continue using the old gate times default, please pass the "legacy" value.'
+        )
+        gate_times_ns = DEFAULT_GATE_NS
+    elif gate_times_ns == 'legacy':
         gate_times_ns = DEFAULT_GATE_NS
+    if not isinstance(gate_times_ns, dict):
+        raise TypeError(
+            f'gate_times_ns must be a dictionary or the "legacy" string. '
+            f'Got {gate_times_ns} instead.'
+        )
 
     # Unpack all values from Calibration object
     # 1. Extract T1 for all qubits

cirq-google/cirq_google/engine/calibration_to_noise_properties_test.py

@@ -237,7 +237,13 @@ def test_noise_properties_from_calibration():
         syc_angles,
         iswap_angles,
     )
-    prop = cirq_google.noise_properties_from_calibration(calibration)
+    with cirq.testing.assert_deprecated(
+        "noise_properties_from_calibration was called without the gate_times_ns", deadline="v1.7"
+    ):
+        prop = cirq_google.noise_properties_from_calibration(calibration)
+    assert prop == cirq_google.noise_properties_from_calibration(
+        calibration, gate_times_ns="legacy"
+    )
 
     for i, q in enumerate(qubits):
         assert np.isclose(
@@ -273,6 +279,9 @@ def test_noise_properties_from_calibration():
             assert prop.fsim_errors[OpIdentifier(gate, *qs)] == values[i]
             assert prop.fsim_errors[OpIdentifier(gate, *qs[::-1])] == values[i]
 
+    with pytest.raises(TypeError, match='gate_times_ns must be a dictionary'):
+        _ = cirq_google.noise_properties_from_calibration(calibration, gate_times_ns=37)
+
 
 def test_zphase_data():
     qubits = [cirq.GridQubit(0, 0), cirq.GridQubit(0, 1), cirq.GridQubit(1, 0)]
@@ -317,7 +326,9 @@ def test_zphase_data():
         },
     }
 
-    prop = cirq_google.noise_properties_from_calibration(calibration, zphase_data)
+    prop = cirq_google.noise_properties_from_calibration(
+        calibration, gate_times_ns="legacy", zphase_data=zphase_data
+    )
     for i, qs in enumerate(qubit_pairs):
         for gate, values in [
             (cirq_google.SycamoreGate, syc_angles),
@@ -418,4 +429,4 @@ def test_incomplete_calibration():
     # Create NoiseProperties object from Calibration
     calibration = cirq_google.Calibration(_CALIBRATION_DATA)
     with pytest.raises(ValueError, match='Keys specified for T1 and Tphi are not identical.'):
-        _ = cirq_google.noise_properties_from_calibration(calibration)
+        _ = cirq_google.noise_properties_from_calibration(calibration, gate_times_ns="legacy")

cirq-google/cirq_google/engine/virtual_engine_factory.py

@@ -27,8 +27,13 @@
 from cirq_google.api import v2
 from cirq_google.devices import grid_device
 from cirq_google.devices.google_noise_properties import NoiseModelFromGoogleNoiseProperties
-from cirq_google.engine import calibration, engine_validator, simulated_local_processor, util
-from cirq_google.engine.calibration_to_noise_properties import noise_properties_from_calibration
+from cirq_google.engine import (
+    calibration,
+    calibration_to_noise_properties,
+    engine_validator,
+    simulated_local_processor,
+    util,
+)
 from cirq_google.engine.simulated_local_engine import SimulatedLocalEngine
 from cirq_google.engine.simulated_local_processor import SimulatedLocalProcessor
 from cirq_google.ops import fsim_gate_family
@@ -124,9 +129,12 @@ def load_device_noise_properties(processor_id: str) -> cirq_google.GoogleNoisePr
     device = create_device_from_processor_id(processor_id)
     calibration = load_median_device_calibration(processor_id)
     zphase_data = load_sample_device_zphase(processor_id) if processor_id in ZPHASE_DATA else None
-    gate_times_ns = extract_gate_times_ns_from_device(device)
-    return noise_properties_from_calibration(
-        calibration=calibration, zphase_data=zphase_data, gate_times_ns=gate_times_ns
+    if processor_id in ('rainbow', 'weber'):
+        gate_times_ns = calibration_to_noise_properties.DEFAULT_GATE_NS
+    else:
+        gate_times_ns = extract_gate_times_ns_from_device(device)
+    return calibration_to_noise_properties.noise_properties_from_calibration(
+        calibration=calibration, gate_times_ns=gate_times_ns, zphase_data=zphase_data
     )
 
 
@@ -444,10 +452,7 @@ def create_default_noisy_quantum_virtual_machine(
 
     calibration = load_median_device_calibration(processor_id)
     device = create_device_from_processor_id(processor_id)
-    gate_times_ns: dict[type[cirq.Gate], float] | None = None
-    if processor_id == "willow_pink":
-        gate_times_ns = extract_gate_times_ns_from_device(device)
-    noise_properties = noise_properties_from_calibration(calibration, gate_times_ns=gate_times_ns)
+    noise_properties = load_device_noise_properties(processor_id)
     noise_model = NoiseModelFromGoogleNoiseProperties(noise_properties)
     simulator = simulator_class(noise=noise_model, **kwargs)  # type: ignore
 

cirq-google/cirq_google/engine/virtual_engine_factory_test.py

@@ -25,6 +25,19 @@
 import cirq_google.api.v2 as v2
 import cirq_google.engine.virtual_engine_factory as factory
 
+# copy of cirq_google.engine.calibration_to_noise_properties.DEFAULT_GATE_NS
+OLD_QVM_DEFAULT_GATE_NS: dict[type[cirq.Gate], float] = {
+    cirq.ZPowGate: 25.0,
+    cirq.MeasurementGate: 4000.0,
+    cirq.ResetChannel: 250.0,
+    cirq.PhasedXZGate: 25.0,
+    cirq.FSimGate: 32.0,
+    cirq.ISwapPowGate: 32.0,
+    cirq.CZPowGate: 32.0,
+    cg.ops.SycamoreGate: 12.0,
+    # ops.WaitGate is a special case.
+}
+
 
 def _test_processor(processor: cg.engine.abstract_processor.AbstractProcessor) -> None:
     """Tests an engine instance with some standard commands.
@@ -62,15 +75,42 @@ def test_create_from_device() -> None:
     _test_processor(engine.get_processor('sycamore'))
 
 
-def test_load_device_noise_properties() -> None:
+def test_load_device_noise_properties_of_rainbow() -> None:
     noise_properties = factory.load_device_noise_properties("rainbow")
     assert noise_properties.readout_errors[cirq.GridQubit(9, 4)] == [0.0124, 0.0464]
-    assert noise_properties.gate_times_ns[cirq.PhasedXZGate] == 25
+    assert noise_properties.gate_times_ns == OLD_QVM_DEFAULT_GATE_NS
     op_id = cirq.OpIdentifier(cirq.ISwapPowGate, cirq.GridQubit(3, 2), cirq.GridQubit(4, 2))
     assert noise_properties.fsim_errors[op_id].zeta == -0.004952147720840733
     assert noise_properties.fsim_errors[op_id].gamma == -0.04094895320428251
 
 
+def test_load_device_noise_properties_of_weber() -> None:
+    noise_properties = factory.load_device_noise_properties("weber")
+    assert noise_properties.readout_errors[cirq.GridQubit(9, 4)] == [0.0086, 0.0634]
+    assert noise_properties.gate_times_ns == OLD_QVM_DEFAULT_GATE_NS
+    op_id = cirq.OpIdentifier(cirq.ISwapPowGate, cirq.GridQubit(3, 2), cirq.GridQubit(4, 2))
+    assert noise_properties.fsim_errors[op_id].zeta == -0.10303422893651185
+    assert noise_properties.fsim_errors[op_id].gamma == -0.0032040209641905903
+
+
+def test_load_device_noise_properties_of_willow_pink() -> None:
+    noise_properties = factory.load_device_noise_properties("willow_pink")
+    assert noise_properties.readout_errors[cirq.GridQubit(6, 5)] == [
+        0.0016608771929824222,
+        0.01175789473684208,
+    ]
+    assert noise_properties.gate_times_ns[cirq.CZPowGate] == 42
+    assert noise_properties.gate_times_ns[cirq.MeasurementGate] == 600
+    assert noise_properties.gate_times_ns[cirq.PhasedXZGate] == 25
+    assert noise_properties.gate_times_ns[cirq.ResetChannel] == 160
+    op_id = cirq.OpIdentifier(cirq.CZPowGate, cirq.GridQubit(4, 6), cirq.GridQubit(5, 6))
+    assert noise_properties.gate_pauli_errors[op_id] == 0.005621218474436904
+    assert noise_properties.fsim_errors[op_id].theta == 0.04183530427211678
+    assert noise_properties.fsim_errors[op_id].phi == 0.008106226272121209
+    assert noise_properties.fsim_errors[op_id].zeta == 0
+    assert noise_properties.fsim_errors[op_id].gamma == 0
+
+
 def test_median_rainbow_device() -> None:
     q0, q1 = cirq.GridQubit.rect(1, 2, 5, 3)
     cal = factory.load_median_device_calibration('rainbow')
@@ -241,7 +281,9 @@ def test_create_default_noisy_quantum_virtual_machine(
     assert device_specification is not None
     assert device_specification == expected
     with mock.patch.object(
-        factory, "extract_gate_times_ns_from_device", return_value=None
+        factory,
+        "extract_gate_times_ns_from_device",
+        wraps=factory.extract_gate_times_ns_from_device,
     ) as mocked_extract:
         _ = factory.create_default_noisy_quantum_virtual_machine(
             processor_id=processor_id, simulator_class=cirq.Simulator