Migrate requirement corroboration

Author: enadeau

tilescopethree/strategies/batch_strategies/cell_insertion.py

@@ -1,6 +1,6 @@
-from itertools import chain
-from typing import List, Optional
+from typing import Iterable, List, Optional
 
+from comb_spec_searcher import Rule
 from permuta import Perm
 from tilings import Tiling
 from tilings.algorithms import (CellInsertion, ColInsertion, CrossingInsertion,
@@ -11,7 +11,7 @@
 def all_cell_insertions(tiling: Tiling, maxreqlen: int = 1, extra_basis:
                         Optional[List[Perm]] = None,
                         ignore_parent: bool = False,
-                        **kwargs):
+                        **kwargs) -> Iterable[Rule]:
     """
     The cell insertion strategy.
 
@@ -25,7 +25,7 @@ def all_cell_insertions(tiling: Tiling, maxreqlen: int = 1, extra_basis:
                              extra_basis).rules(ignore_parent)
 
 
-def root_requirement_insertion(tiling, **kwargs):
+def root_requirement_insertion(tiling, **kwargs) -> Iterable[Rule]:
     """
     The cell insertion strategy performed only on 1 by 1 tilings.
     """
@@ -34,7 +34,7 @@ def root_requirement_insertion(tiling, **kwargs):
     yield from all_cell_insertions(tiling, **kwargs)
 
 
-def all_point_insertions(tiling, **kwargs):
+def all_point_insertions(tiling, **kwargs) -> Iterable[Rule]:
     """
     The cell insertion strategy using only points.
     """
@@ -43,28 +43,31 @@ def all_point_insertions(tiling, **kwargs):
 
 def all_requirement_extensions(tiling: Tiling, maxreqlen: int = 2,
                                extra_basis: Optional[List[Perm]] = None,
-                               ignore_parent: bool = False, **kwargs):
+                               ignore_parent: bool = False,
+                               **kwargs) -> Iterable[Rule]:
     """
     Insert longer requirements in to cells which contain a requirement
     """
     yield from RequirementExtension(tiling, maxreqlen,
                                     extra_basis).rules(ignore_parent)
 
 
-def all_row_insertions(tiling: Tiling, ignore_parent: bool = False, **kwargs):
+def all_row_insertions(tiling: Tiling, ignore_parent: bool = False,
+                       **kwargs) -> Iterable[Rule]:
     """Insert a list requirement into every possibly empty row."""
     yield from RowInsertion(tiling).rules(ignore_parent)
 
 
-def all_col_insertions(tiling, ignore_parent: bool = False, **kwargs):
+def all_col_insertions(tiling, ignore_parent: bool = False,
+                       **kwargs) -> Iterable[Rule]:
     """Insert a list requirement into every possibly empty column."""
     yield from ColInsertion(tiling).rules(ignore_parent)
 
 
 def all_requirement_insertions(tiling: Tiling, maxreqlen: int = 1,
                                extra_basis: Optional[List[Perm]] = None,
                                ignore_parent: bool = False,
-                               **kwargs):
+                               **kwargs) -> Iterable[Rule]:
     """
     Insert all possible requirements the obstruction allows if the tiling does
     not have requirements.
@@ -76,7 +79,7 @@ def all_requirement_insertions(tiling: Tiling, maxreqlen: int = 1,
 
 
 def all_factor_insertions(tiling: Tiling, ignore_parent: bool = False,
-                          **kwargs):
+                          **kwargs) -> Iterable[Rule]:
     """
     Insert all proper factor of the requirement or obstructions on the tiling.
     """

tilescopethree/strategies/batch_strategies/requirement_corroboration.py

@@ -1,15 +1,19 @@
 """
     Module containing the requirement corroboration strategy.
 """
+from typing import Iterable
+
 from comb_spec_searcher import Rule
-from tilings import Obstruction, Requirement, Tiling
+from tilings import Tiling
+from tilings.algorithms import RequirementCorroboration
 
 
-def requirement_corroboration(tiling, basis, **kwargs):
+def requirement_corroboration(tiling: Tiling, ignore_parent: bool = True,
+                              **kwargs) -> Iterable[Rule]:
     """
     The requirement corroboration strategy.
 
-    The requirement corrobation strategy is a batch strategy that considers
+    The requirement corroboration strategy is a batch strategy that considers
     each requirement of each requirement list. For each of these requirements,
     the strategy returns two tilings; one where the requirement has been turned
     into an obstruction and another where the requirement has been singled out
@@ -21,33 +25,4 @@ def requirement_corroboration(tiling, basis, **kwargs):
     that avoid the requirement, must therefore satisfy another requirement from
     the same list and hence the requirement list must be of length at least 2.
     """
-    for reqs in tiling.requirements:
-        if len(reqs) == 1:
-            continue
-        for req in reqs:
-            yield Rule(
-                formal_step="Inserting requirement {}.".format(str(req)),
-                comb_classes=gp_insertion(tiling, req),
-                ignore_parent=True,
-                possibly_empty=[True, True],
-                workable=[True for _ in range(2)],
-                inferable=[True for _ in range(2)],
-                constructor='disjoint')
-
-
-def pos_str(pos):
-    return "/".join("{},{}".format(c[0], c[1]) for c in pos)
-
-
-def gp_insertion(tiling, gp, regions=False):
-    """Return a list of size 2, where the first tiling avoids the gridded perm
-    gp and the second contains gp."""
-    tilings = [tiling.add_obstruction(gp.patt, gp.pos),
-               tiling.add_requirement(gp.patt, gp.pos)]
-
-    if regions:
-        forward_maps = [{c: frozenset([c]) for c in tiling.active_cells},
-                        {c: frozenset([c]) for c in tiling.active_cells}]
-        return tilings, forward_maps
-    else:
-        return tilings
+    yield from RequirementCorroboration(tiling).rules(ignore_parent)