def _pegasus_fragment_helper(m=None, target_graph=None):
# This is a function that takes m or a target_graph and produces a
# `processor` object for the corresponding Pegasus graph, and a function
# that translates embeddings produced by that object back to the original
# pegasus graph. Consumed by `find_clique_embedding` and
# `find_biclique_embedding`.
# Organize parameter values
if target_graph is None:
if m is None:
raise TypeError("m and target_graph cannot both be None.")
target_graph = pegasus_graph(m)
m = target_graph.graph['rows'] # We only support square Pegasus graphs
# Deal with differences in ints vs coordinate target_graphs
if target_graph.graph['labels'] == 'nice':
back_converter = pegasus_coordinates.pegasus_to_nice
back_translate = lambda embedding: {
key: [back_converter(p) for p in chain]
for key, chain in embedding.items()
}
elif target_graph.graph['labels'] == 'int':
# Convert nodes in terms of Pegasus coordinates
coord_converter = pegasus_coordinates(m)
# A function to convert our final coordinate embedding to an ints embedding
back_translate = lambda embedding: {
key: list(coord_converter.iter_pegasus_to_linear(chain))
for key, chain in embedding.items()
}
else:
back_translate = lambda embedding: embedding
# collect edges of the graph produced by splitting each Pegasus qubit into six pieces
fragment_edges = list(fragmented_edges(target_graph))
# Find clique embedding in K2,2 Chimera graph
embedding_processor = processor(fragment_edges,
M=m * 6,
N=m * 6,
L=2,
linear=False)
# Convert chimera fragment embedding in terms of Pegasus coordinates
defragment_tuple = get_tuple_defragmentation_fn(target_graph)
def embedding_to_pegasus(nodes, emb):
emb = map(defragment_tuple, emb)
emb = dict(zip(nodes, emb))
emb = back_translate(emb)
return emb
return embedding_processor, embedding_to_pegasus
def test_nice_coordinates(self):
p = pegasus_graph(3, nice_coordinates=True)
c = chimera_graph(24, coordinates=True)
num_edges = 0
for u, v in fragmented_edges(p):
self.assertTrue(c.has_edge(u, v))
num_edges += 1
#This is a weird edgecount: each node produces 5 extra edges for the internal connections
#between fragments corresponding to a pegasus qubit. But then we need to delete the odd
#couplers, which aren't included in the chimera graph -- odd couplers make a perfect
#matching, so thats 1/2 an edge per node.
self.assertEqual(p.number_of_edges() + 9 * p.number_of_nodes()//2, num_edges)
def find_clique_embedding(k, m=None, target_graph=None):
"""Find an embedding for a clique in a Pegasus graph.
Given a clique (fully connected graph) and target Pegasus graph, attempts
to find an embedding by transforming the Pegasus graph into a :math:`K_{2,2}`
Chimera graph and then applying a Chimera clique-finding algorithm. Results
are converted back to Pegasus coordinates.
Args:
k (int/iterable/:obj:`networkx.Graph`): A complete graph to embed,
formatted as a number of nodes, node labels, or a NetworkX graph.
m (int): Number of tiles in a row of a square Pegasus graph. Required to
generate an m-by-m Pegasus graph when `target_graph` is None.
target_graph (:obj:`networkx.Graph`): A Pegasus graph. Required when `m`
is None.
Returns:
dict: An embedding as a dict, where keys represent the clique's nodes and
values, formatted as lists, represent chains of pegasus coordinates.
Examples:
This example finds an embedding for a :math:`K_3` complete graph in a
2-by-2 Pegaus graph.
>>> from dwave.embedding.pegasus import find_clique_embedding
...
>>> print(find_clique_embedding(3, 2)) # doctest: +SKIP
{0: [10, 34], 1: [35, 11], 2: [32, 12]}
"""
# Organize parameter values
if target_graph is None:
if m is None:
raise TypeError("m and target_graph cannot both be None.")
target_graph = pegasus_graph(m)
m = target_graph.graph['rows'] # We only support square Pegasus graphs
_, nodes = k
# Deal with differences in ints vs coordinate target_graphs
if target_graph.graph['labels'] == 'nice':
back_converter = pegasus_coordinates.pegasus_to_nice
back_translate = lambda embedding: {
key: [back_converter(p) for p in chain]
for key, chain in embedding.items()
}
elif target_graph.graph['labels'] == 'int':
# Convert nodes in terms of Pegasus coordinates
coord_converter = pegasus_coordinates(m)
# A function to convert our final coordinate embedding to an ints embedding
back_translate = lambda embedding: {
key: list(coord_converter.iter_pegasus_to_linear(chain))
for key, chain in embedding.items()
}
else:
back_translate = lambda embedding: embedding
# collect edges of the graph produced by splitting each Pegasus qubit into six pieces
fragment_edges = list(fragmented_edges(target_graph))
# Find clique embedding in K2,2 Chimera graph
embedding_processor = processor(fragment_edges,
M=m * 6,
N=m * 6,
L=2,
linear=False)
chimera_clique_embedding = embedding_processor.tightestNativeClique(
len(nodes))
# Convert chimera fragment embedding in terms of Pegasus coordinates
defragment_tuple = get_tuple_defragmentation_fn(target_graph)
pegasus_clique_embedding = map(defragment_tuple, chimera_clique_embedding)
pegasus_clique_embedding = dict(zip(nodes, pegasus_clique_embedding))
pegasus_clique_embedding = back_translate(pegasus_clique_embedding)
if len(pegasus_clique_embedding) != len(nodes):
raise ValueError("No clique embedding found")
return pegasus_clique_embedding