[ulfarsson]

Generalizes the cell reduction (CellReductionFactory, #428) from one cell to any set of cells, and gives it a counting function, object generation and random sampling, which it did not have: its constructor raised NotImplementedError. The strategy, its constructor and its factory, ReductionStrategy, ReductionConstructor and ReductionFactory, are in tilings/strategies/reduction.py; the condition, the plan, the two children and the words the maps are built from are in tilings/algorithms/reduction.py, whose docstring has the condition and why the reduction holds, as fusion has its algorithm in tilings/algorithms. CellReductionFactory and CellReductionStrategy stay, as the reduction of single cells, with their names and encodings.

The rule. A set X of active cells of a tiling is reducible, in a direction (increasing or decreasing), if every obstruction with points both in X and outside it has exactly one point in X, in a cell c say, and

• it does not have points both in another cell of the row of c and in another cell of the column of c;
• it has a point in another cell of the column (row) of c only if the cells of X in that column (row) are already in the order of the direction: c is the only one, or X's own obstructions put the points of the lower (left) of any two of them all to the left of (below) those of the other, the other way round when decreasing;

and every requirement list lies in X or has, in each of its gridded permutations, no point in X or one point as above; every cell of X lies in an obstruction that lies in X, which keeps it active in the tiling of X (a requirement that lies in X would too, but the condition asks for an obstruction); and no assumption on X is a component assumption or tracks a gridded permutation of two or more points (the sorting below keeps the number of points in each cell, but not the occurrences of a pattern). For a single cell this is the cell reduction's condition.

Why it holds. A gridded permutation is the same as three things chosen independently: for each column, the word of the cells of its points from left to right; for each row, the word of the cells of its points from bottom to top; and the permutation in each cell. The share of X in these is the order of the points of X among themselves in each column and in each row, and the permutations in the cells of X; the rest is the places of X's points among the other points of each column and row, and the other cells' permutations. An obstruction with one point in X sees that point only through its cell and its place among the other points of its column or of its row, never both. Which of the places of X's points in that row are the cell's is fixed by the rest when c is X's only cell there, and also when X's own obstructions fix the order of X's cells there, as the sorting leaves that order as it is. So sorting the share of X into the canonical one, every cell of X increasing (or decreasing) and the points of the cells of X in each row and each column in that order, is a bijection

Grid(T) → ⋃_v Grid(T_reduced)_v × Grid(T_X)_v,

where v is the number of points in each cell of X, T_X is the tiling of the obstructions and requirements of X (every other cell empty) and T_reduced is the tiling with those replaced by the monotone obstructions. Going back, T_X has the obstructions that fix the order, so its share agrees with the canonical one there.

The children, and what the reduced tiling keeps. The children are, in this order as before, the reduced tiling and the tiling of X. The reduced tiling keeps only what the rest of the tiling sees of X:

• a cell of X whose row and column have no cell outside X, and in which no obstruction or requirement with points outside X has a point, is seen only through its number of points, which T_X counts: the reduced tiling leaves it out;
• cells of X in one row whose columns, and the columns between them, have no cell outside X, with no other cell of X that the rest sees between them, and that the obstructions and requirements with points outside X treat alike (each with its point in one of them is one with its point in the other), are seen as one: the reduced tiling keeps the first of them, with all their points (likewise in a column).

Each group seen as one is tracked once, by a tracking assumption in each child (in T_X unless there is one group and nothing left out, when its size is the group's points). The count is the Hadamard product of the two in the variables counting the points in the groups, at 1, and the product in the size of the cells left out:

T(n; p) = Σ_{w, m} T_reduced(n − m; p, w) · T_X(|w| + m; w),

printed with ⊙ (a ↣ b ⊙ c). The parent's assumptions go to the reduced tiling, and a tracked cell of the parent is never left out or grouped. The object maps are the sorting and its inverse, built from the words above (reduce_gridded_perm and combine_gridded_perms, with the own tiling's own RowColMap for its cells): the backward map takes the rest from the reduced tiling's gridded permutation and the share of X, the cells left out and the split of each group included, from T_X's. get_sub_objects pairs the children's objects with the same w and sizes that add up, and random sampling picks w and m by their weight first. There is no sympy equation (get_equation raises NotImplementedError, as for interleaving factors): a Hadamard product keeps D-finite series D-finite, but not algebraic ones.

The factory. ReductionFactory(tracked=True, region="cell", max_cells=None), exported from tilings.strategies beside CellReductionFactory. The region says which sets it tries:

• "cell": every single cell, the current setup (CellReductionFactory is this);
• "row": the active cells of each row;
• "column": the active cells of each column;
• "line": every set of cells in one row or in one column, so the single cells and the whole rows and columns too;
• "cut": the active cells on one side of a line between two adjacent columns or two adjacent rows (left or right of it, below or above it), at most twice the number of columns and rows. The cells left of a placed point are such a set, and these are the sets a threshold reduction reduces: in the specification of Av(2143) built by hand with the reduction, every reduction is of the cells left of a column, five or seven of them, which "any" reaches only with max_cells at least 7 and very many more sets;
• "any": every set of cells (the number of sets grows exponentially with the number of active cells).

With max_cells, the sets of "cut" and "any" have at most that many cells.

A set is offered, in each direction it is reducible in, if it is not all of the active cells, is not rigid (every cell monotone and the points of any two of its cells in a row or a column in a fixed order, where reducing would change nothing or reverse the cells), is not a single finite cell, and the rest of the tiling sees one of its cells (otherwise it is a factor).

The cell reduction. CellReductionFactory(tracked) is ReductionFactory(tracked, "cell"), yielding CellReductionStrategy. On 400 random tilings it gives the reductions develop's factory gives, except those of cells that are factors on their own (30 of 1052), which the factor strategy separates. Three kinds of cells are no longer reduced: a cell with no obstruction of its own, whose own tiling, without a requirement of its own either, would be Tiling(), with only the empty permutation, so that the count would be wrong; a cell in a component assumption, where develop's constructor raised NotImplementedError; and a cell in a tracked gridded permutation of two or more points. The kitchen sink pack uses ReductionFactory(tracked). What else changes in the public API, as the CHANGELOG says:

• CellReductionStrategy.formal_step names the direction: "reducing cell (0, 0) to increasing", where it was "reducing cell (0, 0)".
• The reduced tiling is built with Tiling's defaults (simplified, empty rows and columns removed), where develop built it with simplify=False, derive_empty=False and remove_empty_rows_and_cols=False. A specification saved with develop's CellReductionStrategy may then not rebuild its children identically: on 300 random tilings, 16 of 538 cell reductions have a different reduced tiling, only in develop's unsimplified obstructions, and the same own tiling. None of those specifications could have been counted, as develop's constructor raised NotImplementedError.
• CellReductionConstructor is ReductionConstructor, which takes the parent, the children, the plan and the map of the parent's parameters to the reduced tiling's; develop's CellReductionConstructor(parameter) counted nothing.
• CellReductionFactory.reducible_cells, can_reduce_cell_with_requirements_and_assumptions and gp_in_row_and_col are removed: the condition is tilings.algorithms.reduction.is_reducible.

Examples.

• Av(2143) with its topmost point placed, a 21 inserted into the cell L left of it and the 2 of the 21 placed bottommost: the placed point is the lowest top of an inversion of L, and L becomes five cells, the low ones left and right of the point (every point of the left one below those of the right one), the point, and the high ones. The cell R right of the topmost point sees them only through the two 2143s with one point in a low cell, along the bottom row. The five cells were not reducible before, as the two low cells share that row; now they are, the point and the high cells are left out, the two low cells are one group, and each child tracks one variable, the number of points below the lowest top of an inversion of L. This is the threshold reduction of the cell L: what R sees of L is its values and that lowest top.
• Av(1234, 1342, 2413): with its minimum and the first point to the right of it placed, the class's cell and a decreasing cell D are above, and Av(123, 2413) and Av(123, 231) below, tied to D by 123s with two points in a lower cell. Reducing the two lower cells and D moves those 123s into the tiling of the three cells; the two lower cells are left out of the reduced tiling, which is D beside the class's cell.
• Av(1234, 2431): two cells sharing no row or column, Av(123, 2431) and an increasing cell to its upper right, tied by a 123 with two points in the first. Neither cell is reducible alone, and the pair is.

With the first version, TileScope with point placements, or row and column placements, with fusion and the factory, on the 56 symmetry classes of two patterns of length 4 and the 317 of three, found specifications that reduce sets of two to five cells for 119 classes, every one counting correctly to length 10; with row and column placements, Av(1234, 2431) and Av(1243, 2431) got specifications with the reduction and none without it in the same time.

Tests (tests/strategies/test_reduction.py, and the encoding tests):

• the condition on tilings from these classes, sets that are not reducible, and a set reducible in one direction only, because of a row its own obstructions put in order; the empty set, and sets with an empty cell or a cell off the tiling, which are not reducible; a cell of the set alone in its column, which a crossing there touches, reducible in both directions;
• rigid sets: two cells of a row, and two of a column, in a fixed order either way or in none, and two of a row in a fixed order one of which is not monotone;
• the sets each region offers, the region "cut"'s being the sides of the lines between columns and between rows, each among the sets "any" offers, with and without max_cells; and the sets each region tries on an L of three cells; the factories' names;
• the children, and that the rule is never an equivalence;
• every rule's sanity check (counts, objects and random samples) to size 5, in both directions, for a single cell, a whole row, a whole column, a block of two rows and two cells sharing no row or column, one of them with tracked cells in the parent, and two rows of cells one of which the rest sees only through a 21 of a requirement list; two cells of a row that the rest sees alike one way only, and two cells of a row the first of which is in a column with a cell outside the set; and the five cells of Av(2143) above, and of its inverse, whose group is in a column, to size 6;
• the forward map is a bijection onto the pairs with as many points in each group and sizes that add up, and the backward map is its inverse, for these and the fixtures below, and for the five cells of Av(2143);
• the exact monotone obstructions of a set with two cells in a row and two in a column, in each direction;
• two cells of a row that the rest sees alike (one group), two it does not (two groups, also when decreasing), the same two as a column (two groups, both kept, increasing and decreasing), and two in a row with a cell outside the set, the second of them, or the first, in a column with one too (two groups); two cells of a row that the rest sees alike one way only, a point of a requirement list in one of them and nothing in the other (two groups); a cell kept only because an obstruction touches it, and one kept only because a requirement list does, each beside a cell left out; a cell kept only because a gridded permutation of two points of a requirement list touches it, alone and beside a cell left out; a requirement list with a point in the set and one outside it, which sees two cells of a row apart, or alike when it has a point in each; a requirement list with points outside the set and a gridded permutation with two points in it, a 12 in a list with a point outside the set or a lone 231 with a point outside it, which makes the set not reducible;
• a set with a cell of a tracked gridded permutation of two points is not reduced, and a strategy applied in a direction its set is not reducible in raises StrategyDoesNotApply;
• is_reducible with no direction: a set reducible increasing only, and one reducible decreasing only, are reducible; its cells are read once, so that an iterator serves for both directions;
• constructors that pair their children the same way are equivalent (equiv), and constructors that differ only in leaving cells out, or only in the place of the groups' or of the parent's parameters, are not;
• the factory does not offer a single finite cell, one whose basis has an increasing and a decreasing pattern, though it offers a cell whose basis has only one of them; nor does it offer a set the rest of the tiling sees nothing of; its defaults are tracked, the region "cell" and no bound;
• every reduction the factory offers on 30 random tilings, seeded, passes its sanity check to size 4 (7 seconds here; its timeout is 300 seconds, for slower runners);
• an untracked reduction has no constructor, and a factory's strategies are tracked as the factory is;
• extra_parameters, given no children, computes them;
• CellReductionFactory is the region "cell", with its old encoding;
• the JSON and repr encodings of the factory, in every region, and of the strategies, in each direction, tracked or not; a strategy's cells are sorted and without repeats;
• the compositions the random sampling goes through;
• a search: Av(1243, 2314, 2413) with row and column placements, tracked fusion and the factory with the region "any" (at most three cells), level by level. After the fourth level, the first with a specification, every specification of the class reduces a set of three cells, so the one extracted does, and it has the right counts (about 7 seconds). Level by level, so that the result does not depend on auto_search's timing or on the random choice of a specification it extracts.

Beside these: on 400 random tilings of up to 3 × 3 cells, every one of the 2838 sets of up to four cells reducible before is reducible now in both directions, 13 more sets are reducible now, and all 3817 reductions the factory offers pass their sanity check to size 5 (1012 of them leave cells out, 308 have a group of two or more cells); the cell reduction gives develop's 1052 single-cell reductions but 30, all of cells that are factors on their own; and on tilings grown from 14 classes by point placements, row and column placements and requirement placements, every one of the 791 reductions offered passes its sanity check to size 6. Those 791 tracked 2486 cells in the first version and track 1343 groups now; 661 leave cells out, 5 have a group of two or more cells, and 28 were not reducible before.

CI's mypy, pylint and test_positive_reverse_fusion fail on develop too, at the same lines; #531 fixes them. This pull request's own tests pass in every test job. It changes the CHANGELOG's Unreleased section, as #530 does.

Reviewed before submission, over six rounds, by an automated reviewer. It ran:

• flake8, mypy, pylint, black and the tests on CPython 3.11 to 3.14 and PyPy 3.11, against the develop branches of all three libraries. The one failure is develop's test_positive_reverse_fusion, which Fix CI: the newest mypy and pylint, and test_positive_reverse_fusion #531 fixes.
• The sanity check of every reduction the factory offers on 400 random tilings, in every region, to size 5 (4,518), with point requirements (2,388) and with two-point gridded permutations in requirement lists (2,806).
• The forward and backward maps of every reduction offered on 120 tilings (1,124), and of the 1,770 reductions on 400 tilings that keep two cells of a row or a column.
• develop's encodings decoded, and its cell reductions compared (810, identical).
• The kitchen sink pack on develop and on this branch: the same classes found, in about the same time.
• Mutation testing of both modules, with every surviving mutant classified. Every fault that changes a count, a map, the objects or samples generated, or what a saved specification decodes to is now caught by the tests.

---

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.