minor fix. code cleanup. tests

Author: fandreuz

bispy/__init__.py

@@ -1,10 +1,6 @@
-from .paige_tarjan.paige_tarjan import (
-    paige_tarjan,
-    paige_tarjan_qblocks,
-)
+from .paige_tarjan.paige_tarjan import paige_tarjan
 from .dovier_piazza_policriti.dovier_piazza_policriti import (
     dovier_piazza_policriti,
-    dovier_piazza_policriti_partition,
 )
 from .saha.saha_partition import saha
 
@@ -13,6 +9,8 @@
     decorate_nx_graph,
     to_tuple_list,
 )
+from enum import Enum, auto
+import networkx as nx
 
 
 class Algorithms(Enum):
@@ -23,7 +21,7 @@ class Algorithms(Enum):
 def compute_maximum_bisimulation(
     graph: nx.DiGraph,
     initial_partition,
-    algorithm=Algorithm.PaigeTarjan,
+    algorithm=Algorithms.PaigeTarjan,
 ):
     """Compute the maximum bisimulation of the given graph, possibly using
     an initial partition (or labeling set). The preferred algorithm may be

bispy/dovier_piazza_policriti/dovier_piazza_policriti.py

@@ -140,13 +140,14 @@ def dovier_piazza_policriti_partition(
     # loop over the ranks
     for partition_idx in range(len(partition)):
         if len(partition[partition_idx]) == 1:
-            block = partition[partition_idx][0]
-            survivor_vertex, collapsed_vertexes = collapse(block)
-            if survivor_vertex is not None:
-                # update the collapsed nodes map
-                collapse_map[survivor_vertex.label] = collapsed_vertexes
-                # update the partition
-                split_upper_ranks(partition, block)
+            if len(partition[partition_idx][0].vertexes):
+                block = partition[partition_idx][0]
+                survivor_vertex, collapsed_vertexes = collapse(block)
+                if survivor_vertex is not None:
+                    # update the collapsed nodes map
+                    collapse_map[survivor_vertex.label] = collapsed_vertexes
+                    # update the partition
+                    split_upper_ranks(partition, block)
         # OPTIMIZATION: if at the current rank we only have blocks of single
         # vertexes, skip this step.
         elif any(map(lambda block: block.size > 1, partition[partition_idx])):
@@ -180,6 +181,7 @@ def dovier_piazza_policriti_partition(
                 block_vertexes = []
                 for scaled_vertex in block.vertexes:
                     scaled_vertex.back_to_original_label()
+                    scaled_vertex.back_to_original_graph()
                     block_vertexes.append(scaled_vertex)
 
                 # we can set XBlock to None because PTA won't be called again

tests/api/__init__.py

@@ -121,7 +121,9 @@ def test_dpp_rscp_correctness(graph, initial_partition, expected_q_partition):
     checker_graphs,
 )
 def test_dpp_correctness2(graph):
-    assert to_set(dovier_piazza_policriti(graph)) == to_set(paige_tarjan(graph))
+    assert to_set(dovier_piazza_policriti(graph)) == to_set(
+        paige_tarjan(graph)
+    )
 
 
 def test_dpp_correctness_all_scc_leaf_with_initial_partition():
@@ -131,3 +133,18 @@ def test_dpp_correctness_all_scc_leaf_with_initial_partition():
     assert to_set(dovier_piazza_policriti(graph, [(0, 1), (2,)])) == set(
         [frozenset([0]), frozenset([1]), frozenset([2])]
     )
+
+
+def test_balanced_tree_initial_partition():
+    graph = nx.balanced_tree(2, 3, create_using=nx.DiGraph)
+    initial_partition = [
+        (0, 1, 2),
+        (3, 4),
+        (5, 6),
+        (7, 8, 9, 10),
+        (11, 12, 13),
+        (14,),
+    ]
+    assert to_set(
+        dovier_piazza_policriti(graph, initial_partition=initial_partition)
+    ) == to_set(paige_tarjan(graph, initial_partition=initial_partition))

tests/api/api_test_cases.py

@@ -30,7 +30,9 @@ def test_create_initial_partition(graph):
             vertex.rank == rank for vertex in vertexes
         ].count(True)
         # right rank
-        assert all(vertex.rank == rank for vertex in partition[idx][0].vertexes)
+        assert all(
+            vertex.rank == rank for vertex in partition[idx][0].vertexes
+        )
 
 
 @pytest.mark.parametrize("graph", graphs)
@@ -101,3 +103,21 @@ def test_get_item():
     vertexes, _ = decorate_nx_graph(nx.balanced_tree(2, 3))
     partition = RankedPartition(vertexes)
     assert partition[1] == partition._partition[1]
+
+
+def test_different_blocks_initial_partition():
+    graph = nx.balanced_tree(2, 3, create_using=nx.DiGraph)
+    initial_partition = [
+        (0, 1, 2),
+        (3, 4),
+        (5, 6),
+        (7, 8, 9, 10),
+        (11, 12, 13),
+        (14,),
+    ]
+    vertexes, _ = decorate_nx_graph(nx.balanced_tree(2, 3), initial_partition)
+
+    partition = RankedPartition(vertexes)
+
+    assert len(partition[1]) == 3
+    assert len(partition[2]) == 2

tests/api/test_api.py

@@ -176,19 +176,25 @@
 graph10 = nx.DiGraph()
 graph10.add_nodes_from(range(3))
 graph10.add_edges_from([(0, 1), (0, 2), (1, 0), (1, 2)])
-graph_partition_tuples.append((graph10, initial_partitions[len(graph10.nodes)]))
+graph_partition_tuples.append(
+    (graph10, initial_partitions[len(graph10.nodes)])
+)
 
 # 11
 graph11 = nx.DiGraph()
 graph11.add_nodes_from(range(3))
 graph11.add_edges_from([(0, 1), (1, 2), (2, 0), (2, 1)])
-graph_partition_tuples.append((graph11, initial_partitions[len(graph11.nodes)]))
+graph_partition_tuples.append(
+    (graph11, initial_partitions[len(graph11.nodes)])
+)
 
 # 12
 graph12 = nx.DiGraph()
 graph12.add_nodes_from(range(3))
 graph12.add_edges_from([(0, 1), (0, 2), (1, 0), (1, 2), (2, 0), (2, 1)])
-graph_partition_tuples.append((graph12, initial_partitions[len(graph12.nodes)]))
+graph_partition_tuples.append(
+    (graph12, initial_partitions[len(graph12.nodes)])
+)
 
 graph_partition_rscp_tuples = []
 

tests/dovier_piazza_policriti/test_dovier_piazza_policriti.py

@@ -3,6 +3,7 @@
 
 from bispy.utilities.graph_entities import _Vertex, _QBlock
 
+
 # check if the given partition is stable with respect to the given block, or if
 # it's stable if the block isn't given
 def is_stable_vertexes_partition(partition: List[List[_Vertex]]) -> bool:

tests/dovier_piazza_policriti/test_ranked_partition.py

@@ -30,7 +30,7 @@
     paige_tarjan_qblocks,
     preprocess_initial_partition,
 )
-from bispy.utilities.graph_decorator import decorate_nx_graph
+from bispy.utilities.graph_decorator import decorate_nx_graph, to_set
 import tests.paige_tarjan.paige_tarjan_test_cases as test_cases
 
 
@@ -210,7 +210,8 @@ def test_build_block_counterimage_aux_count(graph, initial_partition):
             vertex.aux_count = None
 
 
-# error "dllistnode belongs to another list" triggered by split when using the result of build_block_counterimage
+# error "dllistnode belongs to another list" triggered by split when using the
+# result of build_block_counterimage
 # error "dllistnode doesn't belong to a list"
 @pytest.mark.parametrize(
     "graph, initial_partition", test_cases.graph_partition_tuples
@@ -227,7 +228,8 @@ def test_vertex_taken_from_right_list(graph, initial_partition):
         assert True
 
 
-# error "dllistnode belongs to another list" triggered by split when using the result of build_block_counterimage
+# error "dllistnode belongs to another list" triggered by split when using the
+# result of build_block_counterimage
 # error "dllistnode doesn't belong to a list"
 @pytest.mark.parametrize(
     "graph, initial_partition", test_cases.graph_partition_tuples
@@ -237,7 +239,7 @@ def test_can_remove_any_vertex_from_its_list(graph, initial_partition):
 
     for qblock in q_partition:
         vertex = qblock.vertexes.first
-        while vertex != None:
+        while vertex is not None:
             qblock.vertexes.remove(vertex)
             vertex = vertex.next
             # check that this doesn't raise an exception
@@ -252,23 +254,27 @@ def test_split(graph, initial_partition):
     xblock = q_partition[0].xblock
 
     qblock_splitter = q_partition[0]
-    # qblock_splitter may be modified by split, therefore we need to keep a copy
+    # qblock_splitter may be modified by split, therefore we need to keep a
+    # copy
     splitter_vertexes = [vertex for vertex in qblock_splitter.vertexes]
 
     block_counterimage = build_block_counterimage(qblock_splitter)
     split(block_counterimage)
 
-    # after split the partition should be stable with respect to the block chosen for the split
+    # after split the partition should be stable with respect to the block
+    # chosen for the split
     for qblock in xblock.qblocks:
         assert check_vertexes_stability(
             [vertex for vertex in qblock.vertexes], splitter_vertexes
         )
 
-    # test if the size of the qblocks after the split is equal to the number of vertexes
+    # test if the size of the qblocks after the split is equal to the number of
+    # vertexes
     for qblock in xblock.qblocks:
         assert qblock.size == len(qblock.vertexes)
 
-    # check if the qblock a vertex belongs to corresponds to the value vertex.qblock for each of its vertexes
+    # check if the qblock a vertex belongs to corresponds to the value
+    # vertex.qblock for each of its vertexes
     for qblock in xblock.qblocks:
         for vertex in qblock.vertexes:
             assert vertex.qblock == qblock
@@ -283,15 +289,18 @@ def test_split_helper_block_right_xblock(graph, initial_partition):
     new_blocks, _, _ = split(vertexes[3:7])
 
     for new_block in new_blocks:
-        assert any([qblock == new_block for qblock in new_block.xblock.qblocks])
+        assert any(
+            [qblock == new_block for qblock in new_block.xblock.qblocks]
+        )
 
     for old_block in q_partition:
         assert old_block.size == 0 or any(
             [qblock == old_block for qblock in old_block.xblock.qblocks]
         )
 
 
-# second_splitter should be E^{-1}(B) - E^{-1}(S-B), namely there should only be vertexes in E^{-1}(B) but not in E^{-1}(S-B)
+# second_splitter should be E^{-1}(B) - E^{-1}(S-B), namely there should only
+# be vertexes in E^{-1}(B) but not in E^{-1}(S-B)
 @pytest.mark.parametrize(
     "graph, initial_partition", test_cases.graph_partition_tuples
 )
@@ -301,7 +310,8 @@ def test_second_splitter_counterimage(graph, initial_partition):
 
     qblock_splitter = q_partition[0]
 
-    # qblock_splitter may be modified by split, therefore we need to keep a copy
+    # qblock_splitter may be modified by split, therefore we need to keep a
+    # copy
     splitter_vertexes = [vertex for vertex in qblock_splitter.vertexes]
 
     block_counterimage = build_block_counterimage(qblock_splitter)
@@ -334,7 +344,8 @@ def test_second_split(graph, initial_partition):
     xblock = q_partition[0].xblock
 
     qblock_splitter = q_partition[0]
-    # qblock_splitter may be modified by split, therefore we need to keep a copy
+    # qblock_splitter may be modified by split, therefore we need to keep a
+    # copy
     splitter_vertexes = [vertex for vertex in qblock_splitter.vertexes]
 
     block_counterimage = build_block_counterimage(qblock_splitter)
@@ -352,7 +363,8 @@ def test_second_split(graph, initial_partition):
     new_qblocks, _, _ = split(second_splitter_counterimage)
     q_partition.extend(new_qblocks)
 
-    # after split the partition should be stable with respect to the block chosen for the split
+    # after split the partition should be stable with respect to the block
+    # chosen for the split
     for qblock in xblock.qblocks:
         assert check_vertexes_stability(
             [vertex for vertex in qblock.vertexes], second_splitter_vertexes
@@ -390,7 +402,7 @@ def test_reset_aux_count_after_refinement(graph, initial_partition):
     refine([xblock], [xblock])
 
     for vertex in vertexes:
-        assert vertex.aux_count == None
+        assert vertex.aux_count is None
 
 
 def test_count_after_refinement():
@@ -451,7 +463,7 @@ def test_no_negative_edge_counts(graph, initial_partition):
 
     for vertex in vertexes:
         for edge in vertex.image:
-            assert edge.count == None or edge.count.value > 0
+            assert edge.count is None or edge.count.value > 0
 
 
 @pytest.mark.parametrize(
@@ -557,12 +569,3 @@ def test_pt_same_initial_partition(graph, initial_partition):
                 vertex.initial_partition_block_id
                 == vertex_to_initial_partition_id[vertex.label]
             )
-
-
-def test_simp():
-    graph = nx.DiGraph()
-    graph.add_nodes_from(range(2))
-    graph.add_edges_from([(0, 1)])
-    initial_partition = [(0, 1)]
-
-    x = paige_tarjan(graph, is_integer_graph=True)