def test_fsim_gate_not_allowed(gate):
q1 = cirq.GridQubit(5, 4)
q2 = cirq.GridQubit(5, 5)
gate_set = cg.SerializableGateSet('test', cgc.LIMITED_FSIM_SERIALIZERS,
[cgc.LIMITED_FSIM_DESERIALIZER])
with pytest.raises(ValueError):
gate_set.serialize_op(gate(q1, q2))
def test_cz_pow_non_integer_does_not_serialize():
gate_set = cg.SerializableGateSet('test', [cgc.CZ_SERIALIZER],
[cgc.CZ_POW_DESERIALIZER])
q1 = cirq.GridQubit(5, 4)
q2 = cirq.GridQubit(5, 5)
with pytest.raises(ValueError):
gate_set.serialize_op(cirq.CZ(q1, q2)**0.5)
def test_serialize_deserialize_fsim_gate_symbols(gate, theta, phi, phys_z):
gate_set = cg.SerializableGateSet('test', cgc.LIMITED_FSIM_SERIALIZERS,
[cgc.LIMITED_FSIM_DESERIALIZER])
q1 = cirq.GridQubit(5, 4)
q2 = cirq.GridQubit(5, 5)
op = gate(q1, q2)
if phys_z:
op = op.with_tags(cg.PhysicalZTag())
expected = op_proto({
'gate': {
'id': 'fsim'
},
'args': {
'theta': theta,
'phi': phi,
**_phys_z_args(phys_z)
},
'qubits': [{
'id': '5_4'
}, {
'id': '5_5'
}],
})
proto = gate_set.serialize_op(op, arg_function_language='linear')
actual = gate_set.deserialize_op(proto, arg_function_language='linear')
assert proto == expected
assert actual == op
assert_phys_z_tag(phys_z, actual)
def test_gateset_with_added_gates_again():
"""Verify that adding a serializer twice doesn't mess anything up."""
q = cirq.GridQubit(2, 2)
x_gateset = cg.SerializableGateSet(
gate_set_name='x',
serializers=[X_SERIALIZER],
deserializers=[X_DESERIALIZER],
)
xx_gateset = x_gateset.with_added_gates(
gate_set_name='xx',
serializers=[X_SERIALIZER],
deserializers=[X_DESERIALIZER],
)
assert xx_gateset.gate_set_name == 'xx'
assert xx_gateset.is_supported_operation(cirq.X(q))
assert not xx_gateset.is_supported_operation(cirq.Y(q))
# test serialization and deserialization
proto = op_proto(
{
'gate': {'id': 'x_pow'},
'args': {
'half_turns': {'arg_value': {'float_value': 0.125}},
},
'qubits': [{'id': '1_1'}],
}
)
expected_gate = cirq.XPowGate(exponent=0.125)(cirq.GridQubit(1, 1))
assert xx_gateset.serialize_op(expected_gate) == proto
assert xx_gateset.deserialize_op(proto) == expected_gate
def test_multiple_serializers():
serializer1 = cg.GateOpSerializer(
gate_type=cirq.XPowGate,
serialized_gate_id='x_pow',
args=[
cg.SerializingArg(serialized_name='half_turns',
serialized_type=float,
op_getter='exponent')
],
can_serialize_predicate=lambda x: x.gate.exponent != 1)
serializer2 = cg.GateOpSerializer(
gate_type=cirq.XPowGate,
serialized_gate_id='x',
args=[
cg.SerializingArg(serialized_name='half_turns',
serialized_type=float,
op_getter='exponent')
],
can_serialize_predicate=lambda x: x.gate.exponent == 1)
gate_set = cg.SerializableGateSet(gate_set_name='my_gate_set',
serializers=[serializer1, serializer2],
deserializers=[])
q0 = cirq.GridQubit(1, 1)
assert gate_set.serialize_op(cirq.X(q0)).gate.id == 'x'
assert gate_set.serialize_op(cirq.X(q0)**0.5).gate.id == 'x_pow'
def test_serialize_deserialize_cz_gate(gate, exponent, phys_z):
gate_set = cg.SerializableGateSet('test', [cgc.CZ_SERIALIZER],
[cgc.CZ_POW_DESERIALIZER])
proto = op_proto({
'gate': {
'id': 'cz'
},
'args': {
'half_turns': {
'arg_value': {
'float_value': exponent
}
},
**_phys_z_args(phys_z),
},
'qubits': [{
'id': '5_4'
}, {
'id': '5_5'
}],
})
q1 = cirq.GridQubit(5, 4)
q2 = cirq.GridQubit(5, 5)
op = gate(q1, q2)
if phys_z:
op = op.with_tags(cg.PhysicalZTag())
assert gate_set.serialize_op(op) == proto
deserialized_op = gate_set.deserialize_op(proto)
expected_gate = cirq.CZPowGate(exponent=exponent)
cirq.testing.assert_allclose_up_to_global_phase(
cirq.unitary(deserialized_op),
cirq.unitary(expected_gate),
atol=1e-7,
)
assert_phys_z_tag(phys_z, deserialized_op)
def test_serialize_deserialize_fsim_gate(gate, theta, phi):
gate_set = cg.SerializableGateSet('test', cgc.LIMITED_FSIM_SERIALIZERS,
[cgc.LIMITED_FSIM_DESERIALIZER])
proto = op_proto({
'gate': {
'id': 'fsim'
},
'args': {
'theta': {
'arg_value': {
'float_value': theta
}
},
'phi': {
'arg_value': {
'float_value': phi
}
}
},
'qubits': [{
'id': '5_4'
}, {
'id': '5_5'
}]
})
q1 = cirq.GridQubit(5, 4)
q2 = cirq.GridQubit(5, 5)
op = cirq.FSimGate(theta=theta, phi=phi)
assert gate_set.serialize_op(gate(q1, q2)) == proto
cirq.testing.assert_allclose_up_to_global_phase(
cirq.unitary(gate_set.deserialize_op(proto)),
cirq.unitary(op),
atol=1e-7,
)
def test_serialize_deserialize_cz_gate(gate, exponent):
gate_set = cg.SerializableGateSet('test', [cgc.CZ_SERIALIZER],
[cgc.CZ_POW_DESERIALIZER])
proto = op_proto({
'gate': {
'id': 'cz'
},
'args': {
'half_turns': {
'arg_value': {
'float_value': exponent
}
}
},
'qubits': [{
'id': '5_4'
}, {
'id': '5_5'
}]
})
q1 = cirq.GridQubit(5, 4)
q2 = cirq.GridQubit(5, 5)
op = cirq.CZPowGate(exponent=exponent)
assert gate_set.serialize_op(gate(q1, q2)) == proto
cirq.testing.assert_allclose_up_to_global_phase(
cirq.unitary(gate_set.deserialize_op(proto)),
cirq.unitary(op),
atol=1e-7,
)
def test_gateset_with_added_gates():
q = cirq.GridQubit(1, 1)
x_gateset = cg.SerializableGateSet(
gate_set_name='x',
serializers=[X_SERIALIZER],
deserializers=[X_DESERIALIZER],
)
xy_gateset = x_gateset.with_added_gates(
gate_set_name='xy',
serializers=[Y_SERIALIZER],
deserializers=[Y_DESERIALIZER],
)
assert x_gateset.gate_set_name == 'x'
assert x_gateset.is_supported_operation(cirq.X(q))
assert not x_gateset.is_supported_operation(cirq.Y(q))
assert xy_gateset.gate_set_name == 'xy'
assert xy_gateset.is_supported_operation(cirq.X(q))
assert xy_gateset.is_supported_operation(cirq.Y(q))
# test serialization and deserialization
proto = op_proto(
{
'gate': {'id': 'y_pow'},
'args': {
'half_turns': {'arg_value': {'float_value': 0.125}},
},
'qubits': [{'id': '1_1'}],
}
)
expected_gate = cirq.YPowGate(exponent=0.125)(cirq.GridQubit(1, 1))
assert xy_gateset.serialize_op(expected_gate) == proto
assert xy_gateset.deserialize_op(proto) == expected_gate
def test_serialize_deserialize_iswap_symbols():
gate_set = cg.SerializableGateSet('test', cgc.LIMITED_FSIM_SERIALIZERS,
[cgc.LIMITED_FSIM_DESERIALIZER])
q1 = cirq.GridQubit(5, 4)
q2 = cirq.GridQubit(5, 5)
op = cirq.ISWAP(q1, q2)**sympy.Symbol('t')
proto = gate_set.serialize_op(op, arg_function_language='linear')
actual = gate_set.deserialize_op(proto, arg_function_language='linear')
assert isinstance(actual.gate, cirq.FSimGate)
assert math.isclose(actual.gate.phi, 0)
assert math.isclose(actual.gate.theta.subs('t', 2), -np.pi, abs_tol=1e-5)
def test_get_engine_device(get_processor):
device_spec = _to_any(
Merge(
"""
valid_gate_sets: [{
name: 'test_set',
valid_gates: [{
id: 'x',
number_of_qubits: 1,
gate_duration_picos: 1000,
valid_targets: ['1q_targets']
}]
}],
valid_qubits: ['0_0', '1_1'],
valid_targets: [{
name: '1q_targets',
target_ordering: SYMMETRIC,
targets: [{
ids: ['0_0']
}]
}]
""",
v2.device_pb2.DeviceSpecification(),
))
gate_set = cg.SerializableGateSet(
gate_set_name='x_gate_set',
serializers=[
cg.GateOpSerializer(gate_type=cirq.XPowGate,
serialized_gate_id='x',
args=[])
],
deserializers=[
cg.GateOpDeserializer(serialized_gate_id='x',
gate_constructor=cirq.XPowGate,
args=[])
],
)
get_processor.return_value = qtypes.QuantumProcessor(
device_spec=device_spec)
device = cirq.google.get_engine_device('rainbow',
'project',
gatesets=[gate_set])
assert set(device.qubits) == {cirq.GridQubit(0, 0), cirq.GridQubit(1, 1)}
device.validate_operation(cirq.X(cirq.GridQubit(0, 0)))
with pytest.raises(ValueError):
device.validate_operation(cirq.X(cirq.GridQubit(1, 2)))
with pytest.raises(ValueError):
device.validate_operation(cirq.Y(cirq.GridQubit(0, 0)))
def test_is_supported_gate_can_serialize_predicate():
serializer = cg.GateOpSerializer(
gate_type=cirq.XPowGate,
serialized_gate_id='x_pow',
args=[
cg.SerializingArg(
serialized_name='half_turns',
serialized_type=float,
gate_getter='exponent',
)
],
can_serialize_predicate=lambda x: x.exponent == 1.0)
gate_set = cg.SerializableGateSet(gate_set_name='my_gate_set',
serializers=[serializer],
deserializers=[X_DESERIALIZER])
assert gate_set.is_supported_gate(cirq.XPowGate())
assert not gate_set.is_supported_gate(cirq.XPowGate()**0.5)
assert gate_set.is_supported_gate(cirq.X)
def test_is_supported_operation_can_serialize_predicate():
q = cirq.GridQubit(1, 2)
serializer = cg.GateOpSerializer(
gate_type=cirq.XPowGate,
serialized_gate_id='x_pow',
args=[
cg.SerializingArg(
serialized_name='half_turns',
serialized_type=float,
op_getter='exponent',
)
],
can_serialize_predicate=lambda x: x.gate.exponent == 1.0,
)
gate_set = cg.SerializableGateSet(gate_set_name='my_gate_set',
serializers=[serializer],
deserializers=[X_DESERIALIZER])
assert gate_set.is_supported_operation(cirq.XPowGate()(q))
assert not gate_set.is_supported_operation(cirq.XPowGate()(q)**0.5)
assert gate_set.is_supported_operation(cirq.X(q))
def test_serialize_deserialize_fsim_gate(gate, theta, phi, phys_z):
gate_set = cg.SerializableGateSet('test', cgc.LIMITED_FSIM_SERIALIZERS,
[cgc.LIMITED_FSIM_DESERIALIZER])
proto = op_proto({
'gate': {
'id': 'fsim'
},
'args': {
'theta': {
'arg_value': {
'float_value': theta
}
},
'phi': {
'arg_value': {
'float_value': phi
}
},
**_phys_z_args(phys_z),
},
'qubits': [{
'id': '5_4'
}, {
'id': '5_5'
}],
})
q1 = cirq.GridQubit(5, 4)
q2 = cirq.GridQubit(5, 5)
op = gate(q1, q2)
if phys_z:
op = op.with_tags(cg.PhysicalZTag())
expected_gate = cirq.FSimGate(theta=theta, phi=phi)
assert gate_set.serialize_op(op) == proto
deserialized_op = gate_set.deserialize_op(proto)
cirq.testing.assert_allclose_up_to_global_phase(
cirq.unitary(deserialized_op),
cirq.unitary(expected_gate),
atol=1e-7,
)
assert_phys_z_tag(phys_z, deserialized_op)
def test_wait_gate():
gate_set = cg.SerializableGateSet('test', [cgc.WAIT_GATE_SERIALIZER],
[cgc.WAIT_GATE_DESERIALIZER])
proto = op_proto({
'gate': {
'id': 'wait'
},
'args': {
'nanos': {
'arg_value': {
'float_value': 20.0
}
}
},
'qubits': [{
'id': '1_2'
}],
})
q = cirq.GridQubit(1, 2)
op = cirq.wait(q, nanos=20)
assert gate_set.serialize_op(op) == proto
assert gate_set.deserialize_op(proto) == op
def test_wait_gate():
gate_set = cg.SerializableGateSet('test', [cgc.WAIT_GATE_SERIALIZER],
[cgc.WAIT_GATE_DESERIALIZER])
proto_dict = {
'gate': {
'id': 'wait'
},
'args': {
'nanos': {
'arg_value': {
'float_value': 20.0
}
}
},
'qubits': [{
'id': '1_2'
}]
}
q = cirq.GridQubit(1, 2)
op = cirq.WaitGate(cirq.Duration(nanos=20)).on(q)
assert gate_set.serialize_op_dict(op) == proto_dict
assert gate_set.deserialize_op_dict(proto_dict) == op
def test_serialize_deserialize_fsim_gate_symbols(gate, theta, phi):
gate_set = cg.SerializableGateSet('test', cgc.LIMITED_FSIM_SERIALIZERS,
[cgc.LIMITED_FSIM_DESERIALIZER])
q1 = cirq.GridQubit(5, 4)
q2 = cirq.GridQubit(5, 5)
expected = op_proto({
'gate': {
'id': 'fsim'
},
'args': {
'theta': theta,
'phi': phi
},
'qubits': [{
'id': '5_4'
}, {
'id': '5_5'
}]
})
proto = gate_set.serialize_op(gate(q1, q2), arg_function_language='linear')
actual = gate_set.deserialize_op(proto, arg_function_language='linear')
assert proto == expected
assert actual == gate(q1, q2)
name: '1q_targets',
target_ordering: SYMMETRIC,
targets: [{
ids: ['0_0']
}]
}]
""",
v2.device_pb2.DeviceSpecification(),
)
)
_GATE_SET = cg.SerializableGateSet(
gate_set_name='x_gate_set',
serializers=[cg.GateOpSerializer(gate_type=cirq.XPowGate, serialized_gate_id='x', args=[])],
deserializers=[
cg.GateOpDeserializer(serialized_gate_id='x', gate_constructor=cirq.XPowGate, args=[])
],
)
@pytest.fixture(scope='session', autouse=True)
def mock_grpc_client():
with mock.patch(
'cirq.google.engine.engine_client.quantum.QuantumEngineServiceClient'
) as _fixture:
yield _fixture
def test_engine():
processor = cg.EngineProcessor('a', 'p', EngineContext())
import copy
import pytest
import cirq
import cirq.google as cg
import cirq.google.api.v2 as v2
import cirq.google.api.v2.device_pb2 as device_pb2
import cirq.google.common_serializers as cgc
_JUST_CZ = cg.SerializableGateSet(
gate_set_name='cz_gate_set',
serializers=[
cg.GateOpSerializer(gate_type=cirq.CZPowGate,
serialized_gate_id='cz',
args=[])
],
deserializers=[
cg.GateOpDeserializer(serialized_gate_id='cz',
gate_constructor=cirq.CZPowGate,
args=[])
],
)
_JUST_MEAS = cg.SerializableGateSet(
gate_set_name='meas_gate_set',
serializers=[
cg.GateOpSerializer(gate_type=cirq.MeasurementGate,
serialized_gate_id='meas',
args=[])
],
deserializers=[
)
Y_DESERIALIZER = cg.GateOpDeserializer(
serialized_gate_id='y_pow',
gate_constructor=cirq.YPowGate,
args=[
cg.DeserializingArg(
serialized_name='half_turns',
constructor_arg_name='exponent',
)
],
)
MY_GATE_SET = cg.SerializableGateSet(
gate_set_name='my_gate_set',
serializers=[X_SERIALIZER],
deserializers=[X_DESERIALIZER],
)
def op_proto(json: Dict) -> v2.program_pb2.Operation:
op = v2.program_pb2.Operation()
json_format.ParseDict(json, op)
return op
def test_supported_gate_types():
assert MY_GATE_SET.supported_gate_types() == (cirq.XPowGate, )
def test_is_supported_operation():
