def test_merging(self):
g = TypedDiGraph()
g.add_node(10, "agent", {"a": 0})
g.add_node(20, "agent", {"b": 0})
g.add_node(30, "action", {"c": 0})
g.add_edges_from([(10, 30), (20, 30)])
g.set_edge(10, 30, {"x": 0})
g.set_edge(20, 30, {"y": 0})
LHS = TypedDiGraph()
LHS.add_node(1, "agent")
LHS.add_node(2, "agent")
P = TypedDiGraph()
P.add_node("a", "agent")
P.add_node("b", "agent")
RHS = TypedDiGraph()
RHS.add_node("x", "agent")
h1 = Homomorphism(P, LHS, {"a": 1, "b": 2})
h2 = Homomorphism(P, RHS, {"a": "x", "b": "x"})
rw = Rewriter(g)
instances = rw.find_matching(LHS)
RHS_instance = rw.apply_rule(instances[0], h1, h2)
def test_homomorphism(self):
new_pattern = TypedDiGraph()
new_pattern.add_node(34, "agent")
new_pattern.add_node(35, "agent")
new_pattern.add_node(36, "action")
new_pattern.add_edges_from([(34, 36), (35, 36)])
mapping = {34: 5, 35: 5, 36: 6}
h = Homomorphism(new_pattern, self.graph_, mapping)
assert_equals(h.is_monic(), False)
def test_undirected_dec_init(self):
__location__ = os.path.realpath(
os.path.join(os.getcwd(), os.path.dirname(__file__)))
g = TypedGraph()
g.add_node(1, "action")
g.add_node(2, "agent", {"u": {0, 1}})
g.add_node(3, "agent", {"u": {4}, "name": "Paul"})
g.add_node(4, "action")
g.add_node(5, "agent", {"u": {0}})
g.add_node(6, "agent", {"u": {7}})
g.add_node(7, "agent", {"u": {4}})
g.add_edges_from([(1, 2), (3, 2), (1, 5), (5, 4), (5, 6)])
g.set_edge(1, 2, {"a": {0}})
g.set_edge(2, 3, {"k": {1, 2, 3}})
rw = Rewriter(g)
LHS = TypedGraph()
LHS.add_nodes_from([(10, "action"), (20, "agent"), (30, "agent")])
LHS.node[20].attrs_ = {"u": {0}}
LHS.add_edges_from([(10, 20), (20, 30)])
LHS.set_edge(20, 30, {"k": {1, 2}})
P = TypedGraph()
P.add_node(100, "agent")
P.add_node(200, "agent", {"u": {0}})
P.add_node(300, "agent")
P.add_edges_from([(300, 100), (200, 300)])
P.set_edge(100, 300, {"k": {1, 2}})
P.set_edge(200, 300, {"k": set()})
RHS = TypedGraph()
RHS.add_node(1000, "region")
RHS.add_node(2000, "agent", {"u": {3}})
RHS.add_node(3000, "agent", {"u": {0, 2}})
RHS.add_edges_from([(1000, 3000), (2000, 3000), (3000, 3000)])
RHS.set_edge(3000, 3000, {"k": {5, 6}})
RHS.set_edge(2000, 3000, {"k": {1, 2, 10}})
RHS.set_edge(1000, 3000, {"a": {12}})
instances = rw.find_matching(LHS)
for i, instance in enumerate(instances):
plot_instance(
rw.graph_, LHS, instance,
os.path.join(__location__, "undir_dec_instance_%d.png" % i))
left_h = Homomorphism(P, LHS, {100: 20, 200: 20, 300: 30})
righ_h = Homomorphism(P, RHS, {100: 2000, 200: 3000, 300: 3000})
RHS_instance = rw.apply_rule(instances[0], left_h, righ_h)
plot_instance(rw.graph_,
RHS,
RHS_instance,
filename=os.path.join(__location__, "undir_dec_RHS.png"))
def pullback(h1, h2):
""" Given h1 : B -> D; h2 : C -> D returns A, rh1, rh2
with rh1 : A -> B; rh2 : A -> C """
if h1.target_ != h2.target_:
raise ValueError(
"Homomorphisms don't have the same codomain, can't do pullback")
if type(h1.target_) == TypedGraph:
res_graph = TypedGraph()
else:
res_graph = TypedDiGraph()
hom1 = {}
hom2 = {}
for n1 in h1.source_.nodes():
for n2 in h2.source_.nodes():
if not h1.mapping_[n1] in res_graph.nodes():
if h1.mapping_[n1] == h2.mapping_[n2]:
res_graph.add_node(
h1.mapping_[n1],
h1.target_.node[h1.mapping_[n1]].type_,
merge_attributes(h1.source_.node[n1].attrs_,
h2.source_.node[n2].attrs_,
'intersection'))
hom1[h1.mapping_[n1]] = n1
hom2[h2.mapping_[n2]] = n2
for n1 in res_graph.nodes():
for n2 in res_graph.nodes():
if res_graph.is_directed():
if (hom1[n1], hom1[n2]) in h1.source_.edges():
if (hom2[n1], hom2[n2]) in h2.source_.edges():
res_graph.add_edge(n1, n2)
res_graph.set_edge(
n1, n2,
merge_attributes(
h1.source_.get_edge(hom1[n1], hom1[n2]),
h2.source_.get_edge(hom2[n1], hom2[n2]),
'intersection'))
else:
if (hom1[n1], hom1[n2]) in h1.source_.edges() or (
hom1[n2], hom1[n1]) in h1.source_.edges():
if (hom2[n1], hom2[n2]) in h2.source_.edges() or (
hom2[n2], hom2[n1]) in h2.source_.edges():
res_graph.add_edge(n1, n2)
res_graph.set_edge(
n1, n2,
merge_attributes(
h1.source_.get_edge(hom1[n1], hom1[n2]),
h2.source_.get_edge(hom2[n1], hom2[n2]),
'intersection'))
res_h1 = Homomorphism(res_graph, h1.source_, hom1)
res_h2 = Homomorphism(res_graph, h2.source_, hom2)
return res_graph, res_h1, res_h2
def test_homomorphism(self):
new_pattern = TypedDiGraph()
new_pattern.add_node(34, "agent")
new_pattern.add_node(35, "agent")
new_pattern.add_node(36, "action")
new_pattern.add_edges_from([(34, 36), (35, 36)])
mapping = {34: 5,
35: 5,
36: 6}
h = Homomorphism(new_pattern, self.graph_, mapping)
assert_equals(h.is_monic(), False)
def test_cloning_cases(self):
g = TypedDiGraph()
g.add_node(10, "agent", {"a": 0})
g.add_node(20, "agent", {"b": 0})
g.add_node(30, "action", {"c": 0})
g.add_edges_from([(10, 30), (20, 30)])
g.set_edge(10, 30, {"x": 0})
g.set_edge(20, 30, {"y": 0})
LHS = TypedDiGraph()
LHS.add_node(1, "agent")
rw = Rewriter(g)
instances = rw.find_matching(LHS)
# simple clone
P1 = TypedDiGraph()
P1.add_node("a", "agent")
P1.add_node("b", "agent")
RHS1 = TypedDiGraph()
RHS1.add_node("x", "agent")
RHS1.add_node("y", "agent")
h1 = Homomorphism(P1, LHS, {"a": 1, "b": 1})
h2 = Homomorphism(P1, RHS1, {"a": "x", "b": "y"})
RHS_instance = rw.apply_rule(instances[0], h1, h2)
# clone merge on the same nodes
RHS2 = TypedGraph()
RHS2.add_node("x", "agent")
h2 = Homomorphism(P1, RHS2, {"a": "x", "b": "x"})
RHS_instance = rw.apply_rule(instances[0], h1, h2)
# clone and merge one with other node
LHS.add_node(2, "agent")
# update matching
instances = rw.find_matching(LHS)
P3 = TypedDiGraph()
P3.add_node("a", "agent")
P3.add_node("b", "agent")
P3.add_node("c", "agent")
RHS3 = TypedDiGraph()
RHS3.add_node("x", "agent")
RHS3.add_node("y", "agent")
h1 = Homomorphism(P3, LHS, {"a": 1, "b": 1, "c": 2})
h2 = Homomorphism(P3, RHS3, {"a": "x", "b": "y", "c": "y"})
RHS_instance = rw.apply_rule(instances[0], h1, h2)
def final_PBC(h1, h2):
if h1.target_ != h2.source_:
raise ValueError(
"Codomain of homomorphism 1 and domain of homomorphism 2 " +
"don't match, can't do pullback complement")
if not h2.is_monic():
raise ValueError(
"Second homomorphism is not monic, cannot find final pullback complement"
)
if type(h1.target_) == TypedGraph:
res_graph = TypedGraph()
else:
res_graph = TypedDiGraph()
hom1 = {}
hom2 = {}
for node in h2.target_.nodes():
B_node = keys_by_value(h2.mapping_, node)
if len(B_node) > 0:
mapped_A_nodes = keys_by_value(h1.mapping_, B_node[0])
print(mapped_A_nodes)
for A_node in mapped_A_nodes:
res_graph.add_node(
str(A_node) + "_" + str(node),
h2.target_.node[h2.mapping_[h1.mapping_[A_node]]].type_,
merge_attributes(
h1.source_.node[A_node].attrs_, h2.target_.node[
h2.mapping_[h1.mapping_[A_node]]].attrs_,
"intersection"))
hom1[A_node] = str(A_node) + "_" + str(node)
hom2[str(A_node) + "_" +
str(node)] = h2.mapping_[h1.mapping_[A_node]]
else:
res_graph.add_node(
str(node) + "_", h2.target_.node[node].type_,
h2.target_.node[node].attrs_)
hom2[str(node) + "_"] = node
for s, t in h2.target_.edges():
B_s = keys_by_value(h2.mapping_, s)
B_t = keys_by_value(h2.mapping_, t)
if len(B_s) > 0 and len(B_t) > 0:
mapped_A_ss = keys_by_value(h1.mapping_, B_s[0])
mapped_A_ts = keys_by_value(h1.mapping_, B_t[0])
for A_s in mapped_A_ss:
for A_t in mapped_A_ts:
if res_graph.is_directed():
if hom1[A_s] == hom1[A_t] and (
A_s, A_t) not in h1.source_.edges():
res_graph.add_edge(
hom1[A_s], hom1[A_t],
h2.target_.get_edge(
h2.mapping_[h1.mapping_[A_s]],
h2.mapping_[h1.mapping_[A_t]]))
else:
res_graph.add_edge(
hom1[A_s], hom1[A_t],
merge_attributes(
h1.source_.get_edge(A_s, A_t),
h2.target_.get_edge(
h2.mapping_[h1.mapping_[A_s]],
h2.mapping_[h1.mapping_[A_t]]),
"intersection"))
else:
if hom1[A_s] == hom1[A_t] and (
A_s, A_t) not in h1.source_.edges() and (
A_t, A_s) not in h1.source_.edges():
res_graph.add_edge(
hom1[A_s], hom1[A_t],
h2.target_.get_edge(
h2.mapping_[h1.mapping_[A_s]],
h2.mapping_[h1.mapping_[A_t]]))
pass
else:
res_graph.add_edge(
hom1[A_s], hom1[A_t],
merge_attributes(
h1.source_.get_edge(A_s, A_t),
h2.target_.get_edge(
h2.mapping_[h1.mapping_[A_s]],
h2.mapping_[h1.mapping_[A_t]]),
"intersection"))
else:
if len(B_s) == 0:
sources_to_add = [str(s) + "_"]
else:
mapped_A_ss = keys_by_value(h1.mapping_, B_s[0])
sources_to_add = [hom1[A_s] for A_s in mapped_A_ss]
if len(B_t) == 0:
targets_to_add = [str(t) + "_"]
else:
mapped_A_ts = keys_by_value(h1.mapping_, B_t[0])
targets_to_add = [hom1[A_t] for A_t in mapped_A_ts]
for new_s in sources_to_add:
for new_t in targets_to_add:
res_graph.add_edge(new_s, new_t, h2.target_.edge[s][t])
res_h1 = Homomorphism(h1.source_, res_graph, hom1)
res_h2 = Homomorphism(res_graph, h2.target_, hom2)
return (res_graph, res_h1, res_h2)
def pushout(h1, h2):
if h1.source_ != h2.source_:
raise ValueError(
"Domain of homomorphism 1 and domain of homomorphism 2 " +
"don't match, can't do pushout")
hom1 = {}
hom2 = {}
if type(h1.target_) == TypedGraph:
res_graph = TypedGraph()
else:
res_graph = TypedDiGraph()
for node in h1.source_.nodes():
res_graph.add_node(
str(h1.mapping_[node]) + "_" + str(h2.mapping_[node]),
h1.source_.node[node].type_,
merge_attributes(h1.target_.node[h1.mapping_[node]].attrs_,
h2.target_.node[h2.mapping_[node]].attrs_,
"union"))
hom1[h1.mapping_[node]] =\
str(h1.mapping_[node]) + "_" + str(h2.mapping_[node])
hom2[h2.mapping_[node]] =\
str(h1.mapping_[node]) + "_" + str(h2.mapping_[node])
for s, t in h1.source_.edges():
res_graph.add_edge(
str(h1.mapping_[s]) + "_" + str(h2.mapping_[s]),
str(h1.mapping_[t]) + "_" + str(h2.mapping_[t]),
merge_attributes(
h1.target_.get_edge(h1.mapping_[s], h1.mapping_[t]),
h2.target_.get_edge(h2.mapping_[s], h2.mapping_[t]), "union"))
for node in h1.target_.nodes():
if node not in h1.mapping_.values():
res_graph.add_node(
str(node) + "_", h1.target_.node[node].type_,
h1.target_.node[node].attrs_)
hom1[node] = str(node) + "_"
for node in h2.target_.nodes():
if node not in h2.mapping_.values():
res_graph.add_node(
str(node) + "_", h2.target_.node[node].type_,
h2.target_.node[node].attrs_)
hom2[node] = str(node) + "_"
for s, t in h1.target_.edges():
if s not in h1.mapping_.values() or t not in h1.mapping_.values():
res_graph.add_edge(hom1[s], hom1[t], h1.target_.get_edge(s, t))
if res_graph.is_directed():
if (hom1[s], hom1[t]) not in res_graph.edges():
res_graph.add_edge(hom1[s], hom1[t], h1.target_.get_edge(s, t))
else:
if (hom1[s], hom1[t]) not in res_graph.edges() and (
hom1[t], hom1[s]) not in res_graph.edges():
res_graph.add_edge(hom1[s], hom1[t], h1.target_.get_edge(s, t))
for s, t in h2.target_.edges():
if s not in h2.mapping_.values() or t not in h2.mapping_.values():
res_graph.add_edge(hom2[s], hom2[t], h2.target_.get_edge(s, t))
if res_graph.is_directed():
if (hom2[s], hom2[t]) not in res_graph.edges():
res_graph.add_edge(hom2[s], hom2[t], h2.target_.get_edge(s, t))
else:
if (hom2[s], hom2[t]) not in res_graph.edges() and (
hom2[t], hom2[s]) not in res_graph.edges():
res_graph.add_edge(hom2[s], hom2[t], h2.target_.get_edge(s, t))
res_h1 = Homomorphism(h1.target_, res_graph, hom1)
res_h2 = Homomorphism(h2.target_, res_graph, hom2)
return (res_graph, res_h1, res_h2)
def test_homomorphism_attributes_mismatch(self):
mapping = {1: 1, 2: 2, 3: 4, 4: 3, 5: 5, 6: 6, 7: 7}
self.LHS_.node[1].attrs_.update({'new_attr': 0})
Homomorphism(self.LHS_, self.graph_, mapping)
def test_homomorphism_type_mismatch(self):
mapping = {1: 1, 2: 2, 3: 4, 4: 3, 5: 5, 6: 6, 7: 7}
cast_node(self.LHS_, 1, 'other_type')
Homomorphism(self.LHS_, self.graph_, mapping)
def test_homomorphism_not_covered(self):
mapping = {1: 1, 2: 2, 3: 4, 4: 3, 5: 5, 6: 6}
Homomorphism(self.LHS_, self.graph_, mapping)
def test_homorphism_init(self):
# Test homomorphisms functionality
mapping = {1: 1, 2: 2, 3: 4, 4: 3, 5: 5, 6: 6, 7: 7}
Homomorphism(self.LHS_, self.graph_, mapping)
def test_homomorphism_edge_attributes_mismatch(self):
mapping = {1: 1, 2: 2, 3: 4, 4: 3, 5: 5, 6: 6, 7: 7}
self.LHS_.edge[5][6].update({'new_attr': 0})
Homomorphism(self.LHS_, self.graph_, mapping)
def test_homomorphism_connectivity_fails(self):
mapping = {1: 1, 2: 2, 3: 4, 4: 3, 5: 5, 6: 6, 7: 7}
remove_edge(self.graph_, 4, 5)
Homomorphism(self.LHS_, self.graph_, mapping)
def generate_rule(self, LHS, commands):
"""Cast sequence of commands to homomorphisms."""
command_strings = [c for c in commands.splitlines() if len(c) > 0]
actions = []
for command in command_strings:
try:
parsed = parser.parseString(command).asDict()
actions.append(parsed)
except:
raise ValueError("Cannot parse command '%s'" % command)
P = LHS.copy()
RHS = LHS.copy()
pl_mapping = dict(zip(LHS.nodes(), LHS.nodes()))
pr_mapping = dict(zip(LHS.nodes(), LHS.nodes()))
# We modify P, RHS and respective mapping
# in the course of command parsing
for action in actions:
if action["keyword"] == "clone":
node_name = None
if "node_name" in action.keys():
node_name = action["node_name"]
cloned_node = clone_node(P, action["node"], node_name)
pl_mapping[action["node"]] = action["node"]
pl_mapping.update({cloned_node: action["node"]})
clone_node(RHS, action["node"], node_name)
elif action["keyword"] == "merge":
method = None
node_name = None
edges_method = None
if "method" in action.keys():
method = action["method"]
if "node_name" in action.keys():
node_name = action["node_name"]
if "edges_method" in action.keys():
edges_method = action["edges_method"]
merged_node = merge_nodes(
RHS,
action["nodes"],
method,
node_name,
edges_method)
for node in action["nodes"]:
pr_mapping.update({node: merged_node})
elif action["keyword"] == "add_node":
name = None
node_type = None
attrs = {}
if "node" in action.keys():
name = action["node"]
if "type" in action.keys():
node_type = action["type"]
if "attrubutes" in action.keys():
attrs = action["attrubutes"]
add_node(RHS, node_type, name, attrs)
elif action["keyword"] == "delete_node":
remove_node(P, action["node"])
del pl_mapping[action["node"]]
del pr_mapping[action["node"]]
remove_node(RHS, action["node"])
elif action["keyword"] == "add_edge":
attrs = {}
if "attrubutes" in action.keys():
attrs = action["attrubutes"]
add_edge(
RHS,
action["node_1"],
action["node_2"],
attrs)
elif action["keyword"] == "delete_edge":
remove_edge(
P,
action["node_1"],
action["node_2"])
remove_edge(
RHS,
action["node_1"],
action["node_2"])
elif action["keyword"] == "add_node_attrs":
add_node_attrs(
RHS,
action["node"],
action["attributes"])
elif action["keyword"] == "add_edge_attrs":
add_edge_attrs(
RHS,
action["node_1"],
action["node_2"],
action["attributes"])
elif action["keyword"] == "delete_node_attrs":
remove_node_attrs(
P,
action["node"],
action["attributes"])
remove_node_attrs(
RHS,
action["node"],
action["attributes"])
elif action["keyword"] == "delete_edge_attrs":
remove_edge_attrs(
P,
action["node_1"],
action["node_2"],
action["attributes"])
remove_edge_attrs(
RHS,
action["node_1"],
action["node_2"],
action["attributes"])
elif action["keyword"] == "update_node_attrs":
remove_node_attrs(
P,
action["node"],
P.node[action["node"]].attrs_)
update_node_attrs(
RHS,
action["node"],
action["attributes"])
elif action["keyword"] == "update_edge_attrs":
remove_edge_attrs(
P,
action["node_1"],
action["node_2"],
P.edge[action["node_1"]][action["node_2"]])
update_edge_attrs(
RHS,
action["node_1"],
action["node_2"],
action["attributes"])
else:
raise ValueError("Unknown command")
h_p_lhs = Homomorphism(P, LHS, pl_mapping)
h_p_rhs = Homomorphism(P, RHS, pr_mapping)
return (h_p_lhs, h_p_rhs)