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_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_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_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_to_proto(): q = XmonQubit(5, 6) # Create a new message. proto = q.to_proto() assert proto.row == 5 assert proto.col == 6 # Populate an existing message. proto2 = operations_pb2.Qubit() q.to_proto(proto2) assert proto2.row == 5 assert proto2.col == 6
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})