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]
