migrate verification strategy

tests/strategies/batch_strategies/test_cell_insertion.py

@@ -1,5 +1,9 @@
 from permuta import Perm
-from tilescopethree.strategies import all_cell_insertions
+from tilescopethree.strategies import (all_cell_insertions, all_col_insertions,
+                                       all_factor_insertions,
+                                       all_requirement_extensions,
+                                       all_requirement_insertions,
+                                       all_row_insertions)
 from tilings import Obstruction, Requirement, Tiling
 
 pytest_plugins = [
@@ -26,7 +30,7 @@ def test_all_cell_insertions_points(simple_tiling):
         obstructions=[Obstruction(Perm((0,)), ((0, 1),)),
                       Obstruction(Perm((0,)), ((1, 0),))],
         requirements=[[Requirement(Perm((0, 1)), ((0, 0), (1, 1)))]]),
-                Tiling(
+        Tiling(
         obstructions=[Obstruction(Perm((0,)), ((0, 1),))],
         requirements=[[Requirement(Perm((0,)), ((1, 0),))],
                       [Requirement(Perm((0, 1)), ((0, 0), (1, 0))),
@@ -41,11 +45,12 @@ def test_all_cell_insertions_points(simple_tiling):
 
     actual.add((Tiling(
         requirements=[[Requirement(Perm((0, 1)), ((0, 0), (1, 0)))]]),
-                Tiling(
+        Tiling(
         obstructions=[Obstruction(Perm((1, 0)), ((0, 1), (1, 0)))],
         requirements=[[Requirement(Perm((0,)), ((1, 1),))],
                       [Requirement(Perm((0, 1)), ((0, 0), (1, 0))),
                        Requirement(Perm((0, 1)), ((0, 0), (1, 1)))]])))
+    print(simple_tiling)
     assert strats == actual
 
 
@@ -60,8 +65,96 @@ def test_all_cell_insertions(typical_redundant_requirements,
         obstructions=typical_redundant_obstructions + [
             Obstruction(Perm((0, 1, 2)), [(0, 1), (0, 1), (0, 1)])],
         requirements=typical_redundant_requirements),
-                Tiling(
+        Tiling(
         obstructions=typical_redundant_obstructions,
         requirements=typical_redundant_requirements + [
             [Requirement(Perm((0, 1, 2)), [(0, 1), (0, 1), (0, 1)])]])
-        ) in strats)
+    ) in strats)
+
+
+def test_all_requirement_extension():
+    t = Tiling.from_string('123_132').add_single_cell_requirement(
+        Perm((0, 1)), (0, 0))
+    strats = set([tuple(s.comb_classes)
+                  for s in all_requirement_extensions(t, maxreqlen=3)])
+    actual = set([
+        (t.add_single_cell_obstruction(Perm((2, 0, 1)), (0, 0)),
+         t.add_single_cell_requirement(Perm((2, 0, 1)), (0, 0))),
+        (t.add_single_cell_obstruction(Perm((1, 0, 2)), (0, 0)),
+         t.add_single_cell_requirement(Perm((1, 0, 2)), (0, 0))),
+        (t.add_single_cell_obstruction(Perm((1, 2, 0)), (0, 0)),
+         t.add_single_cell_requirement(Perm((1, 2, 0)), (0, 0))),
+    ])
+    assert actual == strats
+
+
+def test_all_row_insertion():
+    t = Tiling(obstructions=[
+        Obstruction(Perm((0, 1)), ((0, 0),)*2),
+        Obstruction(Perm((0, 1)), ((1, 0),)*2),
+        Obstruction(Perm((0, 1, 2)), ((0, 1),)*3),
+    ], requirements=[
+        [Requirement(Perm((0, 1)), ((0, 1),)*2)]
+    ])
+    strats = set([tuple(s.comb_classes)
+                  for s in all_row_insertions(t)])
+    actual = set([
+        (Tiling(obstructions=[Obstruction(Perm((0, 1, 2)), ((0, 0),)*3)],
+                requirements=[[Requirement(Perm((0, 1)), ((0, 0),)*2)]]),
+         t.add_list_requirement([Requirement(Perm((0,)), ((0, 0),)),
+                                 Requirement(Perm((0,)), ((1, 0),)), ])), ])
+    assert actual == strats
+    assert (next(all_row_insertions(t)).formal_step ==
+            'Either row 0 is empty or not.')
+
+
+def test_all_col_insertion():
+    t = Tiling(obstructions=[
+        Obstruction(Perm((0, 1)), ((0, 0),)*2),
+        Obstruction(Perm((0, 1)), ((1, 0),)*2),
+        Obstruction(Perm((0, 1, 2)), ((0, 1),)*3),
+    ], requirements=[
+        [Requirement(Perm((0, 1)), ((0, 1),)*2)]
+    ])
+    strats = set([tuple(s.comb_classes)
+                  for s in all_col_insertions(t)])
+    actual = set([
+        (t.add_single_cell_obstruction(Perm((0,)), (1, 0)),
+         t.add_single_cell_requirement(Perm((0,)), (1, 0)),)
+    ])
+    assert actual == strats
+    assert (next(all_col_insertions(t)).formal_step ==
+            'Either column 1 is empty or not.')
+
+
+def test_all_requirement_insertion():
+    t = Tiling(obstructions=[
+        Obstruction(Perm((0, 1)), ((0, 0), (0, 0))),
+        Obstruction(Perm((0, 1)), ((1, 0), (1, 0))),
+        Obstruction(Perm((0, 1)), ((0, 0), (1, 0))),
+    ])
+    strats = set(tuple(s.comb_classes)
+                 for s in all_requirement_insertions(t, 2))
+    assert len(strats) == 5
+    strat_formal_steps = (
+        set(s.formal_step for s in all_requirement_insertions(t, 2)))
+    assert 'Insert 0 in cell (1, 0).' in strat_formal_steps
+    assert 'Insert 10: (0, 0), (1, 0).' in strat_formal_steps
+
+
+def test_all_factor_insertions():
+    t = Tiling(obstructions=[
+        Obstruction(Perm((0, 1)), ((0, 0), (0, 0))),
+        Obstruction(Perm((0, 1)), ((1, 0), (1, 0))),
+        Obstruction(Perm((1, 0)), ((1, 1), (1, 1))),
+        Obstruction(Perm((1, 0)), ((1, 2), (1, 2))),
+        Obstruction(Perm((0, 1, 2)), ((0, 0), (1, 1), (1, 2))),
+        Obstruction(Perm((0, 1)), ((0, 0), (1, 0))),
+    ])
+    strats = set(tuple(s.comb_classes)
+                 for s in all_factor_insertions(t))
+    assert len(strats) == 2
+    strat_formal_steps = (
+        set(s.formal_step for s in all_factor_insertions(t)))
+    assert 'Insert 0 in cell (0, 0).' in strat_formal_steps
+    assert 'Insert 01: (1, 1), (1, 2).' in strat_formal_steps

tests/strategies/decomposition_strategies/test_factor.py

@@ -3,11 +3,10 @@
     factor, factor_with_interleaving, factor_with_monotone_interleaving,
     unions_of_factor, unions_of_factor_with_interleaving,
     unions_of_factor_with_monotone_interleaving)
-from tilescopethree.strategies.decomposition_strategies.factor import \
-    general_factor
 from tilings import Obstruction, Requirement, Tiling
 from tilings.algorithms import (Factor, FactorWithInterleaving,
                                 FactorWithMonotoneInterleaving)
+from tilings.strategies.decomposition import general_factor
 
 pytest_plugins = [
     'tests.fixtures.simple_tiling',

tests/strategies/equivalence_strategies/test_fusion_with_interleaving.py → tests/strategies/equivalence_strategies/test_component_fusion.py

@@ -1,7 +1,7 @@
 import pytest
 
 from permuta import Perm
-from tilescopethree.strategies import fusion_with_interleaving
+from tilescopethree.strategies import component_fusion
 from tilings import Obstruction, Tiling
 
 
@@ -37,5 +37,5 @@ def tiling2():
 
 
 def test_fusion_with_interleaving(tiling1, tiling2):
-    assert len(list(fusion_with_interleaving(tiling1))) == 0
-    assert len(list(fusion_with_interleaving(tiling2))) == 1
+    assert len(list(component_fusion(tiling1))) == 0
+    assert len(list(component_fusion(tiling2))) == 1

tests/strategies/equivalence_strategies/test_fusion.py

@@ -2,7 +2,7 @@
 
 from comb_spec_searcher import Rule
 from permuta import Perm
-from tilescopethree.strategies.equivalence_strategies.fusion import fusion
+from tilescopethree.strategies.equivalence_strategies import fusion
 from tilings import Obstruction, Tiling
 
 

tests/test_tilescope.py

@@ -4,9 +4,9 @@
 from comb_spec_searcher import ProofTree
 from tilescopethree import TileScopeTHREE
 from tilescopethree.strategy_packs_v2 import (
-    all_the_strategies_database_verified, point_placements,
-    point_placements_fusion, point_placements_fusion_with_interleaving,
-    row_and_col_placements_fusion_with_interleaving_fusion)
+    all_the_strategies_verify_database, point_placements,
+    point_placements_component_fusion, point_placements_fusion,
+    row_and_col_placements_component_fusion_fusion)
 
 
 @pytest.mark.timeout(20)
@@ -28,7 +28,7 @@ def test_132_genf():
 
 @pytest.mark.timeout(20)
 def test_123():
-    searcher = TileScopeTHREE('123', all_the_strategies_database_verified)
+    searcher = TileScopeTHREE('123', all_the_strategies_verify_database)
     t = searcher.auto_search(smallest=True)
     assert isinstance(t, ProofTree)
 
@@ -43,7 +43,7 @@ def test_123_with_db():
 @pytest.mark.timeout(20)
 def test_1342_1423():
     searcher = TileScopeTHREE('1342_1423',
-                              point_placements_fusion_with_interleaving)
+                              point_placements_component_fusion)
     t = searcher.auto_search(smallest=True)
     t.number_of_nodes() == 14
     assert isinstance(t, ProofTree)
@@ -53,7 +53,7 @@ def test_1342_1423():
 def test_1324():
     searcher = TileScopeTHREE(
         '1324',
-        row_and_col_placements_fusion_with_interleaving_fusion
+        row_and_col_placements_component_fusion_fusion
     )
     t = searcher.auto_search(smallest=True)
     t.number_of_nodes() == 14

tilescopethree/strategies/batch_strategies/__init__.py

@@ -11,4 +11,3 @@
                                           row_and_col_placements,
                                           row_placements)
 from .requirement_corroboration import requirement_corroboration
-from .targeted_cell_insertion import targeted_cell_insertion