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_two_qubits_apart():
q00 = GridQubit(0, 0)
q11 = GridQubit(1, 1)
assert chip_as_adjacency_list(_create_device([q00, q11])) == {
q00: [],
q11: []
}
def _verify_valid_state(qubits: List[GridQubit], state: _STATE):
seqs, edges = state
search = AnnealSequenceSearch(_create_device(qubits), seed=0xF00D0014)
c_adj = chip_as_adjacency_list(_create_device(qubits))
# Check if every edge is normalized
for e in edges:
assert search._normalize_edge(e) == e
# Check if every edge is valid
for n0, n1 in edges:
assert n0 in c_adj[n1]
# Check if every edge is present
for n0 in c_adj:
for n1 in c_adj[n0]:
assert (n0, n1) in edges or (n1, n0) in edges
assert (n0, n1) in edges or (n1, n0) in edges
c_set = set(qubits)
# Check if every node in the sequences appears exactly once
for seq in seqs:
for n in seq:
c_set.remove(n)
# Check that no node is missing
assert not c_set
def test_force_edge_active_move_calls_force_edge_active():
q00 = GridQubit(0, 0)
q01 = GridQubit(0, 1)
q10 = GridQubit(1, 0)
q11 = GridQubit(1, 1)
q02 = GridQubit(0, 2)
q12 = GridQubit(1, 2)
device = _create_device([q00, q01, q10, q11, q02, q12])
search = AnnealSequenceSearch(device, seed=0xF00D0008)
with mock.patch.object(search, '_force_edge_active') as force_edge_active:
solution = search._create_initial_solution()
search._force_edge_active_move(solution)
force_edge_active.assert_called_once_with(mock.ANY, mock.ANY, mock.ANY)
_, args, _ = force_edge_active.mock_calls[0]
seqs, edge, _ = args
# Verify that edge is not active edge, on some sequence.
for seq in seqs:
for i in range(1, len(seq)):
assert not (seq[i - 1] == edge[0] and seq[i] == edge[1])
assert not (seq[i - 1] == edge[1] and seq[i] == edge[0])
# Verify that edge is a valid edge
assert edge[0] in chip_as_adjacency_list(device)[edge[1]]
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_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 __init__(self, device: 'cirq.google.XmonDevice', seed=None) -> None:
"""Greedy sequence search constructor.
Args:
device: Chip description.
seed: Optional seed value for random number generator.
"""
self._c = device.qubits
self._c_adj = chip_as_adjacency_list(device)
self._rand = np.random.RandomState(seed)
def __init__(self, device: 'cirq.google.XmonDevice',
start: GridQubit) -> None:
"""Greedy sequence search constructor.
Args:
device: Chip description.
start: Starting qubit.
Raises:
ValueError: When start qubit is not part of a chip.
"""
if start not in device.qubits:
raise ValueError('Starting qubit must be a qubit on the chip')
self._c = device.qubits
self._c_adj = chip_as_adjacency_list(device)
self._start = start
self._sequence = None # type: Optional[List[GridQubit]]
def test_single_qubit():
q00 = GridQubit(0, 0)
assert chip_as_adjacency_list(_create_device([q00])) == {q00: []}
def test_empty():
assert chip_as_adjacency_list(_create_device([])) == {}
