def slicing_verified(tiling, **kwargs): """The globally verified strategy. A tiling is slicing verified if every requirement and obstruction that crosses slices is 'simple'. Requirments and obstructions within slices do not affect this strategy """ def deflation_type(gp): patt = gp._patt poss = gp._pos if patt == Perm((0, 2, 1)) or patt == Perm((1, 2, 0)): if poss[0][1] == poss[2][1] and poss[1][1] > poss[0][1]: return True if patt == Perm((1, 0, 2)) or patt == Perm((2, 0, 1)): if poss[0][1] == poss[2][1] and poss[1][1] < poss[0][1]: return True if not tiling.dimensions == (1, 1): if all(ob.is_single_row() or len(ob) <= 2 or deflation_type(ob) for ob in tiling.obstructions): if (all( all((r.is_single_row() or len(r) <= 2) for r in req) for req in tiling.requirements) and not possible_tautology(tiling)): return VerificationRule(formal_step="Slicing verified.") else: return subset_verified(tiling, **kwargs)
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")
def verify_points(tiling, basis, **kwargs): """The verify points strategy. A tiling is verified if it is a point or is the empty tiling. """ if tiling.dimensions == (1, 1): if (not tiling.requirements and len(tiling.obstructions) == 1 and len(tiling.obstructions[0]) == 1): return VerificationRule( formal_step="I understand the empty tiling.") if (len(tiling.obstructions) == 2 and all(len(ob) == 2 for ob in tiling.obstructions) and len(tiling.requirements) == 1 and len(tiling.requirements[0]) == 1 and len(tiling.requirements[0][0]) == 1): return VerificationRule( formal_step="I understand points, no really, I do.")
def verify_short_obstructions(tiling, **kwargs): """ A tiling is verified if it only has obstructions of length at most two. """ if tiling.dimensions == (1, 1): return None else: if all(len(obs) < 3 for obs in tiling.obstructions): return VerificationRule(formal_step=( "The tiling only has obstructions of length at most two."))
def subset_verified(tiling, basis, **kwargs): """The subset verified strategy. A tiling is subset verified if every obstruction and every requirement is localized. """ if kwargs.get("no_factors", False): if len(tiling.find_factors()) > 1: return if kwargs.get("no_reqs", False): if tiling.requirements: return if tiling.dimensions == (1, 1): if one_by_one_verified(tiling, basis, **kwargs): return VerificationRule( formal_step="The tiling is a subset of the class.") elif (all(ob.is_single_cell() for ob in tiling.obstructions) and all( all(r.is_single_cell() for r in req) for req in tiling.requirements)): return VerificationRule( formal_step="The tiling is a subset of the class.")
def globally_verified(tiling, **kwargs): """The globally verified strategy. A tiling is globally verified if every requirement and obstruction is non-interleaving. """ if not tiling.dimensions == (1, 1): if all(not ob.is_interleaving() for ob in tiling.obstructions): if (all( all(not r.is_interleaving() for r in req) for req in tiling.requirements) and not possible_tautology(tiling)): return VerificationRule(formal_step="Globally verified.") else: return subset_verified(tiling, **kwargs)
def subclass_verified(tiling, basis, **kwargs): """The subclass verified strategy. A tiling is subclass verified if it only generates permutations in a proper subclass of Av(basis). """ if tiling.dimensions == (1, 1): return None else: maxlen = kwargs.get('maxpattlen', 4) patterns = set(perm for perm in chain( *[Av(basis).of_length(i) for i in range(maxlen + 1)])) maxlen += tiling.maximum_length_of_minimum_gridded_perm() for i in range(maxlen + 1): for g in tiling.objects_of_length(i): perm = g.patt patterns = set(pattern for pattern in patterns if perm.avoids(pattern)) if not patterns: return None return VerificationRule(formal_step=("The tiling belongs to the " "subclass obtained by adding" " the patterns {}." "".format(Basis(patterns))))
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.")
def one_by_one_verification(tiling, basis, **kwargs): """Return a verification if one-by-one verified.""" if one_by_one_verified(tiling, basis, **kwargs): return VerificationRule( formal_step="The tiling is a subclass of the class.")
def miner_verified(tiling, basis, **kwargs): """The Miner verification strategy.""" # TODO: document all these magic constant scattered all over the function. if ((tiling.dimensions[0] is 1 and tiling.dimensions[1] is 2) or (tiling.dimensions[0] is 2 and tiling.dimensions[1] is 1)): top = [] bottom = [] topbool = None bottombool = None for ob in tiling.obstructions: if ob.is_single_cell(): if ob.pos[0] == (0, 0): bottom.append(ob.patt) else: top.append(ob.patt) else: if topbool is not None or bottombool is not None: return None if ob.patt == Perm((0, 1, 2)): if ob.pos[0] == (0, 0) and ob.pos[1] == (0, 0): bottombool = 0 else: topbool = 0 elif ob.patt == Perm((2, 1, 0)): if ob.pos[1] == (0, 0) and ob.pos[2] == (0, 0): bottombool = 1 elif ob.pos[0] == (0, 1) and ob.pos[1] == (0, 1): topbool = 1 else: return None elif ob.patt == Perm((0, 2, 1)): if ob.pos[1] == ob.pos[2]: topbool = 1 else: return None elif ob.patt == Perm((1, 0, 2)): if ob.pos[0] == ob.pos[1]: bottombool = 1 else: return None elif ob.patt == Perm((1, 2, 0)): if ob.pos[0] == (0, 0) and ob.pos[1] == (0, 0): bottombool = 0 elif ob.pos[0] == (0, 1) and ob.pos[1] == (0, 1): topbool = 0 else: return None elif ob.patt == Perm((2, 0, 1)): if ob.pos[1] == (0, 0) and ob.pos[2] == (0, 0): bottombool = 0 elif ob.pos[1] == (1, 0) and ob.pos[2] == (0, 0): topbool = 0 else: return None else: return None if topbool is not None: topbasis = Basis(top) if ((topbool == 0 and topbasis == Basis([Perm((0, 1, 2))])) or (topbool == 1 and topbasis == Basis([Perm( (2, 1, 0))]))): return VerificationRule("Miner verified!") elif bottombool is not None: bottombasis = Basis(bottom) if ((bottombool == 0 and Basis(bottom) == Basis([Perm( (0, 1, 2))])) or (bottombool == 1 and bottombasis == Basis([Perm((2, 1, 0))]))): return VerificationRule("Miner verified!")