def test_edge_difference(self): states1 = self.state_graph1() states2 = self.state_graph2() formulas = self.formula_graph() self.assertEqual(Graph({node: frozenset() for node in states1}), states1.edge_difference(states1)) self.assertEqual(Graph({node: frozenset() for node in formulas}), formulas.edge_difference(formulas)) self.assertEqual(states1.edge_difference(formulas), states1) self.assertEqual(formulas.edge_difference(states1), formulas) s1 = domaintuple(state="s1") s2 = domaintuple(state="s2") s3 = domaintuple(state="s3") stay = domaintuple(act="stay") run = domaintuple(act="run") self.assertEqual( states1.edge_difference(states2), Graph({ s1: frozenset({ (run, s2), }), s2: frozenset({(stay, s2)}) })) self.assertEqual( states2.edge_difference(states1), Graph({ s1: frozenset({(run, s3)}), s3: frozenset({(run, s1), (stay, s3)}) }))
def test_union(self): states1 = self.state_graph1() states2 = self.state_graph2() formulas = self.formula_graph() self.assertEqual(states1, states1.union(states1)) self.assertEqual(formulas, formulas.union(formulas)) s1f = {} for state in states1.nodes: s1f[state] = states1[state] for formula in formulas.nodes: s1f[formula] = formulas[formula] self.assertEqual(states1.union(formulas), Graph(s1f)) s1 = domaintuple(state="s1") s2 = domaintuple(state="s2") s3 = domaintuple(state="s3") stay = domaintuple(act="stay") run = domaintuple(act="run") self.assertEqual( states1.union(states2), Graph({ s1: frozenset({(stay, s1), (run, s2), (run, s3)}), s2: frozenset({(stay, s2)}), s3: frozenset({(run, s1), (stay, s3)}) }))
def state_graph1(self): s1 = domaintuple(state="s1") s2 = domaintuple(state="s2") stay = domaintuple(act="stay") run = domaintuple(act="run") return Graph({ s1: frozenset({(stay, s1), (run, s2)}), s2: frozenset({(stay, s2)}) })
def state_graph2(self): s1 = domaintuple(state="s1") s3 = domaintuple(state="s3") stay = domaintuple(act="stay") run = domaintuple(act="run") return Graph({ s1: frozenset({(stay, s1), (run, s3)}), s3: frozenset({(stay, s3), (run, s1)}) })
def formula_graph(self): pq = domaintuple(formula="p & q") p = domaintuple(formula="p") q = domaintuple(formula="q") empty = domaintuple() return Graph({ pq: frozenset({(empty, p), (empty, q)}), p: frozenset(), q: frozenset() })
def test_extension(self): states1 = self.state_graph1() s1 = domaintuple(state="s1") s11 = domaintuple(state="s1", id=1) s2 = domaintuple(state="s2") s22 = domaintuple(state="s2", id=2) s3 = domaintuple(state="s3") stay = domaintuple(act="stay") staysure = domaintuple(act="stay", sure=True) run = domaintuple(act="run") runsure = domaintuple(act="run", sure=True) self.assertEqual( states1.extension( node_extension=lambda n: {"id": int(n.state[-1])}), Graph({ s11: frozenset({(stay, s11), (run, s22)}), s22: frozenset({(stay, s22)}) })) self.assertEqual( states1.extension(edge_extension=lambda e: {"sure": True}), Graph({ s1: frozenset({(staysure, s1), (runsure, s2)}), s2: frozenset({(staysure, s2)}) })) self.assertEqual( states1.extension( node_extension=lambda n: {"id": int(n.state[-1])}, edge_extension=lambda e: {"sure": True}), Graph({ s11: frozenset({(staysure, s11), (runsure, s22)}), s22: frozenset({(staysure, s22)}) }))
def test_mapping(self): states1 = self.state_graph1() s1 = domaintuple(state="s1") s1i = domaintuple(id=1) s2 = domaintuple(state="s2") s2i = domaintuple(id=2) s3 = domaintuple(state="s3") stay = domaintuple(act="stay") run = domaintuple(act="run") sure = domaintuple(sure=True) self.assertEqual( states1.mapping(node_mapping=lambda n: {"id": int(n.state[-1])}), Graph({ s1i: frozenset({(stay, s1i), (run, s2i)}), s2i: frozenset({(stay, s2i)}) })) self.assertEqual( states1.mapping(edge_mapping=lambda e: {"sure": True}), Graph({ s1: frozenset({(sure, s1), (sure, s2)}), s2: frozenset({(sure, s2)}) })) self.assertEqual( states1.mapping(node_mapping=lambda n: {"id": int(n.state[-1])}, edge_mapping=lambda e: {"sure": True}), Graph({ s1i: frozenset({(sure, s1i), (sure, s2i)}), s2i: frozenset({(sure, s2i)}) }))
def test_node_difference(self): states1 = self.state_graph1() states2 = self.state_graph2() formulas = self.formula_graph() self.assertEqual(Graph({}), states1.node_difference(states1)) self.assertEqual(Graph({}), formulas.node_difference(formulas)) self.assertEqual(states1.node_difference(formulas), states1) self.assertEqual(formulas.node_difference(states1), formulas) s1 = domaintuple(state="s1") s2 = domaintuple(state="s2") s3 = domaintuple(state="s3") stay = domaintuple(act="stay") run = domaintuple(act="run") self.assertEqual(states1.node_difference(states2), Graph({s2: frozenset({(stay, s2)})})) self.assertEqual(states2.node_difference(states1), Graph({s3: frozenset({(stay, s3)})}))
def test_intersection(self): states1 = self.state_graph1() states2 = self.state_graph2() formulas = self.formula_graph() self.assertEqual(states1, states1.intersection(states1)) self.assertEqual(formulas, formulas.intersection(formulas)) self.assertEqual(states1.intersection(formulas), Graph({})) self.assertEqual(states1.intersection(formulas.union(states1)), states1) self.assertEqual(formulas.intersection(formulas.union(states1)), formulas) s1 = domaintuple(state="s1") s2 = domaintuple(state="s2") s3 = domaintuple(state="s3") stay = domaintuple(act="stay") run = domaintuple(act="run") self.assertEqual(states1.intersection(states2), Graph({s1: frozenset({(stay, s1)})}))
def test_selection(self): states1 = self.state_graph1() s1 = domaintuple(state="s1") s2 = domaintuple(state="s2") s3 = domaintuple(state="s3") stay = domaintuple(act="stay") run = domaintuple(act="run") self.assertEqual( states1.selection(node_selector=lambda n: n.state != "s1"), Graph({s2: frozenset({(stay, s2)})})) self.assertEqual( states1.selection(edge_selector=lambda e: e[1].act == "run"), Graph({ s1: frozenset({(run, s2)}), s2: frozenset() })) self.assertEqual( states1.selection(node_selector=lambda n: n.state == "s1", edge_selector=lambda e: e[1].act == "run"), Graph({s1: frozenset()}))
def test_projection(self): states1 = self.state_graph1() states2 = self.state_graph2() formulas = self.formula_graph() self.assertEqual(states1.projection(node_domain={"state"}), states1) self.assertEqual(states1.projection(edge_domain={"act"}), states1) self.assertEqual( states1.projection(node_domain={"state"}, edge_domain={"act"}), states1) s1f = states1.join(formulas) s1 = domaintuple(state="s1") s2 = domaintuple(state="s2") s3 = domaintuple(state="s3") stay = domaintuple(act="stay") run = domaintuple(act="run") self.assertEqual( s1f.projection(node_domain={"state"}, edge_domain={"act"}), states1) pq = domaintuple(formula="p & q") p = domaintuple(formula="p") q = domaintuple(formula="q") empty = domaintuple() self.assertEqual( s1f.projection(node_domain={"formula"}, edge_domain={}), Graph({ pq: frozenset(), p: frozenset(), q: frozenset() })) self.assertEqual( s1f.projection(node_domain={"formula"}), Graph({ pq: frozenset({(stay, pq), (run, pq), (run, p), (run, q), (stay, p), (stay, q), (empty, p), (empty, q)}), p: frozenset({(stay, p), (run, p)}), q: frozenset({(stay, q), (run, q)}) }))
def test_join(self): states1 = self.state_graph1() states2 = self.state_graph2() formulas = self.formula_graph() self.assertEqual(states1.join(states1), states1) self.assertEqual(states1.join(states2), states1.intersection(states2)) s1pq = domaintuple(state="s1", formula="p & q") s1p = domaintuple(state="s1", formula="p") s1q = domaintuple(state="s1", formula="q") s2pq = domaintuple(state="s2", formula="p & q") s2p = domaintuple(state="s2", formula="p") s2q = domaintuple(state="s2", formula="q") stay = domaintuple(act="stay") run = domaintuple(act="run") empty = domaintuple() j = Graph({ s1pq: frozenset({(stay, s1pq), (stay, s1p), (stay, s1q), (run, s2pq), (run, s2p), (run, s2q), (empty, s1p), (empty, s1q)}), s1p: frozenset({(stay, s1p), (run, s2p)}), s1q: frozenset({(stay, s1q), (run, s2q)}), s2pq: frozenset({(stay, s2pq), (stay, s2p), (stay, s2q), (empty, s2p), (empty, s2q)}), s2p: frozenset({(stay, s2p)}), s2q: frozenset({(stay, s2q)}) }) self.assertEqual(states1.join(formulas), j) self.assertEqual(j.join(states1), j) self.assertEqual(j.join(formulas), j)
def test_ungrouping_not_domaintuple(self): states1 = self.state_graph1() states2 = self.state_graph2() formulas = self.formula_graph() grouped = states1.join(formulas).grouping(node_group=("formulas", {"state"}), edge_group=("actions", {})) def list_formulas(node): node = dict(node) node["formulas"] = frozenset({t.formula for t in node["formulas"]}) return node mapped = grouped.mapping(node_mapping=list_formulas) s1pq = domaintuple(state="s1", formulas="p & q") s1p = domaintuple(state="s1", formulas="p") s1q = domaintuple(state="s1", formulas="q") s2pq = domaintuple(state="s2", formulas="p & q") s2p = domaintuple(state="s2", formulas="p") s2q = domaintuple(state="s2", formulas="q") stayempty = domaintuple( actions=frozenset({domaintuple( act="stay"), domaintuple()})) arun = domaintuple(actions=frozenset({domaintuple(act="run")})) ungrouped = mapped.ungrouping(node_group="formulas") g = Graph({ s1pq: frozenset({(stayempty, s1pq), (stayempty, s1p), (stayempty, s1q), (arun, s2pq), (arun, s2p), (arun, s2q)}), s1p: frozenset({(stayempty, s1pq), (stayempty, s1p), (stayempty, s1q), (arun, s2pq), (arun, s2p), (arun, s2q)}), s1q: frozenset({(stayempty, s1pq), (stayempty, s1p), (stayempty, s1q), (arun, s2pq), (arun, s2p), (arun, s2q)}), s2pq: frozenset({(stayempty, s2pq), (stayempty, s2p), (stayempty, s2q)}), s2p: frozenset({(stayempty, s2pq), (stayempty, s2p), (stayempty, s2q)}), s2q: frozenset({(stayempty, s2pq), (stayempty, s2p), (stayempty, s2q)}) }) self.assertEqual(ungrouped, g)
def test_ungrouping(self): states1 = self.state_graph1() states2 = self.state_graph2() formulas = self.formula_graph() grouped = states1.join(formulas).grouping(node_group=("formulas", {"state"}), edge_group=("actions", {})) s1pq = domaintuple(state="s1", formula="p & q") s1p = domaintuple(state="s1", formula="p") s1q = domaintuple(state="s1", formula="q") s2pq = domaintuple(state="s2", formula="p & q") s2p = domaintuple(state="s2", formula="p") s2q = domaintuple(state="s2", formula="q") s1fo = domaintuple(state="s1", formulas=frozenset({ domaintuple(formula="p & q"), domaintuple(formula="p"), domaintuple(formula="q") })) s2fo = domaintuple(state="s2", formulas=frozenset({ domaintuple(formula="p & q"), domaintuple(formula="p"), domaintuple(formula="q") })) stay = domaintuple(act="stay") empty = domaintuple() run = domaintuple(act="run") stayempty = domaintuple( actions=frozenset({domaintuple( act="stay"), domaintuple()})) arun = domaintuple(actions=frozenset({domaintuple(act="run")})) ungrouped = grouped.ungrouping(node_group="formulas") g = Graph({ s1pq: frozenset({(stayempty, s1pq), (stayempty, s1p), (stayempty, s1q), (arun, s2pq), (arun, s2p), (arun, s2q)}), s1p: frozenset({(stayempty, s1pq), (stayempty, s1p), (stayempty, s1q), (arun, s2pq), (arun, s2p), (arun, s2q)}), s1q: frozenset({(stayempty, s1pq), (stayempty, s1p), (stayempty, s1q), (arun, s2pq), (arun, s2p), (arun, s2q)}), s2pq: frozenset({(stayempty, s2pq), (stayempty, s2p), (stayempty, s2q)}), s2p: frozenset({(stayempty, s2pq), (stayempty, s2p), (stayempty, s2q)}), s2q: frozenset({(stayempty, s2pq), (stayempty, s2p), (stayempty, s2q)}) }) self.assertEqual(ungrouped, g) ungrouped = grouped.ungrouping(edge_group="actions") g = Graph({ s1fo: frozenset({(stay, s1fo), (empty, s1fo), (run, s2fo)}), s2fo: frozenset({(stay, s2fo), (empty, s2fo)}) }) self.assertEqual(ungrouped, g) ungrouped = grouped.ungrouping(node_group="formulas", edge_group="actions") g = Graph({ s1pq: frozenset({(stay, s1pq), (stay, s1p), (stay, s1q), (empty, s1pq), (empty, s1p), (empty, s1q), (run, s2pq), (run, s2p), (run, s2q)}), s1p: frozenset({(stay, s1pq), (stay, s1p), (stay, s1q), (empty, s1pq), (empty, s1p), (empty, s1q), (run, s2pq), (run, s2p), (run, s2q)}), s1q: frozenset({(stay, s1pq), (stay, s1p), (stay, s1q), (empty, s1pq), (empty, s1p), (empty, s1q), (run, s2pq), (run, s2p), (run, s2q)}), s2pq: frozenset({(stay, s2pq), (stay, s2p), (stay, s2q), (empty, s2pq), (empty, s2p), (empty, s2q)}), s2p: frozenset({(stay, s2pq), (stay, s2p), (stay, s2q), (empty, s2pq), (empty, s2p), (empty, s2q)}), s2q: frozenset({(stay, s2pq), (stay, s2p), (stay, s2q), (empty, s2pq), (empty, s2p), (empty, s2q)}) }) self.assertEqual(ungrouped, g)
def test_grouping(self): states1 = self.state_graph1() states2 = self.state_graph2() formulas = self.formula_graph() s1fo = domaintuple(state="s1", formulas=frozenset({ domaintuple(formula="p & q"), domaintuple(formula="p"), domaintuple(formula="q") })) s2fo = domaintuple(state="s2", formulas=frozenset({ domaintuple(formula="p & q"), domaintuple(formula="p"), domaintuple(formula="q") })) stayempty = domaintuple( actions=frozenset({domaintuple( act="stay"), domaintuple()})) run = domaintuple(actions=frozenset({domaintuple(act="run")})) s1f = states1.join(formulas) g = s1f.grouping(node_group=("formulas", {"state"}), edge_group=("actions", {})) self.assertEqual( g, Graph({ s1fo: frozenset({(stayempty, s1fo), (run, s2fo)}), s2fo: frozenset({(stayempty, s2fo)}) }))