Ceilings

Ask for the sign bit [2x ≥ N] — which half of the ring x fell in. The Bayes ceiling is exactly (c+1)/2c when the unknown cofactor is odd and exactly 1/2 when it is even, with no third behaviour. The proof is three lines: the fiber is an arithmetic progression, so its below-count is ⌈c/2 − r/M⌉ at shown residue r, which is c/2 for every r at even c and takes exactly two values at odd c. Because N is squarefree, c is even precisely when 2 divides N and channel 2 is among the unknowns, so this family's dial is a single arithmetic bit: a cell is dead exactly when its ring has a channel 2 and the solver is not shown it. At odd N, which has no channel 2 to withhold, there are no dead cells at all — every proper subset lifts strictly off the floor. The log-loss ceiling is the same dichotomy in entropy dress: the binary entropy H₂((c+1)/2c) nats at odd c and log 2 at even. And the achiever costs a constant per query: reconstruct the shown residues into the single residue r = x mod M, which the Chinese remainder theorem does in one modular pass, then answer “below” iff 2r < M — one reconstruction and one comparison. This is the exact Bayes value of a qualitative fact the hiding lemma already carried, that the fiber's sign bias is at most half an element and exactly zero without channel 2.

Scope. The closed form is proved for every squarefree N and every proper divisor M; the confirmations are exhaustive over the 602 cells of the 57 rings built from the first six primes, largest N = 30030, exact in rationals with entropies to 1e-12 nats. 211 cells sit at the floor and all 211 are the 2-unknown cells; the achiever was enumerated on the 362 cells with N ≤ 2310. Uniform prior; 0-1 and log-loss scores. Toy scale.

verifier: explore_eval_ceiling.py

The sign bit is the predicate [x ≥ t] at the midpoint, so the question can be asked at every threshold, one cell together with one threshold being a slice — dead or interior slice by slice, under the cell tests above. Write s for t mod M; a fiber's below-count is ⌊t/M⌋ + [r < s], so exactly two fiber types exist and the ceiling is the no-evidence floor max(t, N−t)/N everywhere except where c is odd and t lies strictly inside the middle fiber window (mM, (m+1)M), m = (c−1)/2. Inside that window the ceiling is (c+1)/2c, independent of where in the window t sits. So the even half of the parity dial survives verbatim at every threshold — even c is dead at all of them — while the odd half deforms from a parity condition into a window condition. What does depend on t is the lift over the floor, the tent min(s, M−s)/N, maximal at the midpoint: the sign bit is the extremal member of its own family, sitting at the top of the tent. The achiever is unchanged and stays exactly tight.

Scope. The closed form proved for every squarefree N, proper divisor M and threshold; confirmed exhaustively on the 40,914 (cell, threshold) slices of the 194 cells over 37 rings with N ≤ 500, every one of the 2,697 interior slices carrying the tent exactly, plus 2,508 slices sampled at structured thresholds — window edges, midpoint, ends — up to N = 2310. The achiever was enumerated on the 12,090 all-threshold slices with N ≤ 210 and 1,137 sampled above. Uniform prior. Toy scale.

verifier: explore_ceiling_anatomy.py

Change the task shape. Take a uniform ordered triple of distinct points of Z/N, show all three residues mod M, and ask for the triple's cyclic orientation — a relation whose fibers are not intervals. Translating the base point to 0 leaves a difference pair (a, b) with orientation positive iff a < b as integers, and the fiber posterior is uniform on a product of ladders — each difference ranging over its own c-element progression of step M — so the positive count is a staircase threshold count on a c-by-c grid: rung by rung of one ladder, how many rungs of the other lie beyond it, summed. A fiber whose two shown differences are distinct and nonzero leans by exactly (c+1)/2c toward the residue order; a fiber where they agree, or where one of them is zero, is exactly balanced, and at c = 2 the all-zero fiber holds no triples at all. Weighting the fiber classes gives the ceiling

which lifts off the floor exactly when M ≥ 3. The hiding here is total, and independently proved to be — the fraction of triples the shown channels determine is 0 on every cell, no fiber ever deciding (cyclic orientation is totally hidden) — and the skew inside that total hiding is nonetheless real, and priced. The dial inverts against the sign bit: the sole dead subset is {2}, where the sign bit lived in channel 2 alone. So does the channel ordering. Single channels obey the same formula at M = p, worth zero at p = 2 and strictly increasing in p, making the best single channel the largest prime read, where for the sign bit channel 2 was the only single channel worth anything at all. Which channels pay is a property of the task, not of the ring.

Scope. The ceiling proved for every squarefree N and proper divisor M; exhaustive on all 194 cells over the 37 rings with N ≤ 500, where 19 cells sit at the floor and all 19 are the subset-{2} cells. The reduction to difference pairs is confirmed against raw triple evidence at N = 30 over every proper divisor. The log-loss ceiling matches its own closed form to 1e-12 nats and the achiever — two residue subtractions and one comparison — is exactly tight. Uniform prior. Toy scale.

verifier: explore_ceiling_anatomy.py

Ask the archimedean question of two hidden elements at once: [x < y] on a uniform ordered pair of distinct elements, with both residues mod M shown. A fiber with unequal shown residues is a product of two full c-ladders and leans by (c+1)/2c toward the residue order, the same unit again; a fiber with equal ones is exactly balanced, since as many ordered distinct pairs ascend as descend. Weighting them, the unknown cofactor cancels and the ceiling is

against a floor of exactly 1/2. This family has no dead cells: every proper subset lifts, M = 2 included. That is a third dial shape — a constant one, where the sign bit's dial was parity and orientation's was inversion — and the value depends on the ring and the shown modulus alone, not on how much is hidden. The achiever reconstructs both residues, orders them, and answers a fixed way on a tie, at two reconstructions and one comparison; the best single channel is again the largest prime read. These rings do admit an exact comparator, but it buys exactness by importing an extra coordinate and reading every channel (the exact comparator and its cost law); this is the other end of the same question — what a proper subset alone is worth, with nothing imported.

Scope. The ceiling, the floor and the log-loss form proved; exhaustive on the 362 cells of the 49 rings with N ≤ 2310, with the achiever enumerated exactly on the 116 cells with N ≤ 210 and the entropy strictly below log 2 on every cell. Uniform prior on the pair. Toy scale.

verifier: explore_ceiling_dials.py

Four dials over three task shapes, and one number underneath all of them. Every interior mechanism above reduces to a staircase threshold count on a c-ladder, and the per-fiber skew (c+1)/2c is what such a count yields: it is the sign bit's whole ceiling, the threshold family's interior value, the lean of an orientation fiber before dilution by the fraction of fibers that lean at all, and the lean of a comparison fiber before ties. The dials say which cells are alive and differ across the four; what a live cell is worth keeps reducing to the same unit.

The families also price their own cheaper solvers, by their own laws one level coarser. A solver that reads a single channel, or drops one, is the same eval at a smaller modulus — M = p for the single channel — so the cost of doing less is a difference of two instances of the family's own closed form rather than a separate measurement. At N = 2310 with channels {2, 3, 5} shown, the sign bit's joint ceiling is 39/77, the best single channel is worth 578/1155, and the gap is 1/165.

Scope. The recurrence of the skew unit is an observation across the four instances, each of whose ceilings is separately proved and confirmed at the ranges the blocks above state. The self-similarity of the single-channel law is a rule, proved and exhaustive on the same cells. Toy scale.

verifiers: explore_eval_ceiling.py, explore_ceiling_anatomy.py, explore_ceiling_dials.py

At the midpoint threshold — the sign bit — the two scores agree about which cells are dead, both naming exactly the even-c ones, and that agreement is a coincidence of that one threshold. Across the rest of the family they diverge sharply. Call the set of thresholds at which a cell is dead its floor set, one per score. The log-loss floor set is the thin set of thresholds divisible by M — where a threshold on a fiber boundary makes every fiber the same type, so the posterior does not move at all — while the 0-1 floor set is nearly everything, every threshold outside the odd-c middle window. Off that window the posterior does move; it simply never crosses one half, so a decision score cannot spend what a log score is paid for. At any threshold outside the window and not divisible by M, then, the two scores disagree outright about whether the evidence is worth anything: “the evidence is worthless” is not one statement but one per score. What survives the choice of score is the structural core, the thresholds divisible by M, where posterior equals prior. Robustness across a family of priors is what makes a statement of this kind portable — the same test the strongest grade of certified forgetting applies to a forgotten datum, flatness at every reweighting of the prior rather than at a named one (the four grades).

Scope. Proved, and exhaustive on the threshold family's 40,914 slices: 4,599 in the log floor set against 38,217 in the 0-1 floor set, entropies to 1e-12 nats. The structural core's independence of the prior is the window law. Toy scale.

verifiers: explore_ceiling_anatomy.py, explore_ceiling_dials.py

The prior was the one knob held fixed above. Replace the uniform prior by the geometric tilt, P(x) proportional to θ^x for a positive real θ, and re-derive the threshold family from scratch under it; within a fiber the weights become a geometric ladder in q = θ^M, and every value — ceiling, floor and conditional entropy — stays closed-form. A fiber's below-mass exceeds one half exactly when its below-count exceeds

and since a cell offers exactly two fiber types, one apart, its interior thresholds are exactly one fiber window of M−1 thresholds located at ⌊Q^*⌋ — unless Q^* is itself an integer, in which case the window is empty. That exception is where the uniform prior lives: Q^* → c/2, which lands on an integer exactly when c is even, and that is where the window collapses to nothing. Call a tilt resonant for a cell when it lands Q^* on an integer B, closing the window. Which tilts those are is algebra rather than a scan: Q^* = B says q is a root of q^c − 2q^B + 1, monic with constant term 1, so 1 and −1 are its only possible rational roots, and a tilt's q is positive — no rational tilt off uniform is ever resonant: every one leaves every window alive. Each 0 < B < c with 2B ≠ c carries exactly one resonant tilt — the polynomial's two sign changes and its simple root at 1 force exactly one more positive root — an algebraic irrational, below 1 exactly when 2B < c, the resonant tilts of B and c − B reciprocal to each other; and Q^* sits strictly between 0 and c, so 0 < B < c is the only place a resonance can land. At 2B = c the root at 1 is double and the pair carries no other: the parity collapse at even c is that family, met at the uniform point. The parity dial is therefore a resonance of θ = 1 rather than an invariant of the anatomy — every non-resonant tilt frees every even-c cell, while at a resonant tilt of any other B the window is empty and the cell dies again. What does not move with the prior is the structural core: a threshold divisible by M leaves every fiber the same type whatever the tilt, so those cells stay dead at every θ and remain the whole log-loss floor set throughout, while the 0-1 floor set goes on adding everything outside the current window. A single fixed threshold is the brittle object: the sign bit's even-c half is dead structurally, since the midpoint threshold sits on a fiber boundary there and is dead at every prior in the tilt family, and its odd-c half is alive only on a narrow band of tilts around uniform — exactly while q stays strictly between the root ρ in (0, 1) of the algebraic death boundary 2q^m = 1 + q^c, m = (c−1)/2 the middle fiber's index, and that root's reciprocal. Every tilt of this law's own grid sits outside that band; what enters it is the k-ary law's placement scan. The boundary is the B = m member of the resonant locus itself: the tilt where the sign bit's crossing happens is exactly the one that closes the whole window, and its root at c = 3 is the reciprocal golden ratio. Why the band is exact, and what it becomes when the sign bit's two halves are replaced by k parts, is the k-ary ceiling. The threshold family self-repairs where its extremal member does not: the window slides toward the bottom fiber as q → 0 and toward the top as q → ∞, and only the resonant tilts ever close it — off uniform, none of them rational.

Scope. The window law, the resonance and the sign bit's fragility proved — the resonance for every modulus and every c, engine-confirmed at c ≤ 12: an exhaustive rational scan to numerator and denominator 60 finds no rational resonance over 145,332 candidates, the locus count holds at all 66 (B, c) pairs, and the side and the reflection at the 60 with 2B ≠ c. The window law exhaustive on the 116 cells with N ≤ 210 across a nine-point θ grid at every threshold — 1,044 sweeps — plus 234 spot points up to N = 2310. The θ = 1 grid point reproduces the uniform law exactly, and the reflection identity, that tilting by 1/θ and reflecting the threshold leaves the ceiling unchanged, holds throughout. All 39 even-c cells are interior at each of the eight grid tilts and none at uniform; every sign-bit cell is dead at each of the eight. The threshold family is the only one re-derived under tilt — the orientation and comparison evals above stand at the uniform prior only. Two things are open and neither is claimed above: whether a prior outside this one-parameter family also yields a single window, and what the other two task shapes do under a tilted prior. Toy scale.

verifiers: explore_ceiling_dials.py, explore_tilt_resonance.py

The sign bit asks which half of the ring x fell in; ask instead which k-th: the magnitude class Y = ⌊kx/N⌋, the sign bit at k = 2. Write c = ak + b with 0 ≤ b < k. Within a fiber the k classes occupy consecutive runs of a or a+1 elements, exactly b of them the longer — call those b classes heavy — and which classes are heavy rotates with the shown residue r while their count does not; at b ≥ 1 the first of them is class ⌊kr/(bM)⌋. So at uniform the ceiling is ⌈c/k⌉/c at every fiber, against a floor of ⌈N/k⌉/N, and the achiever is one multiplication and one division past reconstruction: guess the first heavy class, when k does not divide c; when k | c every class ties and any fixed guess is optimal. The dial gains a second branch beyond divisibility: a cell is dead at uniform exactly when M⌈c/k⌉ = ⌈Mc/k⌉, which unpacks to k | c or saturation, M(k−b) < k — possible only at k > M — where the class partition is so fine against the shown modulus that the first heavy class is class 0 at every fiber and the evidence never moves the guess.

Under the tilt the runs stand still and only their masses move: each class weighs a difference of two powers of q taken at its run's endpoints, and convexity of q^t leaves at most four classes ever Bayes-optimal on a given fiber off uniform — class 0, the first heavy, the last heavy, class k−1 — at uniform every heavy class ties. The handover off class 0 is pinned by the single root in (0, 1) of a crossing polynomial q^L+a+1 − q^L − q^a + 1, L a multiple of a set by the fiber — two sign changes and a simple root at 1, the resonance argument's shape again — the handover into class k−1 by the reciprocal of such a root, and the switch from first heavy to last happens at uniform itself, where the heavies tie. So every cell with k ∤ c is alive exactly on one open arc of tilts (q_lo, q_up) and dead on the two rays outside it: the threshold family's isolated resonant deaths become algebraic arc endpoints. k | c cells have an empty arc — dead at every tilt. Saturation cells have q_lo = 1: dead at uniform yet revived by any sufficiently small upward tilt and by no downward one, because a floor partition is not mirror-symmetric — class 0 is heavy on the fiber at r = 0, whose top class is light — and at a ≥ 1 they die again from q_up on. Cells with a = 0 — more classes than the cofactor has elements — and no saturation are alive at every tilt. And whenever M > k and a ≥ 1 the arc is the symmetric band (ρ_a, 1/ρ_a): at L = a the crossing polynomial is a resonance polynomial — q^2a+1 − 2q^a + 1, the window law's shape with B = a and the exponent 2a+1 standing where that law's cofactor stood — so the lower edge ρ_a is its single root in (0, 1), and the upper edge is that root's reciprocal, the B = a+1 resonance of the same polynomial by the window law's reciprocal pairing. The band depends on a = ⌊c/k⌋ alone — not on k, b, M or the fiber structure — and at a = 1 its lower edge is the reciprocal golden ratio. The sign bit's death boundary above is this law's k = 2 row.

Scope. The run law, the uniform ceiling, floor, achiever and dial, and the dead-set law proved; exhaustive in exact rationals at the 428 cells with M ∈ {2, 3, 6, 15, 35}, every integer cofactor 2 ≤ c ≤ 12 — the run law reads only the fiber's progression, so N = Mc is not held squarefree here — k ≤ 9 and k ≤ N at uniform (144 dead, 44 of them by saturation) and at 1,602 (cell, tilt) evaluations over a nine-point tilt grid with M ∈ {2, 3, 6, 15}, every c ≤ 10, k ≤ 6 under the same cut, the dead-set law verified exactly at all 126 cells of that grid with k ∤ c — sample tilts on each side of every finite arc edge, each carrying an exact placement certificate before its verdict is read; 44,191 checks. Uniform and geometric-tilt priors; 0-1 score. Toy scale.

verifier: explore_kary_ceiling.py