def test_numpy_directed_no_edges(self):
graph = retworkx.PyDiGraph()
graph.add_nodes_from(list(range(4)))
dist = retworkx.digraph_floyd_warshall_numpy(graph, lambda x: x)
expected = numpy.full((4, 4), numpy.inf)
numpy.fill_diagonal(expected, 0)
self.assertTrue(numpy.array_equal(dist, expected))
def test_floyd_warshall_numpy_digraph_cycle(self):
graph = retworkx.PyDiGraph()
graph.add_nodes_from(list(range(7)))
graph.add_edges_from_no_data([(0, 1), (0, 6), (1, 2), (2, 3), (3, 4),
(4, 5), (5, 6)])
dist = retworkx.digraph_floyd_warshall_numpy(graph, lambda x: 1)
self.assertEqual(dist[0, 3], 3)
self.assertEqual(dist[0, 4], 4)
def _initialize_backend_prop(self):
"""Extract readout and CNOT errors and compute swap costs."""
backend_prop = self.backend_prop
edge_list = []
for ginfo in backend_prop.gates:
if ginfo.gate == 'cx':
for item in ginfo.parameters:
if item.name == 'gate_error':
g_reliab = 1.0 - item.value
break
g_reliab = 1.0
swap_reliab = pow(g_reliab, 3)
# convert swap reliability to edge weight
# for the Floyd-Warshall shortest weighted paths algorithm
swap_cost = -math.log(
swap_reliab) if swap_reliab != 0 else math.inf
edge_list.append((ginfo.qubits[0], ginfo.qubits[1], swap_cost))
edge_list.append((ginfo.qubits[1], ginfo.qubits[0], swap_cost))
self.cx_reliability[(ginfo.qubits[0],
ginfo.qubits[1])] = g_reliab
self.gate_list.append((ginfo.qubits[0], ginfo.qubits[1]))
self.swap_graph.extend_from_weighted_edge_list(edge_list)
idx = 0
for q in backend_prop.qubits:
for nduv in q:
if nduv.name == 'readout_error':
self.readout_reliability[idx] = 1.0 - nduv.value
self.available_hw_qubits.append(idx)
idx += 1
for edge in self.cx_reliability:
self.gate_reliability[edge] = self.cx_reliability[edge] * \
self.readout_reliability[edge[0]] * \
self.readout_reliability[edge[1]]
swap_reliabs_ro = rx.digraph_floyd_warshall_numpy(
self.swap_graph, lambda weight: weight)
for i in range(swap_reliabs_ro.shape[0]):
self.swap_reliabs[i] = {}
for j in range(swap_reliabs_ro.shape[1]):
if (i, j) in self.cx_reliability:
self.swap_reliabs[i][j] = self.cx_reliability[(i, j)]
elif (j, i) in self.cx_reliability:
self.swap_reliabs[i][j] = self.cx_reliability[(j, i)]
else:
best_reliab = 0.0
# TODO: Replace with neighbors_directed() after
# https://github.com/Qiskit/retworkx/pull/147 is released
for n in self.swap_graph.adj_direction(j, False):
if (n, j) in self.cx_reliability:
reliab = math.exp(-swap_reliabs_ro[i][n]
) * self.cx_reliability[(n, j)]
else:
reliab = math.exp(-swap_reliabs_ro[i][n]
) * self.cx_reliability[(j, n)]
if reliab > best_reliab:
best_reliab = reliab
self.swap_reliabs[i][j] = best_reliab
def test_floyd_warshall_numpy_digraph_cycle_with_removals(self):
graph = retworkx.PyDiGraph()
graph.add_nodes_from(list(range(8)))
graph.remove_node(0)
graph.add_edges_from_no_data([(1, 2), (1, 7), (2, 3), (3, 4), (4, 5),
(5, 6), (6, 7)])
dist = retworkx.digraph_floyd_warshall_numpy(graph, lambda x: 1)
self.assertEqual(dist[0, 3], 3)
self.assertEqual(dist[0, 4], 4)
def test_floyd_warshall_numpy_digraph_three_edges(self):
graph = retworkx.PyDiGraph()
graph.add_nodes_from(list(range(6)))
weights = [2, 12, 1, 5, 1]
graph.add_edges_from([(i, i + 1, weights[i]) for i in range(5)])
graph.add_edge(5, 0, 10)
dist = retworkx.digraph_floyd_warshall_numpy(graph, lambda x: x)
self.assertEqual(dist[0, 3], 15)
self.assertEqual(dist[3, 0], 16)
def test_floyd_warshall_numpy_digraph_cycle_default_weight(self):
graph = retworkx.PyDiGraph()
graph.add_nodes_from(list(range(8)))
graph.remove_node(0)
graph.add_edges_from_no_data([(1, 2), (1, 7), (2, 3), (3, 4), (4, 5),
(5, 6), (6, 7)])
dist = retworkx.digraph_floyd_warshall_numpy(graph, default_weight=2)
self.assertEqual(dist[0, 3], 6)
self.assertEqual(dist[0, 4], 8)
def test_floyd_warshall_numpy(self):
res = retworkx.floyd_warshall_numpy(self.graph)
self.assertIsInstance(res, numpy.ndarray)
if self.class_type == "PyGraph":
expected_res = retworkx.graph_floyd_warshall_numpy(self.graph)
else:
expected_res = retworkx.digraph_floyd_warshall_numpy(self.graph)
self.assertTrue(numpy.array_equal(expected_res, res))
def test_weighted_numpy_directed_negative_cycle(self):
graph = retworkx.PyDiGraph()
graph.add_nodes_from(list(range(4)))
graph.add_edges_from([
(0, 1, 1),
(1, 2, -1),
(2, 3, -1),
(3, 0, -1),
])
dist = retworkx.digraph_floyd_warshall_numpy(graph, lambda x: x)
self.assertTrue(numpy.all(numpy.diag(dist) < 0))
def test_weighted_numpy_directed_negative_cycle(self):
graph = retworkx.PyDiGraph()
graph.add_nodes_from(list(range(4)))
graph.add_edges_from([
(0, 1, 1),
(1, 2, -1),
(2, 3, -1),
(3, 0, -1),
])
dist = retworkx.digraph_floyd_warshall_numpy(graph, lambda x: x)
expected = numpy.array([[-2, -1, -2, -3], [-3, -2, -3, -4],
[-2, -1, -2, -3], [-3, -2, -3, -4]],
dtype=numpy.float64)
self.assertTrue(numpy.array_equal(dist, expected))
def test_weighted_numpy_digraph_two_edges(self):
graph = retworkx.PyDiGraph()
graph.add_nodes_from(list(range(8)))
graph.add_edges_from([
(0, 1, 2),
(1, 2, 2),
(2, 3, 1),
(3, 4, 1),
(4, 5, 1),
(5, 6, 1),
(6, 7, 1),
(7, 0, 1),
])
dist = retworkx.digraph_floyd_warshall_numpy(graph, lambda x: x)
self.assertEqual(dist[0, 2], 4)
self.assertEqual(dist[2, 0], 6)
def test_directed_floyd_warshall_numpy_cycle_as_undirected(self):
graph = retworkx.PyDiGraph()
graph.add_nodes_from(list(range(7)))
graph.add_edges_from_no_data([(0, 1), (0, 6), (1, 2), (2, 3), (3, 4),
(4, 5), (5, 6)])
dist = retworkx.digraph_floyd_warshall_numpy(graph,
lambda x: 1,
as_undirected=True)
expected = numpy.array([[0., 1., 2., 3., 3., 2., 1.],
[1., 0., 1., 2., 3., 3., 2.],
[2., 1., 0., 1., 2., 3., 3.],
[3., 2., 1., 0., 1., 2., 3.],
[3., 3., 2., 1., 0., 1., 2.],
[2., 3., 3., 2., 1., 0., 1.],
[1., 2., 3., 3., 2., 1., 0.]])
self.assertTrue(numpy.array_equal(dist, expected))
