def pushout_from_relation(g1, g2, relation, inplace=False):
"""Find the pushout from a relation."""
left_dict = left_relation_dict(relation)
right_dict = right_relation_dict(relation)
if inplace is True:
g12 = g1
else:
g12 = copy.deepcopy(g1)
g1_g12 = id_of(g12.nodes())
g2_g12 = dict()
for node in g1.nodes():
if node in left_dict.keys():
for g2_node in left_dict[node]:
g2_g12[g2_node] = node
for node in g2.nodes():
if node not in right_dict.keys():
node_id = node
if node_id in g12.nodes():
node_id = unique_node_id(g12, node)
add_node(g12, node_id, g2.node[node])
g2_g12[node] = node_id
elif len(right_dict[node]) == 1:
node_attrs_diff = dict_sub(
g2.node[node],
g1.node[list(right_dict[node])[0]])
add_node_attrs(
g12, list(right_dict[node])[0], node_attrs_diff)
elif len(right_dict[node]) > 1:
new_name = merge_nodes(g12, right_dict[node])
for g1_node in right_dict[node]:
g1_g12[g1_node] = new_name
g2_g12[node] = new_name
node_attrs_diff = dict_sub(
g2.node[node],
g12.node[new_name])
add_node_attrs(g12, new_name, node_attrs_diff)
for u, v in g2.edges():
if (g2_g12[u], g2_g12[v]) not in g12.edges():
add_edge(g12, g2_g12[u], g2_g12[v], get_edge(g2, u, v))
else:
edge_attrs_diff = dict_sub(
g2.adj[u][v],
g12.adj[g2_g12[u]][g2_g12[v]])
add_edge_attrs(g12, g2_g12[u], g2_g12[v], edge_attrs_diff)
return (g12, g1_g12, g2_g12)
def added_edge_attrs(self):
"""Get edge attributes added by the rule.
Returns
-------
attrs : dict
Dictionary where keys are edges from `rhs`
and values are attribute dictionaries to add.
"""
attrs = dict()
for s, t in self.rhs.edges():
s_p_nodes = keys_by_value(self.p_rhs, s)
t_p_nodes = keys_by_value(self.p_rhs, t)
new_attrs = {}
for s_p_node in s_p_nodes:
for t_p_node in t_p_nodes:
if (s_p_node, t_p_node) in self.p.edges():
new_attrs = attrs_union(
new_attrs,
dict_sub(
self.rhs.edge[s][t],
self.p.edge[s_p_node][t_p_node]
)
)
return attrs
def removed_edge_attrs(self):
"""Get edge attributes removed by the rule.
Returns
-------
attrs : dict
Dictionary where keys are edges from `lhs`
and values are attribute dictionaries to remove.
"""
attrs = dict()
for s, t in self.lhs.edges():
s_p_nodes = keys_by_value(self.p_lhs, s)
t_p_nodes = keys_by_value(self.p_lhs, t)
new_attrs = {}
for s_p_node in s_p_nodes:
for t_p_node in t_p_nodes:
if (s_p_node, t_p_node) in self.p.edges():
new_attrs = attrs_union(
new_attrs,
dict_sub(
self.lhs.edge[s][t],
self.p.edge[s_p_node][t_p_node]
)
)
if len(new_attrs) > 0:
attrs[(s, t)] = new_attrs
return attrs
def pushout_from_relation(g1, g2, relation, inplace=False):
"""Find the pushout from a relation."""
left_dict = left_relation_dict(relation)
right_dict = right_relation_dict(relation)
if inplace is True:
g12 = g1
else:
g12 = copy.deepcopy(g1)
g1_g12 = id_of(g12.nodes())
g2_g12 = dict()
for node in g1.nodes():
if node in left_dict.keys():
for g2_node in left_dict[node]:
g2_g12[g2_node] = node
for node in g2.nodes():
if node not in right_dict.keys():
node_id = node
if node_id in g12.nodes():
node_id = g12.generate_new_node_id(g12, node)
g12.add_node(node_id, g2.get_node(node))
g2_g12[node] = node_id
elif len(right_dict[node]) == 1:
node_attrs_diff = dict_sub(g2.get_node(node),
g1.get_node(list(right_dict[node])[0]))
g12.add_node_attrs(list(right_dict[node])[0], node_attrs_diff)
elif len(right_dict[node]) > 1:
new_name = g12.merge_nodes(right_dict[node])
for g1_node in right_dict[node]:
g1_g12[g1_node] = new_name
g2_g12[node] = new_name
node_attrs_diff = dict_sub(g2.get_node(node),
g12.get_node(new_name))
g12.add_node_attrs(new_name, node_attrs_diff)
for u, v in g2.edges():
if (g2_g12[u], g2_g12[v]) not in g12.edges():
g12.add_edge(g2_g12[u], g2_g12[v], g2.get_edge(u, v))
else:
edge_attrs_diff = dict_sub(g2.get_edge(u, v),
g12.get_edge(g2_g12[u], g2_g12[v]))
g12.add_edge_attrs(g2_g12[u], g2_g12[v], edge_attrs_diff)
return (g12, g1_g12, g2_g12)
def pushout_from_relation(g1, g2, relation, inplace=False):
"""Find the pushout from a relation."""
left_dict = left_relation_dict(relation)
right_dict = right_relation_dict(relation)
if inplace is True:
g12 = g1
else:
g12 = copy.deepcopy(g1)
g1_g12 = id_of(g12.nodes())
g2_g12 = dict()
for node in g1.nodes():
if node in left_dict.keys():
for g2_node in left_dict[node]:
g2_g12[g2_node] = node
for node in g2.nodes():
if node not in right_dict.keys():
add_node(g12, node, g2.node[node])
g2_g12[node] = node
elif len(right_dict[node]) == 1:
node_attrs_diff = dict_sub(g2.node[node],
g1.node[list(right_dict[node])[0]])
add_node_attrs(g12, list(right_dict[node])[0], node_attrs_diff)
elif len(right_dict[node]) > 1:
new_name = merge_nodes(g12, right_dict[node])
for g1_node in right_dict[node]:
g1_g12[g1_node] = new_name
g2_g12[node] = new_name
node_attrs_diff = dict_sub(g2.node[node], g12.node[new_name])
add_node_attrs(g12, new_name, node_attrs_diff)
for u, v in g2.edges():
if (g2_g12[u], g2_g12[v]) not in g12.edges():
add_edge(g12, g2_g12[u], g2_g12[v], get_edge(g2, u, v))
else:
edge_attrs_diff = dict_sub(g2.edge[u][v],
g12.edge[g2_g12[u]][g2_g12[v]])
add_edge_attrs(g12, g2_g12[u], g2_g12[v], edge_attrs_diff)
return (g12, g1_g12, g2_g12)
def removed_node_attrs(self):
"""."""
attrs = dict()
for node in self.lhs.nodes():
p_nodes = keys_by_value(self.p_lhs, node)
new_attrs = {}
for p_node in p_nodes:
new_attrs = attrs_union(new_attrs, dict_sub(
self.lhs.node[node], self.p.node[p_node]))
if len(new_attrs) > 0:
attrs[node] = new_attrs
return attrs
def added_node_attrs(self):
"""."""
attrs = dict()
for node in self.rhs.nodes():
p_nodes = keys_by_value(self.p_rhs, node)
# if len(p_nodes) == 0:
# attrs[node] = self.rhs.node[node]
new_attrs = {}
for p_node in p_nodes:
new_attrs = attrs_union(new_attrs, dict_sub(
self.rhs.node[node], self.p.node[p_node]))
if len(new_attrs) > 0:
attrs[node] = new_attrs
return attrs
def added_edge_attrs(self):
"""."""
attrs = dict()
for s, t in self.rhs.edges():
s_p_nodes = keys_by_value(self.p_rhs, s)
t_p_nodes = keys_by_value(self.p_rhs, t)
new_attrs = {}
for s_p_node in s_p_nodes:
for t_p_node in t_p_nodes:
if (s_p_node, t_p_node) in self.p.edges():
new_attrs = attrs_union(
new_attrs,
dict_sub(
self.rhs.edge[s][t],
self.p.edge[s_p_node][t_p_node]
)
)
return attrs
def removed_node_attrs(self):
"""Get node attributes removed by the rule.
Returns
-------
attrs : dict
Dictionary where keys are nodes from `lhs`
and values are attribute dictionaries to remove.
"""
attrs = dict()
for node in self.lhs.nodes():
p_nodes = keys_by_value(self.p_lhs, node)
new_attrs = {}
for p_node in p_nodes:
new_attrs = attrs_union(new_attrs, dict_sub(
self.lhs.node[node], self.p.node[p_node]))
if len(new_attrs) > 0:
attrs[node] = new_attrs
return attrs
def removed_edge_attrs(self):
"""."""
attrs = dict()
for s, t in self.lhs.edges():
s_p_nodes = keys_by_value(self.p_lhs, s)
t_p_nodes = keys_by_value(self.p_lhs, t)
new_attrs = {}
for s_p_node in s_p_nodes:
for t_p_node in t_p_nodes:
if (s_p_node, t_p_node) in self.p.edges():
new_attrs = attrs_union(
new_attrs,
dict_sub(
self.lhs.edge[s][t],
self.p.edge[s_p_node][t_p_node]
)
)
if len(new_attrs) > 0:
attrs[(s, t)] = new_attrs
return attrs
def pushout(a, b, c, a_b, a_c, inplace=False):
"""Find the pushour of the span b <- a -> c."""
def get_classes_to_merge():
pass
check_homomorphism(a, b, a_b)
check_homomorphism(a, c, a_c)
if inplace is True:
d = b
else:
d = NXGraph()
d.add_nodes_from(b.nodes(data=True))
d.add_edges_from(b.edges(data=True))
b_d = id_of(b.nodes())
c_d = dict()
# Add/merge nodes
merged_nodes = dict()
for c_n in c.nodes():
a_keys = keys_by_value(a_c, c_n)
# Add nodes
if len(a_keys) == 0:
if c_n not in d.nodes():
new_name = c_n
else:
new_name = d.generate_new_node_id(c_n)
d.add_node(new_name, c.get_node(c_n))
c_d[c_n] = new_name
# Keep nodes
elif len(a_keys) == 1:
c_d[a_c[a_keys[0]]] = b_d[a_b[a_keys[0]]]
# Merge nodes
else:
nodes_to_merge = set()
# find the nodes that need to be merged
for k in a_keys:
nodes_to_merge.add(a_b[k])
# find if exists already some merged node to
# which the new node should be merged
groups_to_remove = set()
new_groups = set()
merge_done = False
for k in merged_nodes.keys():
if nodes_to_merge.issubset(merged_nodes[k]):
merge_done = True
else:
intersect_with_group = nodes_to_merge.intersection(
merged_nodes[k])
if len(intersect_with_group) > 0:
new_nodes_to_merge =\
nodes_to_merge.difference(merged_nodes[k])
if len(new_nodes_to_merge) > 0:
new_nodes_to_merge.add(k)
new_name = d.merge_nodes(new_nodes_to_merge)
merged_nodes[new_name] = merged_nodes[k].union(
nodes_to_merge)
groups_to_remove.add(k)
new_groups.add(new_name)
if len(groups_to_remove) > 0:
new_name = d.merge_nodes(new_groups)
merged_nodes[new_name] = set()
for g in new_groups:
merged_nodes[new_name] = merged_nodes[new_name].union(
merged_nodes[g])
for group in groups_to_remove:
del merged_nodes[group]
elif not merge_done:
if len(nodes_to_merge) > 1:
new_name = d.merge_nodes(nodes_to_merge)
merged_nodes[new_name] = nodes_to_merge
else:
new_name = list(nodes_to_merge)[0]
c_d[c_n] = new_name
for node in nodes_to_merge:
b_d[node] = new_name
for k in c_d.keys():
for vv in keys_by_value(a_c, k):
if b_d[a_b[vv]] == new_name:
c_d[k] = new_name
# Add edges
for (n1, n2) in c.edges():
if (c_d[n1], c_d[n2]) not in d.edges():
d.add_edge(c_d[n1], c_d[n2], c.get_edge(n1, n2))
# Add node attrs
for c_n in c.nodes():
a_keys = keys_by_value(a_c, c_n)
# Add attributes to the nodes which stayed invariant
if len(a_keys) == 1:
attrs_to_add = dict_sub(c.get_node(c_n), a.get_node(a_keys[0]))
d.add_node_attrs(c_d[c_n], attrs_to_add)
# Add attributes to the nodes which were merged
elif len(a_keys) > 1:
merged_attrs = {}
for k in a_keys:
merged_attrs = merge_attributes(merged_attrs, a.get_node(k))
attrs_to_add = dict_sub(c.get_node(c_n), merged_attrs)
d.add_node_attrs(c_d[c_n], attrs_to_add)
# Add edge attrs
for (n1, n2) in c.edges():
d_n1 = c_d[n1]
d_n2 = c_d[n2]
attrs_to_add = dict_sub(c.get_edge(n1, n2), d.get_edge(d_n1, d_n2))
d.add_edge_attrs(c_d[n1], c_d[n2], attrs_to_add)
return (d, b_d, c_d)
def pullback_complement(a, b, d, a_b, b_d, inplace=False):
"""Find the final pullback complement from a->b->d.
Makes changes to d inplace.
"""
check_homomorphism(a, b, a_b, total=True)
check_homomorphism(b, d, b_d, total=True)
if not is_monic(b_d):
raise InvalidHomomorphism(
"Second homomorphism is not monic, "
"cannot find final pullback complement!"
)
if inplace is True:
c = d
else:
c = copy.deepcopy(d)
a_c = dict()
c_d = id_of(c.nodes())
# Remove/clone nodes
for b_node in b.nodes():
a_keys = keys_by_value(a_b, b_node)
# Remove nodes
if len(a_keys) == 0:
remove_node(c, b_d[b_node])
del c_d[b_d[b_node]]
# Keep nodes
elif len(a_keys) == 1:
a_c[a_keys[0]] = b_d[b_node]
# Clone nodes
else:
i = 1
for k in a_keys:
if i == 1:
a_c[k] = b_d[b_node]
c_d[b_d[b_node]] = b_d[b_node]
else:
new_name = clone_node(c, b_d[b_node])
a_c[k] = new_name
c_d[new_name] = b_d[b_node]
i += 1
# Remove edges
for (b_n1, b_n2) in b.edges():
a_keys_1 = keys_by_value(a_b, b_n1)
a_keys_2 = keys_by_value(a_b, b_n2)
if len(a_keys_1) > 0 and len(a_keys_2) > 0:
for k1 in a_keys_1:
for k2 in a_keys_2:
if d.is_directed():
if (k1, k2) not in a.edges() and\
(a_c[k1], a_c[k2]) in c.edges():
remove_edge(c, a_c[k1], a_c[k2])
else:
if (k1, k2) not in a.edges() and\
(k2, k1) not in a.edges():
if (a_c[k1], a_c[k2]) in d.edges() or\
(a_c[k2], a_c[k1]) in d.edges():
remove_edge(c, a_c[k1], a_c[k2])
# Remove node attrs
for a_node in a.nodes():
attrs_to_remove = dict_sub(
b.node[a_b[a_node]],
a.node[a_node]
)
remove_node_attrs(c, a_c[a_node], attrs_to_remove)
# removed_node_attrs[a_c[a_node]] = attrs_to_remove
# Remove edge attrs
for (n1, n2) in a.edges():
attrs_to_remove = dict_sub(
get_edge(b, a_b[n1], a_b[n2]),
get_edge(a, n1, n2)
)
remove_edge_attrs(c, a_c[n1], a_c[n2], attrs_to_remove)
# removed_edge_attrs[(a_c[n1], a_c[n2])] = attrs_to_remove
return (c, a_c, c_d)
def pushout(a, b, c, a_b, a_c, inplace=False):
"""Find the pushour of the span b <- a -> c."""
check_homomorphism(a, b, a_b)
check_homomorphism(a, c, a_c)
if inplace is True:
d = b
else:
d = copy.deepcopy(b)
b_d = id_of(b.nodes())
c_d = dict()
# Add/merge nodes
for c_n in c.nodes():
a_keys = keys_by_value(a_c, c_n)
# Add nodes
if len(a_keys) == 0:
add_node(d, c_n, c.node[c_n])
c_d[c_n] = c_n
# Keep nodes
elif len(a_keys) == 1:
c_d[a_c[a_keys[0]]] = a_b[a_keys[0]]
# Merge nodes
else:
nodes_to_merge = []
for k in a_keys:
nodes_to_merge.append(a_b[k])
new_name = merge_nodes(d, nodes_to_merge)
c_d[c_n] = new_name
for node in nodes_to_merge:
b_d[node] = new_name
# Add edges
for (n1, n2) in c.edges():
if b.is_directed():
if (c_d[n1], c_d[n2]) not in d.edges():
add_edge(d, c_d[n1], c_d[n2], get_edge(c, n1, n2))
else:
if (c_d[n1], c_d[n2]) not in d.edges() and\
(c_d[n2], c_d[n1]) not in d.edges():
add_edge(d, c_d[n1], c_d[n2], get_edge(c, n1, n2))
# Add node attrs
for c_n in c.nodes():
a_keys = keys_by_value(a_c, c_n)
# Add attributes to the nodes which stayed invariant
if len(a_keys) == 1:
attrs_to_add = dict_sub(c.node[c_n], a.node[a_keys[0]])
add_node_attrs(d, c_d[c_n], attrs_to_add)
# Add attributes to the nodes which were merged
elif len(a_keys) > 1:
merged_attrs = {}
for k in a_keys:
merged_attrs = merge_attributes(merged_attrs, a.node[k])
attrs_to_add = dict_sub(c.node[c_n], merged_attrs)
add_node_attrs(d, c_d[c_n], attrs_to_add)
# Add edge attrs
for (n1, n2) in c.edges():
d_n1 = c_d[n1]
d_n2 = c_d[n2]
if d.is_directed():
attrs_to_add = dict_sub(get_edge(c, n1, n2),
get_edge(d, d_n1, d_n2))
add_edge_attrs(d, c_d[n1], c_d[n2], attrs_to_add)
else:
attrs_to_add = dict_sub(get_edge(c, n1, n2),
get_edge(d, d_n1, d_n2))
add_edge_attrs(d, c_d[n1], c_d[n2], attrs_to_add)
return (d, b_d, c_d)
def pushout(a, b, c, a_b, a_c, inplace=False):
"""Find the pushour of the span b <- a -> c."""
def get_classes_to_merge():
pass
check_homomorphism(a, b, a_b)
check_homomorphism(a, c, a_c)
if inplace is True:
d = b
else:
d = copy.deepcopy(b)
b_d = id_of(b.nodes())
c_d = dict()
# Add/merge nodes
merged_nodes = dict()
for c_n in c.nodes():
a_keys = keys_by_value(a_c, c_n)
# Add nodes
if len(a_keys) == 0:
if c_n not in d.nodes():
new_name = c_n
else:
new_name = unique_node_id(d, c_n)
add_node(d, new_name, c.node[c_n])
c_d[c_n] = new_name
# Keep nodes
elif len(a_keys) == 1:
c_d[a_c[a_keys[0]]] = a_b[a_keys[0]]
# Merge nodes
else:
nodes_to_merge = set()
# find the nodes that need to be merged
for k in a_keys:
nodes_to_merge.add(a_b[k])
# find if exists already some merged node to
# which the new node should be merged
groups_to_remove = set()
new_groups = set()
merge_done = False
for k in merged_nodes.keys():
if nodes_to_merge.issubset(merged_nodes[k]):
merge_done = True
else:
intersect_with_group = nodes_to_merge.intersection(
merged_nodes[k])
if len(intersect_with_group) > 0:
new_nodes_to_merge =\
nodes_to_merge.difference(merged_nodes[k])
if len(new_nodes_to_merge) > 0:
new_nodes_to_merge.add(k)
new_name = merge_nodes(d, new_nodes_to_merge)
merged_nodes[new_name] = merged_nodes[k].union(
nodes_to_merge)
groups_to_remove.add(k)
new_groups.add(new_name)
if len(groups_to_remove) > 0:
new_name = merge_nodes(d, new_groups)
merged_nodes[new_name] = set()
for g in new_groups:
merge_nodes[new_name] = merge_nodes[new_name].union(
merged_nodes[g])
for group in groups_to_remove:
del merged_nodes[group]
elif not merge_done:
new_name = merge_nodes(d, nodes_to_merge)
merged_nodes[new_name] = nodes_to_merge
for node in nodes_to_merge:
c_d[c_n] = new_name
b_d[node] = new_name
# Add edges
for (n1, n2) in c.edges():
if b.is_directed():
if (c_d[n1], c_d[n2]) not in d.edges():
add_edge(
d, c_d[n1], c_d[n2],
get_edge(c, n1, n2))
else:
if (c_d[n1], c_d[n2]) not in d.edges() and\
(c_d[n2], c_d[n1]) not in d.edges():
add_edge(
d, c_d[n1], c_d[n2],
get_edge(c, n1, n2)
)
# Add node attrs
for c_n in c.nodes():
a_keys = keys_by_value(a_c, c_n)
# Add attributes to the nodes which stayed invariant
if len(a_keys) == 1:
attrs_to_add = dict_sub(
c.node[c_n],
a.node[a_keys[0]]
)
add_node_attrs(d, c_d[c_n], attrs_to_add)
# Add attributes to the nodes which were merged
elif len(a_keys) > 1:
merged_attrs = {}
for k in a_keys:
merged_attrs = merge_attributes(
merged_attrs,
a.node[k]
)
attrs_to_add = dict_sub(c.node[c_n], merged_attrs)
add_node_attrs(d, c_d[c_n], attrs_to_add)
# Add edge attrs
for (n1, n2) in c.edges():
d_n1 = c_d[n1]
d_n2 = c_d[n2]
if d.is_directed():
attrs_to_add = dict_sub(
get_edge(c, n1, n2),
get_edge(d, d_n1, d_n2)
)
add_edge_attrs(
d, c_d[n1], c_d[n2],
attrs_to_add
)
else:
attrs_to_add = dict_sub(
get_edge(c, n1, n2),
get_edge(d, d_n1, d_n2)
)
add_edge_attrs(
d, c_d[n1], c_d[n2],
attrs_to_add
)
return (d, b_d, c_d)
def pullback_complement(a, b, d, a_b, b_d, inplace=False):
"""Find the final pullback complement from a->b->d.
Makes changes to d inplace.
"""
check_homomorphism(a, b, a_b, total=True)
check_homomorphism(b, d, b_d, total=True)
if not is_monic(b_d):
raise InvalidHomomorphism("Second homomorphism is not monic, "
"cannot find final pullback complement!")
if inplace is True:
c = d
else:
c = NXGraph()
c.add_nodes_from(d.nodes(data=True))
c.add_edges_from(d.edges(data=True))
a_c = dict()
c_d = id_of(c.nodes())
# Remove/clone nodes
for b_node in b.nodes():
a_keys = keys_by_value(a_b, b_node)
# Remove nodes
if len(a_keys) == 0:
c.remove_node(b_d[b_node])
del c_d[b_d[b_node]]
# Keep nodes
elif len(a_keys) == 1:
a_c[a_keys[0]] = b_d[b_node]
# Clone nodes
else:
i = 1
for k in a_keys:
if i == 1:
a_c[k] = b_d[b_node]
c_d[b_d[b_node]] = b_d[b_node]
else:
new_name = c.clone_node(b_d[b_node])
a_c[k] = new_name
c_d[new_name] = b_d[b_node]
i += 1
# Remove edges
for (b_n1, b_n2) in b.edges():
a_keys_1 = keys_by_value(a_b, b_n1)
a_keys_2 = keys_by_value(a_b, b_n2)
if len(a_keys_1) > 0 and len(a_keys_2) > 0:
for k1 in a_keys_1:
for k2 in a_keys_2:
if (k1, k2) not in a.edges() and\
(a_c[k1], a_c[k2]) in c.edges():
c.remove_edge(a_c[k1], a_c[k2])
# Remove node attrs
for a_node in a.nodes():
attrs_to_remove = dict_sub(b.get_node(a_b[a_node]), a.get_node(a_node))
c.remove_node_attrs(a_c[a_node], attrs_to_remove)
# removed_node_attrs[a_c[a_node]] = attrs_to_remove
# Remove edge attrs
for (n1, n2) in a.edges():
attrs_to_remove = dict_sub(b.get_edge(a_b[n1], a_b[n2]),
a.get_edge(n1, n2))
c.remove_edge_attrs(a_c[n1], a_c[n2], attrs_to_remove)
# removed_edge_attrs[(a_c[n1], a_c[n2])] = attrs_to_remove
return (c, a_c, c_d)
def pushout(a, b, c, a_b, a_c, inplace=False):
"""Find the pushour of the span b <- a -> c."""
check_homomorphism(a, b, a_b)
check_homomorphism(a, c, a_c)
if inplace is True:
d = b
else:
d = copy.deepcopy(b)
b_d = id_of(b.nodes())
c_d = dict()
# Add/merge nodes
for c_n in c.nodes():
a_keys = keys_by_value(a_c, c_n)
# Add nodes
if len(a_keys) == 0:
add_node(d, c_n, c.node[c_n])
c_d[c_n] = c_n
# Keep nodes
elif len(a_keys) == 1:
c_d[a_c[a_keys[0]]] = a_b[a_keys[0]]
# Merge nodes
else:
nodes_to_merge = []
for k in a_keys:
nodes_to_merge.append(a_b[k])
new_name = merge_nodes(d, nodes_to_merge)
c_d[c_n] = new_name
for node in nodes_to_merge:
b_d[node] = new_name
# Add edges
for (n1, n2) in c.edges():
if b.is_directed():
if (c_d[n1], c_d[n2]) not in d.edges():
add_edge(
d, c_d[n1], c_d[n2],
get_edge(c, n1, n2))
else:
if (c_d[n1], c_d[n2]) not in d.edges() and\
(c_d[n2], c_d[n1]) not in d.edges():
add_edge(
d, c_d[n1], c_d[n2],
get_edge(c, n1, n2)
)
# Add node attrs
for c_n in c.nodes():
a_keys = keys_by_value(a_c, c_n)
# Add attributes to the nodes which stayed invariant
if len(a_keys) == 1:
attrs_to_add = dict_sub(
c.node[c_n],
a.node[a_keys[0]]
)
add_node_attrs(d, c_d[c_n], attrs_to_add)
# Add attributes to the nodes which were merged
elif len(a_keys) > 1:
merged_attrs = {}
for k in a_keys:
merged_attrs = merge_attributes(
merged_attrs,
a.node[k]
)
attrs_to_add = dict_sub(c.node[c_n], merged_attrs)
add_node_attrs(d, c_d[c_n], attrs_to_add)
# Add edge attrs
for (n1, n2) in c.edges():
d_n1 = c_d[n1]
d_n2 = c_d[n2]
if d.is_directed():
attrs_to_add = dict_sub(
get_edge(c, n1, n2),
get_edge(d, d_n1, d_n2)
)
add_edge_attrs(
d, c_d[n1], c_d[n2],
attrs_to_add
)
else:
attrs_to_add = dict_sub(
get_edge(c, n1, n2),
get_edge(d, d_n1, d_n2)
)
add_edge_attrs(
d, c_d[n1], c_d[n2],
attrs_to_add
)
return (d, b_d, c_d)
def pushout(a, b, c, a_b, a_c, inplace=False):
"""Find the pushour of the span b <- a -> c."""
check_homomorphism(a, b, a_b)
check_homomorphism(a, c, a_c)
if inplace is True:
d = b
else:
d = copy.deepcopy(b)
b_d = id_of(b.nodes())
c_d = dict()
# Add/merge nodes
merged_nodes = dict()
for c_n in c.nodes():
a_keys = keys_by_value(a_c, c_n)
# Add nodes
if len(a_keys) == 0:
if c_n not in d.nodes():
new_name = c_n
else:
new_name = unique_node_id(d, c_n)
add_node(d, new_name, c.node[c_n])
c_d[c_n] = new_name
# Keep nodes
elif len(a_keys) == 1:
c_d[a_c[a_keys[0]]] = a_b[a_keys[0]]
# Merge nodes
else:
nodes_to_merge = set()
# find the nodes that need to be merged
for k in a_keys:
nodes_to_merge.add(a_b[k])
# find if exists already some merged node to
# which the new node should be merged
groups_to_remove = set()
new_groups = set()
merge_done = False
for k in merged_nodes.keys():
if nodes_to_merge.issubset(merged_nodes[k]):
merge_done = True
else:
intersect_with_group = nodes_to_merge.intersection(
merged_nodes[k])
if len(intersect_with_group) > 0:
new_nodes_to_merge =\
nodes_to_merge.difference(merged_nodes[k])
if len(new_nodes_to_merge) > 0:
new_nodes_to_merge.add(k)
new_name = merge_nodes(d, new_nodes_to_merge)
merged_nodes[new_name] = merged_nodes[k].union(
nodes_to_merge)
groups_to_remove.add(k)
new_groups.add(new_name)
if len(groups_to_remove) > 0:
new_name = merge_nodes(d, new_groups)
merged_nodes[new_name] = set()
for g in new_groups:
merge_nodes[new_name] = merge_nodes[new_name].union(
merged_nodes[g])
for group in groups_to_remove:
del merged_nodes[group]
elif not merge_done:
new_name = merge_nodes(d, nodes_to_merge)
merged_nodes[new_name] = nodes_to_merge
for node in nodes_to_merge:
c_d[c_n] = new_name
b_d[node] = new_name
# Add edges
for (n1, n2) in c.edges():
if b.is_directed():
if (c_d[n1], c_d[n2]) not in d.edges():
add_edge(d, c_d[n1], c_d[n2], get_edge(c, n1, n2))
else:
if (c_d[n1], c_d[n2]) not in d.edges() and\
(c_d[n2], c_d[n1]) not in d.edges():
add_edge(d, c_d[n1], c_d[n2], get_edge(c, n1, n2))
# Add node attrs
for c_n in c.nodes():
a_keys = keys_by_value(a_c, c_n)
# Add attributes to the nodes which stayed invariant
if len(a_keys) == 1:
attrs_to_add = dict_sub(c.node[c_n], a.node[a_keys[0]])
add_node_attrs(d, c_d[c_n], attrs_to_add)
# Add attributes to the nodes which were merged
elif len(a_keys) > 1:
merged_attrs = {}
for k in a_keys:
merged_attrs = merge_attributes(merged_attrs, a.node[k])
attrs_to_add = dict_sub(c.node[c_n], merged_attrs)
add_node_attrs(d, c_d[c_n], attrs_to_add)
# Add edge attrs
for (n1, n2) in c.edges():
d_n1 = c_d[n1]
d_n2 = c_d[n2]
if d.is_directed():
attrs_to_add = dict_sub(get_edge(c, n1, n2),
get_edge(d, d_n1, d_n2))
add_edge_attrs(d, c_d[n1], c_d[n2], attrs_to_add)
else:
attrs_to_add = dict_sub(get_edge(c, n1, n2),
get_edge(d, d_n1, d_n2))
add_edge_attrs(d, c_d[n1], c_d[n2], attrs_to_add)
return (d, b_d, c_d)