def test_minimal_sequence_search_returns_none_when_blocked():
q00 = XmonQubit(0, 0)
q10 = XmonQubit(1, 0)
qubits = [q00, q10]
search = MinimalConnectivityGreedySequenceSearch(_create_device(qubits),
q10)
assert search._choose_next_qubit(q10, {q00, q10}) is None
def test_two_qubits_apart():
q00 = XmonQubit(0, 0)
q11 = XmonQubit(1, 1)
assert chip_as_adjacency_list(_create_device([q00, q11])) == {
q00: [],
q11: []
}
def test_two_close_qubits():
q00 = XmonQubit(0, 0)
q01 = XmonQubit(0, 1)
assert chip_as_adjacency_list(_create_device([q00, q01])) == {
q00: [q01],
q01: [q00]
}
def test_multiple_longest_sequences():
q00 = XmonQubit(0, 0)
q01 = XmonQubit(0, 1)
q02 = XmonQubit(0, 2)
q10 = XmonQubit(1, 0)
q20 = XmonQubit(2, 0)
assert longest_sequence_index([[q00], [q01, q02], [q10, q20]]) == 1
def bit_flip_circuit(flip0, flip1):
q1, q2 = XmonQubit(0, 0), XmonQubit(0, 1)
g1, g2 = ExpWGate(half_turns=flip0)(q1), ExpWGate(half_turns=flip1)(q2)
m1, m2 = XmonMeasurementGate('q1')(q1), XmonMeasurementGate('q2')(q2)
circuit = Circuit()
circuit.append([g1, g2, m1, m2])
return circuit
def test_line_placement_eq():
eq = EqualsTester()
eq.make_equality_pair(lambda: LinePlacement([]))
eq.make_equality_pair(
lambda: LinePlacement([LineSequence([XmonQubit(0, 0)])]))
eq.make_equality_pair(lambda: LinePlacement(
[LineSequence([XmonQubit(0, 0)]),
LineSequence([XmonQubit(0, 1)])]))
def test_validate_operation_supported_gate():
d = square_device(3, 3)
class MyGate(ops.Gate):
pass
d.validate_operation(ops.Operation(ExpZGate(), [XmonQubit(0, 0)]))
with pytest.raises(ValueError):
d.validate_operation(ops.Operation(MyGate, [XmonQubit(0, 0)]))
def test_validate_operation_adjacent_qubits():
d = square_device(3, 3)
d.validate_operation(
ops.Operation(Exp11Gate(), (XmonQubit(0, 0), XmonQubit(1, 0))))
with pytest.raises(ValueError):
d.validate_operation(
ops.Operation(Exp11Gate(), (XmonQubit(0, 0), XmonQubit(2, 0))))
def test_largest_collect_unused_collects():
q00 = XmonQubit(0, 0)
q01 = XmonQubit(0, 1)
q02 = XmonQubit(0, 2)
q12 = XmonQubit(1, 2)
qubits = [q00, q01, q02, q12]
start = q01
search = LargestAreaGreedySequenceSearch(_create_device(qubits), start)
assert search._collect_unused(start, {q00, q01}) == {q01, q02, q12}
def test_three_qubits_in_row():
q00 = XmonQubit(0, 0)
q01 = XmonQubit(0, 1)
q02 = XmonQubit(0, 2)
assert chip_as_adjacency_list(_create_device([q00, q01, q02])) == {
q00: [q01],
q01: [q00, q02],
q02: [q01]
}
def square_device(width, height, holes=()):
ns = Duration(nanos=1)
return XmonDevice(measurement_duration=ns,
exp_w_duration=2 * ns,
exp_11_duration=3 * ns,
qubits=[
XmonQubit(x, y) for x in range(width)
for y in range(height)
if XmonQubit(x, y) not in holes
])
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 test_search_sequence_assembles_sequence():
q00 = XmonQubit(0, 0)
q01 = XmonQubit(0, 1)
q02 = XmonQubit(0, 2)
qubits = [q00, q01, q02]
search = GreedySequenceSearch(_create_device(qubits), q01)
with mock.patch.object(search, '_choose_next_qubit') as choose_next_qubit:
choose_next_qubit.side_effect = [q01, q02, None]
assert search._sequence_search(q00, []) == [q00, q01, q02]
def test_find_path_between_finds_path():
q00 = XmonQubit(0, 0)
q01 = XmonQubit(0, 1)
q02 = XmonQubit(0, 2)
q10 = XmonQubit(1, 0)
q11 = XmonQubit(1, 1)
q12 = XmonQubit(1, 2)
q20 = XmonQubit(2, 0)
q21 = XmonQubit(2, 1)
q22 = XmonQubit(2, 2)
qubits = [q00, q01, q10, q11]
start = q00
search = GreedySequenceSearch(_create_device(qubits), start)
assert search._find_path_between(q00, q01, {q00, q01}) == [q10, q11]
# path1: + + + path2: +-+-+
# | |
# + + + +
# | |
# + + + +-+-+
qubits = [q00, q01, q02, q10, q20, q21, q22, q12]
path_1 = [q00, q01, q02]
path_2 = [q00, q10, q20, q21, q22, q12, q02]
start = q00
search = GreedySequenceSearch(_create_device(qubits), start)
assert search._find_path_between(q00, q02, set(path_1)) == path_2[1:-1]
assert search._find_path_between(q02, q00, set(path_1)) == path_2[-2:0:-1]
assert search._find_path_between(q00, q02, set(path_2)) == path_1[1:-1]
assert search._find_path_between(q02, q00, set(path_2)) == path_1[-2:0:-1]
def test_validate_circuit_repeat_measurement_keys():
d = square_device(3, 3)
circuit = Circuit()
circuit.append([
XmonMeasurementGate('a').on(XmonQubit(0, 0)),
XmonMeasurementGate('a').on(XmonQubit(0, 1))
])
with pytest.raises(ValueError, message='Measurement key a repeated'):
d.validate_circuit(circuit)
def test_greedy_search_method_returns_longest(largest, minimal):
q00 = XmonQubit(0, 0)
q10 = XmonQubit(1, 0)
sequence_short = [q00]
sequence_long = [q00, q10]
largest.return_value.get_or_search.return_value = sequence_short
minimal.return_value.get_or_search.return_value = sequence_long
method = GreedySequenceSearchMethod()
assert method.place_line(_create_device([])) == LinePlacement(
[LineSequence(sequence_long)])
def test_largest_sequence_search_does_not_use_used():
q00 = XmonQubit(0, 0)
q10 = XmonQubit(1, 0)
q20 = XmonQubit(2, 0)
q21 = XmonQubit(2, 1)
qubits = [q00, q10, q20, q21]
search = LargestAreaGreedySequenceSearch(_create_device(qubits), q10)
# +-* X
#
# +
assert search._choose_next_qubit(q10, {q10, q20}) == q00
def test_square_of_four():
q00 = XmonQubit(0, 0)
q01 = XmonQubit(0, 1)
q10 = XmonQubit(1, 0)
q11 = XmonQubit(1, 1)
assert chip_as_adjacency_list(_create_device([q00, q01, q10, q11])) == {
q00: [q01, q10],
q01: [q00, q11],
q10: [q00, q11],
q11: [q10, q01]
}
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 test_minimal_sequence_search_does_not_use_used():
q00 = XmonQubit(0, 0)
q10 = XmonQubit(1, 0)
q20 = XmonQubit(2, 0)
q21 = XmonQubit(2, 1)
qubits = [q00, q10, q20, q21]
search = MinimalConnectivityGreedySequenceSearch(_create_device(qubits),
q10)
# + *-+
#
# +
assert search._choose_next_qubit(q10, {q00, q10}) == q20
def test_get_or_search_calls_find_sequence_once():
q00 = XmonQubit(0, 0)
q01 = XmonQubit(0, 1)
search = GreedySequenceSearch(_create_device([q00, q01]), q00)
with mock.patch.object(search, '_find_sequence') as find_sequence:
sequence = [q00, q01]
find_sequence.return_value = sequence
assert search.get_or_search() == sequence
find_sequence.assert_called_once_with()
assert search.get_or_search() == sequence
find_sequence.assert_called_once_with()
def test_init():
d = square_device(2, 2, holes=[XmonQubit(1, 1)])
ns = Duration(nanos=1)
q00 = XmonQubit(0, 0)
q01 = XmonQubit(0, 1)
q10 = XmonQubit(1, 0)
assert d.qubits == {q00, q01, q10}
assert d.duration_of(ExpZGate().on(q00)) == 0 * ns
assert d.duration_of(ops.measure(q00)) == ns
assert d.duration_of(ops.measure(q00, q01)) == ns
assert d.duration_of(ExpWGate().on(q00)) == 2 * ns
assert d.duration_of(Exp11Gate().on(q00, q01)) == 3 * ns
def test_operation_eq():
g1 = ops.Gate()
g2 = ops.Gate()
r1 = [XmonQubit(1, 2)]
r2 = [XmonQubit(3, 4)]
r12 = r1 + r2
r21 = r2 + r1
eq = EqualsTester()
eq.make_equality_pair(lambda: ops.Operation(g1, r1))
eq.make_equality_pair(lambda: ops.Operation(g2, r1))
eq.make_equality_pair(lambda: ops.Operation(g1, r2))
eq.make_equality_pair(lambda: ops.Operation(g1, r12))
eq.make_equality_pair(lambda: ops.Operation(g1, r21))
def test_qubit_not_mutated():
qubit = XmonQubit(0, 0)
above(qubit)
assert qubit == XmonQubit(0, 0)
below(qubit)
assert qubit == XmonQubit(0, 0)
right_of(qubit)
assert qubit == XmonQubit(0, 0)
left_of(qubit)
assert qubit == XmonQubit(0, 0)
def test_greedy_search_method_calls_all(largest, minimal):
q00 = XmonQubit(0, 0)
q01 = XmonQubit(0, 1)
qubits = [q00, q01]
largest_instance = largest.return_value
minimal_instance = minimal.return_value
method = GreedySequenceSearchMethod()
method.place_line(_create_device(qubits))
largest.assert_called_once_with(_create_device(qubits), q00)
largest_instance.get_or_search.assert_called_once_with()
minimal.assert_called_once_with(_create_device(qubits), q00)
minimal_instance.get_or_search.assert_called_once_with()
def test_find_sequence_assembles_head_and_tail():
q00 = XmonQubit(0, 0)
q01 = XmonQubit(0, 1)
q02 = XmonQubit(0, 2)
qubits = [q00, q01, q02]
start = q01
search = GreedySequenceSearch(_create_device(qubits), start)
with mock.patch.object(search, '_sequence_search') as sequence_search:
head = [q01, q00]
tail = [q01, q02]
sequence_search.side_effect = [tail, head]
assert search._find_sequence() == qubits
sequence_search.assert_has_calls(
[mock.call(start, []),
mock.call(start, tail)])
def test_greedy_method_calls_greedy_search():
q00 = XmonQubit(0, 0)
q01 = XmonQubit(0, 1)
q03 = XmonQubit(0, 3)
device = XmonDevice(Duration(nanos=0),
Duration(nanos=0),
Duration(nanos=0),
qubits=[q00, q01, q03])
method = greedy.GreedySequenceSearchMethod()
with mock.patch.object(method, 'place_line') as place_line:
sequences = [[q00, q01]]
place_line.return_value = sequences
assert place_on_device(device, method) == sequences
place_line.assert_called_once_with(device)
def test_search_sequence_calls_choose_next_qubit():
q00 = XmonQubit(0, 0)
q01 = XmonQubit(0, 1)
q02 = XmonQubit(0, 2)
qubits = [q00, q01, q02]
search = GreedySequenceSearch(_create_device(qubits), q01)
with mock.patch.object(search, '_choose_next_qubit') as choose_next_qubit:
choose_next_qubit.return_value = None
search._sequence_search(q01, [])
choose_next_qubit.assert_called_once_with(q01, {q01})
with mock.patch.object(search, '_choose_next_qubit') as choose_next_qubit:
choose_next_qubit.return_value = None
search._sequence_search(q01, [q00])
choose_next_qubit.assert_called_once_with(q01, {q00, q01})
def test_find_sequence_calls_expand_sequence():
q00 = XmonQubit(0, 0)
q01 = XmonQubit(0, 1)
q02 = XmonQubit(0, 2)
qubits = [q00, q01, q02]
start = q01
search = GreedySequenceSearch(_create_device(qubits), start)
with mock.patch.object(
search, '_sequence_search') as sequence_search, mock.patch.object(
search, '_expand_sequence') as expand_sequence:
head = [q01, q00]
tail = [q01, q02]
sequence_search.side_effect = [tail, head]
search._find_sequence()
expand_sequence.assert_called_once_with(qubits)
