Walls

Call f : Z/N → Z/N channel-local if f(x) mod p depends only on x mod p for every channel — the parallel-computable functions — and compatible if a ≡ b (mod p) implies f(a) ≡ f(b) (mod p) for every p | N. On a squarefree ring these coincide with the polynomial functions: every function on a field is a Lagrange polynomial and the coefficients CRT-glue degreewise. The classic residue-system walls all fall outside: sign [x ≥ N/2], comparison, and overflow are incompatible — explicit witnesses at every channel — hence not channel-locally computable at any rung k ≥ 2. And channel-local bijections compose and invert channel-locally, so the obstruction survives every within-ring change of coordinates, linear or not: the wall is locality, not linearity.

Scope. Proved, one- and n-variable; exhaustive at Z/6 (of 46656 functions, compatible = local = polynomial = 108), constructive lift at Z/30. The equivalence is squarefree-only — Z/4 has 64 polynomial functions of 256 channel-local — so the tower's rungs are exactly the regime where channel-parallel = polynomial.

verifier: explore_size_transform.py

What the unknown channels hide, they hide almost completely, and the leak that remains is exact: the fiber over a known proper subset of channels is an arithmetic progression, so the sign bit has bias at most half an element over the fiber — the two sign counts differ by at most one — and the bias is exactly zero when channel 2 is among the unknowns, exactly half an element when it is not, the two cases being the parity of the unknown channels' product: the exact vanishing is the even channel's doing, never the decomposition's alone. One level up, the hiding is total: reading a horizon — the integer range [1, X] — through a window budget Q, the residue mod Q known whatever windows compose it, no archimedean fact about the horizon is certain at or below half coverage (Q ≤ X/2): no point determined, no pair ordered. A proper divisor's budget never exceeds half, so a sub-ring window sits below that onset permanently — while residue order still leaks statistically: at a budget dividing the horizon, guessing a pair's order by comparing residues is right with probability exactly (X + Q − 2)/(2(X − 1)), the accuracy law.

Scope. Proved; exhaustive at k = 4, and the bias dichotomy exhaustive for every proper window of every Z/N, N ≤ 240, prime-power moduli included. The half-coverage law and the sub-ring cap are proved general.

verifiers: explore_size_transform.py, explore_size_crystallization.py, explore_walls_provenance.py

D steps exactly at the multiples of the moduli, so within a D-tie class no channel residue wraps and every channel's residues strictly increase: (D, x mod p_min) is an exact comparator for any squarefree modulus set. The packed key D·p_min + (x mod p_min) is strictly monotone; sign and overflow are each one key compare; a D-only comparator errs — a false “equal”, never an inversion — on exactly the φ(N) tie pairs the residue repairs. The cost law: the diagonal's dot product runs at width log₂ SQ = log₂ N + log₂ Σ_p 1/p, so the comparator beats reconstruction iff Σ_p 1/p < 1 — never on a rung k ≥ 3, narrowly on designed large-prime sets (~10% of the width at 8 channels of 16–32 bits), where exactness costs one residue beyond the approximate diagonal — a residue already in the word — and every channel stays a field. The literature's strictly-monotone repairs pay the injectivity floor instead: a characteristic — a scalar summary of the residues, strict when it is order-faithful — on [0, N) takes at least N values, so a characteristic-based comparator computing narrower than log₂ N is forced into the split shape — non-injective D plus a tie-break residue already in the word — and Σ 1/p < 1 prices exactly when the computed part gets under the floor.

Scope. Tie-break lemma proved for any squarefree set; key monotonicity exhaustive at Z/510510. The residue tie-break is the standard sum-of-quotients comparator's own move (Dimauro 1993; Piestrak 2015) — the lemma is its general proof and scope.

verifier: explore_rns_comparator.py

A 2026 general-moduli residue comparison method (Didier, El Mrabet, Glandus, Robert, arXiv:2605.18415) — both operands held as residues at n pairwise-coprime moduli with product N, plus their residues at one redundant modulus coprime to N — implemented from its own pseudocode, is exact on all 118,485 pairs tested: exhaustive at two toy bases, random pairs plus corner cases (equal values, the range ends, adjacent pairs) at three working bases, its stated generality — composite moduli, composite redundant modulus, full range — holding as stated. And it pays the mixed-radix price whole, measured. Cost: n(n−1)/2 + (n−1) multiplications of channel-sized words — one under the paper's own Table 1, whose Algorithm 3 as printed multiplies n−1 times rather than the n its text states: a reading of the paper's count, not a defect of the method. Width: the computed object is the full mixed-radix digit vector, log₂ N bits in total and injective — the injectivity floor paid exactly, never computed under it; the redundant channel serves as a consistency test, not a reconstruction. Depth: the last digit finalizes at round n−1, the full triangular gate.

And the cost law's boundary is bracketable to order 10⁻⁴: SQ < N flips exactly at Σ 1/p = 1, with {2, 3, 7, 43} at Σ 1/p = 1805/1806 falling under and {2, 3, 7, 41} at 1723/1722 falling over — within 6·10⁻⁴ on either side — while the boundary itself is unattainable: SQ = N would contradict the forced gcd(N, SQ) = 1. On those sets the method's width column reads log₂ N throughout while the diagonal's reads log₂ N + log₂ Σ 1/p: the strict comparator pinned to the floor, the non-strict one dipping under it exactly where Σ 1/p < 1.

Scope. Correctness, cost, width and depth are rules, verified: exhaustive at the toy bases Z/105 and Z/180, sampled plus corner cases at three working bases up to eight prime moduli near 2¹⁶; the flip verified at 8 constructed sets in exact integer arithmetic; the boundary's unattainability is a property of pairwise-coprime sets. The classification being paid is the classification of the literature above, not a theorem over all methods.

verifier: explore_comparator_ruler.py

Equality and divisibility pass — divisibility's conjunct at p being “y_p = 0 or x_p ≠ 0”. Order, cyclic betweenness and the order-grading ord(x) | ord(y) fail, in two different ways. Order and betweenness fail maximally: every channel projection saturates, so the conjunction is the full relation and the channels retain nothing. The grading fails properly — its projections are proper, the residue pair (3, 1) at channel 7 occurring in no true pair, because covering an order 6 depends on the orders the other channels have available. Cyclifying buys no escape: btw(0, a, b) holds exactly when a < b and betweenness is translation-invariant, so the ternary relation is interdefinable with order and carries the entire size wall.

A second, orthogonal axis sharpens the split — the consumption partition, per channel the coarsest partition through which R factors. Divisibility reads one bit per channel, {0 | rest}: the valuation. The grading reads the order class and conflates 0 with 1 — support-blind, so the valuation bit and the order class are independent coordinates. Order and betweenness need the discrete partition at every channel — no per-channel compression at all, which is the hiding lemma read relation-side.

The survivors then collapse to one relation. Divisibility is support reverse-inclusion (x | y iff supp y ⊆ supp x) and Green's ≤_J is support inclusion: the same idempotent lattice read in opposite directions. So what replaces order is location — support, where an element lives — refined by torsion, its grade, how it turns. The refinement is thin: almost every element of ∏_p F_p sits at the top grade, and so do fixed integers (for n = 2 the lcm of ord_p(n) over p ≤ 10⁴ already swallows every prime power ≤ 32), so only support separates Z from the bulk — and in the limit every support stratum is Haar-null, though it thins slowly: the largest stratum still measures 0.05 at 10⁴ channels. The bulk fans into continuum-many null worlds.

Scope. The conjunctive test is exhaustive at Z/210, the ternary relations at Z/30; the consumption partitions are computed exhaustively at Z/30, with the grading's order-class read confirmed at Z/210. The grading's onset is rung 3 — at Z/6 it is still conjunctive, and the failure is a shared-torsion group fact rather than a tower one. The two collapses are algebraic; the top-grade density is computed to 300 channels and monotone there, its limit resting on Dirichlet plus Borel–Cantelli, and the stratum measures on Mertens.

verifier: explore_organizing_relations.py

The split above leaves order and betweenness needing every channel at full resolution. This is how far that goes. A known proper subset of channels — modulus M — pins each point of a triple to its own uniform ladder of N/M positions, and among the triples completing those three ladders, both orientations occur. The fraction of cyclic orientation the known channels determine is therefore not small; it is exactly 0.

The proof is three lines and uses no property of the modulus beyond c ≥ 2. Orientation is translation-invariant, so move the triple's base point to 0, where betweenness is integer comparison on (0, N). Each remaining ladder holds an element ≤ M and an element ≥ (c − 1)M, for c = N/M ≥ 2; pairing the two extremes one way and then the other realizes both orientations. Exactly one configuration escapes — all three residues equal at c = 2 — and it asks for three distinct points on a two-point ladder, so it holds no triple at all. An empty case, not an exception.

Primality is unused, squarefree-ness is unused, the primorial trajectory — the tower's own sequence of rungs — is unused: this is a fact about cyclic groups and their coarsenings, holding at every rung and at every designed tower — a ring built on chosen primes — alike. One bit of cyclic orientation costs the entire complement — the hiding lemma in its sharpest relation-side form.

Scope. Proved for every Z/N and every proper divisor M. Ground truth enumerated over all N ≤ 72 against every proper divisor — 252 pairs, non-squarefree N included: the empty class arises exactly where all three residues agree at c = 2 (the antipodal diagonal), and the extreme-pair witnesses hold everywhere. The claim is DETERMINACY, not independence: both orientations occurring in every class says nothing about their frequencies, and what the known channels leak statistically is the separate law above.

verifier: explore_coupling_order.py

At a rung, descent is rung-bounded: strict support chains have length exactly k+1 — a support is a set of channels and the idempotents realize every set, so the bound is the construction's and is attained at every rung (checked k ≤ 12). Recursion depth is a constant of the ring, not a function of the element, so support-descent recursions are bounded loops — circuits, not while-loops. Euclid splits along the same seam. The gcd ideal is a one-step support read, (x, y) generated by the support idempotent e_{supp x ∪ supp y}, while Euclid's loop has no analogue in the ring: the sizeless remainder x(1 − e_{supp y}) enters a 2-cycle and never terminates. Division with remainder died with the deleted place and only its purpose survives. In the limit both surviving lattices — support and grade — have infinite descending chains, dropping one prime at a time and dividing one prime out at a time, so well-founded descent does not survive either. The trade against Z is exact: Z is well-founded with unbounded recursion depth, the tower is bounded-depth at every rung with no well-foundedness in the limit. Induction is a finite-rung artifact; bounded descent is what replaces it.

Scope. Chain lengths attained k ≤ 12; the gcd ideal exhaustive over all 900 pairs of Z/30, whose eight ideals each recur many times, with gcd(x, y, N) the product of the jointly dead channels at Z/210; the non-termination is a witness. The bounded-loop shape is the Meyer–Ritchie one.

verifier: explore_organizing_relations.py

• Cyclic group — no product, no fields. The hiding facts are coarsening facts: every proper window Z/M of every Z/N (exhaustive N ≤ 240) leaves both signs in every fiber, bias exactly 0 iff N/M is even, prime-power moduli included; orientation hiding; and the channel quantifier [a = 0] is polynomial on no composite N, while at one field it is Fermat's 1 − a^p−1 — the wall vanishing.
• Single field. The Zech wall; the type obstruction — x^y is ill-defined already at one window, with p − 2 witnesses; the floors of the division ladder; where the super-log exists (Number systems).
• Product of ≥ 2 coprime windows, fields unneeded. Order's and betweenness's maximal conjunctive failure — Z/6 and the non-field Z/4 × Z/9 fail identically.
• Product of two abelian groups, no ring at all. The grading's failure and its mode; minimal proper carrier C₂ × C₄ = U(15), so on the trajectory the grading wall first appears at rung 3.
• Product of fields (squarefree). The locality criterion itself (thin boundary Z/4), and the meadow blueprint with everything riding it — division total by a pseudo-inverse at every element, x′ with x·x′·x = x and 0′ = 0, the multiplicative monoid graded by support.
• The primorial trajectory. One result, and it is a SELECTION rather than an obstruction: among the φ(N) translation-invariant cyclic orders the ring carries, the trajectory's own shape — the channel at 2, and Bertrand's postulate on the gaps — singles one out.

No wall needs the trajectory: the hiding is generic to any coarsening of any cyclic group, and the deletion names which window is missing. The mirror chart — capabilities pinned up to their birth rungs, permanent because channels only accumulate, so walls never heal — is the genesis ladder.

Scope. Every row is a rule pinned to the minimal carrier it names. The size/sign census is exhaustive over N ≤ 240; the rungs standing on results by others carry those results' own hypotheses.

verifier: explore_walls_provenance.py

At none of the three do the two capabilities co-habit, and what blocks them is resource rather than the particular ring. CRT independence requires coprime channels that do not couple; a positional magnitude is the carry-coupling of its digits, so asking for both asks one structure to couple and not couple. They exchange across the poles: the tower has independence and borrows magnitude, while its mirror at the other pole — a floating-point number, which keeps only the archimedean window and deletes every finite one (The dual pole) — has magnitude and no independent algebra at all, its only native binding being carry-coupled size.

The obvious first escape does not move the wall, which is worth knowing before proposing it: keep one prime's powers as well — Z/(p^t·m) with m squarefree and coprime to p — and the digit read is still division by the base, native only where the base is invertible, and an invertible base is an infinite value. What the prime-power register buys is a native valuation: a ratchet in depth, not a tree. Any dissolution along this line would re-import the whole deleted place rather than a minimal piece of it.

That verdict rested on one beam — a single commutative ring, where a channel either couples or does not — and dropping the beam does not escape. Give one integrated algebra a second, non-commutative operation and the axis becomes branching: a structure of fixed resource has a finite image, so it cannot injectively receive an unbounded domain, and branching either wraps or grows the magnitude, which is the deleted place again. The statement generalizes from “no single commutative ring” toward the impossible triple — unbounded branching, fixed resource, flat-role independence — with no substrate swept holding all three. One priced escape is known and refused: a rung times a floating-point register does put flat roles in the windows and magnitude in the register, but it re-attaches the whole deleted place as a co-factor, and binding register-side structure to a window-side role crosses the CRT boundary, which is the borrow. Two substrates stapled, and the staple is the borrow.

Scope. Observation at toy scope: codes and readers hand-designed throughout, nothing learned. The third design swept three corners of its own space — commutative, factor-permuting, coordinate-mixing — and that is where “resource-forced” comes from: the finite-image argument, exhibited on S₃ and SL₂(F₂), three principled corners and not an exhaustion over finite algebras. A genuinely different integrated algebra is therefore open rather than impossible: the absence of a found design is not evidence that none exists. One partial did land — those non-commutative operations are invertible, so undoing a nesting step, which a valuation ratchet cannot express, is recovered natively: a real dissolution of that one wall, and of nothing in the triple.

verifiers: explore_merge_dissolution.py, explore_dual_merge.py, explore_noncommutative_merge.py