Nesting

With no resource cap in force, a policy greedy at both kinds — patience 0 at the tree and at the chain — commits, at every step, the floor of the current image interval: the inclusion minimum of the cover cells containing it. Nothing about the run enters, not the route preferences and not a step of its history, so all four such policies hold one cell at every step and are one class — the bottom, which the next paragraph earns the name of. That opening clause is load-bearing: under a rank budget a greedy reader cannot always afford the floor, so the route and drawdown coordinates do enter and the four come apart — one class at rank 0 at each of the three unresourced landscapes of the ten censused, and 3, 4, 8 or 12 classes spanning ranks 0 to 11 at each of the seven resourced ones.

The floor has a closed form — the deepest tree cell strictly containing the image, carried along the straddle chain at that cell's vertex to the deepest element still containing it — built by a descent that reads the image and runs no policy and no commit loop. That is what makes the rest short. Every cell any policy commits stands at a tree cell strictly containing the current image, and no deeper along that cell's straddle chain than the image permits; the tree cells strictly containing a fixed interval form a chain, and the floor is inside every committed cell, at every step, whatever the patiences and whatever the route. Read on the quotient, the bottom's committed cells nest pointwise into every class's. Where a class sits off the bottom and its loss is finite that nesting is somewhere strict, since two distinct classes differ at one committed interval inside the counted window, and a nested interval that differs is strictly shorter — so the bottom carries a strictly smaller deficit. A strictly better class therefore exists from every class off the bottom at finite loss — the three squaring-map stalls, which carry no budget, with the rest — and lowering both patiences to zero reaches it by moves; what is measured rather than proved at those three is how far that is — two moves, in the next block — never whether anything better is there. Under a cap that conclusion is measured rather than proved, and it holds: over all 601 off-bottom classes and 1,362 members of those ten landscapes the doubly pinned class ranks strictly lower wherever it is a distinct class, 1,328 of 1,328, the 34 remaining members being readers already AT their floor. Those 34 sit in exactly 30 classes, and those 30 are exactly the classes no patience jump of any distance improves — cured only by a route flip or a drawdown move, since a class holding its own doubly pinned policy has nowhere left to go down the patience axis. Patience is not the whole alphabet.

Scope. Proved for this cover and move set with NO RESOURCE CAP in force, at any map, any stream, any horizon and any patiences, counted steps and uncounted alike. No map fence and no patience hypothesis stands on it, and none of the fences the census-born statements on stalls carry stands on it either; the resource fence is the one that does. The engine leg checks the containment at 1,789,200 policy-steps with no exception, and the closed form matches the run at 17,892 of 17,892 steps, both over the identity and doubling census. The strictness is the deficit's; the clock ruler is not read here. Toy scale.

verifiers: explore_minimal_cell.py, explore_pinned_freshening.py, explore_bootstrap_cures.py, explore_move_set.py

At two moves the improvement is proved wherever an off-bottom finite-loss class holds a policy with both patiences finite and positive whose counted window still refines. Lowering both patiences by one is an exact delay — that reader's committed cell at every step is the parent reader's cell one step later — so its cells nest inside the parent's pointwise, its loss telescopes to the window's endpoints, and it improves strictly whenever it changes the class, on any map at once, with zero exceptions across all 21,336 censused classes. The hypothesis is what limits it, and it excludes all ten of the finite-loss stalls the census found: every one has a patience pinned to the current image (the escape radius), so the proved cure is a theorem about the classes that do NOT stall. Where the theorem stops, the measurement carries on. Of the strictly improving classes two moves out from the three squaring-map stalls — five, four and three of them — exactly one at each nests pointwise against the stall, reached at all three by lowering the tree patience twice from the stall's own policy, at one pair of route preferences throughout.

At one move instead of two the nesting is measured rather than derived, and the measurements pin its mechanism. The nesting neighbour is a patience-lowering move every single time across both maps censused: no route flip, no diagonal and no patience-raising move ever nests. Which policy of the class is chosen is load-bearing — single patience-down moves break pairwise nesting in 3,225 of 44,040 identity-map pairs — and the two parallel commit loops admit exactly two ways of diverging from equal cells: a nested descent, or a cell where the policy prefers the tree side and only the fresher reference opens a route while the chain is still live. What never breaks is the chain-preferring corner (the chain-preferring nesting theorem), which settles 5,774 of the identity map's 9,401 classes outright; the remaining 3,627 are witnessed only by readers preferring the tree side at one or both cell kinds, and under the identity map every violation of theirs sits before the counted window begins and heals before it opens.

Scope. The two-move statement is a theorem for this cover and move set, unresourced, at any map and stream, under the stated patience hypothesis; the two-move route behind the squaring-map stalls' own escape is an observation, exhaustive at those three. The one-move statements are exhaustive at the censused scope — 21,336 classes, the identity and doubling maps — and the pre-window confinement is a rule at the identity scan's scope, so the one-move law is not a theorem: the corner that is proved is its chain-preferring case under the identity map, below. Toy scale.

verifiers: explore_shift_telescope.py, explore_seed_exclusion.py, explore_chain_persistence.py, explore_pinned_telescope.py, explore_pinned_composite.py

Under the identity map, take a reader preferring the chain route at both cell kinds and lower its tree patience by one. The two runs — that reader and its lowered copy, walked over one stream — commit cells that nest pointwise, the lowered run's inside the other's at every step. This holds across the whole chain-preferring slice — every chain patience against every tree patience, finite or infinite — at every stream, not only the ones scanned.

The argument runs through the door — a step at which a run leaves the straddle chain standing at a vertex, committing instead inside the cell that chain sits in — rather than through the refusal that blocks one. Call that chain the vertex's ladder, its cells the rungs, and — under this map, where a reference is a cylinder — the index of a reference the number of digits it pins, so the finer reference carries the larger index. To fall behind, a run must door off the ladder early, and dooring needs a tree reference fine enough to sit strictly inside the cell it doors into. Three facts close that route, and under this map all three read as facts about cylinders. The vertex of any ladder a run occupies is a convergent of the stream's value — one of the best rational approximations its expansion produces — and the ladder there is exactly as long as the expansion's next digit; at a vertex that is not a convergent the descent turns away and the ladder is never entered. The cylinders strictly inside the cell a door leads into are exactly those of index past the convergent's own, every coarser one holding the vertex on its boundary or inside it. And a chain reference two or more indices past the convergent's own has already maxed the ladder, its near end lying strictly past the last rung. So where the dooring reader's tree reference is the staler of the two, a reference fine enough to door forces a chain reference finer still, which has already maxed the ladder: the run either chains rather than dooring, where that move is still available to it, or leaves from the ladder's top rung, which is the only one left to leave from — never from below the rung the other run will reach. Where it is the fresher, the reference that would let it door already sits inside the chain reference the two share, so the cell it doors into lies inside the other run's cell to begin with. Both cases are read at the patience of whichever run is at risk of falling behind, which is what makes them meet with no gap. What each of the three facts actually asks of the cylinders, and how little it turns out to be, is the door inequalities.

Under the squaring and doubling maps a reference is the image of a cylinder rather than a cylinder, and the law fails thousands of times over the same digit products (the exhaustive enumerations of every stream over a fixed digit alphabet at a fixed length) — always with the lowered reader's tree reference staler than the chain reference the two share, and always in one crossing shape: the run at the higher patience commits a straddle whose near endpoint is strictly interior to the lowered run's cell.

Scope. The identity map and the chain-preferring slice of the policy space, with two lemmas imported already proved — the crossing catalog and the fresh-regime lemma of explore_chain_persistence.py. The scans confirm rather than carry it: 3,696,980 pair runs at distinct coverage over complete digit products with zero bad steps, and each of the three facts checked separately over four exhaustive censuses. The map contrast is measured at the digit products scanned, not proved.

verifiers: explore_ladder_entry.py, explore_chain_persistence.py

The cylinders are not the hypothesis. Take the reference family — the nested sequence of intervals a run's references are drawn from — as the design variable instead of the map, the images of the maps set beside chains built by hand, and the three facts' dependencies come apart. The VERTEX fact asks nothing of the intervals' arithmetic at all, and on closer reading asks nothing of this construction either: it is a property of the Stern–Brocot tree. Every value descends that tree through its semiconvergents — the intermediate fractions its expansion passes through on the way to each convergent, got by stopping a digit short — turning only at the convergents among them, in runs as long as the expansion's digits. The end of a straddle on the value's own side is the next semiconvergent along, so the value sits inside that straddle exactly when the descent stops advancing past its vertex — which is to say the value itself occupies every convergent it reaches and no other vertex at all. What a run commits is a sub-collection of those — a committed cell always contains the value, so containment alone forces the vertex, whatever family the reference was drawn from — which is what leaves the stride below anything to differ about. The scans measure the part that concerns runs — 681,632 occupied vertices over ten families crossed with both route preferences, not one at a vertex that is not a convergent, each ladder running exactly as long as the next digit (the redundant cover's ladder law read from the reader's side) — which makes them a check that the cover behaves like the tree beneath it rather than a finding of their own. The MAXED-LADDER fact asks nothing of the arithmetic either. That leaves the CONTAINMENT fact — which references sit strictly inside the cell a door leads into — and it is the only one whose measured behaviour reads as arithmetic: writing a reference's determinant for |ad − bc| at endpoints a/b and c/d, determinant 1 is sufficient and nothing more — 568,195 doors opened by a determinant-1 reference, zero failures, while determinant 2 fails at 73,354 doors and still holds at 14,939. The determinant was standing in for a decomposition, and the decomposition is the tree's own. Determinant 1 is exactly the condition that makes an interval a tree cell — the tree's cells are bounded by determinant-1 pairs and nothing else is; and a reference of any determinant is a finite union of maximal tree cells — its pieces — which tile it, so its index is the smallest of theirs — a tree cell's index being the length of the digit run that defines it. Exactly one piece holds the value the run is reading, and that OCCUPIED piece is fine enough for free. The cell a door leads into is a child carrying the vertex as an endpoint, and the reference sits strictly inside that cell, so neither the reference nor its occupied piece holds the vertex; the occupied piece, being a tree cell that holds the value, is a node on the value's own path down the tree; and the nodes on that path between one convergent and the next are exactly the semiconvergent intervals, every one of them carrying the vertex as an endpoint. A node holding the value and not the vertex is therefore already of index past the convergent's own — a lemma rather than a tally, with the scan as its control, short at none of 738,910 doors. Containment then holds exactly when the pieces the value does NOT occupy reach that index too, and determinant 1 is sufficient for the empty reason that it has no such piece. Determinant 2 is two pieces glued at the half-mediant — the mediant of the two endpoints with numerator and denominator each halved — and fails exactly where that second piece is too coarse. The criterion cuts across the determinant rather than refining it: determinant 3 splits into two pieces at 49,245 doors and into three at 34,867. So the arithmetic leaves the statement.

What the law needs is none of it, and no family label carries it: two inequalities, both read at the door itself. At a convergent vertex of index σ — its position in the expansion, which is the same digit count an interval's index measures — the tree reference's index is at least σ + 1, and the chain reference's index is strictly larger than the tree reference's. Where both hold, a chain-preferring run's chain reference has maxed the ladder — 68,958 doors on that slice across all ten families, zero short, the count running over the doors whose ladder length the family's own read digits reach, that length being undefined past the horizon. The two conclusions then run on different mechanisms, and they are not one fact read twice. The tree cell door that would leave early is empty because a chain move exists there and the preference takes it: the run chains rather than dooring. The straddle exits are not empty at all — every one of the 68,958 leaves at the maxed rung, the only rung left to leave from, with no chain move on offer at a single one of them, the commit loop requiring a strict improvement. The invariant that the ladder never grows past the index a run doored out at is satisfied by the exit's own height, then, and not by the exit being prevented. Where the first inequality fails — 4,511 doors, the chain reference short at 2,356 of them — is where all 1,583 surviving violations of that invariant sit.

The geometry is preference-free and the law is not, and that is the rest of the hypothesis. Run the same split on the tree-preferring slice: the maxed ladder is still handed over at all 88,932 such doors, while 33,319 of those exits violate the invariant, against zero under chain preference. So the two inequalities force the geometry and the preference is what converts it into the law — the step that decides whether a run takes the maxed rung it has been handed. That also sharpens what the chain/tree axis is. Both preferences chain only at convergents and walk them in strictly increasing index, so neither reads anything but the continued fraction and the axis is stride: where the tree reference is the staler of the two, the chain-preferring run never once walks consecutive convergents, 0 of 5,859 sequences, and the tree-preferring run does in 1,646 of 5,875. The statement is about single decisions rather than about families or policies — a run cannot read its own reference's index without knowing the digits, and a determinant-3 family carries decisions of both kinds. The cylinder family satisfies both inequalities at every door of the kind at issue, so inside that family the inequalities are indistinguishable from the family itself.

Scope. Ten reference families — the maps' images and hand-built chains — × 16 runs × exhaustive digit products, 1,209 to 1,241 streams per family. The geometric half is measured at both route preferences and the nesting half at the chain-preferring one; the two are stated together because the contrast between them is the finding. A rule at that scope and not a theorem over all families: what is proved is the identity-map case above. Nothing the law reads stays keyed to the endpoints' arithmetic: what separates a determinant-2 reference that opens a door respecting the first inequality from one that does not is where its unoccupied piece sits, read over the same ten families at both preferences. The occupied piece's own reach is proved rather than measured, and the classification sets aside 1,690 doors, all at determinant 3, where a family's finite digits leave undecided which piece holds the value.

verifier: explore_reference_families.py, explore_g2_separator.py

On the spine, nesting settles everything: the cover cells containing an interval have an inclusion minimum, that minimum is monotone in its interval, so lowering a patience makes the two runs' committed cells nest pointwise and a lexicographic deficit descent stalls nowhere off the bottom (the stall census's dichotomy). Off the spine that nesting is measured dead — but not everywhere, and where it survives has a name. Call a step decision-free when no iteration of its multi-commit had both candidates available at once: a tree child and a straddle chain cell both containing the current image, which is the one configuration in which the loop has a route preference to consult. Unresourced, along a patience-down move — one that lowers a single patience coordinate — committed cells nest at every step whose whole history is decision-free in both runs — zero exceptions among the 188,928 (policy, step) pairs that qualify. So the spine's nesting dies only where a preference decision was available. That is necessary and not sufficient, and the same counts refute the converse outright: 481,937 such pairs carry a decision in their history and nest anyway. From a common start the nesting is proved — a smaller tree reference sits in the same child and a smaller chain reference gives a weakly longer chain, so both loops walk the same branch sequence with the lower-patience run refining at least as far, and a candidate appearing for the smaller reference would itself be a second candidate. What the scans carry alone is the induction across steps, where the two runs start from different cells: that is the monotone-fixed-point step the bottom lemma records as tight in its single-reference form.

The consequence is a necessary condition on any unresourced stall off the spine — every patience-down neighbour separated from it by an available decision — and the question that condition leaves: can a preference decision alone, with no conserved budget behind it, buy a late gain with an early loss? A budget can, and that is the burst trap's whole mechanism: a conserved spendable quantity, so paying early removes capacity late. Unresourced the answer is still yes. Across three designed batteries, 10,174 pairs of policies one policy move apart carry a first differing counted step and a total deficit pointing opposite ways — the side worse where the traces part ends strictly ahead — and 4,114 of those pairs hold equal patience on both ends, so the two runs read identical references at every step and the entire divergence is the two preference bits. The cleanest witness pays 3.244 in the scale's log units at its divergence step, then collects 6.415 at each of the next three while the early winner freezes — the point at which its committed cell would next subdivide sits inside the shrinking references — before the traces re-merge, 15.9995 apart. Nothing is conserved anywhere in that trade; the only coupling between steps is the ratchet's position. So a budget manufactures not the trade but its assembly into a local minimum: the same landscapes carry thousands of trades and not one stall — zero stalls and zero adjacent value ties across 348 distinct unresourced landscapes, at up to 1.9 times the decision density — the share of counted steps carrying an available preference decision — of the batteries the trades above were drawn from — so a trade's late winner, the end a stall would have to hold wherever a neighbour wins the step at which their traces part, always sits at the bottom or finds a strictly improving move elsewhere in its neighbourhood. A world can deny it one: that is the horizon-cut stall, which ends the counted window inside the trade so the late win stands, and beats whatever neighbours remain outright.

Scope. Exhaustive over 741,888 patience-down comparisons — one policy and one counted step each — unresourced, on the nine rows at horizon 120 and on the spike-stream battery at horizons 16 and 120; the nesting statement is the 188,928 of them that are decision-free throughout. The common-start half is proved for this cover and move set; the induction across steps is carried by the scans at that scope and not by a proof. Nesting beats the coarser trace in the lexicographic deficit only while both traces are finite-loss, which at patiences below the counted-window start is every trace measured. The trade's existence is a rule — an exact-arithmetic witness, re-derived by hand — and its abundance an observation over 276,376 policy pairs in 1,102 landscape runs; the desert is an observation over the 348 landscapes. Toy scale.

verifiers: explore_stall_unresourced.py, explore_decision_trade.py