Remove global gateset references

verult · verult · commit 793e005e8303 · 2022-07-13T23:16:08.000Z
diff --git a/cirq-google/cirq_google/calibration/phased_fsim_test.py b/cirq-google/cirq_google/calibration/phased_fsim_test.py
@@ -222,55 +222,54 @@ def test_floquet_to_calibration_layer_with_measure_qubits():
 
 
 def test_xeb_to_calibration_layer():
-    with cirq.testing.assert_deprecated('SerializableGateSet', deadline='v0.16', count=None):
-        q_00, q_01, q_02, q_03 = [cirq.GridQubit(0, index) for index in range(4)]
-        gate = cirq.FSimGate(theta=np.pi / 4, phi=0.0)
-        request = XEBPhasedFSimCalibrationRequest(
-            gate=gate,
-            pairs=((q_00, q_01), (q_02, q_03)),
-            options=XEBPhasedFSimCalibrationOptions(
-                n_library_circuits=22,
-                fsim_options=XEBPhasedFSimCharacterizationOptions(
-                    characterize_theta=True,
-                    characterize_zeta=True,
-                    characterize_chi=False,
-                    characterize_gamma=False,
-                    characterize_phi=True,
-                ),
+    q_00, q_01, q_02, q_03 = [cirq.GridQubit(0, index) for index in range(4)]
+    gate = cirq.FSimGate(theta=np.pi / 4, phi=0.0)
+    request = XEBPhasedFSimCalibrationRequest(
+        gate=gate,
+        pairs=((q_00, q_01), (q_02, q_03)),
+        options=XEBPhasedFSimCalibrationOptions(
+            n_library_circuits=22,
+            fsim_options=XEBPhasedFSimCharacterizationOptions(
+                characterize_theta=True,
+                characterize_zeta=True,
+                characterize_chi=False,
+                characterize_gamma=False,
+                characterize_phi=True,
             ),
-        )
-        layer = request.to_calibration_layer()
-        assert layer == cirq_google.CalibrationLayer(
-            calibration_type='xeb_phased_fsim_characterization',
-            program=cirq.Circuit([gate.on(q_00, q_01), gate.on(q_02, q_03)]),
-            args={
-                'n_library_circuits': 22,
-                'n_combinations': 10,
-                'cycle_depths': '5_25_50_100_200_300',
-                'fatol': 5e-3,
-                'xatol': 5e-3,
-                'characterize_theta': True,
-                'characterize_zeta': True,
-                'characterize_chi': False,
-                'characterize_gamma': False,
-                'characterize_phi': True,
-            },
-        )
+        ),
+    )
+    layer = request.to_calibration_layer()
+    assert layer == cirq_google.CalibrationLayer(
+        calibration_type='xeb_phased_fsim_characterization',
+        program=cirq.Circuit([gate.on(q_00, q_01), gate.on(q_02, q_03)]),
+        args={
+            'n_library_circuits': 22,
+            'n_combinations': 10,
+            'cycle_depths': '5_25_50_100_200_300',
+            'fatol': 5e-3,
+            'xatol': 5e-3,
+            'characterize_theta': True,
+            'characterize_zeta': True,
+            'characterize_chi': False,
+            'characterize_gamma': False,
+            'characterize_phi': True,
+        },
+    )
 
-        # Serialize to proto
-        calibration = v2.calibration_pb2.FocusedCalibration()
-        new_layer = calibration.layers.add()
-        new_layer.calibration_type = layer.calibration_type
-        for arg in layer.args:
-            arg_to_proto(layer.args[arg], out=new_layer.args[arg])
-        cirq_google.SQRT_ISWAP_GATESET.serialize(layer.program, msg=new_layer.layer)
-        with open(os.path.dirname(__file__) + '/test_data/xeb_calibration_layer.textproto') as f:
-            desired_textproto = f.read()
-
-        layer_str = str(new_layer)
-        # Fix precision issues
-        layer_str = re.sub(r'0.004999\d+', '0.005', layer_str)
-        assert layer_str == desired_textproto
+    # Serialize to proto
+    calibration = v2.calibration_pb2.FocusedCalibration()
+    new_layer = calibration.layers.add()
+    new_layer.calibration_type = layer.calibration_type
+    for arg in layer.args:
+        arg_to_proto(layer.args[arg], out=new_layer.args[arg])
+    cirq_google.CIRCUIT_SERIALIZER.serialize(layer.program, msg=new_layer.layer)
+    with open(os.path.dirname(__file__) + '/test_data/xeb_calibration_layer.textproto') as f:
+        desired_textproto = f.read()
+
+    layer_str = str(new_layer)
+    # Fix precision issues
+    layer_str = re.sub(r'0.004999\d+', '0.005', layer_str)
+    assert layer_str == desired_textproto
 
 
 def test_from_moment():
diff --git a/cirq-google/cirq_google/calibration/test_data/xeb_calibration_layer.textproto b/cirq-google/cirq_google/calibration/test_data/xeb_calibration_layer.textproto
@@ -1,35 +1,58 @@
 calibration_type: "xeb_phased_fsim_characterization"
 layer {
   language {
-    gate_set: "sqrt_iswap"
+    gate_set: "v2_5"
+    arg_function_language: "exp"
   }
   circuit {
     scheduling_strategy: MOMENT_BY_MOMENT
     moments {
       operations {
-        gate {
-          id: "fsim_pi_4"
-        }
-        qubits {
-          id: "0_0"
-        }
-        qubits {
-          id: "0_1"
+        qubit_constant_index: 0
+        qubit_constant_index: 1
+        fsimgate {
+          theta {
+            float_value: 0.7853981852531433
+          }
+          phi {
+            float_value: 0.0
+          }
         }
       }
       operations {
-        gate {
-          id: "fsim_pi_4"
-        }
-        qubits {
-          id: "0_2"
-        }
-        qubits {
-          id: "0_3"
+        qubit_constant_index: 2
+        qubit_constant_index: 3
+        fsimgate {
+          theta {
+            float_value: 0.7853981852531433
+          }
+          phi {
+            float_value: 0.0
+          }
         }
       }
     }
   }
+  constants {
+    qubit {
+      id: "0_0"
+    }
+  }
+  constants {
+    qubit {
+      id: "0_1"
+    }
+  }
+  constants {
+    qubit {
+      id: "0_2"
+    }
+  }
+  constants {
+    qubit {
+      id: "0_3"
+    }
+  }
 }
 args {
   key: "characterize_chi"
diff --git a/cirq-google/cirq_google/engine/engine_validator_test.py b/cirq-google/cirq_google/engine/engine_validator_test.py
@@ -38,34 +38,32 @@ def _big_circuit(num_cycles: int) -> cirq.Circuit:
 
 
 def test_validate_gate_set():
-    with cirq.testing.assert_deprecated('SerializableGateSet', deadline='v0.16', count=None):
-        circuit = _big_circuit(4)
+    circuit = _big_circuit(4)
+
+    engine_validator.validate_program(
+        [circuit] * 5, [{}] * 5, 1000, cg.CIRCUIT_SERIALIZER, max_size=30000
+    )
 
+    with pytest.raises(RuntimeError, match='Program too long'):
         engine_validator.validate_program(
-            [circuit] * 5, [{}] * 5, 1000, cg.FSIM_GATESET, max_size=100000
+            [circuit] * 10, [{}] * 10, 1000, cg.CIRCUIT_SERIALIZER, max_size=30000
         )
 
-        with pytest.raises(RuntimeError, match='Program too long'):
-            engine_validator.validate_program(
-                [circuit] * 10, [{}] * 10, 1000, cg.FSIM_GATESET, max_size=100000
-            )
-
-        with pytest.raises(RuntimeError, match='Program too long'):
-            engine_validator.validate_program(
-                [circuit] * 5, [{}] * 5, 1000, cg.FSIM_GATESET, max_size=10000
-            )
+    with pytest.raises(RuntimeError, match='Program too long'):
+        engine_validator.validate_program(
+            [circuit] * 5, [{}] * 5, 1000, cg.CIRCUIT_SERIALIZER, max_size=10000
+        )
 
 
 def test_create_gate_set_validator():
-    with cirq.testing.assert_deprecated('SerializableGateSet', deadline='v0.16', count=None):
-        circuit = _big_circuit(4)
-
-        smaller_size_validator = engine_validator.create_program_validator(max_size=30000)
-        smaller_size_validator([circuit] * 2, [{}] * 2, 1000, cg.FSIM_GATESET)
-        with pytest.raises(RuntimeError, match='Program too long'):
-            smaller_size_validator([circuit] * 5, [{}] * 5, 1000, cg.FSIM_GATESET)
-        larger_size_validator = engine_validator.create_program_validator(max_size=500000)
-        larger_size_validator([circuit] * 10, [{}] * 10, 1000, cg.FSIM_GATESET)
+    circuit = _big_circuit(4)
+
+    smaller_size_validator = engine_validator.create_program_validator(max_size=30000)
+    smaller_size_validator([circuit] * 2, [{}] * 2, 1000, cg.CIRCUIT_SERIALIZER)
+    with pytest.raises(RuntimeError, match='Program too long'):
+        smaller_size_validator([circuit] * 5, [{}] * 5, 1000, cg.CIRCUIT_SERIALIZER)
+    larger_size_validator = engine_validator.create_program_validator(max_size=500000)
+    larger_size_validator([circuit] * 10, [{}] * 10, 1000, cg.CIRCUIT_SERIALIZER)
 
 
 def test_validate_for_engine():
diff --git a/cirq-google/cirq_google/optimizers/convert_to_sqrt_iswap_test.py b/cirq-google/cirq_google/optimizers/convert_to_sqrt_iswap_test.py
@@ -51,10 +51,9 @@ def test_two_qubit_gates(gate: cirq.Gate, expected_length: int):
     )
     with cirq.testing.assert_deprecated("Use cirq.optimize_for_target_gateset", deadline='v1.0'):
         cgoc.ConvertToSqrtIswapGates().optimize_circuit(converted_circuit)
-    with cirq.testing.assert_deprecated('SerializableGateSet', deadline='v0.16', count=None):
-        cig.SQRT_ISWAP_GATESET.serialize(converted_circuit)
-        cig.SQRT_ISWAP_GATESET.serialize(converted_circuit_iswap)
-        cig.SQRT_ISWAP_GATESET.serialize(converted_circuit_iswap_inv)
+    cig.CIRCUIT_SERIALIZER.serialize(converted_circuit)
+    cig.CIRCUIT_SERIALIZER.serialize(converted_circuit_iswap)
+    cig.CIRCUIT_SERIALIZER.serialize(converted_circuit_iswap_inv)
     assert len(converted_circuit) <= expected_length
     assert (
         len(converted_circuit_iswap) <= expected_length
diff --git a/cirq-google/cirq_google/optimizers/optimize_for_sycamore_test.py b/cirq-google/cirq_google/optimizers/optimize_for_sycamore_test.py
@@ -24,51 +24,6 @@ def __init__(self):
         pass
 
 
-def _optimizers_and_gatesets():
-    with cirq.testing.assert_deprecated('SerializableGateSet', deadline='v0.16', count=None):
-        return [
-            ('sqrt_iswap', cg.SQRT_ISWAP_GATESET),
-            ('sycamore', cg.SYC_GATESET),
-            ('xmon', cg.XMON),
-            ('xmon_partial_cz', cg.XMON),
-        ]
-
-
-@pytest.mark.parametrize('optimizer_type, gateset', _optimizers_and_gatesets())
-def test_optimizer_output_gates_are_supported(optimizer_type, gateset):
-    q0, q1 = cirq.LineQubit.range(2)
-    circuit = cirq.Circuit(
-        cirq.CZ(q0, q1), cirq.X(q0) ** 0.2, cirq.Z(q1) ** 0.2, cirq.measure(q0, q1, key='m')
-    )
-
-    with cirq.testing.assert_deprecated(
-        'Use `cirq.optimize_for_target_gateset', deadline='v0.16', count=1
-    ):
-        new_circuit = cg.optimized_for_sycamore(circuit, optimizer_type=optimizer_type)
-        for moment in new_circuit:
-            for op in moment:
-                assert gateset.is_supported_operation(op)
-
-
-@pytest.mark.parametrize('optimizer_type, gateset', _optimizers_and_gatesets())
-def test_optimize_large_measurement_gates(optimizer_type, gateset):
-    qubits = cirq.LineQubit.range(53)
-    circuit = cirq.Circuit(
-        cirq.X.on_each(qubits),
-        [cirq.CZ(qubits[i], qubits[i + 1]) for i in range(0, len(qubits) - 1, 2)],
-        [cirq.CZ(qubits[i], qubits[i + 1]) for i in range(1, len(qubits) - 1, 2)],
-        cirq.measure(*qubits, key='m'),
-    )
-
-    with cirq.testing.assert_deprecated(
-        'Use `cirq.optimize_for_target_gateset', deadline='v0.16', count=1
-    ):
-        new_circuit = cg.optimized_for_sycamore(circuit, optimizer_type=optimizer_type)
-        for moment in new_circuit:
-            for op in moment:
-                assert gateset.is_supported_operation(op)
-
-
 def test_invalid_input():
     with cirq.testing.assert_deprecated(
         'Use `cirq.optimize_for_target_gateset', deadline='v0.16', count=1
@@ -124,35 +79,6 @@ def test_no_tabulation():
             )
 
 
-def test_one_q_matrix_gate():
-    u = cirq.testing.random_special_unitary(2)
-    q = cirq.LineQubit(0)
-    circuit0 = cirq.Circuit(cirq.MatrixGate(u).on(q))
-    assert len(circuit0) == 1
-
-    # Deprecations: well-known cirq_google SerializableGateSets
-    # (e.g. cirq_google.SYC_GATESET), and
-    # cirq_google.optimized_for_sycamore
-    with cirq.testing.assert_deprecated(
-        'SerializableGateSet', 'Use `cirq.optimize_for_target_gateset', deadline='v0.16', count=6
-    ):
-        circuit_iswap = cg.optimized_for_sycamore(circuit0, optimizer_type='sqrt_iswap')
-        assert len(circuit_iswap) == 1
-        for moment in circuit_iswap:
-            for op in moment:
-                assert cg.SQRT_ISWAP_GATESET.is_supported_operation(op)
-                # single qubit gates shared between gatesets, so:
-                assert cg.SYC_GATESET.is_supported_operation(op)
-
-        circuit_syc = cg.optimized_for_sycamore(circuit0, optimizer_type='sycamore')
-        assert len(circuit_syc) == 1
-        for moment in circuit_iswap:
-            for op in moment:
-                assert cg.SYC_GATESET.is_supported_operation(op)
-                # single qubit gates shared between gatesets, so:
-                assert cg.SQRT_ISWAP_GATESET.is_supported_operation(op)
-
-
 @pytest.mark.parametrize(
     'optimizer_type, two_qubit_gate_type',
     [('sycamore', cg.SycamoreGate), ('sqrt_iswap', cirq.ISwapPowGate), ('xmon', cirq.CZPowGate)],
diff --git a/cirq-google/cirq_google/serialization/arg_func_langs_test.py b/cirq-google/cirq_google/serialization/arg_func_langs_test.py
@@ -154,22 +154,21 @@ def test_serialize_conversion(value: ARG_LIKE, proto: v2.program_pb2.Arg):
 
 
 def test_infer_language():
-    with cirq.testing.assert_deprecated('SerializableGateSet', deadline='v0.16', count=None):
-        q = cirq.GridQubit(0, 0)
-        a = sympy.Symbol('a')
-        b = sympy.Symbol('b')
-
-        c_linear = cirq.Circuit(cirq.X(q) ** (b - a))
-        packed = cirq_google.XMON.serialize(c_linear)
-        assert packed.language.arg_function_language == 'linear'
-
-        c_empty = cirq.Circuit(cirq.X(q) ** b)
-        packed = cirq_google.XMON.serialize(c_empty)
-        assert packed.language.arg_function_language == ''
-
-        c_exp = cirq.Circuit(cirq.X(q) ** (b**a))
-        packed = cirq_google.XMON.serialize(c_exp)
-        assert packed.language.arg_function_language == 'exp'
+    q = cirq.GridQubit(0, 0)
+    a = sympy.Symbol('a')
+    b = sympy.Symbol('b')
+
+    c_linear = cirq.Circuit(cirq.X(q) ** (b - a))
+    packed = cirq_google.CIRCUIT_SERIALIZER.serialize(c_linear)
+    assert packed.language.arg_function_language == 'linear'
+
+    c_empty = cirq.Circuit(cirq.X(q) ** b)
+    packed = cirq_google.CIRCUIT_SERIALIZER.serialize(c_empty)
+    assert packed.language.arg_function_language == ''
+
+    c_exp = cirq.Circuit(cirq.X(q) ** (b**a))
+    packed = cirq_google.CIRCUIT_SERIALIZER.serialize(c_exp)
+    assert packed.language.arg_function_language == 'exp'
 
 
 @pytest.mark.parametrize(
