def moment_by_moment_schedule(device: Device, circuit: Circuit):
"""Returns a schedule aligned with the moment structure of the Circuit.
This method attempts to create a schedule in which each moment of a circuit
is scheduled starting at the same time. Given the constraints of the
given device, such a schedule may not be possible, in this case the
the method will raise a ValueError with a description of the conflict.
The schedule that is produced will take each moments and schedule the
operations in this moment in a time slice of length equal to the maximum
time of an operation in the moment.
Returns:
A Schedule for the circuit.
Raises:
ValueError: if the scheduling cannot be done.
"""
schedule = Schedule(device)
t = Timestamp()
for moment in circuit.moments:
if not moment.operations:
continue
for op in moment.operations:
scheduled_op = ScheduledOperation.op_at_on(op, t, device)
# Raises a ValueError describing the problem if this cannot be
# scheduled.
schedule.include(scheduled_operation=scheduled_op)
# Raises ValueError at first sign of a device conflict.
device.validate_scheduled_operation(schedule, scheduled_op)
# Increment time for next moment by max of ops during this moment.
max_duration = max(device.duration_of(op) for op in moment.operations)
t += max_duration
return schedule
def test_query_point_operation_inclusive():
q = ops.QubitId()
zero = Timestamp(picos=0)
ps = Duration(picos=1)
op = ScheduledOperation(zero, Duration(), ops.H(q))
schedule = Schedule(device=UnconstrainedDevice, scheduled_operations=[op])
def query(t, d=Duration(), qubits=None):
return schedule.query(time=t,
duration=d,
qubits=qubits,
include_query_end_time=True,
include_op_end_times=True)
assert query(zero) == [op]
assert query(zero + ps) == []
assert query(zero - ps) == []
assert query(zero, qubits=[]) == []
assert query(zero, qubits=[q]) == [op]
assert query(zero, ps) == [op]
assert query(zero - 0.5 * ps, ps) == [op]
assert query(zero - ps, ps) == [op]
assert query(zero - 2 * ps, ps) == []
assert query(zero - ps, 3 * ps) == [op]
assert query(zero + ps, ps) == []
def test_query_overlapping_operations_inclusive():
q = ops.QubitId()
zero = Timestamp(picos=0)
ps = Duration(picos=1)
op1 = ScheduledOperation(zero, 2 * ps, ops.H(q))
op2 = ScheduledOperation(zero + ps, 2 * ps, ops.H(q))
schedule = Schedule(device=UnconstrainedDevice,
scheduled_operations=[op2, op1])
def query(t, d=Duration(), qubits=None):
return schedule.query(time=t,
duration=d,
qubits=qubits,
include_query_end_time=True,
include_op_end_times=True)
assert query(zero - 0.5 * ps, ps) == [op1]
assert query(zero - 0.5 * ps, 2 * ps) == [op1, op2]
assert query(zero, ps) == [op1, op2]
assert query(zero + 0.5 * ps, ps) == [op1, op2]
assert query(zero + ps, ps) == [op1, op2]
assert query(zero + 1.5 * ps, ps) == [op1, op2]
assert query(zero + 2.0 * ps, ps) == [op1, op2]
assert query(zero + 2.5 * ps, ps) == [op2]
assert query(zero + 3.0 * ps, ps) == [op2]
assert query(zero + 3.5 * ps, ps) == []
def test_validate_scheduled_operation_not_adjacent_exp_11_exp_w():
d = square_device(3, 3, holes=[XmonQubit(1, 1)])
q0 = XmonQubit(0, 0)
p1 = XmonQubit(1, 2)
p2 = XmonQubit(2, 2)
s = Schedule(d, [
ScheduledOperation.op_at_on(ExpWGate().on(q0), Timestamp(), d),
ScheduledOperation.op_at_on(Exp11Gate().on(p1, p2), Timestamp(), d),
])
d.validate_schedule(s)
def test_validate_scheduled_operation_adjacent_exp_11_exp_z():
d = square_device(3, 3, holes=[XmonQubit(1, 1)])
q0 = XmonQubit(0, 0)
q1 = XmonQubit(1, 0)
q2 = XmonQubit(2, 0)
s = Schedule(d, [
ScheduledOperation.op_at_on(ExpZGate().on(q0), Timestamp(), d),
ScheduledOperation.op_at_on(Exp11Gate().on(q1, q2), Timestamp(), d),
])
d.validate_schedule(s)
def simple_schedule(q, start_picos=0, duration_picos=1, num_ops=1):
time_picos = start_picos
scheduled_ops = []
for _ in range(num_ops):
op = ScheduledOperation(Timestamp(picos=time_picos),
Duration(picos=duration_picos), ops.H(q))
scheduled_ops.append(op)
time_picos += duration_picos
return Schedule(device=UnconstrainedDevice,
scheduled_operations=scheduled_ops)
def validate_scheduled_operation(
self, schedule: schedules.Schedule,
scheduled_operation: schedules.ScheduledOperation) -> None:
operation = scheduled_operation.operation
self.validate_operation(operation)
other_operations = (
scheduled_operation.operation for scheduled_operation in
schedule.operations_happening_at_same_time_as(scheduled_operation))
self.validate_crosstalk(operation, other_operations)
def test_query_overlapping_operations_exclusive():
q = ops.QubitId()
zero = Timestamp(picos=0)
ps = Duration(picos=1)
op1 = ScheduledOperation(zero, 2 * ps, ops.H(q))
op2 = ScheduledOperation(zero + ps, 2 * ps, ops.H(q))
schedule = Schedule(device=UnconstrainedDevice,
scheduled_operations=[op2, op1])
assert schedule.query(time=zero - 0.5 * ps, duration=ps) == [op1]
assert schedule.query(time=zero - 0.5 * ps, duration=2 * ps) == [op1, op2]
assert schedule.query(time=zero, duration=ps) == [op1]
assert schedule.query(time=zero + 0.5 * ps, duration=ps) == [op1, op2]
assert schedule.query(time=zero + ps, duration=ps) == [op1, op2]
assert schedule.query(time=zero + 1.5 * ps, duration=ps) == [op1, op2]
assert schedule.query(time=zero + 2.0 * ps, duration=ps) == [op2]
assert schedule.query(time=zero + 2.5 * ps, duration=ps) == [op2]
assert schedule.query(time=zero + 3.0 * ps, duration=ps) == []
assert schedule.query(time=zero + 3.5 * ps, duration=ps) == []
def validate_scheduled_operation(self, schedule: Schedule,
scheduled_operation: ScheduledOperation):
op = scheduled_operation.operation
self.validate_operation(op)
if isinstance(op.gate, ops.Rot11Gate):
for other in schedule.operations_happening_at_same_time_as(
scheduled_operation):
if self.check_if_cz_adjacent(op, other.operation):
raise ValueError('Adjacent CZ operations: {} vs {}'.format(
scheduled_operation, other))
def test_the_test_device():
device = _TestDevice()
device.validate_gate(cirq.H)
with pytest.raises(ValueError):
device.validate_gate(cirq.X)
device.validate_operation(cirq.H(cirq.LineQubit(0)))
with pytest.raises(ValueError):
device.validate_operation(NotImplementedOperation())
device.validate_schedule(Schedule(device, []))
device.validate_schedule(
Schedule(device, [
ScheduledOperation.op_at_on(cirq.H(cirq.LineQubit(0)),
cirq.Timestamp(), device),
ScheduledOperation.op_at_on(
cirq.CZ(cirq.LineQubit(0), cirq.LineQubit(1)),
cirq.Timestamp(), device)
]))
with pytest.raises(ValueError):
device.validate_schedule(
Schedule(device, [
ScheduledOperation.op_at_on(NotImplementedOperation(),
cirq.Timestamp(), device)
]))
with pytest.raises(ValueError):
device.validate_schedule(
Schedule(device, [
ScheduledOperation.op_at_on(cirq.X(cirq.LineQubit(0)),
cirq.Timestamp(), device)
]))
with pytest.raises(ValueError):
device.validate_schedule(
Schedule(device, [
ScheduledOperation.op_at_on(cirq.H(cirq.NamedQubit('q')),
cirq.Timestamp(), device)
]))
with pytest.raises(ValueError):
device.validate_schedule(
Schedule(device, [
ScheduledOperation.op_at_on(cirq.H(cirq.LineQubit(100)),
cirq.Timestamp(), device)
]))
with pytest.raises(ValueError):
device.validate_schedule(
Schedule(device, [
ScheduledOperation.op_at_on(
cirq.CZ(cirq.LineQubit(1), cirq.LineQubit(3)),
cirq.Timestamp(), device)
]))
def test_exclude():
q = ops.QubitId()
zero = Timestamp(picos=0)
ps = Duration(picos=1)
op = ScheduledOperation(zero, ps, ops.H(q))
schedule = Schedule(device=UnconstrainedDevice, scheduled_operations=[op])
assert not schedule.exclude(ScheduledOperation(zero + ps, ps, ops.H(q)))
assert not schedule.exclude(ScheduledOperation(zero, ps, ops.X(q)))
assert schedule.query(time=zero, duration=ps * 10) == [op]
assert schedule.exclude(ScheduledOperation(zero, ps, ops.H(q)))
assert schedule.query(time=zero, duration=ps * 10) == []
assert not schedule.exclude(ScheduledOperation(zero, ps, ops.H(q)))
def test_validate_schedule_repeat_measurement_keys():
d = square_device(3, 3)
s = Schedule(d, [
ScheduledOperation.op_at_on(
XmonMeasurementGate('a').on(XmonQubit(0, 0)), Timestamp(), d),
ScheduledOperation.op_at_on(
XmonMeasurementGate('a').on(XmonQubit(0, 1)), Timestamp(), d),
])
with pytest.raises(ValueError, message='Measurement key a repeated'):
d.validate_schedule(s)
def schedule_from_proto(
device: XmonDevice,
ops: Iterable[operations_pb2.Operation],
) -> Schedule:
"""Convert protobufs into a Schedule for the given device."""
scheduled_ops = []
last_time_picos = 0
for op in ops:
time_picos = last_time_picos + op.incremental_delay_picoseconds
last_time_picos = time_picos
xmon_op = xmon_gates.XmonGate.from_proto(op)
scheduled_ops.append(
ScheduledOperation.op_at_on(
operation=xmon_op,
time=Timestamp(picos=time_picos),
device=device,
))
return Schedule(device, scheduled_ops)
def schedule_from_proto_dicts(
device: XmonDevice,
ops: Iterable[Dict],
) -> Schedule:
"""Convert proto dictionaries into a Schedule for the given device."""
scheduled_ops = []
last_time_picos = 0
for op in ops:
delay_picos = 0
if 'incremental_delay_picoseconds' in op:
delay_picos = op['incremental_delay_picoseconds']
time_picos = last_time_picos + delay_picos
last_time_picos = time_picos
xmon_op = xmon_gates.XmonGate.from_proto_dict(op)
scheduled_ops.append(ScheduledOperation.op_at_on(
operation=xmon_op,
time=Timestamp(picos=time_picos),
device=device,
))
return Schedule(device, scheduled_ops)
def test_slice_operations():
q0 = ops.QubitId()
q1 = ops.QubitId()
zero = Timestamp(picos=0)
ps = Duration(picos=1)
op1 = ScheduledOperation(zero, ps, ops.H(q0))
op2 = ScheduledOperation(zero + 2 * ps, 2 * ps, ops.CZ(q0, q1))
op3 = ScheduledOperation(zero + 10 * ps, ps, ops.H(q1))
schedule = Schedule(device=UnconstrainedDevice,
scheduled_operations=[op1, op2, op3])
assert schedule[zero] == [op1]
assert schedule[zero + ps*0.5] == [op1]
assert schedule[zero:zero] == []
assert schedule[zero + ps*0.5:zero + ps*0.5] == [op1]
assert schedule[zero:zero + ps] == [op1]
assert schedule[zero:zero + 2 * ps] == [op1]
assert schedule[zero:zero + 2.1 * ps] == [op1, op2]
assert schedule[zero:zero + 20 * ps] == [op1, op2, op3]
assert schedule[zero + 2.5 * ps:zero + 20 * ps] == [op2, op3]
assert schedule[zero + 5 * ps:zero + 20 * ps] == [op3]
def test_query_point_operation_exclusive():
q = ops.QubitId()
zero = Timestamp(picos=0)
ps = Duration(picos=1)
op = ScheduledOperation(zero, Duration(), ops.H(q))
schedule = Schedule(device=UnconstrainedDevice, scheduled_operations=[op])
assert schedule.query(time=zero,
include_query_end_time=False,
include_op_end_times=False) == []
assert schedule.query(time=zero + ps,
include_query_end_time=False,
include_op_end_times=False) == []
assert schedule.query(time=zero - ps,
include_query_end_time=False,
include_op_end_times=False) == []
assert schedule.query(time=zero) == []
assert schedule.query(time=zero + ps) == []
assert schedule.query(time=zero - ps) == []
assert schedule.query(time=zero, qubits=[]) == []
assert schedule.query(time=zero, qubits=[q]) == []
assert schedule.query(time=zero, duration=ps) == []
assert schedule.query(time=zero - 0.5 * ps, duration=ps) == [op]
assert schedule.query(time=zero - ps, duration=ps) == []
assert schedule.query(time=zero - 2 * ps, duration=ps) == []
assert schedule.query(time=zero - ps, duration=3 * ps) == [op]
assert schedule.query(time=zero + ps, duration=ps) == []
def test_include():
q0 = ops.QubitId()
q1 = ops.QubitId()
zero = Timestamp(picos=0)
ps = Duration(picos=1)
schedule = Schedule(device=UnconstrainedDevice)
op0 = ScheduledOperation(zero, ps, ops.H(q0))
schedule.include(op0)
with pytest.raises(ValueError):
schedule.include(ScheduledOperation(zero, ps, ops.H(q0)))
schedule.include(ScheduledOperation(zero + 0.5 * ps, ps, ops.H(q0)))
op1 = ScheduledOperation(zero + 2 * ps, ps, ops.H(q0))
schedule.include(op1)
op2 = ScheduledOperation(zero + 0.5 * ps, ps, ops.H(q1))
schedule.include(op2)
assert schedule.query(time=zero, duration=ps * 10) == [op0, op2, op1]