def pack(self, comb_class: Tiling) -> StrategyPack: try: return InsertionEncodingVerificationStrategy().pack(comb_class) except StrategyDoesNotApply: pass if self.no_factors: raise InvalidOperationError("Cannot get a simpler specification") if ( any(isinstance(ass, ComponentAssumption) for ass in comb_class.assumptions) and len(comb_class.find_factors()) == 1 ): raise InvalidOperationError( "Can't find generating function with component assumption." ) return StrategyPack( initial_strats=[FactorFactory()], inferral_strats=[], expansion_strats=[], ver_strats=[ BasicVerificationStrategy(), OneByOneVerificationStrategy(), InsertionEncodingVerificationStrategy(), MonotoneTreeVerificationStrategy(no_factors=True), LocalVerificationStrategy(no_factors=True), ], name="factor pack", )
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.") try: return InsertionEncodingVerificationStrategy().pack(tiling) except StrategyDoesNotApply: pass if self.no_factors: raise InvalidOperationError( "Cannot get a specification for a tiling in the database") return StrategyPack( initial_strats=[FactorFactory()], inferral_strats=[], expansion_strats=[], ver_strats=[ BasicVerificationStrategy(), OneByOneVerificationStrategy(), InsertionEncodingVerificationStrategy(), MonotoneTreeVerificationStrategy(no_factors=True), ], name="factor pack", )
def get_word_searcher(avoid, alphabet): pack = StrategyPack( initial_strats=[RemoveFrontOfPrefix()], inferral_strats=[], expansion_strats=[[ExpansionStrategy()]], ver_strats=[AtomStrategy()], name=( "Finding specification for words avoiding consecutive patterns."), ) start_class = AvoidingWithPrefix("", avoid, alphabet) searcher = CombinatorialSpecificationSearcher(start_class, pack) return searcher
def _pack_for_shift(comb_class: Tiling) -> StrategyPack: if any(isinstance(ass, ComponentAssumption) for ass in comb_class.assumptions): raise InvalidOperationError( "Can't find generating function with component assumption." ) return StrategyPack( name="LocallyFactorable", initial_strats=[FactorFactory(), RequirementCorroborationFactory()], inferral_strats=[], expansion_strats=[[FactorInsertionFactory()]], ver_strats=[ BasicVerificationStrategy(), OneByOneVerificationStrategy(), InsertionEncodingVerificationStrategy(), MonotoneTreeVerificationStrategy(no_factors=True), LocalVerificationStrategy(no_factors=True), ], )
yield DecompositionRule("Removing last letter.", [ Letter(av_config.last_letter), Suffixes(av_config.config, av_config.basis) ]) def verify_letters_and_perms(config, **kwargs): if isinstance(config, Letter): return VerificationRule("Its a letter.") elif config.last_letter is None and len(config.config.slots) == 0: return VerificationRule("Its a permutation.") pack = StrategyPack(initial_strats=[remove_letter, equivalent], inferral_strats=[], expansion_strats=[[expansion]], ver_strats=[verify_letters_and_perms], name=("Finding regular insertion encodings")) if __name__ == "__main__": from permuta.permutils import is_insertion_encodable_maximum basis = input("Enter comma separated permutations: ") basis = [Perm.to_standard(p) for p in basis.split(',')] if is_insertion_encodable_maximum(basis): start_class = Suffixes(Configuration(Perm(), (0, )), basis) print(Configuration(Perm((0, )), (0, ))) searcher = CombinatorialSpecificationSearcher(start_class, pack, debug=True)
break def verify_point(tiling, **kwargs): """Verify exactly the point tiling.""" if (tiling.tiling.is_point_tiling()): if (isinstance(tiling, Point) or isinstance(tiling, SumIndecomposable) or isinstance(tiling, SkewDecomposable) or isinstance(tiling, All)): return VerificationRule("its the point") pack = StrategyPack(initial_strats=[factor, list_cleanup, all_factor_insertions], inferral_strats=[], expansion_strats=[[expansion]], ver_strats=[verify_point], name=("substition_decomposition")) if __name__ == "__main__": basis = input("Enter comma separated permutations: ") basis = [Perm.to_standard(p) for p in basis.split(',')] start_class = All(basis) searcher = CombinatorialSpecificationSearcher(start_class, pack, debug=True) tree = searcher.auto_search(status_update=30) tree.get_min_poly(solve=True)
@classmethod def from_dict(cls, d): return cls() def __str__(self) -> str: return self.formal_step() def __repr__(self) -> str: return self.__class__.__name__ + "()" pack = StrategyPack( initial_strats=[RemoveFrontOfPrefix()], inferral_strats=[], expansion_strats=[[ExpansionStrategy()]], ver_strats=[AtomStrategy()], name=("Finding specification for words avoiding consecutive patterns."), ) if __name__ == "__main__": example_alphabet = input( ("Input the alphabet (letters should be separated by a" " comma):")).split(",") example_patterns = tuple( map( Word, input(("Input the patterns to be avoided (patterns should be " "separated by a comma):")).split(","), ))