def pack(self, tiling: Tiling) -> StrategyPack:
if any(
isinstance(ass, ComponentAssumption)
for ass in tiling.assumptions):
raise InvalidOperationError(
"Can't find generating function with component assumption.")
# pylint: disable=import-outside-toplevel
from tilings.strategy_pack import TileScopePack
if self.has_rightmost_insertion_encoding(tiling):
return TileScopePack.regular_insertion_encoding(2)
if self.has_topmost_insertion_encoding(tiling):
return TileScopePack.regular_insertion_encoding(3)
raise StrategyDoesNotApply(
"tiling does not has a regular insertion encoding")
def extra_parameters(
self,
comb_class: Tiling,
children: Optional[Tuple[Tiling,
...]] = None) -> Tuple[Dict[str, str]]:
if children is None:
children = self.decomposition_function(comb_class)
if children is None:
raise StrategyDoesNotApply("Strategy does not apply")
child = children[0]
return ({
comb_class.get_assumption_parameter(ass):
child.get_assumption_parameter(ass)
for ass in comb_class.assumptions
}, )
def constructor(
self,
comb_class: Tiling,
children: Optional[Tuple[Tiling, ...]] = None,
) -> AddAssumptionsConstructor:
if children is None:
children = self.decomposition_function(comb_class)
if children is None:
raise StrategyDoesNotApply(
"Can't split the tracking assumption")
new_parameters = [
children[0].get_parameter(ass) for ass in self.assumptions
]
return AddAssumptionsConstructor(
new_parameters,
self.extra_parameters(comb_class, children)[0])
def extra_parameters(
self, comb_class: Tiling, children: Optional[Tuple[Tiling, ...]] = None
) -> Tuple[Dict[str, str]]:
if children is None:
children = self.decomposition_function(comb_class)
if children is None:
raise StrategyDoesNotApply("Strategy does not apply")
res: Dict[str, str] = {}
child = children[0]
for parent_ass, parent_param in zip(
comb_class.assumptions, comb_class.extra_parameters
):
if parent_ass == self.assumption:
continue
child_param = child.extra_parameters[child.assumptions.index(parent_ass)]
res[parent_param] = child_param
return (res,)
def reverse_constructor(
self,
idx: int,
comb_class: Tiling,
children: Optional[Tuple[Tiling, ...]] = None,
) -> ReverseRearrangeConstructor:
if children is None:
children = self.decomposition_function(comb_class)
if children is None:
raise StrategyDoesNotApply("Can't split the tracking assumption")
return ReverseRearrangeConstructor(
comb_class,
children[0],
self.assumption,
self.sub_assumption,
self.extra_parameters(comb_class, children)[0],
)
def get_genf(
self,
comb_class: CombinatorialClass,
funcs: Optional[Dict[CombinatorialClass, Function]] = None,
) -> Expr:
if not self.verified(comb_class):
raise StrategyDoesNotApply("Can't find generating functon for non-atom.")
if not isinstance(comb_class, Tiling):
raise NotImplementedError
cast(Tiling, comb_class)
gp = next(comb_class.minimal_gridded_perms())
expected = {"x": len(gp)}
for assumption in comb_class.assumptions:
expected[
comb_class.get_assumption_parameter(assumption)
] = assumption.get_value(gp)
return reduce(mul, [var(k) ** n for k, n in expected.items()], 1)
def extra_parameters(
self,
comb_class: Tiling,
children: Optional[Tuple[Tiling,
...]] = None) -> Tuple[Dict[str, str]]:
if children is None:
children = self.decomposition_function(comb_class)
if children is None:
raise StrategyDoesNotApply("Strategy does not apply")
extra_parameters: Dict[str, str] = {}
child = children[0]
for assumption in comb_class.assumptions:
mapped_assumption = assumption.remove_components(comb_class)
if mapped_assumption.gps:
extra_parameters[comb_class.get_assumption_parameter(
assumption)] = child.get_assumption_parameter(
mapped_assumption)
return (extra_parameters, )
def extra_parameters(
self, comb_class: Tiling, children: Optional[Tuple[Tiling, ...]] = None,
) -> Tuple[Dict[str, str], ...]:
if not comb_class.extra_parameters:
return super().extra_parameters(comb_class, children)
if children is None:
children = self.decomposition_function(comb_class)
if children is None:
raise StrategyDoesNotApply("Strategy does not apply")
child = children[0]
params: Dict[str, str] = {}
for assumption in comb_class.assumptions:
mapped_assumption = child.forward_map_assumption(assumption)
if mapped_assumption.gps:
parent_var = comb_class.get_parameter(assumption)
child_var = child.get_parameter(mapped_assumption)
params[parent_var] = child_var
return (params,)
def extra_parameters(
self,
comb_class: Tiling,
children: Optional[Tuple[Tiling, ...]] = None
) -> Tuple[Dict[str, str], ...]:
if not comb_class.extra_parameters:
return super().extra_parameters(comb_class, children)
if children is None:
children = self.decomposition_function(comb_class)
if children is None:
raise StrategyDoesNotApply("Strategy does not apply")
algo = self.placement_class(comb_class)
extra_parameters: Tuple[Dict[str, str],
...] = tuple({} for _ in children)
if self.include_empty:
child = children[0]
for assumption in comb_class.assumptions:
mapped_assumption = child.forward_map.map_assumption(
assumption).avoiding(child.obstructions)
if mapped_assumption.gps:
parent_var = comb_class.get_assumption_parameter(
assumption)
child_var = child.get_assumption_parameter(
mapped_assumption)
extra_parameters[0][parent_var] = child_var
for idx, (cell, child) in enumerate(
zip(self._placed_cells,
children[1:] if self.include_empty else children)):
mapped_assumptions = [
child.forward_map.map_assumption(ass).avoiding(
child.obstructions)
for ass in algo.stretched_assumptions(cell)
]
for assumption, mapped_assumption in zip(comb_class.assumptions,
mapped_assumptions):
if mapped_assumption.gps:
parent_var = comb_class.get_assumption_parameter(
assumption)
child_var = child.get_assumption_parameter(
mapped_assumption)
extra_parameters[idx + 1 if self.include_empty else idx][
parent_var] = child_var
return extra_parameters
def constructor(self,
comb_class: Tiling,
children: Optional[Tuple[Tiling, ...]] = None) -> Split:
if children is None:
children = self.decomposition_function(comb_class)
if children is None:
raise StrategyDoesNotApply(
"Can't split the tracking assumption")
child = children[0]
split_parameters: Dict[str, Tuple[str, ...]] = {"n": ("n", )}
components = self.factor_class(
comb_class.remove_assumptions()).get_components()
for idx, assumption in enumerate(comb_class.assumptions):
split_assumptions = self._split_assumption(assumption, components)
child_vars = tuple(
sorted(f"k_{child.assumptions.index(ass)}"
for ass in split_assumptions))
split_parameters[f"k_{idx}"] = child_vars
return Split(split_parameters)
def extra_parameters(
self, comb_class: Tiling, children: Optional[Tuple[Tiling, ...]] = None,
) -> Tuple[Dict[str, str]]:
if children is None:
children = self.decomposition_function(comb_class)
if children is None:
raise StrategyDoesNotApply("Strategy does not apply")
algo = self.fusion_algorithm(comb_class)
child = children[0]
mapped_assumptions = [
child.forward_map_assumption(ass.__class__(gps))
for ass, gps in zip(comb_class.assumptions, algo.assumptions_fuse_counters)
]
return (
{
k: child.get_parameter(ass)
for k, ass in zip(comb_class.extra_parameters, mapped_assumptions)
if ass.gps
},
)
def constructor(
self, comb_class: Tiling, children: Optional[Tuple[Tiling, ...]] = None,
) -> FusionConstructor:
if not self.tracked:
# constructor only enumerates when tracked.
return FusionConstructor("n", {}, tuple(), tuple(), tuple(), 0, 0)
# Need to recompute some info to count, so ignoring passed in children
algo = self.fusion_algorithm(comb_class)
if not algo.fusable():
raise StrategyDoesNotApply("Strategy does not apply")
child = algo.fused_tiling()
assert children is None or children == (child,)
min_left, min_right = algo.min_left_right_points()
return FusionConstructor(
self._fuse_parameter(comb_class),
self.extra_parameters(comb_class, children)[0],
*self.left_right_both_sided_parameters(comb_class),
min_left,
min_right,
)
def extra_parameters(
self,
comb_class: Tiling,
children: Optional[Tuple[Tiling, ...]] = None
) -> Tuple[Dict[str, str], ...]:
if children is None:
children = self.decomposition_function(comb_class)
if children is None:
raise StrategyDoesNotApply("Strategy does not apply")
extra_parameters: Tuple[Dict[str, str],
...] = tuple({} for _ in children)
for parent_var, assumption in zip(comb_class.extra_parameters,
comb_class.assumptions):
for idx, child in enumerate(children):
# TODO: consider skew/sum
new_assumption = child.forward_map.map_assumption(assumption)
if new_assumption.gps:
child_var = child.get_assumption_parameter(new_assumption)
extra_parameters[idx][parent_var] = child_var
return extra_parameters
def constructor(
self,
comb_class: Tiling,
children: Optional[Tuple[Tiling, ...]] = None) -> CountComponent:
if children is None:
children = self.decomposition_function(comb_class)
if children is None:
raise StrategyDoesNotApply("Can't detect components")
removed_components: Dict[str, int] = {}
for ass in comb_class.assumptions:
value = len(ass.get_components(comb_class))
if value:
k = comb_class.get_assumption_parameter(ass)
removed_components[k] = value
return CountComponent(
comb_class,
children[0],
removed_components,
self.extra_parameters(comb_class, children)[0],
)
def extra_parameters(
self,
comb_class: Tiling,
children: Optional[Tuple[Tiling, ...]] = None,
) -> Tuple[Dict[str, str], ...]:
if not comb_class.extra_parameters:
return super().extra_parameters(comb_class, children)
if children is None:
children = self.decomposition_function(comb_class)
if children is None:
raise StrategyDoesNotApply("Strategy does not apply")
child = children[0]
mapped_assumptions = tuple(
ass.__class__(
tuple(self.gp_transform(comb_class, gp) for gp in ass.gps))
for ass in comb_class.assumptions)
return ({
comb_class.get_parameter(assumption):
child.get_parameter(mapped_assumption)
for assumption, mapped_assumption in zip(comb_class.assumptions,
mapped_assumptions)
}, )
def decomposition_function(self, tiling: Tiling) -> Tuple[Tiling]:
if any(assumption in tiling.assumptions
for assumption in self.assumptions):
raise StrategyDoesNotApply(
"The assumption is already on the tiling.")
return (tiling.add_assumptions(self.assumptions), )
def get_genf(
self, comb_class: Tiling, funcs: Optional[Dict[Tiling, Function]] = None
) -> Expr:
if not self.verified(comb_class):
raise StrategyDoesNotApply("tiling is not in the database")
return DatabaseEnumeration(comb_class).get_genf()
