def interleaving_parameters(self,
comb_class: Tiling) -> List[Tuple[str, ...]]:
"""
Return the parameters on the parent tiling that needed to be interleaved.
"""
res: List[Tuple[str, ...]] = []
cols, rows = interleaving_rows_and_cols(self.partition)
for x in cols:
assumptions = [
TrackingAssumption(
GriddedPerm.point_perm(cell) for cell in cells
if x == cell[0]) for cells in self.partition
]
res.append(
tuple(
comb_class.get_assumption_parameter(ass)
for ass in assumptions if ass.gps))
for y in rows:
assumptions = [
TrackingAssumption(
GriddedPerm.point_perm(cell) for cell in cells
if y == cell[1]) for cells in self.partition
]
res.append(
tuple(
comb_class.get_assumption_parameter(ass)
for ass in assumptions if ass.gps))
return res
def enum_verified(self):
t1 = Tiling(
obstructions=[
GriddedPerm((0, 1), ((0, 0), (1, 1))),
GriddedPerm((0, 1), ((0, 0),) * 2),
GriddedPerm((0, 1), ((0, 1),) * 2),
GriddedPerm((0, 1), ((1, 1),) * 2),
]
)
t2 = Tiling(
obstructions=[
GriddedPerm((0, 1), ((0, 1),) * 2),
GriddedPerm((1, 0), ((0, 1),) * 2),
GriddedPerm((0, 1), ((1, 0),) * 2),
GriddedPerm((0, 1), ((2, 0),) * 2),
],
requirements=[[GriddedPerm((0,), ((0, 1),))]],
assumptions=[
TrackingAssumption(
[GriddedPerm((0,), ((0, 1),)), GriddedPerm((0,), ((1, 0),))]
),
TrackingAssumption([GriddedPerm((0,), ((1, 0),))]),
],
)
return [t1, t2]
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 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_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(
[GriddedPerm.point_perm((0, 0)),
GriddedPerm.point_perm((1, 0))]) in child.assumptions)
assert (TrackingAssumption(
[GriddedPerm.point_perm((2, 1)),
GriddedPerm.point_perm((3, 1))]) in child.assumptions)
def test_positive_fusion():
tiling = Tiling([
GriddedPerm(Perm((0, 1, 2)), [(0, 0), (0, 0), (0, 0)]),
GriddedPerm(Perm((0, 1, 2)), [(0, 0), (0, 0), (1, 0)]),
GriddedPerm(Perm((0, 1, 2)), [(0, 0), (1, 0), (1, 0)]),
GriddedPerm(Perm((0, 1, 2)), [(1, 0), (1, 0), (1, 0)]),
])
positive_left = tiling.insert_cell((0, 0))
positive_right = tiling.insert_cell((1, 0))
positive_both = tiling.insert_cell((0, 0)).insert_cell((1, 0))
strategy = FusionStrategy(col_idx=0, tracked=True)
rule = strategy(tiling)
assert rule.children == (Tiling(
obstructions=(GriddedPerm(Perm((0, 1, 2)),
((0, 0), (0, 0), (0, 0))), ),
requirements=(),
assumptions=(TrackingAssumption((GriddedPerm(Perm((0, )),
((0, 0), )), )), ),
), )
rule = strategy(positive_left)
assert rule.children == (Tiling(
obstructions=(GriddedPerm(Perm((0, 1, 2)),
((0, 0), (0, 0), (0, 0))), ),
requirements=((GriddedPerm(Perm((0, )), ((0, 0), )), ), ),
assumptions=(TrackingAssumption((GriddedPerm(Perm((0, )),
((0, 0), )), )), ),
), )
rule = strategy(positive_right)
assert rule.children == (Tiling(
obstructions=(GriddedPerm(Perm((0, 1, 2)),
((0, 0), (0, 0), (0, 0))), ),
requirements=((GriddedPerm(Perm((0, )), ((0, 0), )), ), ),
assumptions=(TrackingAssumption((GriddedPerm(Perm((0, )),
((0, 0), )), )), ),
), )
rule = strategy(positive_both)
assert rule.children == (Tiling(
obstructions=(GriddedPerm(Perm((0, 1, 2)),
((0, 0), (0, 0), (0, 0))), ),
requirements=((
GriddedPerm(Perm((0, 1)), ((0, 0), (0, 0))),
GriddedPerm(Perm((1, 0)), ((0, 0), (0, 0))),
), ),
assumptions=(TrackingAssumption((GriddedPerm(Perm((0, )),
((0, 0), )), )), ),
), )
def test_multiple_parent_parameters_to_same_child_parameter():
tiling = Tiling(
obstructions=(
GriddedPerm((0, 1), ((1, 0), (1, 0))),
GriddedPerm((0, 1), ((2, 0), (2, 0))),
GriddedPerm((0, 1), ((2, 0), (3, 0))),
GriddedPerm((0, 1), ((3, 0), (3, 0))),
GriddedPerm((1, 2, 0), ((1, 0), (2, 0), (2, 0))),
GriddedPerm((1, 2, 0), ((1, 0), (2, 0), (3, 0))),
GriddedPerm((1, 2, 0), ((1, 0), (3, 0), (3, 0))),
GriddedPerm((0, 1, 2, 3), ((0, 0), (0, 0), (0, 0), (0, 0))),
GriddedPerm((0, 1, 2, 3), ((0, 0), (0, 0), (0, 0), (1, 0))),
GriddedPerm((0, 1, 2, 3), ((0, 0), (0, 0), (0, 0), (2, 0))),
GriddedPerm((0, 1, 2, 3), ((0, 0), (0, 0), (0, 0), (3, 0))),
GriddedPerm((0, 1, 2, 3), ((0, 0), (0, 0), (1, 0), (2, 0))),
GriddedPerm((0, 1, 2, 3), ((0, 0), (0, 0), (1, 0), (3, 0))),
GriddedPerm((0, 2, 3, 1), ((0, 0), (0, 0), (0, 0), (0, 0))),
GriddedPerm((0, 2, 3, 1), ((0, 0), (0, 0), (0, 0), (1, 0))),
GriddedPerm((0, 2, 3, 1), ((0, 0), (0, 0), (0, 0), (2, 0))),
GriddedPerm((0, 2, 3, 1), ((0, 0), (0, 0), (0, 0), (3, 0))),
GriddedPerm((0, 2, 3, 1), ((0, 0), (0, 0), (1, 0), (1, 0))),
GriddedPerm((0, 2, 3, 1), ((0, 0), (0, 0), (1, 0), (2, 0))),
GriddedPerm((0, 2, 3, 1), ((0, 0), (0, 0), (1, 0), (3, 0))),
GriddedPerm((0, 2, 3, 1), ((0, 0), (0, 0), (2, 0), (2, 0))),
GriddedPerm((0, 2, 3, 1), ((0, 0), (0, 0), (2, 0), (3, 0))),
GriddedPerm((0, 2, 3, 1), ((0, 0), (0, 0), (3, 0), (3, 0))),
),
requirements=(),
assumptions=(
TrackingAssumption((GriddedPerm((0,), ((2, 0),)),)),
TrackingAssumption(
(GriddedPerm((0,), ((2, 0),)), GriddedPerm((0,), ((3, 0),)))
),
),
)
strategy = RequirementPlacementStrategy(
gps=(
GriddedPerm((0,), ((1, 0),)),
GriddedPerm((0,), ((2, 0),)),
GriddedPerm((0,), ((3, 0),)),
GriddedPerm((0,), ((0, 0),)),
),
indices=(0, 0, 0, 0),
direction=3,
own_col=True,
own_row=True,
ignore_parent=False,
include_empty=True,
)
rule = strategy(tiling)
for i in range(6):
rule.sanity_check(i)
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 rule1():
ass1 = TrackingAssumption([GriddedPerm((0, ), ((0, 0), ))])
ass2 = TrackingAssumption(
[GriddedPerm((0, ), ((0, 0), )),
GriddedPerm((0, ), ((1, 0), ))])
strat = RearrangeAssumptionStrategy(ass2, ass1)
t1 = Tiling(
obstructions=[
GriddedPerm((0, 1), ((0, 0), ) * 2),
GriddedPerm((0, 1), ((1, 0), ) * 2),
],
assumptions=[ass1, ass2],
)
return strat(t1)
def test_fusing_empty_region(self):
tiling = Tiling(
obstructions=(
GriddedPerm((0, 1), ((0, 0), (0, 0))),
GriddedPerm((0, 1), ((0, 0), (0, 1))),
GriddedPerm((0, 1), ((0, 1), (0, 1))),
GriddedPerm((1, 0), ((0, 3), (0, 0))),
GriddedPerm((1, 0), ((0, 3), (0, 1))),
GriddedPerm((0, 1, 2), ((0, 0), (0, 2), (0, 2))),
GriddedPerm((0, 1, 2), ((0, 0), (0, 2), (0, 3))),
GriddedPerm((0, 1, 2), ((0, 0), (0, 3), (0, 3))),
GriddedPerm((0, 1, 2), ((0, 1), (0, 2), (0, 2))),
GriddedPerm((0, 1, 2), ((0, 1), (0, 2), (0, 3))),
GriddedPerm((0, 1, 2), ((0, 1), (0, 3), (0, 3))),
GriddedPerm((0, 1, 2), ((0, 2), (0, 2), (0, 2))),
GriddedPerm((0, 1, 2), ((0, 2), (0, 3), (0, 3))),
GriddedPerm((2, 0, 1), ((0, 3), (0, 2), (0, 2))),
GriddedPerm((0, 1, 2, 3), ((0, 3), (0, 3), (0, 3), (0, 3))),
GriddedPerm((0, 2, 3, 1), ((0, 2), (0, 2), (0, 3), (0, 2))),
GriddedPerm((0, 2, 3, 1), ((0, 3), (0, 3), (0, 3), (0, 3))),
GriddedPerm((3, 0, 1, 2), ((0, 3), (0, 3), (0, 3), (0, 3))),
),
requirements=((GriddedPerm((0, 1), ((0, 3), (0, 3))), ), ),
assumptions=(TrackingAssumption((GriddedPerm((0, ),
((0, 0), )), )), ),
)
assert not Fusion(tiling, col_idx=0, tracked=True).fusable()
def test_mapping_assumptions():
tiling = Tiling(
obstructions=(
GriddedPerm((0,), ((0, 1),)),
GriddedPerm((0,), ((2, 1),)),
GriddedPerm((0, 1), ((1, 0), (1, 0))),
GriddedPerm((0, 1), ((1, 0), (1, 1))),
GriddedPerm((0, 1), ((1, 1), (1, 1))),
GriddedPerm((1, 0), ((1, 0), (1, 0))),
GriddedPerm((1, 0), ((1, 1), (1, 0))),
GriddedPerm((1, 0), ((1, 1), (1, 1))),
GriddedPerm((1, 0), ((2, 0), (2, 0))),
GriddedPerm((0, 2, 1), ((0, 0), (0, 0), (2, 0))),
GriddedPerm((0, 2, 3, 1), ((0, 0), (0, 0), (0, 0), (0, 0))),
GriddedPerm((0, 2, 3, 1), ((0, 0), (0, 0), (0, 0), (1, 0))),
GriddedPerm((0, 3, 2, 1), ((0, 0), (0, 0), (0, 0), (0, 0))),
GriddedPerm((0, 3, 2, 1), ((0, 0), (0, 0), (0, 0), (1, 0))),
),
requirements=((GriddedPerm((0,), ((1, 1),)),),),
assumptions=(
TrackingAssumption(
(GriddedPerm((0,), ((1, 0),)), GriddedPerm((0,), ((1, 1),)))
),
),
)
strategy = RowColumnSeparationStrategy()
rule = strategy(tiling)
assert strategy.extra_parameters(tiling, rule.children) == ({"k_0": "k_0"},)
def assumptions_to_add(cells: Tuple[Cell, ...], cols: Set[int],
rows: Set[int]) -> Tuple[TrackingAssumption, ...]:
"""
Return the assumptions that should be tracked in the set of cells if we are
interleaving the given rows and cols.
"""
col_assumptions = [
TrackingAssumption(
[GriddedPerm.point_perm(cell) for cell in cells if x == cell[0]])
for x in cols
]
row_assumptions = [
TrackingAssumption(
[GriddedPerm.point_perm(cell) for cell in cells if y == cell[1]])
for y in rows
]
return tuple(ass for ass in chain(col_assumptions, row_assumptions)
if ass.gps)
def add_assumption() -> dict:
"""Apply add assumption strategy to given tiling."""
tiling, verification_tactics, gps = _get_add_assumption_input()
try:
rule = AddAssumptionsStrategy((TrackingAssumption(gps), ))(tiling)
except StrategyDoesNotApply as exc:
raise BadRequest() from exc
if not rule.children or rule.children[0] == tiling:
raise BadRequest()
return rule_as_json(rule, verification_tactics)
def new_assumption(self):
"""
Return the assumption that needs to counted in order to enumerate.
"""
return TrackingAssumption(
GriddedPerm.single_cell(Perm((0,)), cell)
for cell in self._tiling.active_cells
if (self._fuse_row and cell[1] == self._row_idx)
or (not self._fuse_row and cell[0] == self._col_idx)
)
def test_indexed_backward_map():
r = FusionStrategy(col_idx=0, tracked=True)(Tiling(
obstructions=(
GriddedPerm((0, 1), ((0, 0), (0, 0))),
GriddedPerm((0, 1), ((0, 0), (1, 0))),
GriddedPerm((0, 1), ((1, 0), (1, 0))),
GriddedPerm((0, 1, 2), ((0, 0), (2, 0), (2, 0))),
GriddedPerm((0, 1, 2), ((1, 0), (2, 0), (2, 0))),
GriddedPerm((0, 1, 2), ((2, 0), (2, 0), (2, 0))),
),
requirements=(),
assumptions=(TrackingAssumption((GriddedPerm((0, ), ((0, 0), )), )), ),
))
order = [
GriddedPerm(
(6, 5, 4, 3, 1, 0, 2),
((1, 0), (1, 0), (1, 0), (1, 0), (1, 0), (1, 0), (2, 0)),
),
GriddedPerm(
(6, 5, 4, 3, 1, 0, 2),
((0, 0), (1, 0), (1, 0), (1, 0), (1, 0), (1, 0), (2, 0)),
),
GriddedPerm(
(6, 5, 4, 3, 1, 0, 2),
((0, 0), (0, 0), (1, 0), (1, 0), (1, 0), (1, 0), (2, 0)),
),
GriddedPerm(
(6, 5, 4, 3, 1, 0, 2),
((0, 0), (0, 0), (0, 0), (1, 0), (1, 0), (1, 0), (2, 0)),
),
GriddedPerm(
(6, 5, 4, 3, 1, 0, 2),
((0, 0), (0, 0), (0, 0), (0, 0), (1, 0), (1, 0), (2, 0)),
),
GriddedPerm(
(6, 5, 4, 3, 1, 0, 2),
((0, 0), (0, 0), (0, 0), (0, 0), (0, 0), (1, 0), (2, 0)),
),
GriddedPerm(
(6, 5, 4, 3, 1, 0, 2),
((0, 0), (0, 0), (0, 0), (0, 0), (0, 0), (0, 0), (2, 0)),
),
]
gp = GriddedPerm((6, 5, 4, 3, 1, 0, 2),
((0, 0), (0, 0), (0, 0), (0, 0), (0, 0), (0, 0), (1, 0)))
assert all(
r.indexed_backward_map((gp, ), i) == target
for i, target in enumerate(order))
assert all(
r.indexed_backward_map((gp, ), i, True) == target
for i, target in enumerate(reversed(order)))
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 test_from_cell():
assert TrackingAssumption.from_cells([]) == TrackingAssumption([])
assert TrackingAssumption.from_cells([
(0, 1)
]) == TrackingAssumption([GriddedPerm((0, ), [(0, 1)])])
assert TrackingAssumption.from_cells([(0, 1),
(2, 3)]) == TrackingAssumption([
GriddedPerm((0, ), [(0, 1)]),
GriddedPerm((0, ), [(2, 3)]),
])
def _split_tracking_assumption(
assumption: TrackingAssumption,
components: Tuple[Set[Cell], ...]) -> List[TrackingAssumption]:
split_gps: List[List[GriddedPerm]] = [[]
for _ in range(len(components))]
for gp in assumption.gps:
for idx, component in enumerate(components):
if all(cell in component for cell in gp.pos):
split_gps[idx].append(gp)
# only add to one list
break
else:
# gridded perm can't be partitioned, so the partition can't be
# partitioned
return [assumption]
return [assumption.__class__(gps) for gps in split_gps if gps]
def __init__(
self,
parent: Tiling,
child: Tiling,
assumption: TrackingAssumption,
sub_assumption: TrackingAssumption,
extra_parameters: Dict[str, str],
):
"""
Constructor for the rearrange strategy.
The extra_parameters should a dict mapping variable on the parent to the
associated variable on the child. The variable for `assumption` should not
appear in the dict since it does not match directly to a variable on the child.
"""
new_ass = TrackingAssumption(set(assumption.gps) - set(sub_assumption.gps))
self.new_ass_child_idx = child.extra_parameters.index(
child.get_assumption_parameter(new_ass)
)
self.ass_parent_idx = parent.extra_parameters.index(
parent.get_assumption_parameter(assumption)
)
self.subass_parent_idx = parent.extra_parameters.index(
parent.get_assumption_parameter(sub_assumption)
)
self.subass_child_idx = child.extra_parameters.index(
child.get_assumption_parameter(sub_assumption)
)
self.child_to_parent_param_map = self._build_child_to_parent_param_map(
parent,
child,
extra_parameters,
assumption,
sub_assumption,
)
self.parent_to_child_param_map = self._build_parent_to_child_param_map(
parent,
child,
extra_parameters,
assumption,
sub_assumption,
)
self.parent_dict_to_param = self._build_map_dict_to_param(parent)
self.child_param_to_dict = self._build_map_param_to_dict(child)
self.eq_subs = self._build_eq_subs(parent, child, extra_parameters)
def test_indexed_forward_map():
assert FusionStrategy(col_idx=0, tracked=True)(Tiling(
obstructions=(
GriddedPerm((0, 1), ((0, 0), (0, 0))),
GriddedPerm((0, 1), ((0, 0), (1, 0))),
GriddedPerm((0, 1), ((1, 0), (1, 0))),
GriddedPerm((0, 1, 2), ((0, 0), (2, 0), (2, 0))),
GriddedPerm((0, 1, 2), ((1, 0), (2, 0), (2, 0))),
GriddedPerm((0, 1, 2), ((2, 0), (2, 0), (2, 0))),
),
requirements=(),
assumptions=(TrackingAssumption((GriddedPerm((0, ), ((0, 0), )), )), ),
)).indexed_forward_map(
GriddedPerm(
(6, 5, 4, 3, 1, 0, 2),
((0, 0), (0, 0), (0, 0), (1, 0), (1, 0), (1, 0), (2, 0)),
)) == (
(GriddedPerm(
(6, 5, 4, 3, 1, 0, 2),
((0, 0), (0, 0), (0, 0), (0, 0), (0, 0), (0, 0), (1, 0)),
), ),
3,
)
GriddedPerm((0, 1, 2), ((1, 0), (3, 0), (3, 0))),
GriddedPerm((0, 1, 2), ((2, 0), (3, 0), (3, 0))),
GriddedPerm((0, 1, 2), ((3, 0), (3, 0), (3, 0))),
GriddedPerm((3, 0, 1, 2), ((0, 0), (0, 0), (0, 0), (0, 0))),
GriddedPerm((3, 0, 1, 2), ((0, 0), (0, 0), (0, 0), (1, 0))),
GriddedPerm((3, 0, 1, 2), ((0, 0), (0, 0), (0, 0), (2, 0))),
GriddedPerm((3, 0, 1, 2), ((0, 0), (0, 0), (0, 0), (3, 0))),
GriddedPerm((3, 0, 1, 2), ((0, 0), (0, 0), (1, 0), (1, 0))),
GriddedPerm((3, 0, 1, 2), ((0, 0), (0, 0), (1, 0), (2, 0))),
GriddedPerm((3, 0, 1, 2), ((0, 0), (0, 0), (1, 0), (3, 0))),
GriddedPerm((3, 0, 1, 2), ((0, 0), (0, 0), (2, 0), (3, 0))),
GriddedPerm((3, 0, 1, 2), ((0, 0), (0, 0), (3, 0), (3, 0))),
),
requirements=(),
assumptions=(
TrackingAssumption((GriddedPerm(
(0, ), ((2, 0), )), GriddedPerm((0, ), ((3, 0), )))),
TrackingAssumption((GriddedPerm((0, ), ((3, 0), )), )),
),
)
def sanity_checker(rules):
found_some = False
for rule in rules:
found_some = True
for length in range(5):
rule.sanity_check(length)
return found_some
def test_sliding_factory():
def enum_verified(self):
t = Tiling(
obstructions=[
GriddedPerm(Perm((0, 1, 2)), ((0, 0), ) * 3),
GriddedPerm(Perm((1, 0, 2)), ((0, 0), ) * 3),
GriddedPerm(Perm((2, 0, 1)), ((0, 0), ) * 3),
GriddedPerm(Perm((0, 2, 1)), ((1, 0), ) * 3),
GriddedPerm(Perm((0, 1, 2)), ((1, 0), ) * 3),
GriddedPerm(Perm((1, 0, 2)), ((1, 0), ) * 3),
GriddedPerm(Perm((2, 0, 1)), ((1, 0), ) * 3),
],
requirements=[
[GriddedPerm(Perm((0, )), ((0, 0), ))],
[GriddedPerm(Perm((0, )), ((1, 0), ))],
],
)
t1 = Tiling(
obstructions=[
GriddedPerm(Perm((0, 1)), [(0, 0), (0, 0)]),
GriddedPerm(Perm((0, 1)), [(1, 1), (1, 1)]),
GriddedPerm(Perm((0, 1)), [(2, 0), (2, 0)]),
GriddedPerm(Perm((1, 0)), [(1, 1), (1, 1)]),
],
requirements=[
[GriddedPerm(Perm((1, 0)), ((0, 0), (0, 0)))],
[GriddedPerm.point_perm((1, 1))],
[GriddedPerm.point_perm((2, 0))],
],
assumptions=[
TrackingAssumption([GriddedPerm.point_perm((0, 0))]),
TrackingAssumption([GriddedPerm.point_perm((1, 1))]),
TrackingAssumption([GriddedPerm.point_perm((2, 0))]),
TrackingAssumption([
GriddedPerm.point_perm((0, 0)),
GriddedPerm.point_perm((2, 0))
]),
],
)
t2 = Tiling(
obstructions=(
GriddedPerm(Perm((0, )), ((0, 0), )),
GriddedPerm(Perm((0, )), ((1, 1), )),
GriddedPerm(Perm((0, )), ((2, 0), )),
GriddedPerm(Perm((0, 1)), ((0, 1), (0, 1))),
GriddedPerm(Perm((0, 1)), ((1, 0), (1, 0))),
GriddedPerm(Perm((0, 1)), ((2, 1), (2, 1))),
GriddedPerm(Perm((1, 0)), ((1, 0), (1, 0))),
),
requirements=(
(GriddedPerm(Perm((0, )), ((1, 0), )), ),
(GriddedPerm(Perm((1, 0)), ((2, 1), (2, 1))), ),
),
assumptions=(
TrackingAssumption((
GriddedPerm(Perm((0, )), ((0, 1), )),
GriddedPerm(Perm((0, )), ((1, 0), )),
)),
TrackingAssumption((
GriddedPerm(Perm((0, )), ((0, 1), )),
GriddedPerm(Perm((0, )), ((1, 0), )),
GriddedPerm(Perm((0, )), ((2, 1), )),
)),
TrackingAssumption((GriddedPerm(Perm((0, )), ((2, 1), )), )),
),
)
return [t, t1, t2]
def from_dict(cls, d: dict) -> "RearrangeAssumptionStrategy":
assumption = TrackingAssumption.from_dict(d.pop("assumption"))
sub_assumption = TrackingAssumption.from_dict(d.pop("sub_assumption"))
assert not d
return cls(assumption, sub_assumption)
def decomposition_function(self, comb_class: Tiling) -> Tuple[Tiling]:
tiling = comb_class.remove_assumption(self.assumption)
new_ass1 = TrackingAssumption(
set(self.assumption.gps) - set(self.sub_assumption.gps)
)
return (tiling.add_assumption(new_ass1),)
def test_eqv_path_complement():
strategy = ObstructionInferralStrategy(
gps=(GriddedPerm((0,), ((0, 1),)), GriddedPerm((0,), ((0, 2),)))
)
tiling = Tiling(
obstructions=(
GriddedPerm((0, 1), ((0, 1), (0, 2))),
GriddedPerm((0, 1), ((0, 1), (0, 3))),
GriddedPerm((0, 1), ((0, 2), (0, 3))),
GriddedPerm((1, 0), ((0, 2), (0, 1))),
GriddedPerm((1, 0), ((0, 3), (0, 1))),
GriddedPerm((1, 0), ((0, 3), (0, 2))),
GriddedPerm((0, 2, 1), ((0, 1), (0, 4), (0, 4))),
GriddedPerm((0, 2, 1), ((0, 2), (0, 4), (0, 4))),
GriddedPerm((0, 2, 1), ((0, 3), (0, 4), (0, 4))),
GriddedPerm((2, 0, 1), ((0, 4), (0, 1), (0, 4))),
GriddedPerm((2, 0, 1), ((0, 4), (0, 2), (0, 4))),
GriddedPerm((2, 0, 1), ((0, 4), (0, 3), (0, 4))),
GriddedPerm((2, 1, 0), ((0, 4), (0, 4), (0, 1))),
GriddedPerm((2, 1, 0), ((0, 4), (0, 4), (0, 2))),
GriddedPerm((2, 1, 0), ((0, 4), (0, 4), (0, 3))),
GriddedPerm((1, 0, 3, 2), ((0, 1), (0, 1), (0, 1), (0, 1))),
GriddedPerm((1, 0, 3, 2), ((0, 1), (0, 1), (0, 4), (0, 1))),
GriddedPerm((1, 0, 3, 2), ((0, 2), (0, 2), (0, 2), (0, 2))),
GriddedPerm((1, 0, 3, 2), ((0, 2), (0, 2), (0, 4), (0, 2))),
GriddedPerm((1, 0, 3, 2), ((0, 3), (0, 3), (0, 3), (0, 3))),
GriddedPerm((1, 0, 3, 2), ((0, 3), (0, 3), (0, 4), (0, 3))),
GriddedPerm((1, 0, 3, 2), ((0, 4), (0, 4), (0, 4), (0, 4))),
GriddedPerm((1, 3, 0, 2), ((0, 1), (0, 1), (0, 1), (0, 1))),
GriddedPerm((1, 3, 0, 2), ((0, 1), (0, 4), (0, 1), (0, 1))),
GriddedPerm((1, 3, 0, 2), ((0, 2), (0, 2), (0, 2), (0, 2))),
GriddedPerm((1, 3, 0, 2), ((0, 2), (0, 4), (0, 2), (0, 2))),
GriddedPerm((1, 3, 0, 2), ((0, 3), (0, 3), (0, 3), (0, 3))),
GriddedPerm((1, 3, 0, 2), ((0, 3), (0, 4), (0, 3), (0, 3))),
GriddedPerm((1, 3, 0, 2), ((0, 4), (0, 4), (0, 4), (0, 4))),
GriddedPerm((1, 3, 2, 0), ((0, 1), (0, 1), (0, 1), (0, 1))),
GriddedPerm((1, 3, 2, 0), ((0, 1), (0, 4), (0, 1), (0, 1))),
GriddedPerm((1, 3, 2, 0), ((0, 2), (0, 2), (0, 2), (0, 2))),
GriddedPerm((1, 3, 2, 0), ((0, 2), (0, 4), (0, 2), (0, 2))),
GriddedPerm((1, 3, 2, 0), ((0, 3), (0, 3), (0, 3), (0, 3))),
GriddedPerm((1, 3, 2, 0), ((0, 3), (0, 4), (0, 3), (0, 3))),
GriddedPerm((1, 3, 2, 0), ((0, 4), (0, 4), (0, 4), (0, 4))),
GriddedPerm((0, 2, 1, 4, 3), ((0, 0), (0, 0), (0, 0), (0, 0), (0, 0))),
GriddedPerm((0, 2, 1, 4, 3), ((0, 0), (0, 0), (0, 0), (0, 1), (0, 0))),
GriddedPerm((0, 2, 1, 4, 3), ((0, 0), (0, 0), (0, 0), (0, 1), (0, 1))),
GriddedPerm((0, 2, 1, 4, 3), ((0, 0), (0, 0), (0, 0), (0, 2), (0, 0))),
GriddedPerm((0, 2, 1, 4, 3), ((0, 0), (0, 0), (0, 0), (0, 2), (0, 2))),
GriddedPerm((0, 2, 1, 4, 3), ((0, 0), (0, 0), (0, 0), (0, 3), (0, 0))),
GriddedPerm((0, 2, 1, 4, 3), ((0, 0), (0, 0), (0, 0), (0, 3), (0, 3))),
GriddedPerm((0, 2, 1, 4, 3), ((0, 0), (0, 0), (0, 0), (0, 4), (0, 0))),
GriddedPerm((0, 2, 1, 4, 3), ((0, 0), (0, 0), (0, 0), (0, 4), (0, 1))),
GriddedPerm((0, 2, 1, 4, 3), ((0, 0), (0, 0), (0, 0), (0, 4), (0, 2))),
GriddedPerm((0, 2, 1, 4, 3), ((0, 0), (0, 0), (0, 0), (0, 4), (0, 3))),
GriddedPerm((0, 2, 1, 4, 3), ((0, 0), (0, 0), (0, 0), (0, 4), (0, 4))),
GriddedPerm((0, 2, 1, 4, 3), ((0, 0), (0, 1), (0, 0), (0, 1), (0, 1))),
GriddedPerm((0, 2, 1, 4, 3), ((0, 0), (0, 1), (0, 0), (0, 4), (0, 1))),
GriddedPerm((0, 2, 1, 4, 3), ((0, 0), (0, 2), (0, 0), (0, 2), (0, 2))),
GriddedPerm((0, 2, 1, 4, 3), ((0, 0), (0, 2), (0, 0), (0, 4), (0, 2))),
GriddedPerm((0, 2, 1, 4, 3), ((0, 0), (0, 3), (0, 0), (0, 3), (0, 3))),
GriddedPerm((0, 2, 1, 4, 3), ((0, 0), (0, 3), (0, 0), (0, 4), (0, 3))),
GriddedPerm((0, 2, 1, 4, 3), ((0, 0), (0, 4), (0, 0), (0, 4), (0, 4))),
GriddedPerm((0, 2, 4, 1, 3), ((0, 0), (0, 0), (0, 0), (0, 0), (0, 0))),
GriddedPerm((0, 2, 4, 1, 3), ((0, 0), (0, 0), (0, 1), (0, 0), (0, 0))),
GriddedPerm((0, 2, 4, 1, 3), ((0, 0), (0, 0), (0, 1), (0, 0), (0, 1))),
GriddedPerm((0, 2, 4, 1, 3), ((0, 0), (0, 0), (0, 2), (0, 0), (0, 0))),
GriddedPerm((0, 2, 4, 1, 3), ((0, 0), (0, 0), (0, 2), (0, 0), (0, 2))),
GriddedPerm((0, 2, 4, 1, 3), ((0, 0), (0, 0), (0, 3), (0, 0), (0, 0))),
GriddedPerm((0, 2, 4, 1, 3), ((0, 0), (0, 0), (0, 3), (0, 0), (0, 3))),
GriddedPerm((0, 2, 4, 1, 3), ((0, 0), (0, 0), (0, 4), (0, 0), (0, 0))),
GriddedPerm((0, 2, 4, 1, 3), ((0, 0), (0, 0), (0, 4), (0, 0), (0, 1))),
GriddedPerm((0, 2, 4, 1, 3), ((0, 0), (0, 0), (0, 4), (0, 0), (0, 2))),
GriddedPerm((0, 2, 4, 1, 3), ((0, 0), (0, 0), (0, 4), (0, 0), (0, 3))),
GriddedPerm((0, 2, 4, 1, 3), ((0, 0), (0, 0), (0, 4), (0, 0), (0, 4))),
GriddedPerm((0, 2, 4, 1, 3), ((0, 0), (0, 1), (0, 1), (0, 0), (0, 1))),
GriddedPerm((0, 2, 4, 1, 3), ((0, 0), (0, 1), (0, 4), (0, 0), (0, 1))),
GriddedPerm((0, 2, 4, 1, 3), ((0, 0), (0, 2), (0, 2), (0, 0), (0, 2))),
GriddedPerm((0, 2, 4, 1, 3), ((0, 0), (0, 2), (0, 4), (0, 0), (0, 2))),
GriddedPerm((0, 2, 4, 1, 3), ((0, 0), (0, 3), (0, 3), (0, 0), (0, 3))),
GriddedPerm((0, 2, 4, 1, 3), ((0, 0), (0, 3), (0, 4), (0, 0), (0, 3))),
GriddedPerm((0, 2, 4, 1, 3), ((0, 0), (0, 4), (0, 4), (0, 0), (0, 4))),
GriddedPerm((0, 2, 4, 3, 1), ((0, 0), (0, 0), (0, 0), (0, 0), (0, 0))),
GriddedPerm((0, 2, 4, 3, 1), ((0, 0), (0, 0), (0, 1), (0, 0), (0, 0))),
GriddedPerm((0, 2, 4, 3, 1), ((0, 0), (0, 0), (0, 1), (0, 1), (0, 0))),
GriddedPerm((0, 2, 4, 3, 1), ((0, 0), (0, 0), (0, 2), (0, 0), (0, 0))),
GriddedPerm((0, 2, 4, 3, 1), ((0, 0), (0, 0), (0, 2), (0, 2), (0, 0))),
GriddedPerm((0, 2, 4, 3, 1), ((0, 0), (0, 0), (0, 3), (0, 0), (0, 0))),
GriddedPerm((0, 2, 4, 3, 1), ((0, 0), (0, 0), (0, 3), (0, 3), (0, 0))),
GriddedPerm((0, 2, 4, 3, 1), ((0, 0), (0, 0), (0, 4), (0, 0), (0, 0))),
GriddedPerm((0, 2, 4, 3, 1), ((0, 0), (0, 0), (0, 4), (0, 1), (0, 0))),
GriddedPerm((0, 2, 4, 3, 1), ((0, 0), (0, 0), (0, 4), (0, 2), (0, 0))),
GriddedPerm((0, 2, 4, 3, 1), ((0, 0), (0, 0), (0, 4), (0, 3), (0, 0))),
GriddedPerm((0, 2, 4, 3, 1), ((0, 0), (0, 0), (0, 4), (0, 4), (0, 0))),
GriddedPerm((0, 2, 4, 3, 1), ((0, 0), (0, 1), (0, 1), (0, 1), (0, 0))),
GriddedPerm((0, 2, 4, 3, 1), ((0, 0), (0, 1), (0, 4), (0, 1), (0, 0))),
GriddedPerm((0, 2, 4, 3, 1), ((0, 0), (0, 2), (0, 2), (0, 2), (0, 0))),
GriddedPerm((0, 2, 4, 3, 1), ((0, 0), (0, 2), (0, 4), (0, 2), (0, 0))),
GriddedPerm((0, 2, 4, 3, 1), ((0, 0), (0, 3), (0, 3), (0, 3), (0, 0))),
GriddedPerm((0, 2, 4, 3, 1), ((0, 0), (0, 3), (0, 4), (0, 3), (0, 0))),
GriddedPerm((0, 2, 4, 3, 1), ((0, 0), (0, 4), (0, 4), (0, 4), (0, 0))),
),
requirements=((GriddedPerm((0,), ((0, 3),)),),),
assumptions=(
TrackingAssumption((GriddedPerm((0,), ((0, 1),)),)),
TrackingAssumption(
(GriddedPerm((0,), ((0, 1),)), GriddedPerm((0,), ((0, 2),)))
),
TrackingAssumption(
(GriddedPerm((0,), ((0, 3),)), GriddedPerm((0,), ((0, 4),)))
),
),
)
rule = EquivalencePathRule([strategy(tiling).to_reverse_rule(0)])
for i in range(5):
rule.sanity_check(i)
def test_sanity_check_big_row_placement():
rule = RequirementPlacementStrategy(
gps=(
GriddedPerm((0,), ((0, 0),)),
GriddedPerm((0,), ((3, 0),)),
GriddedPerm((0,), ((1, 0),)),
GriddedPerm((0,), ((2, 0),)),
),
indices=(0, 0, 0, 0),
direction=1,
own_col=True,
own_row=True,
ignore_parent=False,
include_empty=True,
)(
Tiling(
obstructions=(
GriddedPerm((0, 1), ((0, 0), (0, 0))),
GriddedPerm((0, 1), ((0, 0), (3, 0))),
GriddedPerm((0, 1, 2), ((0, 0), (1, 0), (1, 0))),
GriddedPerm((0, 1, 2), ((1, 0), (1, 0), (1, 0))),
GriddedPerm((0, 1, 2), ((1, 0), (1, 0), (3, 0))),
GriddedPerm((0, 2, 1), ((1, 0), (1, 0), (3, 0))),
GriddedPerm((0, 1, 2, 3), ((0, 0), (1, 0), (2, 0), (2, 0))),
GriddedPerm((0, 1, 2, 3), ((0, 0), (2, 0), (2, 0), (2, 0))),
GriddedPerm((0, 1, 2, 3), ((1, 0), (1, 0), (2, 0), (2, 0))),
GriddedPerm((0, 1, 2, 3), ((1, 0), (2, 0), (2, 0), (2, 0))),
GriddedPerm((0, 1, 2, 3), ((1, 0), (2, 0), (2, 0), (3, 0))),
GriddedPerm((0, 1, 2, 3), ((2, 0), (2, 0), (2, 0), (2, 0))),
GriddedPerm((0, 1, 2, 3), ((2, 0), (2, 0), (2, 0), (3, 0))),
GriddedPerm((0, 1, 3, 2), ((1, 0), (2, 0), (2, 0), (3, 0))),
GriddedPerm((0, 1, 3, 2), ((2, 0), (2, 0), (2, 0), (3, 0))),
GriddedPerm((0, 2, 3, 1), ((1, 0), (2, 0), (2, 0), (3, 0))),
GriddedPerm((0, 2, 3, 1), ((2, 0), (2, 0), (2, 0), (3, 0))),
GriddedPerm((0, 1, 2, 3, 4), ((1, 0), (2, 0), (3, 0), (3, 0), (3, 0))),
GriddedPerm((0, 1, 2, 3, 4), ((1, 0), (3, 0), (3, 0), (3, 0), (3, 0))),
GriddedPerm((0, 1, 2, 3, 4), ((2, 0), (2, 0), (3, 0), (3, 0), (3, 0))),
GriddedPerm((0, 1, 2, 3, 4), ((2, 0), (3, 0), (3, 0), (3, 0), (3, 0))),
GriddedPerm((0, 1, 2, 3, 4), ((3, 0), (3, 0), (3, 0), (3, 0), (3, 0))),
GriddedPerm((0, 1, 2, 4, 3), ((1, 0), (2, 0), (3, 0), (3, 0), (3, 0))),
GriddedPerm((0, 1, 2, 4, 3), ((1, 0), (3, 0), (3, 0), (3, 0), (3, 0))),
GriddedPerm((0, 1, 2, 4, 3), ((2, 0), (2, 0), (3, 0), (3, 0), (3, 0))),
GriddedPerm((0, 1, 2, 4, 3), ((2, 0), (3, 0), (3, 0), (3, 0), (3, 0))),
GriddedPerm((0, 1, 2, 4, 3), ((3, 0), (3, 0), (3, 0), (3, 0), (3, 0))),
GriddedPerm((0, 1, 3, 4, 2), ((1, 0), (2, 0), (3, 0), (3, 0), (3, 0))),
GriddedPerm((0, 1, 3, 4, 2), ((1, 0), (3, 0), (3, 0), (3, 0), (3, 0))),
GriddedPerm((0, 1, 3, 4, 2), ((2, 0), (2, 0), (3, 0), (3, 0), (3, 0))),
GriddedPerm((0, 1, 3, 4, 2), ((2, 0), (3, 0), (3, 0), (3, 0), (3, 0))),
GriddedPerm((0, 1, 3, 4, 2), ((3, 0), (3, 0), (3, 0), (3, 0), (3, 0))),
GriddedPerm((0, 2, 3, 4, 1), ((1, 0), (2, 0), (3, 0), (3, 0), (3, 0))),
GriddedPerm((0, 2, 3, 4, 1), ((1, 0), (3, 0), (3, 0), (3, 0), (3, 0))),
GriddedPerm((0, 2, 3, 4, 1), ((2, 0), (2, 0), (3, 0), (3, 0), (3, 0))),
GriddedPerm((0, 2, 3, 4, 1), ((2, 0), (3, 0), (3, 0), (3, 0), (3, 0))),
GriddedPerm((0, 2, 3, 4, 1), ((3, 0), (3, 0), (3, 0), (3, 0), (3, 0))),
),
requirements=(),
assumptions=(
TrackingAssumption((GriddedPerm((0,), ((0, 0),)),)),
TrackingAssumption(
(GriddedPerm((0,), ((0, 0),)), GriddedPerm((0,), ((1, 0),)))
),
TrackingAssumption((GriddedPerm((0,), ((1, 0),)),)),
),
)
)
rule.sanity_check(2)
from tilings.strategies.sliding import SlidingFactory
rules_to_check = [
RequirementInsertionStrategy(
gps=frozenset({GriddedPerm((0,), ((0, 0),))}), ignore_parent=True
)(
Tiling(
obstructions=(
GriddedPerm((0, 1), ((0, 0), (0, 0))),
GriddedPerm((0, 1), ((0, 0), (1, 0))),
GriddedPerm((0, 1), ((1, 0), (1, 0))),
GriddedPerm((1, 0), ((0, 0), (1, 0))),
GriddedPerm((1, 0), ((1, 0), (1, 0))),
),
requirements=((GriddedPerm((0,), ((1, 0),)),),),
assumptions=(TrackingAssumption((GriddedPerm((0,), ((0, 0),)),)),),
)
),
RequirementInsertionStrategy(
gps=frozenset({GriddedPerm((0,), ((2, 0),))}), ignore_parent=True
)(
Tiling(
obstructions=(
GriddedPerm((0, 1), ((1, 0), (1, 0))),
GriddedPerm((0, 1), ((2, 0), (2, 0))),
GriddedPerm((0, 1), ((2, 0), (3, 0))),
GriddedPerm((0, 1), ((3, 0), (3, 0))),
GriddedPerm((1, 0), ((0, 0), (2, 0))),
GriddedPerm((1, 0), ((0, 0), (3, 0))),
GriddedPerm((1, 0), ((2, 0), (2, 0))),
GriddedPerm((1, 0), ((2, 0), (3, 0))),
def test_with_assumptions(self, strategy):
ass = TrackingAssumption([GriddedPerm.point_perm((0, 0))])
t = Tiling.from_string("01").add_assumption(ass)
assert strategy.verified(t)
assert strategy.get_genf(t) == sympy.sympify("-1/(k_0*x - 1)")
def from_dict(cls, d: dict) -> "AddAssumptionsStrategy":
assumptions = [
TrackingAssumption.from_dict(ass) for ass in d["assumptions"]
]
return cls(assumptions)
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(
[GriddedPerm.point_perm((0, 0)),
GriddedPerm.point_perm((1, 0))]) in child.assumptions)
