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 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 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 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 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 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)")
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(
