Esempio n. 1
0
def test_circuit_op_from_proto(repetitions):
    deserializer = cg.CircuitOpDeserializer()

    repetition_spec = v2.program_pb2.RepetitionSpecification()
    if isinstance(repetitions, int):
        repetition_ids = None
        repetition_spec.repetition_count = repetitions
    else:
        repetition_ids = repetitions
        repetitions = len(repetition_ids)
        for rep_id in repetition_ids:
            repetition_spec.repetition_ids.ids.append(rep_id)

    qubit_map = v2.program_pb2.QubitMapping()
    q_p1 = qubit_map.entries.add()
    q_p1.key.id = '1_1'
    q_p1.value.id = '1_2'

    measurement_key_map = v2.program_pb2.MeasurementKeyMapping()
    meas_p1 = measurement_key_map.entries.add()
    meas_p1.key.string_key = 'm'
    meas_p1.value.string_key = 'results'

    arg_map = v2.program_pb2.ArgMapping()
    arg_p1 = arg_map.entries.add()
    arg_p1.key.arg_value.string_value = 'k'
    arg_p1.value.arg_value.float_value = 1.0

    serialized = v2.program_pb2.CircuitOperation(
        circuit_constant_index=1,
        repetition_specification=repetition_spec,
        qubit_map=qubit_map,
        measurement_key_map=measurement_key_map,
        arg_map=arg_map,
    )

    constants = [
        v2.program_pb2.Constant(string_value=DEFAULT_TOKEN),
        v2.program_pb2.Constant(circuit_value=default_circuit_proto()),
    ]
    deserialized_constants = [DEFAULT_TOKEN, default_circuit()]

    actual = deserializer.from_proto(
        serialized,
        constants=constants,
        deserialized_constants=deserialized_constants)
    expected = cirq.CircuitOperation(
        circuit=default_circuit(),
        qubit_map={cirq.GridQubit(1, 1): cirq.GridQubit(1, 2)},
        measurement_key_map={'m': 'results'},
        param_resolver={'k': 1.0},
        repetitions=repetitions,
        repetition_ids=repetition_ids,
    )
    assert actual == expected
Esempio n. 2
0
def test_circuit_op_from_proto_errors():
    deserializer = cg.CircuitOpDeserializer()
    serialized = v2.program_pb2.CircuitOperation(circuit_constant_index=1)

    constants = [
        v2.program_pb2.Constant(string_value=DEFAULT_TOKEN),
        v2.program_pb2.Constant(circuit_value=default_circuit_proto()),
    ]
    deserialized_constants = [DEFAULT_TOKEN, default_circuit()]

    with pytest.raises(
            ValueError,
            match='CircuitOp deserialization requires a constants list'):
        deserializer.from_proto(serialized)

    with pytest.raises(
            ValueError,
            match='CircuitOp deserialization requires a constants list'):
        deserializer.from_proto(serialized, constants=constants)

    with pytest.raises(
            ValueError,
            match='CircuitOp deserialization requires a constants list'):
        deserializer.from_proto(serialized,
                                deserialized_constants=deserialized_constants)

    bad_deserialized_constants = [DEFAULT_TOKEN]
    with pytest.raises(
            ValueError,
            match='does not appear in the deserialized_constants list'):
        deserializer.from_proto(
            serialized,
            constants=constants,
            deserialized_constants=bad_deserialized_constants)

    bad_deserialized_constants = [DEFAULT_TOKEN, 2]
    with pytest.raises(
            ValueError,
            match='Constant at index 1 was expected to be a circuit'):
        deserializer.from_proto(
            serialized,
            constants=constants,
            deserialized_constants=bad_deserialized_constants)
Esempio n. 3
0
def test_circuit_op_arg_val_errors():
    deserializer = cg.CircuitOpDeserializer()
    arg_map = v2.program_pb2.ArgMapping()
    p1 = arg_map.entries.add()
    p1.key.arg_value.string_value = 'k'
    p1.value.arg_value.bool_values.values.extend([True, False])

    serialized = v2.program_pb2.CircuitOperation(circuit_constant_index=1,
                                                 arg_map=arg_map)

    constants = [
        v2.program_pb2.Constant(string_value=DEFAULT_TOKEN),
        v2.program_pb2.Constant(circuit_value=default_circuit_proto()),
    ]
    deserialized_constants = [DEFAULT_TOKEN, default_circuit()]

    with pytest.raises(ValueError, match='Invalid value parameter type'):
        deserializer.from_proto(serialized,
                                constants=constants,
                                deserialized_constants=deserialized_constants)
    ],
)

Y_DESERIALIZER = cg.GateOpDeserializer(
    serialized_gate_id='y_pow',
    gate_constructor=cirq.YPowGate,
    args=[
        cg.DeserializingArg(
            serialized_name='half_turns',
            constructor_arg_name='exponent',
        )
    ],
)

CIRCUIT_OP_SERIALIZER = cg.CircuitOpSerializer()
CIRCUIT_OP_DESERIALIZER = cg.CircuitOpDeserializer()

MY_GATE_SET = cg.SerializableGateSet(
    gate_set_name='my_gate_set',
    serializers=[X_SERIALIZER, CIRCUIT_OP_SERIALIZER],
    deserializers=[X_DESERIALIZER, CIRCUIT_OP_DESERIALIZER],
)


def test_deprecated_methods():
    with assert_deprecated('Use supported_internal_types', deadline='v0.13'):
        _ = MY_GATE_SET.supported_gate_types()

    with assert_deprecated('Use with_added_types', deadline='v0.13'):
        _ = MY_GATE_SET.with_added_gates()