# IMAGE — the set of limits a greedy walk reaches

The object: a greedy growth walk under the dynamics demand, every tie
followed, over Z, over an imaginary quadratic ring and over the ring of
a curve over F₂, in the ideal and the element world. Its **greedy image**
is the set of limits of all its branches. This page asks how big that
set is, what the walk must be run for and what the ring's supply
decides without a run, which of a ring's features reach the count, and
whether a lock that carries its rider adds a limit or removes one, and
what the image becomes when every policy is free, and what a policy
between greed and freedom keeps of greed's fate. Its verifiers are
image.py and free_image.py, with race.py for the widest tie a cubic
ring stages, cgreedy.py for the walk between, dam.py for the dam past
linear slack, slack.py for a slack polynomial in the tide, track.py
for the anchor, envelope.py for the depth dam and the record run's
price and choosy.py for the runs that seat less.

A place's **colour** is what the dynamics reads of it: over a curve its
degree in the ideal world and its (degree, class) in the element world,
as in ELEMENT.md; over a number ring its norm and local kind, the (e, f)
and width that fix its ladder (CLOCK.md), with its class in the element
world. The **supply** σ(ω) counts the places of colour ω, LIMIT.md's
count of items per degree read by colour. A limit gives every place an
exponent or ∞; a walk that locks repeats one vehicle forever, sending
that vehicle's support to ∞ and freezing the rest. The shape of a state or a
limit forgets which place of a
colour carries which exponent, keeping per colour the multiset of
exponents. The **rider reach** is the union of the supports of the least
divisors of every class, the minimal riders MINREP(c), c a class.

The answer, in one line: the image is a sum over the limit shapes a walk
reaches of products of multinomials over the supply, so a walk is run
only to find its shapes; over Z that is one point, over an imaginary
quadratic ring, on every seed run, where the walk locks within 60 moves,
a finite number, 2^t in the ideal world, t the ties a trajectory meets,
and over a curve with a rational place besides the one removed, at
LIMIT.md's corner, in the ideal world, the continuum; and the lock that
carries its rider removes a limit, the one choice it can reach, at the
two seeds of Q(√−23) whose tie lies in its support. Free every policy in
the ideal world and the ring drops out: the image is one of five forms
fixed by the demand and the seed, and the ring reaches it only through
the wall. Between the two, over Z, a walk free to take any move within a
factor c of the least one is dammed, below a ratio set by the largest
least move its states can hold: its support stays on finitely many
primes, so its fate is greed's, depth and never breadth, at every c from
every seed: that move is at most 2's price, set by the largest 2-adic
depth of p − 1 over the state's odd primes p, and at infinitely many e
every j·2^e + 1 with j below a given J, which would deepen it, is
composite. The same e dam a slack a little past linear, any move up to
max(c·m₀, κ·m₀·ln(ln m₀)), m₀ the least move, at every c and κ < 1/4,
from every seed.
Below c = 11/5 the supports of the factor-c walk's limits from the void,
with the primes they send to ∞, are computed exactly. A slack polynomial
in the least move escapes from the void: once the walk has read the
primes up to P, seating each that raises λ, that move is at least the
least element order unborn at P, at least a fixed power of P by Linnik's
theorem, so a nondecreasing slack at least p(t) on the prime powers,
p(t) the least prime ≡ 1 mod t, seats infinitely many primes, and one at
least p(t)² reaches breadth. No slack escapes from every seed: an odd
prime q held at exponent a with no held prime ≡ 1 mod q^a holds the
least move at most q, so f(q) < p(q^a) dams the walk, as from 3^N
whenever 3^N ≥ f(3), and an escaping run climbs an infinite chain of
primes, each ≡ 1 mod the one before and at most f of it. From the void
every escape pays p(r^e) once the least move reaches r^(e+1), 2^(e+2)
at 2, and the walk that reads the primes in order escapes exactly when
the slack also pays p(r^e) at r^e for each prime r it seats.

## The colour count
Tier: theorem.
Verifier: proof; image.py::section_o.

Every permutation π of the places that preserves colour and fixes the
seed maps branches to branches. λ of a state, the exponent of its unit
group (GROWTH.md, the dynamics demand), is an lcm of place
contributions read off (degree, exponent), or (norm, kind, exponent)
over a number ring; a door is the least r with λ_P(a + r) not dividing
L, where a is P's exponent, λ_P(b) is λ(P^b) and L is the state's λ; a
price is d·r over a curve, d the place's degree, or N^r over a number
ring, N the place's norm, joined in the element world by the least rider of
class −r·c, c the place's class, its degree m(−r·c) added over a curve
and its norm multiplied over a number ring; and a rider is a least
divisor of class −r·c, which π, keeping degree or norm and class, sends
to a least divisor of the same class. With every least vehicle on the
menu, π carries menus to menus (over the curves one least divisor per
class, ELEMENT.md#the-minimal-rider-is-unique, and at the two quadratic
rings walked; over Q(√−15) two, which π may swap), and the limit map
commutes with π, and the image Im(s) of the seed s is a union of
orbits. The orbit of a limit X is counted by the supply alone:

    |Im(s)| = Σ over the limit shapes reached of
              ∏ over colours ω of σ(ω)! / ∏_k n(ω, k)!,

a colour refined by the seed's exponent, σ(ω) then counting the places
of the refined colour, and n(ω, k) the places of ω at exponent k in X,
the places at 0 included. The walk is run to find the
shapes, and the supply prices each. The product of tie multiplicities
over a trajectory's openings is the case of one shape whose opened
colours carry one place at exponent 1 each, and a tie between two
colours separates limits wherever its branches reach different shapes.
A count of trajectories is not a count of limits: a limit forgets the
order of seating and the finite exponents at the places it sends to ∞.

The verifier checks the count on states, not limits, by brute force
from the void, to a finite depth. An engine over every place of
degree ≤ 9, λ read as an integer, reaches exactly the shapes of the
walker that reads colours alone (limit.py's corner, element.py's element
world) at every depth, and every shape's labelled states number exactly
its product: F₂[x] and ELEMENT.md's curves h2 and g2 in the ideal world
to depth 9, 9 and 8 (6,480, 12,096 and 4,608 states at the last), h2, h3
and g2 in the element world to depth 11. In the element world the
(degree, class) colouring is the coarsest that prices every menu
(ELEMENT.md#the-coarsest-colouring), and the one coarsening run on the
count fails it: grouped by degree alone the element world's states sit
off the degree multinomial at every depth of all three rings. A price
reading one place's label breaks the count at every depth of F₂[x].

## A quadratic ring's ideal image is 2^t
Tier: rule (the tie shape and the conjugate never seated proved; the
count verified at Z[√−5] and Q(√−23) over the void and every ideal of
norm ≤ 40; the bound on a tie's width attained at one cubic ring).
Verifier: image.py::section_q, race.py::section_width.

A least move P^r costs N(P)^r, a power of P's rational prime, so two of
equal cost lie over one prime, and a prime carries two places only when
it splits: every tie is a conjugate pair, one colour with σ = 2.
Conjugates share a ladder, so if K is the least exponent with λ_P(K)
not dividing L, a seated P at exponent a ≥ 1 has door K − a and its
unseated
conjugate door K: the conjugate is dearer by a factor of at least
N(P)^a at every later state, its **starvation**, and is never seated; a
conjugate seated shallower, at b < a, stands dearer by a factor
N(P)^(a−b) and never moves. Every seed run reaches a lock, read as 20
repeated tie-free moves within 60, the lock of
GROWTH.md#the-lock-over-a-number-ring taken as final there, and before
it a trajectory makes finitely many ties t, the same t on every branch by the
colour count, and the two members of each stand at different exponents
in every limit. The image is one shape, of 2^t
limits. Its symmetry is a swap at each split prime separately, so it is
a single Galois orbit only when t ≤ 1, and then only at a Galois-stable
seed. Over a field of degree n every tie still lies over one rational
prime, which carries at most n places, so a tie is at most n wide, and
the bound is reached: at x³ − x + 3, discriminant −239, 3 splits
completely, its three places each complete to Q₃ and share a ladder, and
they tie at the void; the winner runs at price 3, and once it is seated
λ = 2, which each partner's N − 1 = 2 divides, so the partners' doors
rise to 2, price 9 and more, and they are never seated, one shape of
3!/(1!·2!) = 3 limits.

At Z[√−5] t is 0, 1 and 2 at 35, 15 and 2 of 52 seeds, and at Q(√−23) 0
and 1 at 65 and 14 of 79: every seed's branches share one t, its limits
number 2^t in one shape, and the starvation held at every state visited,
4,028 checks of strict dearness.

## The lock's rider erases a choice
Tier: rule (verified at the void and every principal ideal of norm ≤
40: 26 seeds at Z[√−5] and 27 at Q(√−23)).
Verifier: image.py::section_q, element_ring.py::section_walks.

In the element world conjugates carry inverse classes, so a conjugate
pair is one colour where its class is its own inverse and two colours
where it is not. At Z[√−5], of class number h = 2, the ten seeds with a
tie reach two
limits each in one shape. At Q(√−23), h = 3, four seeds reach two limits
in two shapes, and two reach two lock-time states and one limit. Those
two are the seeds (2) and (2)², and their two states differ at the two
places over 2 and nowhere else. The lock vehicle is (2) = P₂P₂′, a core
at door 1 and its rider (ELEMENT.md#the-lock-carries-its-rider), which
sends both places to ∞: which of the two stands deeper is a finite gap
the state keeps forever and the limit forgets. So the rider adds no
limit and erases one, and on the seeds run the count is 2^(t − ε), ε
the ties whose two members both lie in a rider-carrying lock's support.
Z[√−5]'s lock (2) is the ramified place squared with no rider, and
Q(√−23)'s inert lock (5), at 3 of its 27 seeds on the single walk,
carries one place:
neither erases anything. Each of the 1,599 element menus the branched
walks read (image.py, every branch followed, a count apart from the
3,180 states of the single walks of
ELEMENT.md#the-number-rings-price-in-min-) equals the ring's own least
raising elements.

## A curve's image is the continuum
Tier: rule (proved from LIMIT.md's ideal limit at the corner and
ELEMENT.md's element world, both rules; the element half at every ring
whose principal places number two or more at all but finitely many degrees,
which six rings meet at every degree above 2 opened past the transient
in 300 moves, the hypothesis read only at the degrees the run opens).
Verifier: image.py::section_c, image.py::section_e.

In the ideal world at the corner, over a curve holding a rational place
besides the one removed (all six the verifier runs), every branch's
limit is ∞ at one runaway C of degree 1 or 2 and one place at exponent 1
at each other opened degree, every supplied degree above 1 opening
(LIMIT.md#the-ideal-limit). So the shapes are at most two, and

    |Im| = σ(1) ∏_(d ≥ 2) σ(d)  +  σ(2) ∏_(d ≥ 3) σ(d),

each product over the supplied degrees, σ(d) > 0, the second present
exactly when σ(2) > 0, as the void menu then ties. Each product has
infinitely many factors of 2 or more, so each shape's orbit is the
continuum and its points are choice functions on the degrees: the
runaway, then one place per degree. The runaway degrees over every
branch followed, every tie branched over the first 10 moves, are {1, 2}
at the five rings with a degree-2 place and {1} at h5, which has none;
the runaway and the first ten openings of the degree-1 shape already
offer 10^11.6 at F₂[x] and 10^11.6 to 10^17.0 over the curves. No lock
is needed for a coordinate to be decided: every coordinate of this limit
is written down.

In the element world, past the transient, the walk to its last opening
that pays a rider, an opening at degree d takes a principal core and
pays no rider (ELEMENT.md#greed-pays-no-avoidable-rider), so it chooses
one of σ(d, 0) places. A declined one is never seated later: as a core
it is raised by a clock move (LIMIT.md), T the notch, at d(T + 1)
against its seated sibling's d·T at most, neither paying a rider, and
as a rider it cannot come, a rider's place being alone in its colour.
The recurrent price doubles while an opening costs its degree, so the
openings never stop, and every limit carries each
opened colour outside the rider reach as one place at a positive
exponent and the rest at 0: a factor σ(d, 0) per degree opened past
the transient. Over
every branch followed at the six rings, ties branched over the first 8
moves and each branch walked to 300, every opening past the transient
chose from two or more principal places but F₂[x]'s one of degree 2, and
every opened colour outside the reach ended with one seated place. The
reach is finite, since the class group is and each class has finitely
many least divisors: h − 1 rational places over an elliptic curve and
six places over g2.

## The gap
Tier: rule (the point proved, the continuum as the curve section's
rule, the finite count verified at the two quadratic rings on the seeds
run).
Verifier: growth.py::section_c, image.py::section_q.

Over Z least moves at distinct primes are powers of distinct primes and
never tie (GROWTH.md#the-lock-prime-law), so every branch is the one walk and
the image is a point. Over an imaginary quadratic ring it is a finite
number wherever the walk locks, as every seed run does within 60
moves, and over a curve
with a rational place besides the one removed, at LIMIT.md's corner, the
continuum; neither is countably infinite. Over the curve, however many
choices the walk loses to erasure, a limit forgetting the order of
seating and the finite history of a place it sends to ∞, one shape's
orbit is already the continuum, so the count cannot fall to the
countable.

## The free image has five forms
Tier: theorem.
Verifier: proof; free_image.py::section_k1, free_image.py::section_k2,
free_image.py::section_k3.

Let a policy take any move its demand admits, the demand one of the five
named below: transparency, independence, new idempotents and dynamics as
GROWTH.md defines them, and semisimplicity, which asks that the new
modulus be squarefree. The **free image** of a demand and a seed s is
the set of limits of every maximal run from s. In the ideal world, a
move multiplying the state by any proper ideal, several places at once
allowed, over every ring this page walks and any Dedekind ring with
finite residue fields, finitely many places of each norm and infinitely
many places (the rings of integers away from finitely many places of any
global field), it takes one of five forms, W(L) the wall, for any L the
maximum of the states whose λ divides L (shown below). A limit is
finite when its support is finite and every exponent finite, that
is when it is a state, and X ≥ s means every exponent of X is at least
the seed's:

    transparency     the one finite point W(λ(s));
    semisimplicity   s·∏_{P∈S} P, S infinite and off supp(s), at a
                     squarefree seed; the point s at any other;
    independence     s·∏_{P∈S} P^(a_P), S infinite and off supp(s),
                     every a_P finite;
    new idempotents  every X ≥ s of infinite support;
    dynamics         every X ≥ s that is not finite.

Closure: a coprime move carries no seated place, so the seed's and each
seated exponent are final, and a coprime move always exists, the places
being infinitely many, so S is infinite; a squarefree product admits no second
copy; a new idempotent needs a new place, so the support is infinite;
and a dynamics run never halts, a place P off the current state M
with λ_P(1) > λ(M) always existing since finitely many places have
bounded size, while infinitely many non-unit moves cannot converge to a
finite limit.
λ(lcm) = lcm(λ) and λ is monotone under divisibility, so {M : λ(M) | L}
is closed under lcm, and finite, since finitely many places have
N(P) − 1 dividing L and each ladder is unbounded
(GROWTH.md#the-module-law); its maximum is W(L)
(GROWTH.md#the-three-fates over Z, GROWTH.md#the-wall-over-f₂x); a
transparent run from s stays among the multiples of s dividing W(λ(s)),
and any smaller state admits a place of the quotient, so every run ends
at W. Reach, the places listed by norm and ties in a fixed order:
seat the least unseated support place each step at
its target exponent (1 where the target is ∞), bring one seated place
short of its finite target up to it (seed places included), raise every
seated place bound for ∞ by one, several places making one move, and
under dynamics add a pad when λ has not risen: an unseated support place
Q with λ_Q(1) not dividing λ, seated at its target exponent (1 where the
target is ∞), which exists when the support is infinite; or else the
least place bound for ∞, seated or not, pushed up its unbounded ladder
until λ rises, which exists since a target of finite support in the
image is not finite. The least
unseated place rises strictly, so every support place is seated at a
finite step, and from then rises at every step or reaches its finite
target within finitely many. At a squarefree seed the last four nest
strictly, witnessed by exponents 1, 2, 3 on an infinite support, one
infinite exponent on an infinite support whose other exponents are 1,
and s·P^∞, one infinite exponent on a finite support; the transparency
point lies in none.

The verifier runs the closure over Z and F₂[x] on a battery of 14
states and 12 states against every move to a cap, 8,634 state-move
pairs: the zeros of the three demands that do not read λ, independence,
semisimplicity and new idempotents, are their definitions read
back, and its content is that every battery state has a dynamics move.
It runs the transparent reach from four seeds per ring, 2, 6, 12, 30
and 1, x, x², x² + x + 1, exact at all eight; and the reach construction
from the void and a squarefree seed: 56 constructions clean for 12
steps, every step admissible (the construction builds each below its
target and rising), every place off the seed at ∞ and, from the
squarefree seed, its places raised to 3 among them, 3,124 dynamics
targets of finite support, each with an infinite exponent, run 12
steps, every place bound for ∞ rising at every step after its seating,
and each of eight out-of-image targets stalling, its step and reason
printed.

## The free image forgets the ring
Tier: theorem.
Verifier: proof; free_image.py::section_k4.

Every image but transparency's is described by conditions on the seed's
places and, off them, on the multiset of exponents alone, every place
taken as one colour. So each is a union of orbits of G_s, the
permutations of all places fixing the seed's exponents: the colour
count's symmetry with the coarsest colouring there is, every place
alike, whose supply is infinite, so the orbit is no number to count; and
each of these four holds a continuum orbit, but semisimplicity's at a
seed that is not squarefree, the point s. An image can have more
symmetry than its demand. Dynamics reads λ_P, so a permutation breaking
the ring's colouring changes which moves it admits, at 161 of the 5,586
(state, move) pairs tested over Z and 96 of the 3,048 over F₂[x], and
two degree-preserving ones over F₂[x] at none; yet every dynamics target
with such a pair exchanged is reached, dynamics' image being a union of
orbits of G_s, and the verifier runs the construction toward six such
targets from two seeds per ring, one exchanged pair each, three of the
six moved by the exchange, every construction completing 12 steps. The
one image that reads the ring is transparency's point, the wall, where
the ring's arithmetic sits: Adams' number over Z
(GROWTH.md#the-wall-is-adams-number), a product of whole degree classes
of irreducibles over F₂[x] (GROWTH.md#the-wall-over-f₂x). The ring
reaches the greedy image through its colours and the free image through
the wall, and nowhere else.

## The fates are the image's extremes
Tier: property.
Verifier: proof; free_image.py::section_k5.

A limit in a free image has two coordinates, the support and the
exponents. BREADTH is the support every place and DEPTH an exponent
infinite, each a face, extreme in one coordinate with the other free;
MORTALITY, a finite limit, is where both bottom out. Every move at least
doubles the size, so a run from a seed dies exactly when its limit is
finite. Breadth and depth hold together at 2^∞ times every odd prime; a
member missing infinitely many places with every exponent finite holds
no fate; and new idempotents and dynamics hold the same fates as
different images, so fates do not determine an image. A finite reachable
set puts a demand at MORTALITY, since no run can repeat a state; a ban
on depth does not: **fresh dynamics**, which admits only a new place
lifting λ, never deepens and never dies, such a place always existing.
The verifier runs it 20 steps from four seeds, every place it seats at
exponent 1 by definition, and over F₂[x] no two of them of one degree,
which holds by construction: two places of one degree share
λ_P(1) = 2^d − 1.

## Greed's point
Tier: rule (resting on GROWTH.md's lock rules, this page's curve rule and
the five forms; the places at ∞ read at the 27 principal seeds of norm
≤ 40 of Q(√−23)).
Verifier: free_image.py::section_c, free_image.py::section_k3,
image.py::section_c, image.py::section_q,
element_ring.py::section_walks.

Where a greedy walk locks, over Z and over an imaginary quadratic ring
on the seeds run (GROWTH.md#the-lock-prime-law,
GROWTH.md#the-lock-over-a-number-ring), its limit has a finite support
and its lock vehicle's places at infinity, one place over Z, and at
Q(√−23) in the element world both places over 2 at 24 of 27 seeds on the
single walk with one tie-break, an element-world run being an
ideal-world run whose moves are principal: a member of the dynamics
image, finite support with an infinite exponent, that no smaller image
holds. Over Z greedy dynamics runs from the void to 3^∞, while a free
policy reaches 2^∞ by refusing the least move, 4 lifting λ where 2 does
not: that the walk never sends 2 to ∞ is greed's choice, not the
demand's. Where the walk sprawls, over a curve over F₂ at LIMIT.md's
corner, its limit keeps the infinite exponent and seats one place per
opened colour outside a finite rider reach (the curve section above), a
support infinite and missing infinitely many places, interior in its
coordinate. Both hold the depth fate alone; only the support separates
them. Over Z the walk is deterministic only because least moves at
distinct primes never tie; a tie-break is needed wherever moves share a
cost, and the greedy image prices it, nothing over Z, a factor of two
per surviving tie over the two quadratic rings walked, the continuum
over F₂[x].

## The c-greedy walk is dammed
Tier: theorem (the dam, the striking rule for the tide ceiling,
τ(P) ≤ 2^(W(P)+3), every c dammed from every seed, every slack at
most max(ct, κ·t·ln(ln t)), κ < 1/4, dammed from every seed); rule (τ(P)
and the dam ratio verified at every prime P ≤ 10,000; the lock patterns
of the image from the void verified exact for every c in [1, 11/5); the
least k with k·2^e + 1 prime, and the ratio it proves, at every
e ≤ 600; the lower dam's steps verified at J ≤ 40 and x ≤ 2000);
observation (the record tides' form, at four tides).
Verifier: proof; cgreedy.py::section_tau, cgreedy.py::section_dams,
cgreedy.py::section_census, cgreedy.py::section_two,
dam.py::section_dam.

Over Z, a class of policies between greed and freedom: the **c-greedy
walk**, c ≥ 1, takes at a state M any m ≥ 2 that raises λ with
m ≤ c·m₀(M), where the **tide** m₀(M) is the least such m. Composite
moves are allowed, so one move may seat several primes. c = 1 is the
greedy walk, and the image I_c(s) of every run from s grows with c,
inside the free dynamics image. Wider still, the **f-greedy walk**, f
nondecreasing with f(t) ≥ t, takes any λ-raising m ≤ f(m₀(M)), and the
c-greedy walk is f(t) = ct. The tide is a prime power, the least of
the prices q^door(q) over the primes q (the door lemma,
GROWTH.md#the-lock-prime-law). Write P⁺ for the prime after P and
**τ(P)**, the **tide ceiling**, for the largest tide of a state whose
primes are all at most P; τ(P) ≤ P from P = 5 on, since a state's
largest odd prime p has price p, no smaller prime being 1 mod p, and a
power of 2 has tide at most 4.

**The dam.** If f(τ(P)) < P⁺, every f-greedy run from a seed whose
primes are at most P keeps them at most P: at each state the tide is at
most τ(P), so every move is at most f(τ(P)), below P⁺, and brings in no
prime past P, and the claim follows by induction along the run. The
support stays finite while M grows without bound, so some exponent goes
to ∞: the limit holds DEPTH and never BREADTH. A walk restricted to
prime-power moves runs a subset of these runs and is dammed with them.
With the **dam ratio** ρ(P) = P⁺/τ(P), a seed is dammed at every
c < ρ(P) for any prime P at or past its largest prime.

**The striking rule.** τ(P) is the largest prime power T > 4 that some
state on the primes ≤ P holds as a tide, every price at least T, or 4,
the tide of the state 4, when there is none, and it is found without a
search. Fix T, let k_ℓ be least with ℓ^(k_ℓ) ≥ T, and
v_ℓ the ℓ-adic valuation. A state with every price at least T stays one,
with λ's part below T only larger, when: every prime of [T, P] is seated once,
its own price being at least T in any case and its only part of λ below T being
p − 1; 2 is unseated, since seated at a its price is at most
2^(v + 3 − a), v = v₂(λ), and its own part of λ tops the rest of λ's
2-part only where that price is at most 4, so unseating it keeps λ and
raises its price to 2^(v + 3); and each odd ℓ < T sits at exponent 0 or
1, since seated at a its price ℓ^(v − a + 2), v = v_ℓ(λ), reaches T only
when v ≥ a + k_ℓ − 2 > a − 1, so the other primes' p − 1 supply λ's
ℓ-part and a = 1 keeps λ at a higher price. Each change keeps λ's part
at the primes below T or enlarges it, the only part a price below T
reads, and a larger such part only raises every price of a prime below
T, a prime at or past T pricing at least T in any case, so none loses
the tide. With S the seated odd primes below T and N the lcm of p − 1
over S and the primes of [T, P], λ = N, and every price is at least T
exactly when

    ℓ in S             v_ℓ(N) ≥ k_ℓ − 1        (price ℓ^(v+1));
    odd ℓ < T, not S   (ℓ − 1) | N and          (price ℓ^(v+2),
                       v_ℓ(N) ≥ k_ℓ − 2          ℓ if (ℓ − 1) ∤ N);
    2                  v₂(N) ≥ max(1, k₂ − 3)   (price 2^(v+3), 4 at
                                                 odd N).

Every bar is monotone in N and N(S ∪ S′) = lcm(N(S), N(S′)), so the
feasible sets are closed under union and the greatest, G, exists when
any does. Striking finds it: start from every odd prime below T and at
most P, strike each member whose seated bar fails under the current N,
and repeat to a fixpoint X. G is never struck, N(G) dividing the
current N at every stage, so G ⊆ X, and X meets every seated bar. If X
meets the unseated bars and 2's, X = G; if it fails one, so does every
subset of X, a prime outside X being unseated there too while N only
shrinks, and no state on the primes ≤ P has tide T.

The rule gives τ(2) = τ(3) = 4, τ(5) = τ(7) = 5, τ(11) = 7 and
τ(13) = 11, each equal to the largest tide over a box of states on the
same primes (exponents to 6, 4 and 3 at 2, 3 and 5, to 2 elsewhere), and
at every prime P ≤ 10,000 a state built from G, at the prime where τ
last rose, has tide exactly τ(P) by the door formulas, so the ceiling is
attained. τ(P)/P trends down, 0.636 at 11, 0.465 at 101, 0.225 at 1009,
0.183 at 9973, and ρ's records climb
on the tides 5, 17, 107, 227 and 839 to 11/5 = 2.200 at P = 7,
97/17 = 5.706 at 89, 643/107 = 6.009 at 641, 1583/227 = 6.974 at 1579
and 5867/839 = 6.993 at 5861, with no record after it to 10,000,
and the least dam is at P = 7 for c = 2, 47 for 3, 67 for 4, 83 for 5
and 641 for 6. Observed at the four record tides d past
5, d − 1 is 2⁴ or 2r with r prime, and d is passed first at a prime
1 mod 16, d or r: 17
at 97 = 6·16 + 1, 107 at 643 = 6·107 + 1, 227 at 1583 = 14·113 + 1 and
839 at 5867 = 14·419 + 1.

**Every c is dammed.** A tide is at most 2's price, and 2's price is
bounded through one valuation, v = v₂(λ): unseated at odd M > 1 it is
2^(v + 3), the 2-door v + 3 of GROWTH.md#the-two-adic-prices, and seated at
a it is at most
2^(v + 3 − a), as in the striking rule. With w the largest v₂(p − 1)
over a state's odd primes, v is w unless 2's own part tops it, at
v = a − 2 with a ≥ 3 and a price at most 2, so 2's price is at most
2^(w + 3), equal to it at odd M > 1 and an inequality where 2 is
seated, and at most 4 on a power of 2. Hence τ(P) ≤ 2^(W(P)+3) for
P ≥ 3, W(P) the largest v₂(p − 1) over the odd primes p ≤ P. If
j·2^e + 1 is composite for every j ≤ J, let P be the largest prime
≤ J·2^e: a prime p ≤ P with 2^e | p − 1 would be j·2^e + 1 with j < J,
so W(P) ≤ e − 1, τ(P) ≤ 2^(e+2) and P⁺ > J·2^e, and ρ(P) > J/4. Such e
exist for every J, infinitely many: with L_J the lcm of the orders of 2
modulo 2j + 1 over j ≤ J, every e = 1 + t·L_J, t ≥ 1, makes 2j + 1 a
proper divisor of j·2^e + 1 = 2j·2^(e−1) + 1. So ρ is unbounded with no
prime-pattern hypothesis, and every c-greedy walk over Z, from every
seed and at every c, is dammed: its fate is greed's, depth and never
breadth. The construction is astronomical, L₂₉ = 240,360,120 placing
ρ > 7.25 at a P near 10^72,355,607.6. The **Proth route** does better:
the least k with k·2^e + 1 prime gives ρ > k/4 at the prime before it,
by the same count, and its records over e ≤ 600, each prime proved
(Miller–Rabin deterministic below 3·10^24, Proth's theorem above), give
ρ > 8.75 at a P near 10^10.9 (k = 35 at e = 31), the first past 5867/839, and
ρ > 224 near 10^130.9 (k = 896 at e = 425). 2's bar is not what holds
the tides of the table: dropped from the striking rule, it changes τ at
no prime P ≤ 10,000, the bound 2^(W(P)+3) standing at least 1.377
times above τ(P) there (first at P = 7547).

**Past every linear slack.** The same covering dams a slack a little
past every linear one. The order of 2 modulo n = 2j + 1 divides
Carmichael's λ(n), which is even with λ(n)/2 ≤ j, so L_J divides
2·lcm(1..J); and lcm(1..x) ≤ 4^(x−1) at every x ≥ 1, since
lcm(1..x)/lcm(1..⌈x/2⌉) is the product of the primes with a power in
(⌈x/2⌉, x], each dividing C(x, ⌊x/2⌋) ≤ 4^⌊x/2⌋ (its Legendre term at
that power is 1), and the steps ⌊x/2⌋ telescope to x − 1. At
e = 1 + L_J the dam holds when f(2^(e+2)) ≤ J·2^e, which
g(t) = max(ct, κ·t·ln(ln t)) meets when 4c ≤ J and
κ·ln((L_J + 3)·ln 2) ≤ J/4; as (L_J + 3)·ln 2 < 4^J, κ = 1/(8 ln 2)
meets it at every J ≥ 4. So every f-greedy walk with f ≤ g past some t,
at any c and κ ≤ 1/(8 ln 2), is dammed from every seed, at the largest
prime below J·2^(1+L_J) for every large J, and Every c is dammed is its
case κ = 0. With ψ(J) = ln lcm(1..J), ln((L_J + 3)·ln 2) < ln 3 + ψ(J)
at J ≥ 3, and ψ(J) ~ J by the prime number theorem (known: Hadamard
and de la Vallée Poussin, 1896), so every
κ < 1/4 is dammed the same way at every large J. The steps are checked
at J ≤ 40 and x ≤ 2000. The largest κ the covering admits at one J,
J/(4·ln((L_J + 3)·ln 2)), runs from 0.331 (J = 5) to 0.558 (J = 22)
over 4 ≤ J ≤ 40, but each J dams only the seeds below its one P: a κ
at or past 1/4 is dammed from every seed this way only if
ln((L_J + 3)·ln 2) ≤ J/(4κ) at infinitely many J, which is not proved,
and ln L_J/J lies in 0.51 to 0.82 at the twelve J the run tables.

**The image from the void.** Below c = 11/5 the dam at 7 keeps every
state on 2, 3, 5 and 7. There the dynamics reads an exponent a only up
to a cap B_p = ⌊log_p 1000⌋ + 3: past it, p's part of λ, a − 1
(a − 2 at 2), exceeds v_p(r − 1) for every prime r ≤ 1000, so p's price
stays p and a move raises λ at p exactly when p divides it. A state and
its capped image have the same tide and the same moves, and the capped
states form a finite graph. Every move raises a capped exponent or
leaves the capped state fixed, so a run climbs to one capped state and
then takes its self-loops, moves on its capped primes alone, forever:
its limit sends a nonempty union U of self-loop supports to ∞, keeps the
other capped primes at a finite exponent at or past the cap, and the
rest as they stand, and every such U is reached by cycling. The graph
changes with c only where c·m₀ crosses an integer, at c = m/m₀ with m₀ a
tide of a state on 2, 3, 5, 7, so in {2, 3, 4, 5}, and the census runs
at every such point in [1, 11/5). A **lock pattern** is a limit's
support with the primes it sends to ∞; the patterns there are exact, and
they arrive at eight values of c:

    c      patterns arriving (support | at ∞)
    1      3 | 3
    4/3    2 | 2;  2,5 | 5
    7/5    2,5,7 | 5;  2,5,7 | 5,7;  2,5,7 | 7
    8/5    2,5 | 2;  2,5,7 | 2
    5/3    3,5 | 3;  3,5 | 3,5;  3,5 | 5;  5 | 5;  5,7 | 5;
           5,7 | 5,7;  5,7 | 7
    7/4    2,7 | 2;  2,7 | 7
    9/5    2,3,5 | 3;  2,3,5 | 3,5;  2,3,5 | 5
    2      2,3 | 2;  2,3 | 2,3;  2,3 | 3;  2,3,5 | 2;  2,3,5 | 2,3

At c = 4/3 the image is exactly 3^∞, 2^∞ and 2²·5^∞: the c-greedy walk
reaches 2^∞, the limit greed never reaches from the void
(IMAGE.md#greeds-point), from c = 4/3 on. No pattern below 11/5 holds
both 3 and 7. The dam at 7 is
sharp at its own ratio: at c = 11/5 a state on 2, 3, 5, 7 with tide 5
admits 11, and the census seats primes to 23, completing under the next
dam, ρ(37) = 41/17. The census merges a pattern's finite exponents past
the cap into one class, so how many limits a pattern carries is not
computed, and only the patterns and their thresholds are read as the
law.

## Polynomial slack reaches breadth from the void
Tier: theorem (the floor τ(P) ≥ β(P), the escape, breadth, the depth
dam, the anchor, its chain, the slack below p(q) dammed from every seed,
the least slack past the dam dammed from the void at 23, the record
run's price max(S, B) ≤ E ≤ max(S, B, t), every p(s) a record seat);
rule (the inequalities the
floor, the escape and breadth lean on, verified at every prime
3 ≤ P ≤ 10,000 and at every move of the riding run whose record is at
most 10,000; the anchor's m₀ ≤ q and its edges over the capped walks
stated below; E = S, max(S, B) ≥ t at 3 ≤ t ≤ 10,000, the readings of
E, S, B and U and the two runs that seat less, verified at every
t ≤ 10,000); observation
(min{p(q) : q ≥ t} at t ≤ 10,000).
Verifier: proof; slack.py::section_record, slack.py::section_riding,
track.py::section_anchor, track.py::main, envelope.py::main,
choosy.py::main.

Over Z, widen the slack of the f-greedy walk
(IMAGE.md#the-c-greedy-walk-is-dammed) further. Write p(t) for the
least prime ≡ 1 mod t, and **β(P)** for the least prime power dividing
no p − 1 with p ≤ P prime: the least element order not yet born at P's
rung (TOWER.md#the-birthday-formula), so p(β(P)) > P.

**The floor.** The **record run** reads the odd primes in increasing
order from the void and seats, once, each p whose p − 1 does not divide
λ; a skipped prime's p − 1 divides λ already. Once every prime ≤ P is
read, its state M_P has λ = lcm(p − 1 : p ≤ P), and every price there
is a prime power q^e with e > v = v_q(λ): 2^(v+3) at 2, unseated;
q^(v+1) at a seated odd q and q^(v+2) at a skipped one; at least the
prime itself past P, a prime dividing no p − 1 with p ≤ P. None divides
λ, so the tide is at least β(P), and **τ(P) ≥ β(P)**, a floor under the
dam's ceiling 2^(W(P)+3). Linnik's theorem gives p(m) ≤ C·m^L at every
m ≥ 2 for constants C and L; as p(β(P)) > P, β(P) > (P/C)^(1/L), so the
tide ceiling grows at least as a fixed power of P and
ρ(P) ≤ P⁺/β(P) ≪ P^(1 − 1/L), past the trivial ρ(P) ≤ P⁺/4.

**The escape.** If f(t) ≥ p(t) at every prime power t, the record run
is an f-greedy run. Its next seat R(P) is the least prime past P whose
R − 1 does not divide λ, and p(β(P)) is one, so
R(P) ≤ p(β) ≤ f(β) ≤ f(m₀(M_P)). It seats infinitely many primes, each
once: its support is infinite and no exponent grows, so it escapes the
dam, holding neither depth nor breadth, 2 and the skipped primes
staying out. f(t) = C·t^L qualifies, and under the generalized
Riemann hypothesis, where p(m) ≪ (m log m)², a slack of that order
does.

**Every place.** If f(t) ≥ p(t)² at every prime power t, an f-greedy
walk from the void reaches breadth. The **riding run** moves 4 first, λ
rising from 1 to 2 at 4 ≤ f(3); it then reads the records from λ = 2,
so 3 is skipped, and moves each record R with the oldest skipped prime
q not yet seated, m = R·q, or with R alone when none waits. A rider
leaves λ unchanged, its q − 1 dividing λ, so λ stays
lcm(p − 1 : p ≤ P) and the move raises it through R. 2 at exponent 2
prices 2^(v+1) and a seated rider q^(v+1): every price is still a prime
power not dividing λ, the tide at least β, and m < R² ≤ p(β)² ≤ f(m₀).
Records never end and each carries the oldest waiting prime, if any, so
every skipped prime rides at a finite step: the limit gives 2 the
exponent 2 and every odd prime the exponent 1, breadth without depth.
By Linnik f(t) = C²·t^(2L) qualifies. So a policy strictly between
greed and freedom changes greed's fate: from the void a slack
polynomial in the tide reaches the free image's breadth, which every
c-greedy walk misses.

At every prime 3 ≤ P ≤ 10,000 the computed tide at M_P and τ(P) are at
least β(P), and R(P) ≤ p(β(P)); τ(P)/β(P) is 5.05 at P = 9973, where
β = 361 = 19². Along the riding run's 302 moves, the move 4 and the
records 5 to 9887, every move raises λ, its rider is below its record
with q − 1 | λ, the tide before it is at least β, and m ≤ p(β)²; at the
time every prime ≤ 10,000 is read, 631 skipped primes wait, the least
2897. The record run's slack R/m₀ reaches 27.7 at 9973, close to P/β
by construction: it does not locate the least slack that escapes.

**The depth dam.** Write u_r for the largest v_r(p − 1) over the held
primes p (odd p at r = 2). The prices bound the tide by them: m₀ is at
most r^(u_r+2) at an unheld odd r, r^max(1, u_r−a+2) at r held at
exponent a, and 2^(u₂+3) at 2 (4 before an odd prime). A tide that stays at
most T keeps every move at most f(T) and the support finite, so an
escaping run's tide is unbounded, and with it every u_r. Each e past the
seed's u_r is then crossed by one move, which brings a prime ≡ 1 mod
r^e, at least p(r^e), from a state with u_r ≤ e − 1, whose tide is at
most r^(e+1) at odd r (r^max(1, e−a+1) if r is held at exponent a) and
2^(e+2) at 2. So from the void every escaping run has
f(r^(e+1)) ≥ p(r^e) at every odd prime r and f(2^(e+2)) ≥ p(2^e), at
every e ≥ 1, and one pair failing dams every run from the void. Write
**B(t)** for the largest p(r^e) whose point, r^(e+1) or 2^(e+2), is at
most t: every slack under which a run escapes from the void is at least
B. It is carried by small r at depth: B(t)/t is largest at
B(2048) = p(2⁹) = 7681, 3.7505, over t ≤ 10,000, and B(10,000) = 17,497.
The covering dam works at r = 2 alone, and the anchor is the held case
at e = a.

**The anchor.** Neither the escape nor breadth holds from every seed,
and the held case says why. Call a held prime ≡ 1 mod q^a
an **anchor** of q at depth a. If a state
holds an odd prime q at exponent exactly a and no anchor of q at depth
a, q's own part, a − 1, is the whole of v_q(λ), the other primes giving
v_q(p − 1) < a; so the move q raises λ and m₀ ≤ q. Every move is then
at most f(q), and an anchor is at least p(q^a), so if f(q) < p(q^a) none
ever enters: q's exponent may grow, but an anchor at the new depth
would be one at depth a, m₀ stays at most q, and the run's primes stay
at most the larger of the state's and f(q). The run is dammed. At the
seed 3^N, q = 3 and a = N, and 3^N ≥ f(3) puts f(3) below
p(3^N) > 3^N: every f-greedy walk from such a seed is dammed, whatever
f.

So a run escapes only if f(q) ≥ p(q^a) at every state, for every odd q
it holds at exponent a with no anchor at depth a. It then climbs an
infinite **anchor chain**. Take q₀ past the seed's primes, the largest
of the support right after the move that brings it in (an escaping run
has infinitely many such), and q_(i+1) the first anchor of q_i at
depth 1 to enter. Each exists, or q_i is never anchored and the run is
dammed at f(q_i). Every q_i with i ≥ 1 exceeds q₀, so it enters after
q₀, the largest when it entered. At the move bringing q_(i+1), take
the least j with q_(j+1) not yet held: q_j is held (q₀ by the remark,
the rest by the choice of j) and has no anchor yet, q_(j+1) being its
first, so m₀ ≤ q_j ≤ q_i and q_(i+1) ≤ m ≤ f(q_i). Two classes follow.
Every f with f(q) < p(q) at every large prime q, for f nondecreasing the
same as f(t) < min{p(q) : q prime ≥ t} at large t, is dammed from every
seed, at any q₀ past that point, as p(q) ≤ p(q^a). This adds nothing to
the covering if that minimum is at most ct at large t: it lies between
2t and 3t at 9990 of the 9999 t in 2..10,000, and whether it stays below
ct asks for primes k·q + 1 with k bounded, open. So the anchor's force
is per run. The least nondecreasing slack on t ≥ 4 with f(τ(P)) ≥ P⁺ at
every P, F(t) = max{P⁺ : τ(P) ≤ t}, with F(3) = 5, is dammed from the
void at 23: on the primes ≤ 11 the tide is at most τ(11) = 7 and every
move at most F(7) = 13, so the first prime past 11 is 13, which has no
anchor until p(13) = 53 is held, while every move is at most F(13) = 23,
as τ(19) = 11 and τ(23) = 17. The bar f(τ(P)) ≥ P⁺ does not suffice from
the void either.

m₀ ≤ q holds at every odd q held with no anchor at depth 1 over the
687 states of capped walks (exponents to 3 at odd primes, 5 at 2): F's
from the void, and those under f = min{p(q) : q ≥ t} − 1 from the void,
3, 5, 7 and 3·5·7, which hold no prime past 7; along the latter's edges
no move passes f(q) or brings an anchor of such a q. Under F the
capped walk from the void reaches 591 states, all on the primes ≤ 23.

**The record run's price.** For nondecreasing f the record run is
f-greedy exactly when f ≥ E, E(t) = max{R : m₀(M) ≤ t} over its seat
states M, R the seat taken from M. Write S(t) = max{p(r^e) : r seated,
r^e ≤ t}. Then max(S, B) ≤ E ≤ max(S, B, t). Below: a seat r is past
every held prime, so it enters with u_r = 0 at exponent 1 and each e is
crossed from a tide at most r^e by a seat at least p(r^e); and the run
escapes under E, so E ≥ B. Above: the next seat is the least unread
prime R with R − 1 ∤ λ, and every read prime p has p − 1 | λ, a skipped
one by the rule and a seated one by its seat. The tide m₀ is a price at
some r. At a seated r it is s = r^(u_r+1), which does not divide λ, so
p(s) is unread and R ≤ p(s) ≤ S(m₀); at an unheld r with r − 1 ∤ λ, r is
unread and R ≤ r = m₀; at an unheld r with r − 1 | λ, R ≤ p(m₀/r), and
at 2, R ≤ p(m₀/4), each a power not dividing λ and B's term at the point
m₀. Every f of the class has f(t) ≥ t, so the record run is f-greedy
exactly when f ≥ max(S, B): every escape from the void pays B, and the
record run pays its seated primes' powers besides. At every 3 ≤ t ≤
10,000, max(S, B) ≥ t, and B never binds: E = S, with E(10,000) =
359,747. Every p(s), s a prime power, is a record seat: no prime below
it is ≡ 1 mod s, so s divides no p − 1 read before it, nor, being a
prime power, their lcm λ. The **tide-led run** seats at each move the
least anchor of the tide's unborn power, p(m₀) at a seated r, p(m₀/r)
at a skipped one and p(m₀/4) at 2, and an open tide prime r (unheld,
r − 1 ∤ λ) itself. Run until its tide passes 10,000, every seat it takes
is a record seat, its held primes up to 10,000 are the record run's
302, and its envelope is E at every t ≤ 10,000. Skipping each open r
instead, by seating the least prime P > r ≡ 1 mod the part of r − 1 not
dividing λ, prices below E at 6816 of the 9999 t in 2..10,000 and above
it at 484, from 13 to 9466; it never falls below 0.2538·E on
3..10,000, and is 324,469, 0.9019·E, at 10,000. The hull
U(t) = max{p(s) : s a prime power ≤ t} of the escape above bounds E,
and E = U at only 2640 of the 9999 t in 2..10,000, those where U's
largest p(s) has s a power of a seated prime; at the rest s is a power
of a skipped prime or of 2, whose p(s) the bounds force only at B's
point.

## Open fronts

Whether a Dedekind ring with an infinite class group, where the rider
reach need not be finite, can lose endlessly many choices and land
between the finite and the continuum, is open.

Whether ρ tends to ∞ along every P, that is whether τ(P)/P → 0, is
open: ρ is unbounded, but the bound at 2 alone would not give it if
primes k·2^w + 1 with k bounded occur at infinitely many w, as expected
and unproved, and τ(P)/P is computed only to 10,000. How fast ρ's
records grow is open too: the Proth route proves ρ > k/4 at a P near
k·2^e, its k averaging 1.12 times e·ln2/2 over 100 ≤ e ≤ 600 and its
records running higher (k = 896 at e = 425), and an upper bound
proved is ρ(P) ≪ P^(1 − 1/L) from the floor τ(P) ≥ β(P), L a Linnik
exponent.

Where the fate changes along the slack is open: a slack at most
max(ct, κ·t·ln(ln t)), κ < 1/4, or below p(q) at every large prime q is
dammed, every walk from every seed; from the void every escape pays
the depth dam's B pointwise, the record run escapes exactly at
max(S, B), which is S to 10,000, and one at least p(t)² on the prime
powers reaches breadth. Whether some run from the void escapes under a
slack at most max(S, t) at every t and below S somewhere,
seating primes whose powers cost less than the record run's, is open:
the tide-led run pays E to 10,000, and the run skipping every open
prime passes it at some t.
A walk from a seed escapes only if f(τ(P)) ≥ P⁺ at every prime P past
the seed's primes and
f(q) ≥ p(q^a) at every odd q it holds at exponent a with no anchor at
depth a (the anchor, above); the first bar alone does not suffice, F
being dammed from the void at 23 and every f from 3^N with 3^N ≥ f(3).
How the classes between greed and freedom order by their images is open
past the c-greedy one: its images nest in c and are computed, as lock
patterns, from the void below 11/5 only, and a class that is not a
threshold on the tide is not computed at all.