def test_minimal_sequence_search_returns_none_when_blocked(): q00 = GridQubit(0, 0) q10 = GridQubit(1, 0) qubits = [q00, q10] search = MinimalConnectivityGreedySequenceSearch(_create_device(qubits), q10) assert search._choose_next_qubit(q10, {q00, q10}) is None
def test_two_close_qubits(): q00 = GridQubit(0, 0) q01 = GridQubit(0, 1) assert chip_as_adjacency_list(_create_device([q00, q01])) == { q00: [q01], q01: [q00] }
def test_greedy_search_method_calls_all(): q00 = GridQubit(0, 0) q01 = GridQubit(0, 1) qubits = [q00, q01] length = 2 method = GreedySequenceSearchStrategy() assert len(method.place_line(_create_device(qubits), length)) == 2
def test_square_of_four(): q00 = GridQubit(0, 0) q01 = GridQubit(0, 1) q10 = GridQubit(1, 0) q11 = GridQubit(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_w_to_proto(): assert proto_matches_text( cg.ExpWGate(half_turns=Symbol('k'), axis_half_turns=1).to_proto(GridQubit(2, 3)), """ exp_w { target { row: 2 col: 3 } axis_half_turns { raw: 1 } half_turns { parameter_key: "k" } } """) assert proto_matches_text( cg.ExpWGate(half_turns=0.5, axis_half_turns=Symbol('j')).to_proto(GridQubit(2, 3)), """ exp_w { target { row: 2 col: 3 } axis_half_turns { parameter_key: "j" } half_turns { raw: 0.5 } } """)
def test_z_to_proto(): assert proto_matches_text( cg.ExpZGate(half_turns=Symbol('k')).to_proto(GridQubit(2, 3)), """ exp_z { target { row: 2 col: 3 } half_turns { parameter_key: "k" } } """) assert proto_matches_text( cg.ExpZGate(half_turns=0.5).to_proto(GridQubit(2, 3)), """ exp_z { target { row: 2 col: 3 } half_turns { raw: 0.5 } } """)
def test_force_edge_active_creates_valid_solution_different_sequnces(): q00, q10, q20, q30 = [GridQubit(x, 0) for x in range(4)] q01, q11, q21, q31 = [GridQubit(x, 1) for x in range(4)] qubits = [q00, q10, q20, q30, q01, q11, q21, q31] search = AnnealSequenceSearch(_create_device(qubits), seed=0xF00D0009) # +-+-+-+ -> +-+-+-+ # | # +-+-+-+ +-+-+-+ assert search._force_edge_active( [[q00, q10, q20, q30], [q01, q11, q21, q31]], (q00, q01), lambda: True ) == [[q30, q20, q10, q00, q01, q11, q21, q31]] # +-+-+-+ -> +-+-+-+ # | # +-+-+-+ +-+-+-+ assert search._force_edge_active( [[q00, q10, q20, q30], [q01, q11, q21, q31]], (q30, q31), lambda: True ) == [[q00, q10, q20, q30, q31, q21, q11, q01]] # +-+-+-+ -> + +-+-+ # | # +-+-+-+ + +-+-+ assert search._force_edge_active( [[q00, q10, q20, q30], [q01, q11, q21, q31]], (q10, q11), lambda: True ) == [[q30, q20, q10, q11, q21, q31], [q00], [q01]] # +-+-+-+ -> +-+ +-+ # | # +-+-+-+ +-+ +-+ assert search._force_edge_active( [[q00, q10, q20, q30], [q01, q11, q21, q31]], (q10, q11), lambda: False ) == [[q00, q10, q11, q01], [q20, q30], [q21, q31]]
def test_two_qubits_apart(): q00 = GridQubit(0, 0) q11 = GridQubit(1, 1) assert chip_as_adjacency_list(_create_device([q00, q11])) == { q00: [], q11: [] }
def test_anneal_search_method_calls(): q00, q01 = GridQubit(0, 0), GridQubit(0, 1) device = _create_device([q00, q01]) length = 1 seed = 1 method = AnnealSequenceSearchStrategy(None, seed) assert len(method.place_line(device, length)) == length
def test_force_edge_active_move_quits_when_no_free_edge(): q00 = GridQubit(0, 0) q01 = GridQubit(0, 1) search = AnnealSequenceSearch( _create_device([q00, q01]), seed=0xF00D0007) seqs, edges = search._create_initial_solution() assert search._force_edge_active_move((seqs, edges)) == (seqs, edges)
def test_three_qubits_in_row(): q00 = GridQubit(0, 0) q01 = GridQubit(0, 1) q02 = GridQubit(0, 2) assert chip_as_adjacency_list(_create_device([q00, q01, q02])) == { q00: [q01], q01: [q00, q02], q02: [q01] }
def test_force_edges_active_move_calls_force_edge_active_move(): q00 = GridQubit(0, 0) q01 = GridQubit(0, 1) q10 = GridQubit(1, 0) q11 = GridQubit(1, 1) search = AnnealSequenceSearch(_create_device([q00, q01, q10, q11]), seed=0xF00D0005) with mock.patch.object(search, '_force_edge_active_move') as force_edge_active_move: search._force_edges_active_move(search._create_initial_solution()) force_edge_active_move.assert_called_with(mock.ANY)
def test_greedy_search_method_fails_when_unknown(): q00 = GridQubit(0, 0) q01 = GridQubit(0, 1) qubits = [q00, q01] length = 2 method = GreedySequenceSearchStrategy('fail') with pytest.raises(ValueError): method.place_line(_create_device(qubits), length)
def test_largest_collect_unused_collects(): q00 = GridQubit(0, 0) q01 = GridQubit(0, 1) q02 = GridQubit(0, 2) q12 = GridQubit(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_search_sequence_assembles_sequence(): q00 = GridQubit(0, 0) q01 = GridQubit(0, 1) q02 = GridQubit(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 = GridQubit(0, 0) q01 = GridQubit(0, 1) q02 = GridQubit(0, 2) q10 = GridQubit(1, 0) q11 = GridQubit(1, 1) q12 = GridQubit(1, 2) q20 = GridQubit(2, 0) q21 = GridQubit(2, 1) q22 = GridQubit(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_largest_sequence_search_does_not_use_used(): q00 = GridQubit(0, 0) q10 = GridQubit(1, 0) q20 = GridQubit(2, 0) q21 = GridQubit(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_search_calls_anneal_minimize_reversed(anneal_minimize): q00 = GridQubit(0, 0) q01 = GridQubit(0, 1) seqs = [[q01, q00]] edges = {(q00, q01)} anneal_minimize.return_value = seqs, edges assert AnnealSequenceSearch(_create_device([]), seed=0xF00D0001).search() == seqs anneal_minimize.assert_called_once_with( mock.ANY, mock.ANY, mock.ANY, mock.ANY, trace_func=mock.ANY )
def test_force_edge_active_move_does_not_change_input(): q00 = GridQubit(0, 0) q01 = GridQubit(0, 1) q10 = GridQubit(1, 0) q11 = GridQubit(1, 1) search = AnnealSequenceSearch(_create_device([q00, q01, q10, q11]), seed=0xF00D0006) seqs, edges = search._create_initial_solution() seqs_copy, edges_copy = list(seqs), edges.copy() search._force_edge_active_move((seqs, edges)) assert seqs_copy == seqs assert edges_copy == edges
def test_minimal_sequence_search_does_not_use_used(): q00 = GridQubit(0, 0) q10 = GridQubit(1, 0) q20 = GridQubit(2, 0) q21 = GridQubit(2, 1) qubits = [q00, q10, q20, q21] search = MinimalConnectivityGreedySequenceSearch(_create_device(qubits), q10) # + *-+ # # + assert search._choose_next_qubit(q10, {q00, q10}) == q20
def test_normalize_edge_normalizes(): q00, q01 = GridQubit(0, 0), GridQubit(0, 1) q10, q11 = GridQubit(1, 0), GridQubit(1, 1) search = AnnealSequenceSearch(_create_device([]), seed=0xF00D0012) assert search._normalize_edge((q00, q01)) == (q00, q01) assert search._normalize_edge((q01, q00)) == (q00, q01) assert search._normalize_edge((q01, q10)) == (q01, q10) assert search._normalize_edge((q10, q01)) == (q01, q10) assert search._normalize_edge((q00, q11)) == (q00, q11) assert search._normalize_edge((q11, q00)) == (q00, q11)
def test_get_or_search_calls_find_sequence_once(): q00 = GridQubit(0, 0) q01 = GridQubit(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_greedy_search_method_calls_minimal_only(minimal, largest): q00 = GridQubit(0, 0) q01 = GridQubit(0, 1) device = _create_device([q00, q01]) length = 2 sequence = [q00, q01] minimal.return_value.get_or_search.return_value = sequence method = GreedySequenceSearchStrategy('minimal_connectivity') assert method.place_line(device, length) == GridQubitLineTuple(sequence) largest.return_value.get_or_search.assert_not_called() minimal.return_value.get_or_search.assert_called_once_with()
def test_greedy_search_method_returns_longest(minimal, largest): q00 = GridQubit(0, 0) q10 = GridQubit(1, 0) device = _create_device([]) length = 1 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 = GreedySequenceSearchStrategy() assert method.place_line( device, length) == GridQubitLineTuple(sequence_long)[:length]
def test_get_state_histogram(): simulator = cirq.Simulator() q0 = GridQubit(0, 0) q1 = GridQubit(1, 0) circuit = cirq.Circuit() circuit.append([cirq.X(q0), cirq.X(q1)]) circuit.append([cirq.measure(q0, key='q0'), cirq.measure(q1, key='q1')]) result = simulator.run(program=circuit, repetitions=5) values_to_plot = state_histogram.get_state_histogram(result) expected_values = [0.0, 0.0, 0.0, 5.0] np.testing.assert_equal(values_to_plot, expected_values)
def test_search_converts_trace_func(anneal_minimize): q00 = GridQubit(0, 0) q01 = GridQubit(0, 1) seqs = [[q00, q01]] edges = {(q00, q01)} anneal_minimize.return_value = seqs, edges trace_func = mock.Mock() assert (AnnealSequenceSearch(_create_device( []), seed=0xF00D0002).search(trace_func=trace_func) == seqs) wrapper_func = anneal_minimize.call_args[1]['trace_func'] wrapper_func((seqs, edges), 1.0, 2.0, 3.0, True) trace_func.assert_called_once_with(seqs, 1.0, 2.0, 3.0, True)
def test_qubit_not_mutated(): qubit = GridQubit(0, 0) above(qubit) assert qubit == GridQubit(0, 0) below(qubit) assert qubit == GridQubit(0, 0) right_of(qubit) assert qubit == GridQubit(0, 0) left_of(qubit) assert qubit == GridQubit(0, 0)
def test_find_sequence_assembles_head_and_tail(): q00 = GridQubit(0, 0) q01 = GridQubit(0, 1) q02 = GridQubit(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_plot_state_histogram(): pl.switch_backend('PDF') simulator = cg.XmonSimulator() q0 = GridQubit(0, 0) q1 = GridQubit(1, 0) circuit = cirq.Circuit() circuit.append([cirq.X(q0), cirq.X(q1)]) circuit.append([cirq.measure(q0, key='q0'), cirq.measure(q1, key='q1')]) result = simulator.run(program=circuit, repetitions=5) values_plotted = visualize.plot_state_histogram(result) expected_values = [0., 0., 0., 5.] np.testing.assert_equal(values_plotted, expected_values)
def test_choose_random_edge_chooses(): q00, q11, q22 = [GridQubit(x, x) for x in range(3)] e0, e1, e2 = (q00, q11), (q11, q22), (q22, q00) search = AnnealSequenceSearch(_create_device([]), seed=0xF00D0013) assert search._choose_random_edge(set()) is None assert search._choose_random_edge({e0}) == e0 assert search._choose_random_edge({e0, e1, e2}) in [e0, e1, e2]