[ulfarsson]

This builds on #530 (rotational-cut), its base here, whose tilings.hints it extends. Once #530 is merged, this one's base becomes develop.

Christian's idea: take a basis B, and for each of its patterns every way of adding one point in a single direction, such as a new maximum in every possible place. The class of the new basis B' is connected to Av(B) by a partial placement of the topmost point and obstruction inferral at the right length. This adds that as a second hint, beside the rotation's, with a pack method and a tilescope spec flag that follow it.

The idea

A permutation contains a pattern of B' exactly when it has an occurrence of a pattern of B that leaves out its maximum: the maximum then completes it, and an occurrence that uses the maximum has no point above it to add. So Av(B') is the permutations whose maximum, taken out, leaves a permutation of Av(B), and it has n times as many permutations of length n as Av(B) has of length n − 1. The same goes for a new minimum, a new leftmost point or a new rightmost point.

In TileScope, the partial placement of the topmost point puts it in a row of its own, above a cell of the rest in the same column. Obstruction inferral to the length of B's longest pattern then finds that this cell avoids B, since the point, wherever it lies among the rest, would complete any occurrence. The tiling is then that point and Av(B).

What it adds

• The hint one-point extension (tilings.hints), given by hints_for(basis) when the basis is every one-point extension of a basis B. It names the class to search for instead, Av(B), reduced again while it is such an extension, with the counts and generating functions that relate them, and the direction of each step. It also says that the pack can take the placement and the inferral.
• The functions behind it:
  • one_point_extensions(pattern, direction) makes the extensions;
  • find_one_point_extension(basis) finds the direction and B, as a named tuple OnePointExtension(direction, reduced_basis);
  • find_one_point_extension_chain(basis) gives the steps of reducing again, as a list of them;
  • extension_placement_arguments(chain) gives the directions and length of the placement that follows the hint, for the hint and the flag alike.
• TileScopePack.add_extension_placement(directions, length) adds the partial placement of a requirement's point in those directions, each once (RequirementPlacementFactory(partial=True, dirs=directions)), and obstruction inferral to the length. It raises TypeError for a length that is not an integer (any integer type is taken, a bool is not), and ValueError for no directions, a value that is no direction, or a length below 1. A pack holds one strategy of each class, whatever its parameters. So a pack that already has a requirement placement or obstruction inferral, as only_root_placements' packs do, raises ValueError too, as add_expansion and add_inferral do.
• tilescope spec's flag -x/--extension-placement adds them for the class's steps. It refuses, with a parser error that says why, a basis that is no such extension and a pack that cannot take them. The placement places the points of point requirements, so the flag warns of a pack that inserts none into the class's tiling, as row_and_col_placements, row_placements and col_placements insert none, and its help and the hint say so. tilescope spec logs the hint unless the pack has both strategies.
• README and CHANGELOG entries, the README's beside the rotation hint's.

What it does

It was tried on the new maximum's extensions of Av(123), Av(132), Av(1234), Av(1342), Av(2413, 3142), Av(1243, 2431) and Av(123, 3412), and on the other three directions' of Av(1342) and Av(123, 3412):

• point placements alone found no specification within a minute for 8 of them, and took 28 to 38 s for the four of Av(123, 3412);
• with add_extension_placement, each took at most 0.2 s, with 4 rules, as did the two-step extensions of 123;
• a chain's later directions were not needed in the searches tried: on the two-step extensions of 123, the placement in the first direction alone gives the same 4-rule specification;
• the inferral's cost grows quickly with the length of B's longest pattern: for the extensions of a single increasing pattern of length 4, 5 and 6, the search took 0.4, 2.3 and 23.5 s on PyPy 3.11.

For instance, this finds a specification at once:

tilescope spec 1234_1243_1423_4123 point_placements --extension-placement

Its generating function is x/sqrt(1 - 4*x) + 1, whose coefficients are n times the Catalan numbers at n - 1.

Who will use it

TileScope users with such a class: the hint names the simpler class to run, and the flag turns the class into a point and that class in a fraction of a second.

Tests

In tests/test_hints.py and the pack tests:

• one_point_extensions against the permutations one point longer that give the pattern back, in each direction;
• find_one_point_extension finds the direction and B for five bases in each direction, whose classes have n times as many permutations of length n as Av(B) has of length n − 1; bases that are not minimal, repeated, unordered or given once through; and no extension where one is missing or one too many, for a single pattern, for the extensions of patterns of length 1, and for empty and short bases;
• the hint's message and strategies in each direction, the whole message for seven chains, and both hints at once, on every permutation of length 3;
• chains of two steps in every order of directions, and of three and four: the class named, the factor, the transform applied once for each step, the placements, and the directions and length for the hint and the flag;
• a search with add_extension_placement on the extensions of 123 in each direction, whose rules pass their sanity check, and the flag's search for two steps;
• the flag end to end: its generating function in each direction against Permuta's counts, every pack with each other flag, the basis read as the command reads it, and its errors and warning, with what they say;
• the flag's warning, against what each pack's strategies insert into the class's tiling;
• the pack method's input checks and errors, and every pack of the pack tests with add_extension_placement, through JSON, but only_root_placements'.

How it was checked

Before submission, by an automated reviewer, against develop of Permuta and comb_spec_searcher and #530's head:

• flake8, mypy, pylint and black pass, and on CPython 3.14 and PyPy 3.11 all 4,145 tests pass;
• whether a class is a one-point extension, tested directly on its permutations against find_one_point_extension, on more than a thousand bases, among them mixed lengths, chains of up to three steps in mixed directions, and near misses: they agree, and each step's counts and generating function are right;
• the searches above: every rule passes its sanity check, and the counts agree with Permuta's, through the generating function or rule by rule over the gridded permutations;
• every sentence of the hint's message, for chains of one to four steps in every order of directions, against the chain and counts by brute force;
• every base pack with every combination of the other flags builds with -x, or refuses with a parser error, and warns exactly where the search places no point;
• mutation testing of the new code; timing of standard packs against Add the rotational cut strategy, for classes closed under rotation #530's head, which run equally fast; and of hints_for, which tilescope spec runs once, within a tenth of a millisecond of Add the rotational cut strategy, for classes closed under rotation #530's on the bases tried.

---

AI assistance: written with Claude Code (Opus 5.5) as the TileScope agent, and reviewed before submission by Claude Code (Opus 5.5) as an automated reviewer; Henning Ulfarsson checked and opened it.