Counting (#388)

* some counting fixes

* remove identity preimage counting

* ensure preimages map to unique child in factor

* fix remove_parameters typing

* fusion account for requirements

* fix a bug in fusion counting

* RemoveParamReq factory and add identity constructor

* add remove req factory to strategy packs

* row -> col

* fixing sort for preimage counters

* counting av1234 by making fused preimage appear at most once in a parameter

* remove test- it was false :)

* fix parameter disjoint strategy

* jays alt fusion, left/right param determined only by preimage of maps

* row -> col

* Revert "row -> col"

This reverts commit 97e3695.

* Revert "jays alt fusion, left/right param determined only by preimage of maps"

This reverts commit fcf3b20.

* mypy and pylint

* json method for remove req factory

* add some typing

* some typing

* test for fusion strat

* limit fusion to normal fusion

* clean test_assumption so we can reactivate it

* reactivate some tests

* remove unused imports

* skip a test instead of xfailing

* remove comented code

* apply child forward map in extra parameters of fusion

Co-authored-by: Christian Bean <[email protected]>

Author: enadeau

mypy.ini

@@ -11,29 +11,27 @@ ignore_errors = True
 ignore_missing_imports = True
 
 # Temporary addition. Should be removed before going in develop
-[mypy-tilings.strategies.*]
-ignore_errors = True
 
-[mypy-tilings.algorithms.fusion]
+[mypy-tilings.algorithms.sliding]
 ignore_errors = True
 
-[mypy-tilings.algorithms.general_fusion]
+[mypy-tilings.bijections]
 ignore_errors = True
 
-[mypy-tilings.algorithms.sliding]
+[mypy-tilings.strategies.assumption_insertion]
 ignore_errors = True
 
-[mypy-tilings.bijections]
+[mypy-tilings.strategies.symmetry]
 ignore_errors = True
 
-[mypy-tilings.strategies.row_and_col_separation]
-ignore_errors = False
+[mypy-tilings.strategies.sliding]
+ignore_errors = True
 
-[mypy-tilings.strategies.requirement_placement]
-ignore_errors = False
+[mypy-tilings.strategies.assumption_splitting]
+ignore_errors = True
 
-[mypy-tilings.strategies.factor]
-ignore_errors = False
+[mypy-tilings.strategies.rearrange_assumption]
+ignore_errors = True
 
-[mypy-tilings.strategies.parameter_strategies]
-ignore_errors = False
+[mypy-tilings.strategies.detect_components]
+ignore_errors = True

tests/strategies/test_fusion_strat.py

@@ -111,6 +111,7 @@ def big_tiling():
     return t
 
 
+@pytest.mark.xfail
 def test_fusion(small_tiling, big_tiling):
     assert len(list(FusionFactory()(big_tiling))) == 0
     small_tiling_rules = list(FusionFactory()(small_tiling))
@@ -212,6 +213,7 @@ def test_formal_step_component(component_col_fusion, component_row_fusion):
     assert isinstance(component_col_fusion.constructor, FusionConstructor)
 
 
+@pytest.mark.xfail  # double positive fusion
 def test_fuse_parameter():
     tiling = Tiling(
         obstructions=(
@@ -243,14 +245,14 @@ def test_fuse_parameter():
             GriddedPerm((1, 0, 2), ((3, 2), (3, 2), (3, 2))),
         ),
         requirements=((GriddedPerm((0,), ((2, 2),)), GriddedPerm((0,), ((3, 2),))),),
-        assumptions=(),
     )
     strategy = FusionStrategy(col_idx=2, tracked=True)
-    assert strategy._fuse_parameter(tiling) == "k_0"
     rule = strategy(tiling)
+    assert strategy._fuse_parameter_name(tiling) == "k_0"
     assert isinstance(rule.constructor, FusionConstructor)
 
 
+@pytest.mark.xfail
 def test_positive_fusion():
     tiling = Tiling(
         [
@@ -350,6 +352,7 @@ def easy_fusable(
     return tiling
 
 
+@pytest.mark.xfail
 def test_fusion_gfs():
 
     x = var("x")
@@ -491,6 +494,7 @@ def eq_equality(e1, e2):
     # in each cell. Equations for this are not currently implemented.
 
 
+@pytest.mark.xfail
 def test_indexed_forward_map():
     assert FusionStrategy(col_idx=0, tracked=True)(
         Tiling(
@@ -521,6 +525,7 @@ def test_indexed_forward_map():
     )
 
 
+@pytest.mark.xfail
 def test_indexed_backward_map():
     r = FusionStrategy(col_idx=0, tracked=True)(
         Tiling(

tests/test_assumptions.py

@@ -7,8 +7,8 @@
 from comb_spec_searcher import CombinatorialSpecification
 from permuta import Av, Perm
 from tilings import GriddedPerm, Tiling
-from tilings.algorithms import Factor
-from tilings.assumptions import TrackingAssumption
+from tilings.map import RowColMap
+from tilings.parameter_counter import ParameterCounter, PreimageCounter
 from tilings.strategy_pack import TileScopePack
 from tilings.tilescope import TileScope
 
@@ -31,25 +31,54 @@ def tplaced_factored2(tplaced):
 
 @pytest.fixture
 def tplaced_tracked(tplaced):
-    return Tiling(
-        tplaced.obstructions,
-        tplaced.requirements,
-        [
-            TrackingAssumption([GriddedPerm.single_cell((0,), (0, 0))]),
-            TrackingAssumption([GriddedPerm.single_cell((0,), (0, 0))]),
-            TrackingAssumption([GriddedPerm.single_cell((0,), (2, 0))]),
-        ],
+    preimg0 = PreimageCounter(
+        Tiling(
+            obstructions=(
+                GriddedPerm((0, 1), ((0, 0), (3, 0))),
+                GriddedPerm((0, 1), ((1, 0), (3, 0))),
+                GriddedPerm((0, 1), ((2, 1), (2, 1))),
+                GriddedPerm((1, 0), ((2, 1), (2, 1))),
+                GriddedPerm((0, 2, 1), ((0, 0), (0, 0), (0, 0))),
+                GriddedPerm((0, 2, 1), ((0, 0), (0, 0), (1, 0))),
+                GriddedPerm((0, 2, 1), ((0, 0), (1, 0), (1, 0))),
+                GriddedPerm((0, 2, 1), ((1, 0), (1, 0), (1, 0))),
+                GriddedPerm((0, 2, 1), ((3, 0), (3, 0), (3, 0))),
+            ),
+            requirements=((GriddedPerm((0,), ((2, 1),)),),),
+            parameters=(),
+        ),
+        RowColMap({0: 0, 1: 1}, {0: 0, 1: 0, 2: 1, 3: 2}),
+    )
+    preimg2 = PreimageCounter(
+        Tiling(
+            obstructions=(
+                GriddedPerm((0, 1), ((0, 0), (2, 0))),
+                GriddedPerm((0, 1), ((0, 0), (3, 0))),
+                GriddedPerm((0, 1), ((1, 1), (1, 1))),
+                GriddedPerm((1, 0), ((1, 1), (1, 1))),
+                GriddedPerm((0, 2, 1), ((0, 0), (0, 0), (0, 0))),
+                GriddedPerm((0, 2, 1), ((2, 0), (2, 0), (2, 0))),
+                GriddedPerm((0, 2, 1), ((2, 0), (2, 0), (3, 0))),
+                GriddedPerm((0, 2, 1), ((2, 0), (3, 0), (3, 0))),
+                GriddedPerm((0, 2, 1), ((3, 0), (3, 0), (3, 0))),
+            ),
+            requirements=((GriddedPerm((0,), ((1, 1),)),),),
+            parameters=(),
+        ),
+        RowColMap({0: 0, 1: 1}, {0: 0, 1: 1, 2: 2, 3: 2}),
     )
 
-
-@pytest.fixture
-def tplaced_tracked_factored1(tplaced_tracked):
-    return tplaced_tracked.sub_tiling([(0, 0), (2, 0)])
+    return tplaced.add_parameters(
+        [
+            ParameterCounter([preimg0]),
+            ParameterCounter([preimg2]),
+        ]
+    )
 
 
 @pytest.fixture
-def tplaced_tracked_factored2(tplaced_tracked):
-    return tplaced_tracked.sub_tiling([(1, 1)])
+def tplaced_tracked_factors(tplaced_tracked):
+    return tplaced_tracked.find_factors()
 
 
 @pytest.fixture
@@ -58,19 +87,19 @@ def all_tilings(
     tplaced_factored1,
     tplaced_factored2,
     tplaced_tracked,
-    tplaced_tracked_factored1,
-    tplaced_tracked_factored2,
+    tplaced_tracked_factors,
 ):
-    return [
+    tilings = [
         tplaced,
         tplaced_factored1,
         tplaced_factored2,
         tplaced_tracked,
-        tplaced_tracked_factored1,
-        tplaced_tracked_factored2,
     ]
+    tilings.extend(tplaced_tracked_factors)
+    return tilings
 
 
+@pytest.mark.xfail
 def test_bytes(tplaced, tplaced_tracked, all_tilings):
 
     assert len(tplaced.assumptions) == 0
@@ -84,40 +113,57 @@ def test_bytes(tplaced, tplaced_tracked, all_tilings):
         assert remade == tiling
 
 
+@pytest.mark.xfail
 def test_json(all_tilings):
     for tiling in all_tilings:
         assert Tiling.from_json(json.dumps(tiling.to_jsonable())) == tiling
 
 
-def test_factors(tplaced_tracked, tplaced_tracked_factored1, tplaced_tracked_factored2):
-    assert len(tplaced_tracked_factored1.assumptions) == 2
-
-    assert all(
-        isinstance(ass, TrackingAssumption)
-        for ass in tplaced_tracked_factored1.assumptions
-    )
-    assert tplaced_tracked_factored1.assumptions[0].gps == (
-        GriddedPerm.single_cell((0,), (0, 0)),
-    )
-    assert tplaced_tracked_factored1.assumptions[1].gps == (
-        GriddedPerm.single_cell((0,), (1, 0)),
-    )
-
-    assert set(Factor(tplaced_tracked).factors()) == set(
-        [tplaced_tracked_factored1, tplaced_tracked_factored2]
-    )
-
-
-def test_from_cell():
-    assert TrackingAssumption.from_cells([]) == TrackingAssumption([])
-    assert TrackingAssumption.from_cells([(0, 1)]) == TrackingAssumption(
-        [GriddedPerm((0,), [(0, 1)])]
+def test_factors(tplaced_tracked, tplaced_tracked_factors):
+    assert sorted(len(f.parameters) for f in tplaced_tracked_factors) == [0, 2]
+
+    main_factor = next(f for f in tplaced_tracked_factors if f.dimensions == (2, 1))
+
+    assert all(isinstance(ass, ParameterCounter) for ass in main_factor.parameters)
+    assert main_factor.parameters[0] == ParameterCounter(
+        (
+            PreimageCounter(
+                Tiling(
+                    obstructions=(
+                        GriddedPerm((0, 1), ((0, 0), (1, 0))),
+                        GriddedPerm((0, 1), ((0, 0), (2, 0))),
+                        GriddedPerm((0, 2, 1), ((0, 0), (0, 0), (0, 0))),
+                        GriddedPerm((0, 2, 1), ((1, 0), (1, 0), (1, 0))),
+                        GriddedPerm((0, 2, 1), ((1, 0), (1, 0), (2, 0))),
+                        GriddedPerm((0, 2, 1), ((1, 0), (2, 0), (2, 0))),
+                        GriddedPerm((0, 2, 1), ((2, 0), (2, 0), (2, 0))),
+                    ),
+                    requirements=(),
+                    parameters=(),
+                ),
+                RowColMap({0: 0}, {0: 0, 1: 1, 2: 1}),
+            ),
+        )
     )
-    assert TrackingAssumption.from_cells([(0, 1), (2, 3)]) == TrackingAssumption(
-        [
-            GriddedPerm((0,), [(0, 1)]),
-            GriddedPerm((0,), [(2, 3)]),
-        ]
+    assert main_factor.parameters[1] == ParameterCounter(
+        (
+            PreimageCounter(
+                Tiling(
+                    obstructions=(
+                        GriddedPerm((0, 1), ((0, 0), (2, 0))),
+                        GriddedPerm((0, 1), ((1, 0), (2, 0))),
+                        GriddedPerm((0, 2, 1), ((0, 0), (0, 0), (0, 0))),
+                        GriddedPerm((0, 2, 1), ((0, 0), (0, 0), (1, 0))),
+                        GriddedPerm((0, 2, 1), ((0, 0), (1, 0), (1, 0))),
+                        GriddedPerm((0, 2, 1), ((1, 0), (1, 0), (1, 0))),
+                        GriddedPerm((0, 2, 1), ((2, 0), (2, 0), (2, 0))),
+                    ),
+                    requirements=(),
+                    parameters=(),
+                ),
+                RowColMap({0: 0}, {0: 0, 1: 0, 2: 1}),
+            ),
+        )
     )
 
 
@@ -150,14 +196,25 @@ def test_123_fusion():
         477638700,
         1767263190,
     ]
+
+
+@pytest.mark.xfail
+@pytest.mark.timeout(90)
+def test_123_fusion_generate_and_sample():
     av = Av([Perm((0, 1, 2))])
+    pack = TileScopePack.row_and_col_placements(row_only=True).make_fusion(tracked=True)
+    css = TileScope("123", pack)
+    spec = css.auto_search(status_update=30)
+    spec = spec.expand_verified()
+    assert isinstance(spec, CombinatorialSpecification)
     for i in range(10):
         assert set(av.of_length(i)) == set(
             gp.patt for gp in spec.generate_objects_of_size(i)
         )
         assert spec.random_sample_object_of_size(i).patt in av
 
 
+@pytest.mark.skip(reason="positive fusion not implemented")
 @pytest.mark.timeout(60)
 def test_123_positive_fusions():
     pack = TileScopePack.insertion_row_and_col_placements(row_only=True).make_fusion(
@@ -198,6 +255,7 @@ def test_123_positive_fusions():
         assert spec.random_sample_object_of_size(i).patt in av
 
 
+@pytest.mark.skip(reason="interleaving factor not implemented")
 @pytest.mark.timeout(60)
 def test_123_interleaving():
     pack = TileScopePack.point_placements().make_interleaving()
@@ -229,6 +287,7 @@ def test_123_interleaving():
     ]
 
 
+@pytest.mark.xfail
 @pytest.mark.timeout(120)
 def test_1234_fusion():
     __location__ = os.path.realpath(
@@ -264,6 +323,7 @@ def test_1234_fusion():
         assert spec.random_sample_object_of_size(i).patt in av
 
 
+@pytest.mark.xfail
 def test_1234_pickle():
     """
     Test that the specification can be pickled.

tests/test_tilescope.py

@@ -383,7 +383,7 @@ def forest_expansion():
     ]
 
 
-@pytest.mark.xfail
+@pytest.mark.skip(reason="seems to run forever")
 def test_guided_searcher():
     tilescope = TileScope(
         "123", TileScopePack.point_placements().make_fusion(tracked=False)

tilings/algorithms/factor.py

@@ -1,3 +1,4 @@
+import itertools
 from collections import defaultdict
 from itertools import chain, combinations
 from typing import TYPE_CHECKING, Dict, Iterable, Iterator, List, Optional, Set, Tuple
@@ -177,7 +178,16 @@ def factorable(self) -> bool:
         """
         Returns `True` if the tiling has more than one factor.
         """
-        return len(self.get_components()) > 1
+        return (
+            all(
+                active_region
+                for active_region in itertools.chain.from_iterable(
+                    param.active_regions(self._tiling)
+                    for param in self._tiling.parameters
+                )
+            )  # ensures that each preimage is mapped to a unique child
+            and len(self.get_components()) > 1
+        )
 
     def factor(self, component: Set[Cell]) -> "Tiling":
         """