Learning
Learning as exact descent in reader space — no
gradients, no floats, every comparison a big-integer comparison — and
where the destination such a descent reaches stops being independent
of the data.
A stream here is the continued-fraction expansion of a real
number, arriving digit by digit, and a map is a function
applied to it. After n digits the value is pinned to a
cylinder In, and what a reader is certain of
about the output is the image interval Jn =
f(In) — these nest and shrink as digits
arrive. A row is one (map, stream) pair, and a slate of rows is
what stands in for training data throughout.
The window carries its own cell family: the Stern–Brocot cells plus
the straddle chains standing at their vertices — a cell's
vertex being the mediant of its two endpoints, the fraction whose
numerator and denominator are their sums — overlapping, and graded by
rank, which steps by one along every child relation
(the redundant cover). A
reader is a commitment policy on that cover — at each step it
may commit cells containing the current image, and a commitment is a
ratchet: never undone, and permanently sound, since a cell
containing Jn contains every later image. What is
left to choose is which route to take past a vertex, the tree child or
the chain, and how long to wait before committing, so a policy
is four coordinates — a route preference at tree cells, a route
preference at straddles, and two patiences, one per cell class.
A class at patience p commits a candidate only once it has
contained the image for p+1 consecutive steps; patience 0 is
greedy, committing on sight, and patience ∞ refuses the class
outright, the policy refusing both being the refuser.
Two exact rulers price a policy over a counted window. The
deficit at a step is the scale the reader is short: writing a
cell's scale for ln(1/length), the image interval's scale less the
committed cell's, which is the
quantity the commitment bound already bounds on this window
(the commitment bound).
Summed over the counted steps it orders policies exactly as the
product of their committed cells' lengths does, which is how it is
compared, and it is infinite for as long as a committed cell is.
The clock loss is the lag, in whole steps, of the reader's
committed scale behind the stream's own emission: how many images ago
the reader's cell was the current one. Neither is order-isomorphic to
the other, since the clock quantizes scale by the stream's local rate.
Both compare by cross-multiplying big integers, so no float and no
derivative enters any decision, and descent is the matching
finite-graph notion: neighbouring policies differ in one coordinate, a
move is taken only when it strictly lowers the loss, and a stall
is a policy with no strictly better neighbour.
Resources enter as settings rather than as policy coordinates: a
rank budget B of cover-rank units per input step, and a
bank of capacity W holding what a step does not spend.
What the policy gains is one coordinate for spending them, the
drawdown schedule, capping what a single step may withdraw —
spend-all at one end, withholding at the other. The pair
(B, W) is the reader's metabolism, and what it is
spent against is the row's demand: the rank per input step that
row asks for, about one per digit at the golden ratio and about eight
at [0; 8, 8, …]. And descent
runs on the behavioural quotient — policies identified when
their committed-cell traces over the counted window agree — because
two policies with identical traces cannot be ordered by any loss
reading that window, so their tie is structural rather than
signal-starved, and unquotiented coordinates manufacture stalls that
the honest space does not have.
The landscape
The funnel and its
one blind corner rule
With no budget in force the deficit is a perfect loss over the
committing policies: monotone strict descent converges from every
one of them to the exact global optimum — greedy in both classes,
and route-free — and the sole trap is total refusal, which sits on a
flat plateau of infinite loss where every single-coordinate
neighbour prices infinite too. The corner is a real trap and not a
shallow basin: a stalled reader's shortfall grows quadratically in
the horizon, the per-step deficit growing like the step times the
stream's scale rate. Two window-native cures address it, both
working at the original space and separating when the
patience axis grows. The signal cure refines the comparator
lexicographically — finite deficit beats infinite, and two infinite
policies compare by their committed-scale shortfall, the finite part
of the infinite loss — and converges from every start at both
widths, for a reason that does not depend on width: that shortfall
orders the plateau however far it extends. The move cure keeps the plain comparator and widens
the move set with the patience diagonals; it is radius-bounded,
stalling exactly where the whole neighbourhood is infinite, since
the blind region grows with the axis while a move set's radius is
fixed. Signal cures scale; move cures are sized to the plateau they
were designed against.
Scope. Exhaustive at both spaces — 100
policies on the patience axis (0, 1, 2, 3, ∞) and 324 on the
extended axis (0…7, ∞) — over eight rows whose streams are quadratic
irrationals, so their expansions are eventually periodic, including
the wall row (x², √2), where the map sends the stream
to a vertex and the window can never resolve it
(the wall criterion).
Horizon 120, counted from step 8. Toy scale.
verifiers:
explore_ratchet_learner.py,
explore_bootstrap_cures.py
The bottom
lemma rule
Fix a bounded nondegenerate interval. The cover cells containing
it form a sub-poset with an inclusion minimum, and greedy
multi-commit — taking commit moves within one input step for
as long as any remains available — reaches that minimum in any
preference order: the containing cells are finitely many, every
commit move strictly raises rank, and local confluence holds in
three cases, so Newman's lemma applies. Two corollaries follow. Confluence:
at greedy patience the committed cell sequence is preference-free,
which is why the funnel's optimum is route-free. Pointwise global
optimality: greedy patience dominates every policy at every
step, in any policy space of this family — so the optimum with no
budget in force carries nothing stream-specific, and nothing about it can be
learned from data at all. The single-reference hypothesis is tight:
at mixed patience the fixed point can depend on preference. In the
partition cover — the tree cells alone, where the containing cells
form one nested chain — loss is instead pointwise monotone in
patience, strictly where the compared losses are finite, with total
refusal worst.
Scope. The lemma and the partition valley
proved for this cover and move set; the engine checks the lemma's
statement at every counted step (169,082 containments) and the
tightness witness is a policy at the same slate and horizon.
verifier:
explore_bootstrap_cures.py
What the optimum depends on
The start-delay and
catch-up laws rule
Pointwise optimality consumes unbounded multi-commit, so a rank
budget breaks its proof and prices the coordinates that proof made
free. The start-delay law: a patience-p reader opens
about B·p ranks behind greedy, and under a binding
budget that gap is never erased — what used to erase it, in the
unthrottled reader, was exactly the unbounded multi-commit the
budget removes. So patience costs a permanent lag rather than a
transient one, and the patience valley is strict wherever a row
lags. The catch-up threshold law: greedy at budget B
matches the unthrottled loss exactly once B reaches a per-row
threshold — the ceiling of mean demand where fluctuation is bounded,
one rank higher on a row whose leading digit leaves a warm-up debt
standing — and never on exponential demand, the
wall row's per-step deficit growing linearly in the step so that no
finite budget catches up. A threshold read off a coarse budget grid
is an interval and not a value: the coarse grid records 4 where the
finer measures 3. Banking moves exactly one threshold on the slate,
and by warm-up funding rather than by smoothing — a row whose greedy
reader waits while the first digits arrive banks that step's income
and later repays the debt that warm-up left, taking that row's
threshold from 2 to 1. Off the optimum, route-locking is real: 83
strict wins for a withholding schedule over spend-all, an early
cheap commit steering a preference-fixed route past a better later
cell. Every one of them is strictly off the optimum, where every
drawing schedule ties.
Scope. Exhaustive at budgets 1, 2, 4, 8 and
unthrottled, bank caps 0, 2, 4, 8, over the eight quadratic rows,
horizon 120. Toy scale.
verifiers:
explore_throttled_reader.py,
explore_banking_reader.py
Destination
universality rule
Each row's argmin class is the set of behaviours
minimizing that row's loss. At every setting one universal policy
sits in every row's argmin class, and transfer gaps — the
excess a policy picked on one ensemble of rows pays on another — are
exactly zero: under the deficit on the eight quadratic rows at every
budget and cap, and under the clock loss, taken with the deficit as
tiebreak and taken alone, on all nine rows, the one aperiodic
non-quadratic row included. No loss tried that reads only the
committed-cell trace lets training data pick the destination —
and both of these do. What the optimum does depend on is the resource
environment: at exactly one setting, (B, W) = (4, 2),
the route order inverts and the universal set shifts — verbatim
under both losses. The shift being loss-invariant exhausts both
layers for stream dependence at once: the allocation layer (route,
patience, drawdown schedule) and the loss layer (scale units against
whole steps). A reader adapts to its metabolism, never to its data;
what descent learns here is how to spend, not what the stream
says.
Scope. Exact and exhaustive at the stated
scope and nowhere beyond it — this policy space, these nine rows,
horizon 120, these two losses. Toy scale, and the statement is about
this family of exact readers: outside it universality can fail, and
the law of when it fails is the data
door.
verifiers:
explore_throttled_reader.py,
explore_banking_reader.py,
explore_scale_clock.py
What strict descent cannot see
The blindness
census pattern
Every stall found at scope, with the cure the species takes.
| species | what stalls | cure |
| the plateau (space-born) |
a blind region of unbounded width — total refusal, where
every neighbour prices infinite and the comparator has no
signal |
a SIGNAL: lexicographic refinement by the loss's own finite
part; radius-free, so it scales with the plateau |
| the degeneracy (space-born) |
a flat quotient fiber — behaviourally identical policies
tied into a flat, manufactured by resource abundance (a full
bank smooths two patiences into one trace) |
the QUOTIENT: descend counted-window behaviours rather than
coordinates, on which the species cannot form |
| the ruler disagreement (loss-born) |
two exact losses over one window ordering an edge oppositely
— the coarse ruler dams the fine one's gradient, so the
deficit's own exit is clock-blocked and the class stalls under
the clock order alone |
two-move LOOKAHEAD, or descending the finer ruler across the
coarse ruler's plateaus |
A fourth species held a seat and lost it: coordination blindness,
the trap a binding budget seemed to open under the unthrottled
optimum itself, cured by a diagonal move — on the quotient the
trapped class merges with its behavioural twin one route flip from
the bottom, so the diagonal cure was two ordinary moves through a
twin-flat and the honest space never had the disease. What the
survivors have in common is an open conjecture: every
stall found here is a tie artifact, and two instruments
dissolve them all — refine the ruler where coarseness starves the
signal, quotient the space where coordinates outnumber behaviours.
At scope the pair suffices, lexicographic deficit descent on the
behavioural quotient stalling nowhere off the optimum at any setting
scanned. Whether that is a theorem of exact reader spaces is
open.
Scope. A census over the settings scanned,
not a classification of exact reader spaces. The two space-born
species and their cures are rules at the scopes the funnel and the
resource blocks state; the ruler
disagreement is a single specimen, at (B, W) = (2, 0)
with escape radius 2, and whether it is knife-edge or a family is
open.
verifiers:
explore_bootstrap_cures.py,
explore_scale_clock.py
The data door
The data
door rule
Destination universality is a property of (space, loss) jointly, and
the loss is the axis that breaks it. Relax exactly what the loss
reads — a decision-valued prediction score, where the committed
state alone guesses which side of its cell's vertex the stream will
land on, and is charged for a miss — and destination universality
dies. The rows' argmin classes stop intersecting under both orders,
the score alone and the score with the deficit beneath it as
tiebreak;
greedy leaves the argmin on six of nine rows, and eight rows are
perfectly predictable in-family but by different policies.
Two hand lemmas locate the door. Collapse: any local proper
score — one a truthful prediction minimizes — read against the flat
belief on the committed cell telescopes back into the family of
losses that see only the committed-cell trace, so leaving that
family takes a discrete decision. Coarsening: the ratchet
state is coarser than the public past, so the honest score is a
function of the state alone. The door has no width. Each
counted step carries one future bit — which side the stream
in fact took — and each of the 112 of them, taken alone as the top
order with the full deficit beneath it, already empties the
intersection, while zero bits restore it: a step at zero rather than
a threshold. So the price of data is
not conserved across bandwidth: thinning the scored bits collapses
it, and at a single scored bit a row's specialist ties the pooled
winner's miss total outright, losing only the deficit tiebreak.
“Reads the stream” is not the law, and
it fails from both sides. Losses consulting future bits only in
their values keep universality whenever the per-row
orderings they induce never move, and at this scope they never do:
467 of the 475 within-row pairs that tie in value are identical in
trace, so a tiebreak sitting below the deficit has nothing to act
on. Meanwhile 146 losses that read nothing of the stream at all —
indicators of a band of deficit values, row-uniform functions of the
deficit alone — break universality outright. What does break is
every non-degenerate loss tried whose top order consults future
bits, the perverse direction included: no universal anti-predictor
exists either.
Scope. The hand lemmas proved. Everything
else exact and exhaustive on one frozen arena — the behavioural
quotient with no budget in force, 100 policies in 38 classes, nine rows, horizon
120 — and over the loss species tried, which is what makes the
surviving criterion statements patterns at scope rather than
rules.
verifiers:
explore_prediction_door.py,
explore_bandwidth_dial.py,
explore_score_criterion.py
The keep law
rule
An empty intersection turns out to be the generic case, so the
thing needing a law is the keep. Order classes by
containment of their committed cells, step by step and row by row;
a loss whose optimum is pulled monotonically toward one extreme of
that order keeps universality, and both extremes exist. The greedy
class is pointwise-tightest — its
committed cell contained in every class's cell at every counted step
on every row, two steps from the bottom lemma and confirmed against
a cell family that is massively non-laminar — 76,058 sites where two
classes' cells overlap without either containing the other, so no
chain argument reaches it — and the refuser is
pointwise-coarsest by construction, holding the root cell
throughout. All four monotone loss species tried keep, each through
the extreme class its direction points at. For the losses that
simply reward landing in a band of deficit values, the criterion is
exact and proved. Rank a row's classes by their deficit, and a
class's hull is the interval its rank spans across the rows;
a clean band keeps if and only if it contains some class's hull —
the class it then hands every row at once. That hull spectrum is
bimodal, and the gap is the mechanism behind generic emptiness: the
refuser's hull has width 0 and its near-refuser sibling's width 2,
where every adapted class spans at least
85 of the 117 ranks, so adaptation makes a class's standing
violently row-dependent and only refusal is row-stable. The law is
sufficiency-only, and a band pair shows it: 213 keepers built from
two disjoint bands exist, and in 201 of them the universal optimum
set contains neither extreme — a keep handed out by where the values
happen to fall, not by monotone structure.
What holding data costs is read off the same arena. Within a row,
the committed geometry exhausts the visible: no loss tried separates
any of the 475 within-row pairs of classes whose committed cells
agree, step for step, on that row. So data content is a cross-row
quantity, witnessed only where two rows collide in geometry —
canonically at the golden near-twins, the two rows on which
φ² = φ + 1 acts as a translation of the cover tree and
which therefore agree in geometry on 32 of the 38 classes. The price
is then structural rather than statistical: the optimum set becomes
the row's fingerprint, an advantage on one row costs loss on the
pooled slate wherever it is not free (measured exchange rates of 4:1
to 15:1 at full bandwidth), and no adapted optimum keeps its
cross-row standing.
Scope. The coarse extreme, the hull
criterion and the two-band construction proved; the tight extreme
proved from the bottom lemma and engine-confirmed on the frozen arena
the data door names; the loss-species results exhaustive there. Toy scale.
verifier:
explore_keep_law.py