def test_tiling_from_dict(client):
tiling = Tiling(
obstructions=(
GriddedPerm((0, 1), ((0, 0), (0, 0))),
GriddedPerm((0, 1), ((1, 1), (1, 1))),
GriddedPerm((0, 1, 2), ((0, 0), (1, 0), (1, 0))),
GriddedPerm((0, 1, 2), ((0, 0), (1, 0), (1, 1))),
GriddedPerm((0, 1, 2), ((1, 0), (1, 0), (1, 0))),
GriddedPerm((0, 1, 2), ((1, 0), (1, 0), (1, 1))),
),
requirements=((GriddedPerm((0, ), ((1, 0), )), ), ),
assumptions=(
TrackingAssumption([
GriddedPerm.single_cell((0, ), (0, 0)),
GriddedPerm.single_cell((0, ), (1, 0)),
]),
TrackingAssumption([GriddedPerm.single_cell((0, ), (1, 1))]),
),
)
res = post(client, _INIT_PATH, verify_wrap(tiling.to_jsonable()))
assert_code_and_mimetype(res)
assert_tiling(
res.json,
tiling,
assumptions=[["0: (0, 0)", "0: (1, 0)"], ["0: (1, 1)"]],
crossing=[
"012: (0, 0), (1, 0), (1, 0)",
"012: (0, 0), (1, 0), (1, 1)",
"012: (1, 0), (1, 0), (1, 1)",
],
label_map={"1": "Av+(123)"},
matrix=[[" ", "\\"], ["\\", "1"]],
requirements=[["0: (1, 0)"]],
)
def test_splitting_gf():
parent = Tiling(
obstructions=(
GriddedPerm.single_cell((0, 1), (0, 1)),
GriddedPerm.single_cell((0, 1), (1, 0)),
),
assumptions=(
TrackingAssumption([
GriddedPerm.point_perm((0, 1)),
GriddedPerm.point_perm((1, 0))
]),
TrackingAssumption([GriddedPerm.point_perm((1, 0))]),
),
)
child = Tiling(
obstructions=(
GriddedPerm.single_cell((0, 1), (0, 1)),
GriddedPerm.single_cell((0, 1), (1, 0)),
),
assumptions=(
TrackingAssumption([GriddedPerm.point_perm((0, 1))]),
TrackingAssumption([GriddedPerm.point_perm((1, 0))]),
),
)
strat = SplittingStrategy()
rule = strat(parent)
x, k0, k1 = var("x k_0 k_1")
parent_func = Function("F_0")(x, k0, k1)
child_func = Function("F_1")(x, k0, k1)
expected_eq = Eq(parent_func, child_func.subs({k1: k0 * k1}))
assert len(rule.children) == 1
assert rule.children[0] == child
assert rule.constructor.get_equation(parent_func,
(child_func, )) == expected_eq
def test_single_cell():
gp = GriddedPerm.single_cell((0, 1, 2), (2, 3))
assert gp.patt == Perm((0, 1, 2))
assert gp.pos == ((2, 3), (2, 3), (2, 3))
gp = GriddedPerm.single_cell((0, ), (45, 64))
assert gp.patt == Perm((0, ))
assert gp.pos == ((45, 64), )
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))]),
],
)
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_order():
sum_ass = SumComponentAssumption((GriddedPerm(
(0, ), ((1, 1), )), GriddedPerm((0, ), ((2, 0), ))))
skew_ass = SkewComponentAssumption((
GriddedPerm((0, ), ((1, 1), )),
GriddedPerm((0, ), ((2, 0), )),
GriddedPerm((0, ), ((2, 2), )),
))
point_ass = TrackingAssumption([GriddedPerm.single_cell((0, ), (0, 0))])
point_ass2 = TrackingAssumption([GriddedPerm.single_cell((0, ), (2, 0))])
assert point_ass < point_ass2 and not point_ass2 < point_ass
assert xor(sum_ass < skew_ass, skew_ass < sum_ass)
assert xor(sum_ass < point_ass, point_ass < sum_ass)
assert xor(point_ass < skew_ass, skew_ass < point_ass)
def get_genf(
self, comb_class: Tiling, funcs: Optional[Dict[Tiling, Function]] = None
) -> Expr:
if not self.verified(comb_class):
raise StrategyDoesNotApply("tiling not locally verified")
if len(comb_class.obstructions) == 1 and comb_class.obstructions[0] in (
GriddedPerm.single_cell((0, 1, 2), (0, 0)),
GriddedPerm.single_cell((2, 1, 0), (0, 0)),
):
return LocalEnumeration(comb_class).get_genf(funcs=funcs)
try:
return super().get_genf(comb_class, funcs)
except InvalidOperationError:
return LocalEnumeration(comb_class).get_genf(funcs=funcs)
def gps_indices_direction_owncol_ownrow_ignoreparent_includeempty(strategy):
return [
strategy(
gps=gps,
indices=indices,
direction=direction,
own_col=own_col,
own_row=own_row,
ignore_parent=ignore_parent,
include_empty=include_empty,
) for (
gps,
indices,
), direction, own_col, own_row, ignore_parent, include_empty in
product(
(
((GriddedPerm(Perm((0, )), ((0, 0), )), ), (0, )),
((GriddedPerm.single_cell(Perm((0, 1, 2)), (2, 1)), ), (1, )),
(
(
GriddedPerm(Perm((0, 1)), ((0, 1), (1, 1))),
GriddedPerm(Perm((1, 0)), ((2, 2), (3, 1))),
),
(1, 0),
),
),
(DIR_EAST, DIR_WEST, DIR_NORTH, DIR_SOUTH),
(True, False),
(True, False),
(True, False),
(True, False),
)
]
def req_lists_to_insert(self, tiling: Tiling) -> Iterator[ListRequirement]:
active = tiling.active_cells
bdict = tiling.cell_basis()
for cell, length in product(active, range(1, self.maxreqlen + 1)):
basis = bdict[cell][0] + self.extra_basis
yield from ((GriddedPerm.single_cell(patt, cell), )
for patt in Av(basis).of_length(length)
if not any(patt in perm for perm in bdict[cell][1]))
def test_shifts(self):
t1 = Tiling(
obstructions=[
GriddedPerm.single_cell((0, 1, 3, 2), ((0, 0))),
GriddedPerm.single_cell((0, 2, 1), ((1, 1))),
]
)
t2 = Tiling(
obstructions=[
GriddedPerm.single_cell((0, 1, 3, 2), ((0, 0))),
GriddedPerm.single_cell((0, 2, 1), ((1, 1))),
GriddedPerm((0, 2, 1), ((0, 0), (1, 1), (1, 1))),
],
requirements=[
[
GriddedPerm.single_cell((0, 1), ((1, 1))),
]
],
)
t3 = Tiling(
obstructions=[
GriddedPerm.single_cell((0, 2, 1), ((0, 0))),
GriddedPerm.single_cell((0, 2, 1), ((1, 1))),
]
)
strat = LocallyFactorableVerificationStrategy(basis=[Perm((0, 1, 3, 2))])
assert strat(t1).shifts() == (0,)
assert strat(t2).shifts() == (2,)
assert strat(t3).shifts() == ()
def _split_sum_assumption(
self,
assumption: SumComponentAssumption) -> List[TrackingAssumption]:
decomposition = self.sum_decomposition(assumption.cells)
return [
SumComponentAssumption(
GriddedPerm.single_cell((0, ), cell) for cell in cells)
for cells in decomposition
]
def test_children(self):
t1 = Tiling(
obstructions=[
GriddedPerm.single_cell((0, 1, 3, 2), ((0, 0))),
GriddedPerm.single_cell((0, 2, 1), ((0, 1))),
GriddedPerm((0, 1, 2), ((0, 0), (0, 0), (0, 1))),
]
)
t2 = Tiling(
obstructions=[
GriddedPerm.single_cell((0, 2, 1), ((0, 0))),
GriddedPerm.single_cell((0, 2, 1), ((0, 1))),
GriddedPerm((0, 1, 2), ((0, 0), (0, 0), (0, 1))),
]
)
strategy = ShortObstructionVerificationStrategy(basis=[Perm((0, 1, 3, 2))])
assert strategy(t1).children == (Tiling.from_string("0132"),)
assert strategy(t2).children == ()
def _split_skew_assumption(
self,
assumption: SkewComponentAssumption,
) -> List[TrackingAssumption]:
decomposition = self.skew_decomposition(assumption.cells)
return [
SkewComponentAssumption(
GriddedPerm.single_cell(Perm((0, )), cell) for cell in cells)
for cells in decomposition
]
def enum_verified(self):
return [
# any 231 subclass
Tiling.from_string("132_4321"),
# any with regular insertion encoding, regardless of reqs
Tiling.from_string("012_1032"),
Tiling.from_string("012_1302").add_list_requirement([
GriddedPerm.single_cell(Perm((1, 0)), (0, 0)),
GriddedPerm.single_cell(Perm((0, 1)), (0, 0)),
]),
Tiling.from_string("0231_2103"),
# subclass of Av(123) avoiding patterns of length <= 4, positive or not
Tiling.from_string("012_2301").add_requirement(
Perm((0, )), [(0, 0)]),
# uses fusion
Tiling.from_string("123").insert_cell((0, 0)),
# no pack yet
Tiling.from_string("1324"),
]
def req_lists_to_insert(self, tiling: Tiling) -> Iterator[ListRequirement]:
bdict = tiling.cell_basis()
cell_with_req = ((cell, obs, reqlist[0])
for cell, (obs, reqlist) in bdict.items()
if len(reqlist) == 1)
for cell, obs, curr_req in cell_with_req:
for length in range(len(curr_req) + 1, self.maxreqlen + 1):
for patt in Av(obs + self.extra_basis).of_length(length):
if curr_req in patt:
yield (GriddedPerm.single_cell(patt, cell), )
def req_lists_to_insert(self, tiling: Tiling) -> Iterator[ListRequirement]:
if self.one_cell_only:
assert self.maxreqlen == 1 and self.ignore_parent
cells = sorted(
frozenset(tiling.active_cells) - frozenset(tiling.positive_cells)
)
if cells:
yield (GriddedPerm.single_cell((0,), cells[0]),)
return
active = tiling.active_cells
bdict = tiling.cell_basis()
for cell, length in product(active, range(1, self.maxreqlen + 1)):
basis = bdict[cell][0] + self.extra_basis
patterns = Av(basis).of_length(length) if basis else Perm.of_length(length)
yield from (
(GriddedPerm.single_cell(patt, cell),)
for patt in patterns
if not any(patt in perm for perm in bdict[cell][1])
)
def gps_ignoreparent(strategy):
return [
strategy(gps=gps, ignore_parent=ignore_parent)
for gps, ignore_parent in product(
(
(GriddedPerm(Perm((0, )), ((0, 0), )), ),
(GriddedPerm.single_cell(Perm((0, 1, 2)), (2, 1)), ),
(
GriddedPerm(Perm((0, 1)), ((0, 1), (1, 1))),
GriddedPerm(Perm((1, 0)), ((2, 2), (3, 1))),
),
),
(True, False),
)
]
def test_from_iterable():
pos = ((0, 0), (1, 1), (2, 1))
gp = GriddedPerm(Perm((0, 1, 2)), pos)
assert GriddedPerm((0, 1, 2), pos) == gp
assert GriddedPerm([0, 1, 2], pos) == gp
assert GriddedPerm(range(3), pos) == gp
assert GriddedPerm((i for i in range(3)), pos) == gp
assert GriddedPerm.single_cell(
(0, 1), (0, 0)) == GriddedPerm(Perm((0, 1)), ((0, 0), (0, 0)))
assert GriddedPerm((0, 2, 1, 3, 4),
((0, 0), (0, 1), (1, 0), (1, 1), (1, 1)))._cells == {
(0, 0),
(0, 1),
(1, 0),
(1, 1),
}
def test_children(self):
t1 = Tiling(
obstructions=[
GriddedPerm.single_cell((0, 1, 3, 2), ((0, 0))),
GriddedPerm.single_cell((0, 2, 1), ((1, 1))),
]
)
t2 = Tiling(
obstructions=[
GriddedPerm.single_cell((0, 1, 3, 2), ((0, 0))),
GriddedPerm.single_cell((0, 2, 1), ((1, 1))),
GriddedPerm((0, 2, 1), ((0, 0), (1, 1), (1, 1))),
]
)
t3 = Tiling(
obstructions=[
GriddedPerm.single_cell((0, 2, 1), ((0, 0))),
GriddedPerm.single_cell((0, 2, 1), ((1, 1))),
]
)
t4 = Tiling(
obstructions=[
GriddedPerm.single_cell((0, 1, 3, 2), ((0, 0))),
GriddedPerm.single_cell((0, 2, 1), ((0, 1))),
GriddedPerm((0, 2, 1), ((0, 0), (0, 1), (0, 1))),
]
)
strat = LocallyFactorableVerificationStrategy(basis=[Perm((0, 1, 3, 2))])
assert strat(t1).children == (Tiling.from_string("0132"),)
assert strat(t2).children == (Tiling.from_string("0132"),)
assert strat(t3).children == tuple()
with pytest.raises(StrategyDoesNotApply):
strat(t4).children
assert strat.decomposition_function(t4) is None
assert strat(t1.add_single_cell_requirement(Perm((0,)), (0, 0))).children == (
Tiling.from_string("0132"),
)
strat_with_sym = LocallyFactorableVerificationStrategy(
basis=[Perm((0, 1, 3, 2))], symmetry=True
)
assert strat_with_sym(t1).children == (Tiling.from_string("0132"),)
assert strat_with_sym(t1.rotate90()).children == (Tiling.from_string("0132"),)
def test_stretched_obstructions_and_assumptions(
placement1, placement1owncol, placement1ownrow
):
obs, reqs, _ = placement1._stretched_obstructions_requirements_and_assumptions(
(1, 1)
)
assert set(obs) == set(
placement1.stretched_obstructions((1, 1))
+ [
GriddedPerm.single_cell(Perm((0, 1)), (2, 2)),
GriddedPerm.single_cell(Perm((1, 0)), (2, 2)),
]
)
assert sorted(reqs) == sorted(
placement1.stretched_requirements((1, 1))
+ [[GriddedPerm(Perm((0,)), ((2, 2),))]]
)
(
obs,
reqs,
_,
) = placement1ownrow._stretched_obstructions_requirements_and_assumptions((1, 1))
assert set(obs) == set(
placement1ownrow.stretched_obstructions((1, 1))
+ [
GriddedPerm.single_cell(Perm((0, 1)), (1, 2)),
GriddedPerm.single_cell(Perm((1, 0)), (1, 2)),
]
)
assert sorted(reqs) == sorted(
placement1ownrow.stretched_requirements((1, 1))
+ [[GriddedPerm(Perm((0,)), ((1, 2),))]]
)
(
obs,
reqs,
_,
) = placement1owncol._stretched_obstructions_requirements_and_assumptions((1, 1))
assert set(obs) == set(
placement1owncol.stretched_obstructions((1, 1))
+ [
GriddedPerm.single_cell(Perm((0, 1)), (2, 1)),
GriddedPerm.single_cell(Perm((1, 0)), (2, 1)),
]
)
assert sorted(reqs) == sorted(
placement1owncol.stretched_requirements((1, 1))
+ [[GriddedPerm(Perm((0,)), ((2, 1),))]]
)
def __init__(
self,
start_class: Union[str, Iterable[Perm], Tiling],
strategy_pack: TileScopePack,
ruledb: Optional[RuleDBAbstract] = None,
expand_verified: bool = False,
debug: bool = False,
) -> None:
"""Initialise TileScope."""
if isinstance(start_class, str):
basis = Basis.from_string(start_class)
elif isinstance(start_class, Tiling):
if start_class.dimensions == (1, 1):
basis = Basis(*[o.patt for o in start_class.obstructions])
start_tiling = start_class
else:
try:
basis = Basis(*start_class)
except TypeError as e:
raise ValueError(
"start class must be a string, an iterable of Perm or a tiling"
) from e
if not isinstance(start_class, Tiling):
start_tiling = Tiling(obstructions=[
GriddedPerm.single_cell(patt, (0, 0)) for patt in basis
])
if start_tiling.dimensions == (1, 1):
logger.debug(
"Fixing basis in basis aware verification strategies.")
strategy_pack = strategy_pack.add_basis(basis)
strategy_pack = strategy_pack.setup_subclass_verification(start_tiling)
super().__init__(
start_class=start_tiling,
strategy_pack=strategy_pack,
ruledb=ruledb,
expand_verified=expand_verified,
debug=debug,
)
def __init__(self,
start_class: Union[str, Iterable[Perm], Tiling],
strategy_pack: TileScopePack,
logger_kwargs: Optional[dict] = None,
**kwargs) -> None:
"""Initialise TileScope."""
if isinstance(start_class, str):
basis = Basis([
Perm.to_standard([int(c) for c in p])
for p in start_class.split("_")
])
elif isinstance(start_class, Tiling):
start_tiling = start_class
if start_class.dimensions == (1, 1):
basis = Basis([o.patt for o in start_class.obstructions])
elif isinstance(start_class, collections.abc.Iterable):
basis = Basis(start_class)
assert all(isinstance(p, Perm)
for p in basis), "Basis must contains Perm only"
else:
raise ValueError(
"start class must be a string, an iterable of Perm or a tiling"
)
if not isinstance(start_class, Tiling):
start_tiling = Tiling(obstructions=[
GriddedPerm.single_cell(patt, (0, 0)) for patt in basis
])
if start_tiling.dimensions == (1, 1):
procname = kwargs.get("logger_kwargs", {"processname": "runner"})
logger.debug("Fixing basis in OneByOneVerificationStrategy",
extra=procname)
strategy_pack = strategy_pack.fix_one_by_one(basis)
super().__init__(
start_tiling,
strategy_pack,
logger_kwargs=logger_kwargs,
**kwargs,
)
def easy_fusable(
pos_left=False,
pos_right=False,
track_left=False,
track_right=False,
same_tracking=False,
):
if same_tracking:
assert track_left and track_right
obs = [
GriddedPerm.single_cell((0, 1), (0, 0)),
GriddedPerm((0, 1), ((0, 0), (1, 0))),
GriddedPerm.single_cell((0, 1), (1, 0)),
]
reqs = []
if pos_left:
reqs.append([GriddedPerm.single_cell((0, ), (0, 0))])
if pos_right:
reqs.append([GriddedPerm.single_cell((0, ), (1, 0))])
ass = []
if same_tracking:
ass.append(
TrackingAssumption([
GriddedPerm.single_cell((0, ), (0, 0)),
GriddedPerm.single_cell((0, ), (1, 0)),
]))
else:
if track_left:
ass.append(
TrackingAssumption([GriddedPerm.single_cell((0, ), (0, 0))]))
if track_right:
ass.append(
TrackingAssumption([GriddedPerm.single_cell((0, ), (1, 0))]))
tiling = Tiling(obstructions=obs, requirements=reqs, assumptions=ass)
return tiling
def singlecellob():
return GriddedPerm.single_cell((1, 0, 3, 2), (2, 2))
def test_cell_insertion():
t1 = Tiling.from_string("123")
ci1 = CellInsertionFactory(maxreqlen=3)
assert set(ci1.req_lists_to_insert(t1)) == set(
[
(GriddedPerm.single_cell(Perm((0,)), (0, 0)),),
(GriddedPerm.single_cell(Perm((0, 1)), (0, 0)),),
(GriddedPerm.single_cell(Perm((1, 0)), (0, 0)),),
(GriddedPerm.single_cell(Perm((0, 2, 1)), (0, 0)),),
(GriddedPerm.single_cell(Perm((1, 0, 2)), (0, 0)),),
(GriddedPerm.single_cell(Perm((1, 2, 0)), (0, 0)),),
(GriddedPerm.single_cell(Perm((2, 0, 1)), (0, 0)),),
(GriddedPerm.single_cell(Perm((2, 1, 0)), (0, 0)),),
]
)
assert len(list(ci1(t1))) == 8
t2 = t1.add_single_cell_requirement(Perm((2, 1, 0)), (0, 0))
ci2 = CellInsertionFactory(maxreqlen=3)
assert set(ci2.req_lists_to_insert(t2)) == set(
[
(GriddedPerm.single_cell(Perm((0, 1)), (0, 0)),),
(GriddedPerm.single_cell(Perm((0, 2, 1)), (0, 0)),),
(GriddedPerm.single_cell(Perm((1, 0, 2)), (0, 0)),),
(GriddedPerm.single_cell(Perm((1, 2, 0)), (0, 0)),),
(GriddedPerm.single_cell(Perm((2, 0, 1)), (0, 0)),),
]
)
assert len(list(ci2(t2))) == 5
ci3 = CellInsertionFactory(maxreqlen=3, extra_basis=[Perm((0, 2, 1))])
assert set(ci3.req_lists_to_insert(t1)) == set(
[
(GriddedPerm.single_cell(Perm((0,)), (0, 0)),),
(GriddedPerm.single_cell(Perm((0, 1)), (0, 0)),),
(GriddedPerm.single_cell(Perm((1, 0)), (0, 0)),),
(GriddedPerm.single_cell(Perm((1, 0, 2)), (0, 0)),),
(GriddedPerm.single_cell(Perm((1, 2, 0)), (0, 0)),),
(GriddedPerm.single_cell(Perm((2, 0, 1)), (0, 0)),),
(GriddedPerm.single_cell(Perm((2, 1, 0)), (0, 0)),),
]
)
assert len(list(ci3(t1))) == 7
from sympy import Eq, Function, var
from tilings import GriddedPerm, Tiling
from tilings.assumptions import TrackingAssumption
from tilings.strategies import SplittingStrategy
t = Tiling(
obstructions=[
GriddedPerm.single_cell((0, 1, 2), (0, 0)),
GriddedPerm.single_cell((0, 1), (1, 0)),
GriddedPerm.single_cell((0, 1, 2), (2, 1)),
GriddedPerm.single_cell((0, 1, 2), (3, 1)),
],
assumptions=[
TrackingAssumption([
GriddedPerm.point_perm((0, 0)),
GriddedPerm.point_perm((1, 0)),
GriddedPerm.point_perm((2, 1)),
GriddedPerm.point_perm((3, 1)),
])
],
)
def test_no_interleaving():
strat = SplittingStrategy(interleaving="none")
rule = strat(t)
assert len(rule.children) == 1
child = rule.children[0]
assert len(child.assumptions) == 2
assert (TrackingAssumption(
