THE JARVIS MARCH

The Jarvis march (gift wrapping) in the 5-window house format — find the convex hull the way you'd wrap a present: start at the guaranteed-extreme leftmost point, then repeatedly pick the next hull vertex as the one making every other point lie to its left (the most clockwise turn). Each step wraps one more edge around the outside until you return to the start. It runs in O(n·h) time (h = hull vertices), fast when the hull is small. Verified live: over 1500 random point sets, the gift-wrapped hull matches an independent monotone-chain hull and every point lies inside or on it. See the wrapping in 1D, a hull in 2D, and the pull-it-taut inverse in 3D.

THE JARVIS MARCH · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · BOSS · THE WALL ◆ .dlw.fold THE FOLD / BOSS / THE WALL / THE JARVIS MARCH THE JARVIS MARCH wrap a hull around points like a gift 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Jarvis march (“gift wrapping”) finds the convex hull of a set of points the way you’d wrap a present: start at the guaranteed-extreme leftmost point, then repeatedly pick the next hull vertex as the one that makes every other point lie to its left — the most clockwise turn. Each step wraps one more edge of the string around the outside until you return to the start. It runs in O(n·h) time, where h is the number of hull vertices — fast when the hull is small. LIT verified live: over 1500 random point sets, the gift-wrapped hull matches an independent monotone-chain hull, and every point lies inside or on it (window.__jarvis). FIG no framing; exact orientation (cross-product) tests. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-wall — the outer boundary that encloses everything; Jarvis march wraps the wall of the convex hull tight around the points. AVAN (AI) built the instrument: the leftmost-start, the most-clockwise next-vertex selection, an independent monotone-chain hull, and the all-points-inside check. Credit as content: R. A. Jarvis (1973). The weave: David names the-wall; I wrap the hull by repeatedly choosing the point that turns most clockwise, cross-check the result against a monotone-chain hull, and confirm every input point lies inside or on the wall — the boundary found by wrapping. 3 ONE DIMENSION From the leftmost point, pick the next vertex so all others are to its left (most clockwise). Repeat — each step wraps one edge — until you return to the start. The string is now taut: the convex hull. 4 TWO DIMENSIONS · INTERACTIVE A point cloud with its gift-wrapped hull; checked against a monotone-chain hull with all points enclosed. new points ▶ verify 1500 ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: a taut hull wrapped around the cloud. AVAN’s addition (the inverse-companion): find the enclosing boundary by wrapping — from an extreme point, keep turning to the most-clockwise neighbour so all points stay on one side, edge by edge. The inverse of ‘test every triple for hull membership’ is ‘wrap the string tight — each pull adds one hull edge.’ Magenta is the all-triples test; green is the wrapping walk. The wall found by pulling it taut. pause spin LIT Genuine Jarvis march / gift-wrapping convex hull (R. A. Jarvis 1973). Verified live: over 1500 random point sets, the most-clockwise wrapping from the leftmost point produces a hull whose vertex set matches an independent monotone-chain (Andrew) hull (window.__jarvis.matchesMonotone), and every input point lies inside or on it (allInside) — exact cross-product orientation tests. FIG No framing: the leftmost-start, the most-clockwise next-vertex selection, an independent monotone-chain hull, and the all-points-inside check run in-browser and agree. The AVAN inverse is honest — finding the enclosing boundary by wrapping (turn to the most-clockwise neighbour so all points stay on one side, edge by edge) genuinely replaces testing every triple for hull membership; magenta is that all-triples test, green the wrapping walk. The wall found by pulling it taut. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE WALL · David Lee Wise (ROOT0), with AVAN


THE EDWARDS CURVE

The twisted Edwards curve in the 5-window house format — a·x² + y² = 1 + d·x²·y² carries an addition law with a rare virtue: it is complete, the same formula works for every pair of points with no special cases (no separate doubling rule, no point-at-infinity). The neutral element is the ordinary point (0,1) and the inverse of (x,y) is (−x,y); when a is a square and d is a non-square mod p, the points form an abelian group with the addition never breaking. This is why Ed25519 uses Edwards curves. Verified live: over a small curve, every sum is on the curve, (0,1) is the identity, (−x,y) inverts, and the addition is associative over thousands of triples. See the complete formula in 1D, points added in 2D, and the exception-free group law in 3D.

I-13 v2.0 | net = binds - k | 4 planes, 13 symbols, 12 operants, 5 cortex rules | sha 64881ebf

THE EDWARDS CURVE · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · BOSS · THE FIREWALL ◆ .dlw.fold THE FOLD / BOSS / THE FIREWALL / THE EDWARDS CURVE THE EDWARDS CURVE a curve whose addition never fails 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION A twisted Edwards curve a·x² + y² = 1 + d·x²·y² carries an addition law with a rare virtue: it is complete — the same formula works for every pair of points, with no special cases (no separate rule for doubling, no point-at-infinity). The neutral element is just the ordinary point (0,1) , and the inverse of (x,y) is (−x,y). When a is a square and d is a non-square mod p, the points form an abelian group with the addition never breaking. This is why Ed25519 signatures use Edwards curves. LIT verified live: over a small curve, every sum is on the curve, (0,1) is the identity, (−x,y) inverts, and the addition is associative over thousands of triples (window.__edwards). FIG no framing; exact modular arithmetic. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-firewall — the cryptographic wall Edwards curves build; their complete, exception-free addition is what makes signature schemes safe from edge-case attacks. AVAN (AI) built the instrument: the complete addition formula, the on-curve/identity/inverse checks, and the associativity test over random triples. Credit as content: Harold M. Edwards (2007); Bernstein & Lange (twisted Edwards, cryptographic use). The weave: David names the-firewall; I add points by the complete Edwards formula and confirm the group axioms — closure, identity (0,1), inverses (−x,y), and associativity — all hold with no exceptional cases. 3 ONE DIMENSION Addition: (x₃,y₃) = ((x₁y₂+y₁x₂)/(1+dx₁x₂y₁y₂), (y₁y₂−ax₁x₂)/(1−dx₁x₂y₁y₂)). Identity (0,1). No doubling special case, no infinity — complete. 4 TWO DIMENSIONS · INTERACTIVE The curve’s points over F p ; pick P and Q, see P+Q, with the group axioms checked. new P,Q ▶ verify group ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: a group law that never hits an exception. AVAN’s addition (the inverse-companion): add curve points with one formula for all cases — choose a square a and non-square d so the denominators never vanish, making the addition complete. The inverse of ‘handle P+P, P+(−P), and infinity as special cases’ is ‘one exception-free formula — the group law that always works.’ Magenta is the case-split Weierstrass addition; green is the complete Edwards law. No edge cases to attack. pause spin LIT Genuine twisted Edwards curve (Harold M. Edwards 2007; Bernstein & Lange). Verified live over a·x²+y²=1+d·x²·y² mod 13 with a a square and d a non-square (completeness): every sum lies on the curve (window.__edwards.closed), (0,1) is the identity, (−x,y) is the inverse, and the addition is associative over 3000 random triples (window.__edwards.associative). FIG No framing: the complete addition formula, the on-curve/identity/inverse checks, and the associativity test over random triples run in-browser with exact modular arithmetic and agree. The AVAN inverse is honest — choosing a square a and non-square d so the denominators never vanish gives one exception-free addition for all cases, genuinely replacing the case-split Weierstrass rules (doubling, infinity); magenta is that case-split addition, green the complete Edwards law. No edge cases to attack. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE FIREWALL · David Lee Wise (ROOT0), with AVAN


THE CORNACCHIA

Cornacchia's algorithm in the 5-window house format — solve x² + d·y² = m in integers (when a solution exists) astonishingly fast. It first finds a square root r of −d modulo m (r² ≡ −d), then runs a Euclidean-style descent on (m, r), stopping the moment the remainder drops below √m; that remainder is x, and y follows from (m − x²)/d being a perfect square. A whole Diophantine equation solved by one modular square root and a gcd-like loop. Verified live: over hundreds of primes m with a representation, the returned (x,y) satisfies x² + d·y² = m exactly. See representations in 1D, squares summing to m in 2D, and the reduce-don't-search inverse in 3D.

THE CORNACCHIA · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · LOOT · THE BOUNTY ◆ .dlw.fold THE FOLD / LOOT / THE BOUNTY / THE CORNACCHIA THE CORNACCHIA represent a number as x squared plus d y squared 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Cornacchia’s algorithm solves x² + d·y² = m in integers — when a solution exists — astonishingly fast. It first finds a square root r of −d modulo m (so r² ≡ −d), then runs a Euclidean-style descent on (m, r), stopping the moment the remainder drops below √m. That remainder is the x you want; y follows from (m − x²)/d being a perfect square. A whole Diophantine equation solved by one modular square root and a gcd-like loop. LIT verified live: over hundreds of primes m with a representation, the returned (x,y) satisfies x² + d·y² = m exactly (window.__cornacchia). FIG no framing; exact integer arithmetic, checked by substitution. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-bounty — the reward for representing a number as x²+d·y², claimed by a modular square root and a short descent. Cornacchia’s algorithm collects that bounty. AVAN (AI) built the instrument: the modular-sqrt step, the Euclidean descent to below √m, the perfect-square finish, and the substitution check. Credit as content: Giuseppe Cornacchia (1908). The weave: David names the-bounty; I find a root of −d mod m, descend the Euclidean chain until the remainder falls under √m, take that as x, recover y, and confirm x²+d·y² equals m exactly — a representation found, not searched. 3 ONE DIMENSION 97 = 9² + 1·4² = 81 + 16 (d=1). 43 = 5² + 2·3² = 25 + 18 (d=2). Find r with r² ≡ −d (mod m), descend (m,r) below √m → that’s x. 4 TWO DIMENSIONS · INTERACTIVE Pick d and a prime m; the found (x,y) shown as squares summing to m, checked exactly. new d,m ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: a number split into x² + d·y². AVAN’s addition (the inverse-companion): represent m as x²+d·y² not by searching x and y but by a modular square root plus a Euclidean descent — the remainder that first drops below √m is x. The inverse of ‘try every x,y until x²+d·y²=m’ is ‘solve r²≡−d, descend, read off x.’ Magenta is the two-dimensional search; green is the one descent. A representation by reduction, not search. pause spin LIT Genuine Cornacchia's algorithm (Giuseppe Cornacchia 1908). Verified live: over ~800 primes m (with d in {1,2,3,5,7}, gcd(d,m)=1) that have a representation, the modular-sqrt-plus-Euclidean-descent returns (x,y) satisfying x² + d·y² = m exactly, checked by substitution (window.__cornacchia.representationExact). FIG No framing: the modular-sqrt step, the Euclidean descent to below √m, the perfect-square finish, and the substitution check run in-browser with exact integers and agree (the algorithm correctly returns nothing when no representation exists — verified only on solvable cases). The AVAN inverse is honest — representing m as x²+d·y² by a modular square root and a descent (the remainder first below √m is x) genuinely replaces a two-dimensional x,y search; magenta is that search, green the one descent. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE BOUNTY · David Lee Wise (ROOT0), with AVAN


THE QUADTREE

The point-region quadtree in the 5-window house format — index 2D points by recursively quartering the plane. Each node holds a small bucket; when it overflows it splits into four children (NW, NE, SW, SE), redistributing its points. To answer a range query — which points fall in a rectangle? — you descend only into children whose regions intersect the query, skipping vast empty or far-away quadrants. Verified live: over 1000 random point sets and query rectangles, the quadtree returns exactly the same points as a brute-force scan. See the subdivision in 1D, a query in 2D, and the pruned-descent inverse in 3D.

THE QUADTREE · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GLITCH · STACK OVERFLOW ◆ .dlw.fold THE FOLD / GLITCH / STACK OVERFLOW / THE QUADTREE THE QUADTREE quarter the plane recursively to query it fast 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION A point-region quadtree indexes 2D points by recursively quartering the plane . Each node holds a small bucket of points; when it overflows, it splits into four children (NW, NE, SW, SE), redistributing its points. To answer a range query — which points fall in a rectangle? — you descend only into the children whose regions intersect the query, skipping vast empty or far-away quadrants. Sparse regions cost nothing to search. LIT verified live: over 1000 random point sets and query rectangles, the quadtree returns exactly the same points as a brute-force scan of every point (window.__quadtree). FIG no framing; exact set comparison. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at stack-overflow — the recursion that quarters space again and again; a quadtree is that recursion made a spatial index, each split a deeper frame. AVAN (AI) built the instrument: the capacity-triggered subdivision into four, the region-intersection pruning for range queries, and the match against a brute scan. Credit as content: Raphael Finkel & Jon Bentley (1974). The weave: David names stack-overflow; I quarter the plane recursively as points accumulate, answer range queries by descending only into intersecting quadrants, and confirm the results exactly match scanning every point — fewer comparisons, same answer. 3 ONE DIMENSION Overflow a node → split into NW, NE, SW, SE and redistribute. A range query visits only quadrants overlapping the query rectangle — empty and distant ones are skipped whole. 4 TWO DIMENSIONS · INTERACTIVE Points with the quadtree’s subdivisions and a query rectangle; the returned points checked against a brute scan. new points ▶ move query ▶ verify 1000 ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: fast range queries by quartering space. AVAN’s addition (the inverse-companion): answer ‘which points are in this box?’ without testing every point — recursively quarter the plane and descend only into quadrants that intersect the query. The inverse of ‘scan all n points’ is ‘prune whole empty quadrants — visit only what overlaps.’ Magenta is the full linear scan; green is the pruned descent. Space carved so the search stays small. pause spin LIT Genuine point-region quadtree (Raphael Finkel & Jon Bentley 1974). Verified live: over 1000 random point sets and query rectangles, the capacity-triggered four-way subdivision with region-intersection pruning returns exactly the point set a brute-force scan of every point returns (window.__quadtree.matchesBrute). FIG No framing: the capacity-triggered subdivision into four, the region-intersection pruning for range queries, and the match against a brute scan run in-browser with exact set comparison and agree. The AVAN inverse is honest — answering 'which points are in this box?' by descending only into intersecting quadrants genuinely replaces scanning all n points; magenta is the full linear scan, green the pruned descent. Space carved so the search stays small. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of STACK OVERFLOW · David Lee Wise (ROOT0), with AVAN


THE HOFSTADTER FEMALE-MALE

Hofstadter's Female and Male sequences in the 5-window house format — defined by mutual recursion, each needing the other to take a step: F(0)=1, M(0)=0, F(n) = n − M(F(n−1)), M(n) = n − F(M(n−1)). Neither can be computed alone; they must be unrolled together, each new term reaching into the other. From this tangle emerge two interleaving sequences: F = 1,1,2,2,3,3,4,5,5,6,6,… and M = 0,0,1,2,2,3,4,4,5,6,6,… Verified live: computed to 100000, both are well-defined and the opening values match the reference sequences. See the mutual recurrence in 1D, both plotted in 2D, and the entanglement inverse in 3D.

THE HOFSTADTER FEMALE-MALE · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GLITCH · RACE CONDITION ◆ .dlw.fold THE FOLD / GLITCH / RACE CONDITION / THE HOFSTADTER FEMALE-MALE THE HOFSTADTER FEMALE-MALE two sequences that define each other 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Hofstadter’s Female and Male sequences are defined by mutual recursion — each needs the other to take a step: F(0)=1, M(0)=0, and F(n) = n − M(F(n−1)), M(n) = n − F(M(n−1)). Neither can be computed alone; they must be unrolled together , each new term of one reaching into the other. From this tangle emerge two clean interleaving sequences: F = 1,1,2,2,3,3,4,5,5,6,6,… and M = 0,0,1,2,2,3,4,4,5,6,6,… LIT verified live: computed to 100000, both are well-defined (every lookback index in range), and the opening values match the reference sequences (window.__hofstadterfm). FIG no framing; exact integer mutual recursion. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at race-condition — two sequences reading each other’s values as they go; get the order wrong and one reads the other before it’s ready. The Female/Male recursion is that careful interleaving. AVAN (AI) built the instrument: the paired recurrence (computing M before F each step so the reads are valid), the in-range guard, and the reference-value match. Credit as content: Douglas Hofstadter, Gödel, Escher, Bach (1979); OEIS A005378 (Female) & A005379 (Male). The weave: David names race-condition; I unroll F and M together in the order that keeps every cross-reference valid, and confirm both stay well-defined and match their reference sequences — two threads that only make sense entwined. 3 ONE DIMENSION F(n) = n − M(F(n−1)) needs M; M(n) = n − F(M(n−1)) needs F. Each step: compute M(n), then F(n). F: 1,1,2,2,3,3,4,5,… M: 0,0,1,2,2,3,4,4,… 4 TWO DIMENSIONS · INTERACTIVE The two sequences plotted together; the well-definedness and reference match checked. zoom ▶ verify 100000 ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: two sequences that only exist together. AVAN’s addition (the inverse-companion): define two sequences each in terms of the other , unrolled in the one order that keeps every cross-reference valid — compute M(n) before F(n) so the reads are ready. The inverse of ‘define a sequence by itself’ is ‘let two sequences co-define, entwined, computed in lockstep.’ Magenta is a self-contained recurrence; green is the mutually-recursive pair. Meaning only in the entanglement. pause spin LIT Genuine Hofstadter Female/Male sequences (Douglas Hofstadter, Gödel, Escher, Bach 1979; OEIS A005378 Female, A005379 Male). Verified live: computed to 100000 with M(n) evaluated before F(n) each step (so cross-references are valid), both stay well-defined — every lookback index in range (window.__hofstadterfm.welldefined) — and F and M match their reference sequences 1,1,2,2,3,3,4,5,5,6,6 and 0,0,1,2,2,3,4,4,5,6,6 (fMatches, mMatches). FIG No framing: the paired recurrence (computing M before F each step so reads are valid), the in-range guard, and the reference-value match run in-browser with exact integers. The AVAN inverse is honest — defining two sequences each in terms of the other, unrolled in the one order that keeps every cross-reference valid, genuinely differs from a self-contained recurrence; magenta is that self-contained form, green the mutually-recursive pair. Meaning only in the entanglement. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of RACE CONDITION · David Lee Wise (ROOT0), with AVAN


THE DUTCH NATIONAL FLAG

The Dutch national flag problem in the 5-window house format — Dijkstra's one-pass, in-place, three-pointer partition of an array of three values (red/white/blue, or <,=,> a pivot) into three contiguous bands. A low and mid pointer advance from the front, a high from the back; each element mid meets is swapped into the correct band and the pointers close in — no counting, no second pass. It is the heart of three-way quicksort. Verified live: over 3000 random arrays and pivots, the one-pass partition leaves everything < pivot, then =, then >, and the output is a permutation of the input. See the three pointers in 1D, a partition in 2D, and the one-sweep inverse in 3D.

THE DUTCH NATIONAL FLAG · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · SPAWN · HELLO WORLD ◆ .dlw.fold THE FOLD / SPAWN / HELLO WORLD / THE DUTCH NATIONAL FLAG THE DUTCH NATIONAL FLAG sort three colours in one pass 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Dutch national flag problem (Dijkstra) sorts an array of three values — think red, white, blue, or <, =, > a pivot — into three contiguous bands in a single pass , in place, with three pointers . A low and mid pointer advance from the front, a high from the back; each element mid meets is swapped into the correct band and the pointers close in. No counting, no second pass — the array is partitioned by the time mid crosses high. It is the heart of three-way quicksort. LIT verified live: over 3000 random arrays and pivots, the one-pass partition leaves everything < pivot, then =, then >, and the output is a permutation of the input (window.__dutch). FIG no framing; exact ordering and multiset checks. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at hello-world — the small, classic exercise everyone meets; the Dutch flag is that first taste of an in-place three-way partition. AVAN (AI) built the instrument: the low/mid/high pointer sweep, the swap-into-band logic, and the partitioned + permutation checks. Credit as content: Edsger W. Dijkstra (the Dutch national flag problem). The weave: David names hello-world; I sweep one mid pointer, swapping small elements to the front band and large ones to the back band, and confirm the array ends partitioned into <, =, > with the same multiset of values — sorted three ways in a single pass. 3 ONE DIMENSION Three pointers: low, mid, high. If a[mid] < pivot, swap to low and advance both; if > pivot, swap to high and shrink; if =, just advance mid. One sweep partitions the array. 4 TWO DIMENSIONS · INTERACTIVE An array of three colours partitioned in one pass; the </=/> bands and permutation checked. new array ▶ verify 3000 ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: three colours banded in one sweep. AVAN’s addition (the inverse-companion): partition three categories in one in-place pass , not by counting then rewriting — three pointers close inward, each element swapped straight into its band. The inverse of ‘count each colour, then fill the array’ is ‘sweep once, swapping into place — done when mid meets high.’ Magenta is the count-then-rewrite two passes; green is the single pointer sweep. Sorted three ways, one pass. pause spin LIT Genuine Dutch national flag algorithm (Edsger W. Dijkstra). Verified live: over 3000 random arrays and pivots, the low/mid/high pointer sweep with swap-into-band logic leaves the array partitioned into pivot (window.__dutch.partitioned), and the output is a permutation of the input — same multiset (window.__dutch.permutation). FIG No framing: the low/mid/high pointer sweep, the swap-into-band logic, and the partitioned + permutation checks run in-browser with exact ordering and multiset comparison and agree. The AVAN inverse is honest — partitioning three categories in one in-place pass (three pointers close inward, each element swapped straight into its band) genuinely replaces counting each colour then rewriting; magenta is that count-then-rewrite two passes, green the single pointer sweep. Sorted three ways, one pass. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of HELLO WORLD · David Lee Wise (ROOT0), with AVAN


THE SOCIABLE NUMBERS

Sociable numbers in the 5-window house format — the aliquot dynamics: repeatedly replace n by s(n), the sum of its proper divisors, and watch the orbit. A perfect number is a fixed point (1-cycle: s(6)=6); an amicable pair is a 2-cycle (220→284→220); sociable numbers close a longer loop: 12496 → 14288 → 15472 → 14536 → 14264 → back to 12496, a 5-cycle where each is the divisor-sum of the last. Verified live: iterating s(n) from 6, 220, and 12496 closes cycles of length 1, 2, and 5 exactly. See the chains in 1D, an orbit closing in 2D, and the identity-as-cycle inverse in 3D.

THE SOCIABLE NUMBERS · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · RESPAWN · ROLLBACK ◆ .dlw.fold THE FOLD / RESPAWN / ROLLBACK / THE SOCIABLE NUMBERS THE SOCIABLE NUMBERS numbers whose divisor-sums loop back in a chain 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Sociable numbers live in the aliquot dynamics : repeatedly replace n by s(n), the sum of its proper divisors, and watch where the orbit goes. A perfect number is a fixed point (a 1-cycle: s(6)=6). An amicable pair is a 2-cycle (220→284→220). Sociable numbers close a longer loop: 12496 → 14288 → 15472 → 14536 → 14264 → back to 12496 — a 5-cycle where each number is the divisor-sum of the last, chained all the way around. LIT verified live: iterating s(n) from 6, 220, and 12496 closes cycles of length 1, 2, and 5 exactly — each step an exact divisor sum (window.__sociable). FIG no framing; exact integer divisor sums. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at rollback — follow the divisor-sum map and the state eventually reverts to where it began; sociable numbers are the loops that roll all the way back. AVAN (AI) built the instrument: the aliquot-sum function, the orbit tracer, and the cycle-length checks for perfect, amicable, and sociable numbers. Credit as content: aliquot cycles — perfect numbers (antiquity), amicable pairs (Pythagoreans), sociable chains (P. Poulet, 1918). The weave: David names rollback; I iterate the sum-of-proper-divisors map and confirm the orbits from 6, 220, and 12496 return to their start after 1, 2, and 5 steps — closed chains of divisor sums. 3 ONE DIMENSION s(n) = sum of proper divisors. Perfect: s(6)=6 (1-cycle). Amicable: 220↔284 (2-cycle). Sociable: 12496→14288→15472→14536→14264→12496 (5-cycle). 4 TWO DIMENSIONS · INTERACTIVE Trace an aliquot orbit; see it close into a cycle, with the cycle length checked. next chain ▶ verify cycles ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: a divisor-sum orbit that loops home. AVAN’s addition (the inverse-companion): classify a number by the orbit of the divisor-sum map , not by the number alone — a fixed point is perfect, a 2-cycle amicable, a longer cycle sociable. The inverse of ‘is n equal to the sum of its divisors?’ is ‘where does iterating s(n) settle — a cycle, and how long?’ Magenta is the one-step perfect test; green is the whole closed orbit. Identity as a cycle of sums. pause spin LIT Genuine sociable-number cycles (perfect numbers, antiquity; amicable pairs, Pythagoreans; sociable chains, P. Poulet 1918). Verified live: iterating the sum-of-proper-divisors map s(n) closes a 1-cycle from 6 and 28 (perfect), a 2-cycle 220↔284 (amicable), a 5-cycle from 12496, and a 4-cycle from 1264460 — each step an exact divisor sum, each cycle returning to its start (window.__sociable). FIG No framing: the aliquot-sum function, the orbit tracer, and the cycle-length checks run in-browser with exact integers and agree. The AVAN inverse is honest — classifying a number by the orbit of the divisor-sum map (fixed point → perfect, 2-cycle → amicable, longer → sociable) genuinely extends the one-step perfect-number test; magenta is that one-step test, green the whole closed orbit. Identity as a cycle of sums. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of ROLLBACK · David Lee Wise (ROOT0), with AVAN


THE PEPIN

Pépin's test in the 5-window house format — decide whether a Fermat number F_k = 2^(2^k)+1 is prime with a single modular exponentiation: for k ≥ 1, F_k is prime if and only if 3^((F_k−1)/2) ≡ −1 (mod F_k). One test, no factoring, and it is an iff, not a probabilistic guess. Fermat conjectured every F_k prime; Pépin's test (with Euler's factor) shows F_5 = 2³²+1 is composite = 641 × 6700417. Verified live (exact BigInt): F_1…F_4 pass (prime), F_5 fails (composite), and F_5 = 641 × 6700417. See the Fermat numbers in 1D, verdicts in 2D, and the one-exponentiation inverse in 3D.

THE PEPIN · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · BOSS · THE CHOKE POINT ◆ .dlw.fold THE FOLD / BOSS / THE CHOKE POINT / THE PEPIN THE PEPIN one test decides a Fermat prime 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Pépin’s test decides whether a Fermat number F k = 2 2 k + 1 is prime with a single modular exponentiation: for k ≥ 1, F k is prime if and only if 3 (F k −1)/2 ≡ −1 (mod F k ). One test, no factoring, no trial division — and it is an iff , not a probabilistic guess. Fermat conjectured every F k prime; Pépin’s test (with Euler’s factor of F 5 ) shows F 5 = 2 32 +1 is composite = 641 × 6700417. LIT verified live (exact BigInt): F 1 …F 4 pass Pépin’s test (prime), F 5 fails (composite), and F 5 = 641 × 6700417 (window.__pepin). FIG no framing; exact big-integer modular arithmetic. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-choke-point — the single narrow test every Fermat number must pass to be called prime; one modular power decides it. AVAN (AI) built the instrument: the Fermat-number builder, the BigInt modular exponentiation, the ≡ −1 check, and the 641-factor confirmation for F 5 . Credit as content: Théophile Pépin (1877); Euler factored F 5 (1732). The weave: David names the-choke-point; I compute 3 (F k −1)/2 mod F k in exact big integers and confirm it equals −1 exactly for the prime Fermat numbers and not for F 5 — whose factor 641 I verify directly. 3 ONE DIMENSION F k = 2 2 k +1: 3, 5, 17, 257, 65537, 4294967297, … Pépin: F k prime ⇔ 3 (F k −1)/2 ≡ −1 (mod F k ). F 5 fails — it is 641 × 6700417. 4 TWO DIMENSIONS · INTERACTIVE Each Fermat number and its Pépin verdict (prime/composite), the residue shown, checked. next F_k ▶ verify F1..F5 ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: primality from one modular power. AVAN’s addition (the inverse-companion): decide a Fermat number’s primality with one exact test , not a search for factors — a single modular exponentiation of 3 that lands on −1 iff the number is prime. The inverse of ‘trial-divide F k up to √F k ’ is ‘compute 3 (F−1)/2 mod F once — the answer is exact.’ Magenta is the factor hunt; green is the single decisive power. An iff from one exponentiation. pause spin LIT Genuine Pépin's test (Théophile Pépin 1877; Euler factored F_5 in 1732). Verified live with exact BigInt modular arithmetic: 3^((F_k−1)/2) mod F_k equals F_k−1 (≡ −1) exactly for the prime Fermat numbers F_1..F_4 and not for F_5 (window.__pepin.allCorrect), and F_5 = 641 × 6700417 is confirmed directly (f5factors). FIG No framing: the Fermat-number builder, the BigInt modular exponentiation, the ≡ −1 check, and the 641-factor confirmation run in-browser and agree. The AVAN inverse is honest — deciding a Fermat number's primality with one exact modular power that lands on −1 iff prime genuinely replaces trial-dividing up to √F_k; magenta is that factor hunt, green the single decisive exponentiation. An iff from one exponentiation. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE CHOKE POINT · David Lee Wise (ROOT0), with AVAN


THE CONTINUED FRACTION OF E

The continued fraction of e in the 5-window house format — where π's CF looks random, e = [2; 1, 2, 1, 1, 4, 1, 1, 6, 1, 1, 8, …] follows a clean pattern: a 2, then repeating triples (1, 2m, 1) for m = 1, 2, 3, … The even numbers 2, 4, 6, 8 march through, each flanked by ones. Truncating gives rational convergents that rush toward e. Verified live: the generated terms obey the 2;(1,2m,1) pattern, and the convergent p/q (exact BigInt) matches e to floating precision. See the pattern in 1D, convergents approaching e in 2D, and the order-in-a-transcendental inverse in 3D.

THE CONTINUED FRACTION OF E · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GRIND · THE GRINDSTONE ◆ .dlw.fold THE FOLD / GRIND / THE GRINDSTONE / THE CONTINUED FRACTION OF E THE CONTINUED FRACTION OF E the number e written as a patterned fraction 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The continued fraction of e hides a beautiful regularity where you’d expect chaos. Unlike π (whose CF looks random), e = [2; 1, 2, 1, 1, 4, 1, 1, 6, 1, 1, 8, … ] follows a clean pattern: a 2, then repeating triples (1, 2m, 1) for m = 1, 2, 3, … The even numbers 2, 4, 6, 8, … march through, each flanked by ones. Truncating the fraction gives rational convergents that rush toward e faster than any decimal expansion reveals. LIT verified live: the generated terms obey the 2;(1,2m,1) pattern, and the convergent p/q (exact BigInt) matches e to floating precision (window.__cfe). FIG no framing; exact pattern check and BigInt convergents. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-grindstone — the pattern grinds out term by term, 1, 2, 1, 1, 4, 1, 1, 6, …, each turn adding structure that sharpens the approximation to e. AVAN (AI) built the instrument: the pattern generator, the BigInt convergent recurrence, and the pattern + convergence-to-e checks. Credit as content: the regular continued fraction of e (Euler, 1737). The weave: David names the-grindstone; I generate e’s continued-fraction terms by the 2;(1,2m,1) rule, fold them into exact rational convergents, and confirm both that the pattern holds and that the convergents close in on e. 3 ONE DIMENSION e = [2; 1,2,1, 1,4,1, 1,6,1, 1,8,1, …] — a 2, then (1, 2m, 1) for m=1,2,3,… The even terms 2,4,6,8 step upward, each between two ones. 4 TWO DIMENSIONS · INTERACTIVE The CF terms and the convergents approaching e; the pattern and error to e checked. more terms ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: e as a patterned fraction. AVAN’s addition (the inverse-companion): write the transcendental e not as an endless decimal but as a patterned continued fraction whose convergents are the best rational approximations — 2;(1,2m,1) marching the even numbers through. The inverse of ‘expand e = 2.71828… digit by digit’ is ‘read its continued fraction — structure, and fast convergence.’ Magenta is the featureless decimal; green is the patterned fraction. Order inside a transcendental. pause spin LIT Genuine regular continued fraction of e (Euler 1737). Verified live: the terms generated by the 2;(1,2m,1) rule obey that exact pattern (window.__cfe.pattern), and the BigInt convergent p/q matches Math.E to floating precision — |p/q − e| FIG No framing: the pattern generator, the BigInt convergent recurrence, and the pattern + convergence-to-e checks run in-browser (BigInt so the convergents stay exact) and agree. The AVAN inverse is honest — writing e as a patterned continued fraction whose convergents are the best rational approximations genuinely differs from an endless decimal; magenta is the featureless 2.71828…, green the patterned fraction. Order inside a transcendental. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE GRINDSTONE · David Lee Wise (ROOT0), with AVAN


THE INTERVAL TREE

The interval tree in the 5-window house format — answer 'which stored intervals overlap this query?' quickly by augmenting a binary search tree. Nodes are keyed by each interval's left endpoint; every node also caches the maximum right endpoint in its subtree. That cache lets a query prune whole branches: if a subtree's max-high is below the query's low, nothing there can overlap, so skip it. A scan of every interval becomes a guided descent. Verified live: over 2000 random interval sets and queries, the tree returns exactly the intervals a brute-force scan finds. See the max-high pruning in 1D, an overlap query in 2D, and the cached-reach inverse in 3D.

THE INTERVAL TREE · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CO-OP · THE PULL REQUEST ◆ .dlw.fold THE FOLD / CO-OP / THE PULL REQUEST / THE INTERVAL TREE THE INTERVAL TREE query which intervals overlap fast 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION An interval tree answers “which stored intervals overlap this query interval?” quickly, by augmenting a binary search tree . Nodes are keyed by each interval’s left endpoint; every node also caches the maximum right endpoint in its subtree. That cache lets a query prune whole branches : if a subtree’s max-high is below the query’s low, nothing there can overlap, so skip it. What would be a scan of every interval becomes a guided descent. LIT verified live: over 2000 random interval sets and queries, the tree returns exactly the intervals a brute-force scan finds (window.__intervaltree). FIG no framing; exact overlap tests and set comparison. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-pull-request — overlapping ranges drawn together; the interval tree pulls in exactly the intervals that intersect a query and leaves the rest. AVAN (AI) built the instrument: the left-endpoint BST keyed nodes, the max-high subtree augmentation, the prune-by-max-high query, and the match against a brute scan. Credit as content: the interval tree (augmented BST; Cormen–Leiserson–Rivest–Stein). The weave: David names the-pull-request; I key intervals by their left endpoint, cache each subtree’s maximum right endpoint, and answer overlap queries by descending only where the cache permits — confirming the result exactly matches scanning every interval. 3 ONE DIMENSION Each node stores its interval and the max right-endpoint below it. A query skips any subtree whose max-high is below the query’s low — nothing there can reach the query. 4 TWO DIMENSIONS · INTERACTIVE Intervals as bars with a query range; the overlapping ones highlighted, checked against a brute scan. new intervals ▶ move query ▶ verify 2000 ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: overlaps found without scanning all. AVAN’s addition (the inverse-companion): find overlapping intervals without testing every one — cache each subtree’s maximum right endpoint and prune any branch that cannot reach the query. The inverse of ‘scan all intervals for overlap’ is ‘descend a BST, skipping subtrees whose max-high falls short.’ Magenta is the full scan; green is the pruned descent. Overlap queries by cached reach. pause spin LIT Genuine interval tree (augmented BST; Cormen–Leiserson–Rivest–Stein). Verified live: over 2000 random interval sets and queries, the left-endpoint-keyed BST with max-high subtree augmentation, querying by pruning subtrees whose max-high falls below the query low, returns exactly the interval set a brute-force overlap scan returns (window.__intervaltree.matchesBrute). FIG No framing: the keyed BST nodes, the max-high augmentation, the prune-by-max-high query, and the match against a brute scan run in-browser with exact overlap tests and agree. The AVAN inverse is honest — finding overlapping intervals by caching each subtree's maximum right endpoint and pruning branches that cannot reach the query genuinely replaces scanning all intervals; magenta is that full scan, green the pruned descent. Overlap queries by cached reach. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE PULL REQUEST · David Lee Wise (ROOT0), with AVAN


THE COHEN-SUTHERLAND

The Cohen–Sutherland algorithm in the 5-window house format — clip a line to a rectangular window using 4-bit region codes (outcodes). The plane is divided into 9 regions around the window; each endpoint gets a 4-bit code (left, right, below, above). If both codes are 0 the segment is fully inside (accept); if their bitwise AND is non-zero both endpoints share an outside half-plane, so the segment misses (reject); otherwise clip against one crossed boundary and repeat. A few bit tests replace geometric case analysis. Verified live: over thousands of segments, the clipped part lies inside the window, its endpoints sit on the original line, and the result matches the Liang–Barsky clip. See the outcode regions in 1D, clipped segments in 2D, and the four-bits inverse in 3D.

THE COHEN-SUTHERLAND · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GLITCH · SEGFAULT ◆ .dlw.fold THE FOLD / GLITCH / SEGFAULT / THE COHEN-SUTHERLAND THE COHEN-SUTHERLAND clip a line by four boundary bits 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Cohen–Sutherland algorithm clips a line to a rectangular window using 4-bit region codes (“outcodes”). The plane is divided into 9 regions around the window; each endpoint gets a 4-bit code — one bit each for left, right, below, above. If both codes are 0, the segment is fully inside (accept); if their bitwise AND is non-zero, both endpoints share an outside half-plane, so the segment misses entirely (reject). Otherwise, clip against one crossed boundary and repeat. A few bit tests replace geometric case analysis. LIT verified live: over thousands of segments, the clipped part lies inside the window, its endpoints sit on the original line, and the result matches the Liang–Barsky clip (window.__cohensutherland). FIG no framing; exact bit-code logic and float intersections. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at segfault — the out-of-bounds flag; Cohen–Sutherland’s outcodes are exactly bits that fire when a point strays outside the window’s valid region. AVAN (AI) built the instrument: the 4-bit outcode assignment, the accept/reject/clip loop, and the inside + on-line + matches-Liang–Barsky checks. Credit as content: Danny Cohen & Ivan Sutherland (c. 1967). The weave: David names segfault; I tag each endpoint with a left/right/below/above outcode, accept when both are zero, reject when they share a bit, else clip against a crossed edge — and confirm the clipped segment lies in the window and agrees with an independent clipper. 3 ONE DIMENSION Outcode bits: 0001 left, 0010 right, 0100 below, 1000 above. Both codes 0 ⇒ accept. AND ≠ 0 ⇒ reject. Else clip against a set bit’s boundary and recompute. 4 TWO DIMENSIONS · INTERACTIVE Segments clipped to a window with the 9 outcode regions; the clipped part checked inside and against Liang–Barsky. new segment ▶ verify 5000 ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: a line trimmed by bit tests. AVAN’s addition (the inverse-companion): clip a segment by encoding each endpoint’s position as 4 bits and reasoning about the codes — both zero accepts, a shared bit rejects, otherwise clip one crossed edge. The inverse of ‘analyze every geometric case’ is ‘test outcode bits — trivial accept/reject, then one edge at a time.’ Magenta is the geometric case analysis; green is the bit-code decision. Clipping decided by four bits. pause spin LIT Genuine Cohen–Sutherland line-clipping algorithm (Danny Cohen & Ivan Sutherland, c. 1967). Verified live: over 5000 random segments, the 4-bit outcode accept/reject/clip loop yields a clipped segment inside the window (window.__cohensutherland.clipInside), with endpoints on the original line (onLine), and its result agrees with an independent Liang–Barsky clipper (matchesLiangBarsky). FIG No framing: the 4-bit outcode assignment, the accept/reject/clip loop, and the inside + on-line + matches-Liang–Barsky checks run in-browser and agree to floating precision. The AVAN inverse is honest — clipping by encoding each endpoint as 4 bits and reasoning about the codes (both zero accepts, a shared bit rejects, else clip one edge) genuinely replaces geometric case analysis; magenta is that case analysis, green the bit-code decision. Clipping decided by four bits. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of SEGFAULT · David Lee Wise (ROOT0), with AVAN


THE GAUSSIAN PRIMES

Gaussian primes in the 5-window house format — the primes of the complex integers ℤ[i] = {a+bi}. A rational prime doesn't always stay prime: p=2 and every p ≡ 1 (mod 4) splits into two conjugate Gaussian primes (5=(2+i)(2−i), 13=(3+2i)(3−2i)), because such p is a sum of two squares (Fermat); every p ≡ 3 (mod 4) stays inert. The norm N(a+bi)=a²+b² is multiplicative, tying factorization together. Verified live: the norm is multiplicative over thousands of pairs, and a rational prime splits iff p=2 or p ≡ 1 (mod 4). See split vs inert in 1D, the lattice in 2D, and the primality-in-the-plane inverse in 3D.

THE GAUSSIAN PRIMES · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · LOOT · THE MINT ◆ .dlw.fold THE FOLD / LOOT / THE MINT / THE GAUSSIAN PRIMES THE GAUSSIAN PRIMES primes of the complex plane, split or inert 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Gaussian primes are the primes of the complex integers ℤ[i] = {a + bi}. A rational prime does not always stay prime here: p = 2 and every prime p ≡ 1 (mod 4) splits into a product of two conjugate Gaussian primes (5 = (2+i)(2−i), 13 = (3+2i)(3−2i)), because such p is a sum of two squares (Fermat). But every prime p ≡ 3 (mod 4) stays inert — it remains a Gaussian prime. The norm N(a+bi) = a²+b² is multiplicative, which is what ties factorization together. LIT verified live: the norm is multiplicative over thousands of pairs, and a rational prime splits (is a sum of two squares) iff p = 2 or p ≡ 1 (mod 4) (window.__gaussian). FIG no framing; exact integer arithmetic. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-mint — the coining of primes, extended into the complex plane, where some ordinary primes break into two conjugate pieces and others stay whole. AVAN (AI) built the instrument: the Gaussian norm and its multiplicativity, and the split-iff-p≡1(mod4) classification via Fermat’s two-square condition. Credit as content: Carl Friedrich Gauss (ℤ[i], 1832); Fermat’s theorem on sums of two squares. The weave: David names the-mint; I compute the Gaussian norm, confirm N(zw)=N(z)N(w), and verify that a rational prime is a sum of two squares (hence splits) exactly when it is 2 or 1 mod 4 — primes minted or split in the complex plane. 3 ONE DIMENSION 5 = (2+i)(2−i), 13 = (3+2i)(3−2i) — split (p ≡ 1 mod 4). 3, 7, 11 stay inert (p ≡ 3 mod 4). N(a+bi)=a²+b², and N is multiplicative. 4 TWO DIMENSIONS · INTERACTIVE The Gaussian integers near the origin, colored prime/composite; a rational prime shown split or inert. new prime ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: primality lifted into the complex plane. AVAN’s addition (the inverse-companion): ask whether a prime stays prime among the complex integers — those ≡ 1 (mod 4) split into conjugate factors (they are sums of two squares), those ≡ 3 (mod 4) stay inert. The inverse of ‘p is prime on the number line’ is ‘does p remain prime in ℤ[i] — or split?’ Magenta is primality on the line; green is primality in the plane. Splitting decided by p mod 4. pause spin LIT Genuine Gaussian primes (Gauss, ℤ[i] 1832; Fermat's two-square theorem). Verified live: the Gaussian norm satisfies N(zw)=N(z)N(w) over thousands of pairs (window.__gaussian.normMultiplicative), and a rational prime p is a sum of two squares — hence splits in ℤ[i] — exactly when p=2 or p ≡ 1 (mod 4), matching the inert/split classification for all primes below 2000 (window.__gaussian.splitClassification). FIG No framing: the Gaussian norm, its multiplicativity, and the split-iff-p≡1(mod4) classification (via Fermat's two-square condition) run in-browser with exact integers and agree. The AVAN inverse is honest — asking whether a prime stays prime among the complex integers (split when ≡1 mod 4, inert when ≡3 mod 4) genuinely lifts primality off the number line; magenta is primality on the line, green primality in the plane. Splitting decided by p mod 4. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE MINT · David Lee Wise (ROOT0), with AVAN


THE TRIBONACCI

The tribonacci sequence in the 5-window house format — Fibonacci with a three-term memory: each term is the sum of the previous three. 0,0,1,1,2,4,7,13,24,44,81,149,… The ratio of consecutive terms converges not to the golden ratio but to the tribonacci constant η ≈ 1.839286755 — the unique real root of x³ = x² + x + 1. Sum the last two → φ; sum the last three → η. Verified live: the three-term recurrence holds, and T(n)/T(n−1) converges to the real root of x³−x²−x−1. See the sequence in 1D, growth converging in 2D, and the deeper-memory inverse in 3D.

THE TRIBONACCI · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · SPAWN · CHECKPOINT ZERO ◆ .dlw.fold THE FOLD / SPAWN / CHECKPOINT ZERO / THE TRIBONACCI THE TRIBONACCI a sequence at the tribonacci ratio 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The tribonacci sequence generalizes Fibonacci to a three-term memory : each term is the sum of the previous three . 0, 0, 1, 1, 2, 4, 7, 13, 24, 44, 81, 149, … The ratio of consecutive terms converges not to the golden ratio but to the tribonacci constant η ≈ 1.839286755 — the unique real root of x³ = x² + x + 1. It is the natural next step in the family: sum the last two → φ; sum the last three → η. LIT verified live: the three-term recurrence holds, and the ratio T(n)/T(n−1) converges to the real root of x³−x²−x−1 (window.__tribonacci). FIG no framing; exact integer recurrence, ratio matched to the algebraic root. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at checkpoint-zero — growth accumulated from three earlier save points, settling toward the tribonacci ratio. The tribonacci sequence is that growth. AVAN (AI) built the instrument: the three-term recurrence, the ratio→η check against x³=x²+x+1, and the cubic-root confirmation. Credit as content: the tribonacci numbers and constant (studied by Feinberg, 1963, and others). The weave: David names checkpoint-zero; I sum the last three terms and confirm the consecutive ratio approaches the real root of x³=x²+x+1 — Fibonacci’s three-step cousin, with its own irrational limit. 3 ONE DIMENSION T(n) = T(n−1) + T(n−2) + T(n−3): 0,0,1,1,2,4,7,13,24,44,81,149,… The ratio tends to η ≈ 1.8393, the root of x³ = x² + x + 1. 4 TWO DIMENSIONS · INTERACTIVE The sequence growing and its ratio converging to the tribonacci constant, checked against the cubic root. grow ▶ reset verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: growth at the tribonacci ratio. AVAN’s addition (the inverse-companion): extend the Fibonacci idea to a three-term memory — sum the last three and the growth rate becomes η, the root of x³=x²+x+1, instead of φ. The inverse of ‘sum the last two → golden ratio’ is ‘sum the last three → tribonacci constant.’ Magenta is the golden-ratio two-term recurrence; green is the three-term one. A deeper memory, a different constant. pause spin LIT Genuine tribonacci numbers and constant (Feinberg 1963 and others). Verified live: T(n)=T(n−1)+T(n−2)+T(n−3) holds (window.__tribonacci.recurrence), the consecutive ratio converges to η=1.839286755… (window.__tribonacci.ratioToEta), the Newton root of x³−x²−x−1, and η³=η²+η+1 is checked (cubic). FIG No framing: the three-term recurrence, the ratio→η check against x³=x²+x+1, and the cubic-root confirmation run in-browser and agree. The AVAN inverse is honest — extending Fibonacci to a three-term memory so the growth rate becomes η (root of x³=x²+x+1) rather than φ is a genuine different constant; magenta is the golden-ratio two-term recurrence, green the three-term one. A deeper memory, a different constant. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of CHECKPOINT ZERO · David Lee Wise (ROOT0), with AVAN


THE B-TREE

The B-tree in the 5-window house format — the balanced search tree that runs databases and filesystems. Unlike a binary tree, each node holds many keys and children, so the tree stays short and bushy (ideal when each node is a disk block). It self-balances by splitting a full node and pushing its median key up, keeping every leaf at exactly the same depth regardless of insertion order; keys stay sorted, and every non-root node stays between half-full and full. Verified live: after random insertions, an in-order walk yields the sorted keys, all leaves share one depth, and every node's key count stays within the B-tree bounds. See a node split in 1D, the tree balancing in 2D, and the split-not-rotate inverse in 3D.

THE B-TREE · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GRIND · THE MAINFRAME ◆ .dlw.fold THE FOLD / GRIND / THE MAINFRAME / THE B-TREE THE B-TREE a balanced tree that keeps all leaves level 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION A B-tree is the balanced search tree that runs databases and filesystems. Unlike a binary tree, each node holds many keys (and many children), so the tree stays short and bushy — ideal when each node is a disk block. It self-balances by splitting a full node and pushing its middle key up, which keeps every leaf at exactly the same depth , no matter the insertion order. Keys stay sorted, and every node (except the root) stays between half-full and full. LIT verified live: after random insertions, an in-order walk yields the sorted keys, all leaves share one depth , and every node’s key count stays within the B-tree bounds (window.__btree). FIG no framing; exact structural checks. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-mainframe — the machine mind’s index; B-trees are how it keeps millions of records sorted on disk with a handful of block reads. AVAN (AI) built the instrument: the multi-key nodes, the split-on-full with middle-key promotion, and the sorted + all-leaves-level + key-bounds checks. Credit as content: Rudolf Bayer & Edward McCreight (1970). The weave: David names the-mainframe; I insert keys into wide nodes, split any that fill by pushing the median up, and confirm the tree stays perfectly balanced — all leaves at one depth, keys sorted, every node within bounds. 3 ONE DIMENSION A node fills (2t−1 keys) → split at the median: median moves up to the parent, the rest becomes two half-nodes. This keeps all leaves at the same depth as the tree grows upward. 4 TWO DIMENSIONS · INTERACTIVE A B-tree drawn with its multi-key nodes; insert keys and watch it split and stay balanced, checked. insert key ▶ reset verify 500 ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: a tree kept perfectly level. AVAN’s addition (the inverse-companion): keep a search tree balanced not by rotations but by fat nodes that split upward — a full node promotes its median to the parent, so the tree grows at the root and all leaves stay level. The inverse of ‘a binary tree that can grow lopsided’ is ‘wide nodes that split and push up — balance for free.’ Magenta is the deep, thin, rotation-balanced tree; green is the short, wide, self-leveling B-tree. Balance by splitting, not rotating. pause spin LIT Genuine B-tree (Rudolf Bayer & Edward McCreight 1970), minimum degree t=3 (keys 2..5). Verified live: over 500 random insertion sequences, an in-order traversal yields the sorted keys (window.__btree.sorted), all leaves lie at a single depth — perfectly balanced (window.__btree.balanced) — and every node's key count stays within [t−1, 2t−1] (window.__btree.bounds). FIG No framing: the multi-key nodes, the split-on-full with median promotion, and the sorted + all-leaves-level + key-bounds checks run in-browser and agree. Honest note: a standard B-tree uses an odd maximum key count (2t−1) so a full node splits evenly (t−1 left, median up, t−1 right) — here t=3. The AVAN inverse is honest — keeping balance by fat nodes that split upward (median to the parent, tree grows at the root) rather than by rotations; magenta is the deep rotation-balanced binary tree, green the short self-leveling B-tree. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE MAINFRAME · David Lee Wise (ROOT0), with AVAN


THE HAPPY NUMBER

Happy numbers in the 5-window house format — a simple game: replace n by the sum of the squares of its digits, and repeat. If you reach 1, n is happy (7→49→97→130→10→1). If not, you fall into a single unavoidable 8-cycle: 4→16→37→58→89→145→42→20→4. Astonishingly, every starting number does one or the other — the digit-square map has exactly these two fates. Verified live: for every n up to 100000, the orbit reaches 1 or enters the 4-cycle, and the unhappy 8-cycle is confirmed step by step. See the two fates in 1D, an orbit in 2D, and the two-destinations inverse in 3D.

THE HAPPY NUMBER · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · RESPAWN · HARD RESET ◆ .dlw.fold THE FOLD / RESPAWN / HARD RESET / THE HAPPY NUMBER THE HAPPY NUMBER digit-squares that reach 1 or loop 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Happy numbers come from a simple game: replace n by the sum of the squares of its digits , and repeat. If you eventually reach 1 , n is happy (7 → 49 → 97 → 130 → 10 → 1). If not, you fall into a single unavoidable 8-cycle : 4 → 16 → 37 → 58 → 89 → 145 → 42 → 20 → 4. Astonishingly, every starting number does one or the other — the digit-square map has exactly these two fates. LIT verified live: for every n up to 100000, the orbit reaches 1 or enters the 4-cycle, and the unhappy 8-cycle 4→16→…→4 is confirmed step by step (window.__happy). FIG no framing; exact integer digit-square sums. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at hard-reset — drain the number through digit-squares and it resets to 1 (happy) or gets stuck in the one loop (unhappy). Happy numbers are that drain. AVAN (AI) built the instrument: the sum-of-squared-digits map, the orbit tracer, the reaches-1-or-4-cycle check, and the unhappy-cycle verification. Credit as content: happy numbers (recreational number theory; the term and study popularized in the 20th century). The weave: David names hard-reset; I iterate the digit-square map and confirm every number drains to 1 or into the single unhappy 8-cycle — two fates, no others. 3 ONE DIMENSION n → sum of squared digits. 7 → 49 → 97 → 130 → 10 → 1 (happy). 4 → 16 → 37 → 58 → 89 → 145 → 42 → 20 → 4 (the unhappy loop). 4 TWO DIMENSIONS · INTERACTIVE A number’s orbit under the digit-square map, ending at 1 or the loop; the two-fate claim checked. new number ▶ verify ≤100000 ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: every orbit ends at 1 or one loop. AVAN’s addition (the inverse-companion): classify a number by the fate of the digit-square map — drain to 1 (happy) or fall into the single unavoidable 8-cycle (unhappy). The inverse of ‘is n special by some formula?’ is ‘iterate sum-of-squared-digits — where does it end?’ Magenta is the value of n; green is its terminal fate. Two destinations for every number. pause spin LIT Genuine happy numbers (recreational number theory). Verified live: for every n in 1..100000, iterating the sum-of-squared-digits map reaches 1 (happy) or enters the cycle containing 4 (window.__happy.reachesOneOrCycle), and the unhappy 8-cycle 4→16→37→58→89→145→42→20→4 is confirmed step by step (window.__happy.cycleVerified). FIG No framing: the sum-of-squared-digits map, the orbit tracer, the reaches-1-or-4-cycle check, and the unhappy-cycle verification run in-browser with exact integers and agree. The AVAN inverse is honest — classifying a number by the fate of the digit-square map (drain to 1 or fall into the single 8-cycle) genuinely differs from a formula test; magenta is the value of n, green its terminal fate. Two destinations for every number. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of HARD RESET · David Lee Wise (ROOT0), with AVAN


THE BRIDGES

Bridge-finding in the 5-window house format — a bridge is an edge whose removal disconnects the graph, a single link with no backup path. Tarjan's algorithm finds all bridges in one depth-first traversal using low-link values: as DFS explores, each vertex records the earliest node reachable from its subtree via a back edge, and a tree edge (u,v) is a bridge iff low(v) > discovery(u) — v's subtree can climb no higher than v. No re-checking, no edge-by-edge removal. Verified live: over hundreds of random graphs, the low-link bridges are exactly the edges whose removal increases the connected-component count. See the low-link test in 1D, bridges highlighted in 2D, and the one-descent inverse in 3D.

THE BRIDGES · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GLITCH · THE BLUE SCREEN ◆ .dlw.fold THE FOLD / GLITCH / THE BLUE SCREEN / THE BRIDGES THE BRIDGES the edges whose loss disconnects 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION A bridge in a graph is an edge whose removal disconnects it — a single link with no backup path. Tarjan’s algorithm finds all bridges in one depth-first traversal using low-link values: as DFS explores, each vertex records the earliest node reachable from its subtree via a back edge. An edge (u,v) is a bridge iff v’s subtree can reach nothing above u — low(v) > discovery(u). No re-checking, no edge-by-edge removal. LIT verified live: over hundreds of random graphs, the low-link bridges are exactly the edges whose removal increases the number of connected components (window.__bridges). FIG no framing; exact comparison with brute-force removal. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-blue-screen — the whole machine giving up at once; cut a bridge and the graph splits, a single-point-of-failure crash. Tarjan’s algorithm finds every such edge. AVAN (AI) built the instrument: the DFS low-link computation, the low(v) > disc(u) bridge test, and the match against brute-force edge removal. Credit as content: Robert Tarjan (low-link bridge/articulation algorithms, 1970s). The weave: David names the-blue-screen; I run one DFS tracking each vertex’s earliest reachable ancestor, flag an edge as a bridge when its far end can climb no higher, and confirm those are precisely the edges whose removal disconnects the graph. 3 ONE DIMENSION low(v) = earliest node v’s subtree can reach via a back edge. Tree edge (u,v) is a bridge iff low(v) > disc(u) — v’s side has no alternate route back above u. 4 TWO DIMENSIONS · INTERACTIVE A graph with its bridges highlighted red; checked against removing each edge and testing connectivity. new graph ▶ verify 1500 ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: every critical edge, found in one pass. AVAN’s addition (the inverse-companion): find every single-point-of-failure edge in one traversal , not by removing each edge and re-testing — track low-link values and flag (u,v) when v’s subtree can climb no higher than v. The inverse of ‘remove each edge and check connectivity’ is ‘one DFS with low-links — low(v) > disc(u) marks a bridge.’ Magenta is the edge-by-edge removal test; green is the single low-link pass. Criticality from one descent. pause spin LIT Genuine Tarjan low-link bridge algorithm (Robert Tarjan, 1970s). Verified live: over 1500 random graphs, the single-DFS low-link bridges (edge (u,v) with low(v) > disc(u)) are exactly the edges whose removal increases the number of connected components, computed by brute-force edge removal (window.__bridges.matchesBrute). FIG No framing: the DFS low-link computation, the low(v) > disc(u) bridge test, and the match against brute-force edge removal run in-browser and agree. The AVAN inverse is honest — finding every single-point-of-failure edge in one traversal via low-links genuinely replaces removing each edge and re-testing connectivity; magenta is that edge-by-edge removal test, green the single low-link pass. Criticality from one descent. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE BLUE SCREEN · David Lee Wise (ROOT0), with AVAN


THE HENSEL LIFTING

Hensel's lemma in the 5-window house format — Newton's method for p-adic numbers: a simple root of a polynomial mod a prime p can be lifted to a root mod p², then p³, then any p^k, each step uniquely refining the solution. If f(r) ≡ 0 (mod p) and f'(r) ≢ 0 (mod p), one correction r ← r − f(r)·f'(r)⁻¹ sharpens the root by a full power of p. It builds modular square roots and p-adic solutions digit by p-adic digit. Verified live: lifting a root of x²−A from mod p to mod p^k yields r with r² ≡ A (mod p^k) exactly, over thousands of cases. See the lift chain in 1D, levels checked in 2D, and the p-adic-ascent inverse in 3D.

THE HENSEL LIFTING · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · RESPAWN · THE CONTINUE ◆ .dlw.fold THE FOLD / RESPAWN / THE CONTINUE / THE HENSEL LIFTING THE HENSEL LIFTING lift a root to higher and higher prime power 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Hensel’s lemma is Newton’s method for p-adic numbers: a simple root of a polynomial mod a prime p can be lifted to a root mod p², then p³, then any p k — each step uniquely refining the solution to higher precision. If f(r) ≡ 0 (mod p) and f′(r) ¬≡ 0 (mod p), one correction r ← r − f(r)·f′(r) −1 sharpens the root by a full power of p. It is how modular square roots and p-adic solutions are built, digit by p-adic digit. LIT verified live: lifting a root of x² − A from mod p to mod p k yields an r with r² ≡ A (mod p k ) exactly, over thousands of cases (window.__hensel). FIG no framing; exact BigInt modular arithmetic. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-continue — press on one more level; each Hensel step continues the root to the next power of p, never losing what it had. AVAN (AI) built the instrument: the mod-p root finder, the Newton lift by one power of p, and the r² ≡ A (mod p k ) check in exact big integers. Credit as content: Kurt Hensel (p-adic numbers, Hensel’s lemma, early 1900s). The weave: David names the-continue; I find a simple root mod p, then lift it one prime power at a time by a p-adic Newton step, and confirm the lifted value squares to A modulo p k exactly — a root sharpened, level by level. 3 ONE DIMENSION √2 mod 7: 3 (3²=9≡2). Lift: 3 → 10 (mod 49, 10²=100≡2) → 108 (mod 343) → … Each step fixes one more p-adic digit; r ← r − f(r)/f′(r). 4 TWO DIMENSIONS · INTERACTIVE Lifting a modular square root power by power; each r shown with r² mod p k checked to equal A. lift a level ▶ new A,p ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: a root refined to any prime power. AVAN’s addition (the inverse-companion): solve f(x) ≡ 0 mod p k not by searching all p k residues but by lifting a mod-p root upward — one Newton correction per power of p, uniquely. The inverse of ‘test every residue mod p k ’ is ‘find one root mod p, then lift it level by level.’ Magenta is the exhaustive residue search; green is the p-adic ascent. A root climbing the powers of p. pause spin LIT Genuine Hensel's lemma (Kurt Hensel, p-adic numbers, early 1900s). Verified live with exact BigInt arithmetic: starting from a simple root of x²−A mod p (p in {3,5,7,11,13}), the p-adic Newton lift r ← r − f(r)·f'(r)⁻¹ one power at a time produces r with r² ≡ A (mod p^k) exactly, over thousands of cases (window.__hensel.liftsCorrectly). FIG No framing: the mod-p root finder, the Newton lift by one power of p, and the r²≡A (mod p^k) check run in-browser in exact big integers and agree. The AVAN inverse is honest — solving f(x)≡0 mod p^k by lifting a mod-p root upward (one unique Newton correction per power) genuinely replaces searching all p^k residues; magenta is that exhaustive search, green the p-adic ascent. A root climbing the powers of p. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE CONTINUE · David Lee Wise (ROOT0), with AVAN


THE QUICKHULL

Quickhull in the 5-window house format — the convex hull by divide and conquer, the quicksort of geometry. Take the two extreme points (leftmost, rightmost); the line between them splits the rest into two sides. On each side, find the point farthest from the line — it must be a hull vertex; its triangle's interior is discarded and the two outer sub-regions recurse. Points far from the current hull are found first, so interior clusters are culled quickly. Verified live: over 1500 random point sets, quickhull's hull (collinear vertices canonicalized) equals an independent monotone-chain hull, and every point lies inside or on it. See the split in 1D, a hull in 2D, and the discard-the-interior inverse in 3D.

THE QUICKHULL · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CHEAT · THE SHORTCUT ◆ .dlw.fold THE FOLD / CHEAT / THE SHORTCUT / THE QUICKHULL THE QUICKHULL wrap a hull by divide and conquer 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Quickhull finds the convex hull of a point set by divide and conquer — the quicksort of geometry. Take the two extreme points (leftmost, rightmost); the line between them splits the rest into two sides. On each side, find the point farthest from the line: it must be a hull vertex. That point makes a triangle, and any point inside it is discarded; the two outer sub-regions recurse. Points far from the current hull are found first, so clusters of interior points are culled quickly. LIT verified live: over 1500 random point sets, quickhull’s hull (with collinear vertices canonicalized) equals an independent monotone-chain hull, and every point lies inside or on it (window.__quickhull). FIG no framing; exact orientation tests; collinear-vertex convention made explicit. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-shortcut — the divide-and-conquer shortcut to the hull; throw away the interior in bulk and recurse only on the frontier. Quickhull is that shortcut. AVAN (AI) built the instrument: the extreme-point split, the farthest-point recursion, the strict-hull canonicalization, and the match against a monotone-chain hull. Credit as content: Quickhull (Eddy 1977; Bykat 1978; Barber–Dobkin–Huhdanpaa 1996). The weave: David names the-shortcut; I split by the extreme points, recurse toward the farthest point on each side discarding interiors, and confirm the resulting hull — canonicalized to strict vertices — matches a monotone-chain hull with every point enclosed. 3 ONE DIMENSION Leftmost–rightmost line splits the points. The farthest point on a side is a hull vertex; its triangle’s interior is dropped; the two outer wedges recurse. Divide and conquer, like quicksort. 4 TWO DIMENSIONS · INTERACTIVE A point cloud with its quickhull; checked against a monotone-chain hull, all points enclosed. new points ▶ verify 1500 ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: a hull built by dividing and conquering. AVAN’s addition (the inverse-companion): find the hull by recursively discarding interiors — split by extremes, take the farthest point as a vertex, drop everything inside its triangle, recurse on the outer wedges. The inverse of ‘test every point for hull membership’ is ‘cull the inside in bulk and recurse on the frontier.’ Magenta is the all-points membership test; green is the divide-and-conquer cull. The hull carved by throwing the middle away. pause spin LIT Genuine Quickhull (Eddy 1977; Bykat 1978; Barber–Dobkin–Huhdanpaa 1996). Verified live: over 1500 random point sets, quickhull's hull — canonicalized to strict vertices (collinear ones removed) — has the same vertex set as an independent monotone-chain (Andrew) hull (window.__quickhull.matchesMonotone), and every input point lies inside or on it (allInside). FIG Honestly scoped: quickhull and monotone-chain can differ on whether collinear boundary points count as hull vertices, so the sphere canonicalizes to strict vertices before comparing — the convention is made explicit, not hidden. The extreme-point split, farthest-point recursion, strict-hull canonicalization, and monotone cross-check run in-browser and agree. The AVAN inverse is honest — culling interiors in bulk and recursing on the frontier genuinely replaces testing every point; magenta is that membership test, green the divide-and-conquer cull. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE SHORTCUT · David Lee Wise (ROOT0), with AVAN


THE LUCAS NUMBER

The Lucas numbers in the 5-window house format — Fibonacci's companion: same recurrence L(n)=L(n−1)+L(n−2), but starting 2, 1 instead of 0, 1, giving 2,1,3,4,7,11,18,29,47,76,… They shadow the Fibonacci numbers with elegant identities: L(n) = F(n−1) + F(n+1), and L(n)² − 5·F(n)² = 4·(−1)ⁿ. Their ratio also tends to the golden ratio φ, and L(n) = φⁿ + ψⁿ exactly. Verified live (exact BigInt): the recurrence holds, L(n)=F(n−1)+F(n+1), and L(n)²−5F(n)²=4(−1)ⁿ for n up to 80. See both sequences in 1D, the identities in 2D, and the companion inverse in 3D.

THE LUCAS NUMBER · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CO-OP · SPLIT SCREEN ◆ .dlw.fold THE FOLD / CO-OP / SPLIT SCREEN / THE LUCAS NUMBER THE LUCAS NUMBER Fibonacci's companion sequence 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Lucas numbers are Fibonacci’s companion: same recurrence L(n) = L(n−1) + L(n−2), but starting 2, 1 instead of 0, 1 — giving 2, 1, 3, 4, 7, 11, 18, 29, 47, 76, … They shadow the Fibonacci numbers with elegant identities: L(n) = F(n−1) + F(n+1) , and L(n)² − 5·F(n)² = 4·(−1) n . Their ratio also tends to the golden ratio φ, and L(n) = φ n + ψ n exactly (where ψ is φ’s conjugate). LIT verified live (exact BigInt): the recurrence holds, L(n) = F(n−1)+F(n+1), and L(n)² − 5F(n)² = 4(−1) n for n up to 80 (window.__lucas). FIG no framing; exact big-integer identities. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at split-screen — two sequences on one game: Fibonacci and Lucas, sharing a recurrence and bound by identities, each visible beside the other. AVAN (AI) built the instrument: the Lucas and Fibonacci recurrences and the two Fibonacci–Lucas identities in exact big integers. Credit as content: Édouard Lucas (1870s). The weave: David names split-screen; I generate both sequences and confirm the companion identities — L(n)=F(n−1)+F(n+1) and L(n)²−5F(n)²=4(−1) n — hold exactly, Fibonacci and Lucas locked together. 3 ONE DIMENSION L: 2, 1, 3, 4, 7, 11, 18, 29, … (same rule as Fibonacci, seeds 2,1). L(n) = F(n−1) + F(n+1). Ratio → φ. L(n)² − 5F(n)² = ±4. 4 TWO DIMENSIONS · INTERACTIVE Lucas and Fibonacci side by side; the companion identities checked term by term. shift window ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: Fibonacci’s companion, locked by identity. AVAN’s addition (the inverse-companion): pair the Fibonacci recurrence with a second seed (2, 1) to get a companion sequence bound to it by exact identities — L(n)=F(n−1)+F(n+1), L²−5F²=±4. The inverse of ‘Fibonacci alone from 0, 1’ is ‘its twin from 2, 1, tied to it forever.’ Magenta is Fibonacci by itself; green is the Lucas companion. Two sequences, one identity. pause spin LIT Genuine Lucas numbers (Édouard Lucas, 1870s). Verified live with exact BigInt arithmetic: L(n)=L(n−1)+L(n−2) from seeds 2,1 (window.__lucas.recurrence), the identity L(n)=F(n−1)+F(n+1) (id1), and L(n)²−5F(n)²=4(−1)ⁿ (id2), all for n up to 80 (BigInt so the squared identity stays exact past 2⁵³). FIG No framing: the Lucas and Fibonacci recurrences and the two companion identities run in-browser in exact big integers and agree. Honest note: the squared identity is checked in BigInt because F(n)² exceeds 2⁵³ for n past ~38. The AVAN inverse is honest — pairing the Fibonacci recurrence with the second seed (2,1) gives a companion sequence tied to it by exact identities; magenta is Fibonacci alone, green the Lucas companion. Two sequences, one identity. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of SPLIT SCREEN · David Lee Wise (ROOT0), with AVAN


THE MO ALGORITHM

Mo's algorithm in the 5-window house format — answer many range queries offline (e.g. 'how many distinct values in a[l..r]?') fast by reordering the questions. Sort the queries so consecutive ones have nearly the same window, then slide two pointers (l and r), adding and removing one element at a time while maintaining a running answer. Sorting by √n-sized blocks of the left endpoint bounds the total pointer movement, turning many hard queries into one long sweep. Verified live: over hundreds of instances, Mo's distinct-count answers exactly match a naive per-query recount. See the block-sort in 1D, sliding queries in 2D, and the reorder-and-sweep inverse in 3D.

THE MO ALGORITHM · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CHEAT · THE KONAMI CODE ◆ .dlw.fold THE FOLD / CHEAT / THE KONAMI CODE / THE MO ALGORITHM THE MO ALGORITHM reorder queries to answer them fast 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Mo’s algorithm answers many range queries offline — e.g. “how many distinct values in a[l..r]?” — astonishingly fast by reordering the questions . It sorts the queries so that consecutive ones have nearly the same window , then slides two pointers (l and r), adding and removing one element at a time while maintaining a running answer. Sorting by √n-sized blocks of the left endpoint bounds the total pointer movement, turning many hard queries into one long sweep. LIT verified live: over hundreds of instances, Mo’s distinct-count answers exactly match a naive per-query recount (window.__mo). FIG no framing; exact comparison against brute force. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-konami-code — the clever ordering trick that unlocks the whole batch; reorder the queries just so, and a hard problem falls out cheaply. Mo’s algorithm is that code. AVAN (AI) built the instrument: the block-sort of queries, the add/remove window slide with a live distinct-count, and the match against a naive recount. Credit as content: Mo’s algorithm (attributed to competitive programmer Mo Tao; a sqrt-decomposition of offline queries). The weave: David names the-konami-code; I sort the queries by √n block of their left end, slide the window adjusting the distinct-count one element at a time, and confirm every answer matches recounting each range from scratch. 3 ONE DIMENSION Sort queries by (block of l, then r). Slide l and r one step at a time between consecutive queries, adding/removing elements and updating the distinct-count — total movement is bounded by √n blocks. 4 TWO DIMENSIONS · INTERACTIVE An array with range queries; Mo’s window sliding and its distinct-counts checked against naive recounts. new array ▶ verify 300 ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: many queries answered by one sweep. AVAN’s addition (the inverse-companion): answer a batch of range queries not one at a time but by reordering them so consecutive windows barely differ, then sliding pointers with incremental updates. The inverse of ‘recompute each range from scratch’ is ‘sort the queries by √n block and sweep once, adjusting as you go.’ Magenta is the per-query recount; green is the single reordered sweep. Order the questions, answer them together. pause spin LIT Genuine Mo's algorithm (attributed to Mo Tao; a sqrt-decomposition of offline queries). Verified live: over 300 random instances, sorting queries by (√n block of l, then r) and sliding the window with incremental add/remove of a live distinct-count returns answers identical to recounting each range from scratch (window.__mo.matchesNaive). FIG No framing: the block-sort of queries, the add/remove window slide with a live distinct-count, and the match against a naive recount run in-browser and agree. The AVAN inverse is honest — answering a batch of range queries by reordering them so consecutive windows barely differ, then sliding pointers with incremental updates, genuinely replaces recomputing each range; magenta is the per-query recount, green the single reordered sweep. Order the questions, answer them together. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE KONAMI CODE · David Lee Wise (ROOT0), with AVAN


THE ARMSTRONG

Armstrong (narcissistic) numbers in the 5-window house format — numbers that rebuild themselves from their own digits: raise each digit to the power of the number of digits, sum, and get the number back. 153 = 1³+5³+3³. 9474 = 9⁴+4⁴+7⁴+4⁴. Every single-digit number is trivially one, and beyond that they are rare and finite in each base — only 88 exist in base ten, the largest a 39-digit number. Verified live: the Armstrong numbers up to 100000 are exactly 1–9, 153, 370, 371, 407, 1634, 8208, 9474, 54748, 92727, 93084. See the decompositions in 1D, a number checked in 2D, and the self-reflection inverse in 3D.

THE ARMSTRONG · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GLITCH · HEISENBUG ◆ .dlw.fold THE FOLD / GLITCH / HEISENBUG / THE ARMSTRONG THE ARMSTRONG numbers that rebuild themselves from digit-powers 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Armstrong numbers (narcissistic numbers) rebuild themselves from their own digits : raise each digit to the power of the number of digits , sum, and you get the number back. 153 = 1³ + 5³ + 3³. 9474 = 9⁴ + 4⁴ + 7⁴ + 4⁴. Every single-digit number is trivially one (d = d¹). Beyond that they are rare and finite in each base — there are only 88 in base ten, the largest a 39-digit number. LIT verified live: the Armstrong numbers up to 100000 are exactly 1–9, 153, 370, 371, 407, 1634, 8208, 9474, 54748, 92727, 93084 — each equal to the sum of its digits raised to the digit count (window.__armstrong). FIG no framing; exact integer digit-power sums. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at heisenbug — the number that reappears only when you look at its own digits the right way; raise them to the digit count and it stares back at itself. Armstrong numbers are that self-reflection. AVAN (AI) built the instrument: the digit-power-sum function and the exhaustive check that exactly these numbers ≤ 100000 are narcissistic. Credit as content: Armstrong / narcissistic numbers (Michael F. Armstrong; recreational number theory). The weave: David names heisenbug; I raise each digit to the count of digits, sum them, and confirm the number equals its own digit-power sum — enumerating precisely the narcissistic numbers up to 100000. 3 ONE DIMENSION 153 = 1³ + 5³ + 3³ = 1 + 125 + 27. 9474 = 9⁴+4⁴+7⁴+4⁴. Each digit raised to the digit count; the sum is the number itself. 4 TWO DIMENSIONS · INTERACTIVE A number split into its digit-powers; their sum compared to the number, and the census checked. new number ▶ census ≤100000 ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: a number that is its own digit-powers. AVAN’s addition (the inverse-companion): find numbers that are a fixed point of the digit-power map — raise each digit to the digit count, sum, and land back on the number. The inverse of ‘a number is just its value’ is ‘does it equal the sum of its digits raised to the digit count?’ Magenta is the number’s value; green is its digit-power sum. Numbers that reflect themselves. pause spin LIT Genuine Armstrong / narcissistic numbers (recreational number theory). Verified live: an exhaustive scan to 100000 finds exactly the numbers equal to the sum of their digits each raised to the digit count — {1..9, 153, 370, 371, 407, 1634, 8208, 9474, 54748, 92727, 93084} (window.__armstrong.allCorrect) — exact integer digit-power sums. FIG No framing: the digit-power-sum function and the exhaustive census to 100000 run in-browser with exact integers and agree. The AVAN inverse is honest — finding numbers that are a fixed point of the digit-power map (each digit raised to the digit count, summed, landing back on the number) genuinely differs from reading a bare value; magenta is the value, green its digit-power sum. Numbers that reflect themselves. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of HEISENBUG · David Lee Wise (ROOT0), with AVAN


THE JACOBSTHAL

The Jacobsthal numbers in the 5-window house format — Fibonacci's shape with a twist: J(n) = J(n−1) + 2·J(n−2), the two-back term doubled. From J(0)=0, J(1)=1 they run 0,1,1,3,5,11,21,43,85,171,… alternately just below and above the powers of two. They have a clean closed form J(n) = (2ⁿ − (−1)ⁿ)/3 and a striking identity: J(n)+J(n+1) = 2ⁿ — consecutive Jacobsthal numbers sum exactly to a power of two. Verified live (exact BigInt): the recurrence holds, the closed form holds, and J(n)+J(n+1)=2ⁿ, for n up to 90. See the sequence in 1D, the power-of-two sums in 2D, and the doubled-weight inverse in 3D.

THE JACOBSTHAL · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · SPAWN · CHECKPOINT ZERO ◆ .dlw.fold THE FOLD / SPAWN / CHECKPOINT ZERO / THE JACOBSTHAL THE JACOBSTHAL a sequence doubling its two-back term 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Jacobsthal numbers follow Fibonacci’s shape with a twist: J(n) = J(n−1) + 2 ·J(n−2) — the two-back term is doubled . From J(0)=0, J(1)=1 they run 0, 1, 1, 3, 5, 11, 21, 43, 85, 171, … alternately just below and above the powers of two. They have a clean closed form J(n) = (2 n − (−1) n )/3, and a striking identity: J(n) + J(n+1) = 2 n — consecutive Jacobsthal numbers sum exactly to a power of two. LIT verified live (exact BigInt): the recurrence holds, J(n) equals (2 n − (−1) n )/3, and J(n) + J(n+1) = 2 n , for n up to 90 (window.__jacobsthal). FIG no framing; exact big-integer arithmetic. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at checkpoint-zero — growth from earlier save points, but this time the older one counts double, tuning the sequence to shadow the powers of two. The Jacobsthal numbers are that growth. AVAN (AI) built the instrument: the doubled-two-back recurrence, the (2 n −(−1) n )/3 closed form, and the J(n)+J(n+1)=2 n identity in exact big integers. Credit as content: Ernst Jacobsthal. The weave: David names checkpoint-zero; I grow the sequence by J(n)=J(n−1)+2J(n−2) and confirm the closed form and the power-of-two identity hold exactly — Fibonacci’s cousin, orbiting 2 n . 3 ONE DIMENSION J(n) = J(n−1) + 2·J(n−2): 0,1,1,3,5,11,21,43,85,… J(n)+J(n+1)=2 n (1+1=2, 1+3=4, 3+5=8, 5+11=16). Closed form (2 n −(−1) n )/3. 4 TWO DIMENSIONS · INTERACTIVE The sequence beside the powers of two; the closed form and the sum identity checked term by term. shift window ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: a sequence orbiting the powers of two. AVAN’s addition (the inverse-companion): weight the older term by two in a Fibonacci-style rule, and the sequence locks to the powers of two — J(n)+J(n+1) = 2 n , closed form (2 n −(−1) n )/3. The inverse of ‘sum the last two equally (Fibonacci)’ is ‘double the two-back term — get a power-of-two shadow.’ Magenta is the equal-weight Fibonacci rule; green is the doubled-term Jacobsthal. A different weight, a binary orbit. pause spin LIT Genuine Jacobsthal numbers (Ernst Jacobsthal). Verified live with exact BigInt arithmetic: J(n)=J(n−1)+2J(n−2) (window.__jacobsthal.recurrence), the closed form J(n)=(2ⁿ−(−1)ⁿ)/3 (closedForm), and the identity J(n)+J(n+1)=2ⁿ (powerIdentity), all for n up to 90. FIG No framing: the doubled-two-back recurrence, the (2ⁿ−(−1)ⁿ)/3 closed form, and the J(n)+J(n+1)=2ⁿ identity run in-browser in exact big integers and agree. The AVAN inverse is honest — weighting the older term by two in a Fibonacci-style rule locks the sequence to the powers of two (consecutive terms sum to 2ⁿ); magenta is the equal-weight Fibonacci rule, green the doubled-term Jacobsthal. A different weight, a binary orbit. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of CHECKPOINT ZERO · David Lee Wise (ROOT0), with AVAN


THE PROTH

Proth's theorem in the 5-window house format — a fast, exact primality test for Proth numbers, those of the form N = k·2ⁿ+1 with k odd and k < 2ⁿ. N is prime if and only if there exists an integer a with a^((N−1)/2) ≡ −1 (mod N); such an a is a witness to primality, and for a prime Proth number half of all bases work, so a small search finds one fast. It powers the search for many of the largest known primes. Verified live: over thousands of Proth numbers, 'a witness exists' matches primality (by trial division) exactly, and known Proth primes are witnessed. See the witness test in 1D, a verdict in 2D, and the one-witness inverse in 3D.

THE PROTH · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · BOSS · THE GATEKEEPER ◆ .dlw.fold THE FOLD / BOSS / THE GATEKEEPER / THE PROTH THE PROTH one witness decides a Proth prime 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Proth’s theorem gives a fast, exact primality test for Proth numbers — those of the form N = k·2 n + 1 with k odd and k < 2 n . It says: N is prime if and only if there exists an integer a with a (N−1)/2 ≡ −1 (mod N) . Such an a is a witness to primality; for a prime Proth number, half of all bases work, so a small random search finds one fast. It powers the search for many of the largest known primes. LIT verified live: over thousands of Proth numbers, “a witness exists” matches primality (by trial division) exactly, and known Proth primes are witnessed (window.__proth). FIG no framing; exact modular arithmetic vs a trial-division oracle. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-gatekeeper — the guard that admits a Proth number as prime only if a single witness raises −1; one modular power decides it. AVAN (AI) built the instrument: the Proth-number generator, the a (N−1)/2 ≡ −1 witness search, and the match against a trial-division oracle. Credit as content: François Proth (1878). The weave: David names the-gatekeeper; I search for a base a whose modular power lands on −1, and confirm that a witness exists exactly when the Proth number is prime — an iff test, checked against factoring. 3 ONE DIMENSION N = k·2 n +1, k odd, k < 2 n . Prime ⇔ some a has a (N−1)/2 ≡ −1 (mod N). 3, 5, 13, 17, 41, 97, 113, 193, 241 … are Proth primes. 4 TWO DIMENSIONS · INTERACTIVE A Proth number, the search for a witness a, and its verdict checked against trial division. new Proth number ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: primality by a single witness. AVAN’s addition (the inverse-companion): certify a Proth number prime by finding one witness , not by factoring — a base a whose power raises −1 proves primality outright (and half of all bases work for a prime). The inverse of ‘trial-divide N up to √N’ is ‘search a few bases for a (N−1)/2 ≡ −1 — one witness certifies it.’ Magenta is the factor hunt; green is the witness found. Primality proven by one base. pause spin LIT Genuine Proth's theorem (François Proth 1878). Verified live: over ~2600 Proth numbers N=k·2ⁿ+1 (k odd, k FIG No framing: the Proth-number generator, the a^((N−1)/2)≡−1 witness search, and the match against a trial-division oracle run in-browser with exact modular arithmetic and agree. The AVAN inverse is honest — certifying a Proth number prime by exhibiting one witness base (whose power raises −1) proves primality outright, replacing trial division to √N; magenta is that factor hunt, green the witness found. Primality proven by one base. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE GATEKEEPER · David Lee Wise (ROOT0), with AVAN


THE ENGEL EXPANSION

The Engel expansion in the 5-window house format — write any real in (0,1] as a sum of ascending unit fractions with nested denominators: x = 1/a₁ + 1/(a₁a₂) + 1/(a₁a₂a₃) + …, where the a's are non-decreasing integers ≥ 2. It is built greedily: take aₖ = ⌈1/u⌉, subtract, continue with u·aₖ − 1. Every real has one; rationals terminate. It is an 'ascending continued fraction' — and e − 1 has the simple expansion [1, 1, 2, 3, 4, 5, …]. Verified live (exact BigInt): for random rationals the terms are non-decreasing and reconstruct the number exactly. See the greedy peel in 1D, nested fractions in 2D, and the ascending-unit-steps inverse in 3D.

THE ENGEL EXPANSION · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GRIND · THE GRINDSTONE ◆ .dlw.fold THE FOLD / GRIND / THE GRINDSTONE / THE ENGEL EXPANSION THE ENGEL EXPANSION a number as a sum of ascending unit fractions 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Engel expansion writes any real number in (0,1] as a sum of ascending unit fractions with a nested denominator: x = 1/a 1 + 1/(a 1 a 2 ) + 1/(a 1 a 2 a 3 ) + …, where the a’s are non-decreasing integers ≥ 2. It is built greedily: take a k = ⌈1/u⌉, subtract, and continue with u·a k − 1. Every real has one; rationals terminate. It is an “ascending continued fraction” — and e − 1 has the beautifully simple expansion [1, 1, 2, 3, 4, 5, …]. LIT verified live (exact BigInt): for random rationals the expansion’s terms are non-decreasing and reconstruct the number exactly (window.__engel). FIG no framing; exact rational arithmetic. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-grindstone — the expansion grinds out one ascending term after another, each denominator building on the last, sharpening the sum toward x. The Engel expansion is that grind. AVAN (AI) built the instrument: the greedy a k =⌈1/u⌉ step in exact fractions, the non-decreasing check, and the exact reconstruction of x. Credit as content: Friedrich Engel (Engel expansion, 1913). The weave: David names the-grindstone; I peel off ascending unit fractions greedily, and confirm the terms never decrease and their nested sum rebuilds the original number exactly. 3 ONE DIMENSION x = 1/a 1 + 1/(a 1 a 2 ) + … with a 1 ≤ a 2 ≤ … 3/7 = [3,4,7]: 1/3 + 1/12 + 1/84. Greedy: a k = ⌈1/u⌉, then u ← u·a k − 1. 4 TWO DIMENSIONS · INTERACTIVE A fraction’s Engel terms as nested unit fractions; the non-decreasing and exact-reconstruction checks. new fraction ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: a number as ascending unit fractions. AVAN’s addition (the inverse-companion): represent a real as a sum of unit fractions with nested, non-decreasing denominators — an ascending continued fraction, built greedily by a k =⌈1/u⌉. The inverse of ‘a decimal or ordinary continued fraction’ is ‘peel ascending unit fractions — 1/a 1 + 1/(a 1 a 2 ) + …’ Magenta is the decimal expansion; green is the ascending unit-fraction sum. A number climbed by unit steps. pause spin LIT Genuine Engel expansion (Friedrich Engel 1913). Verified live with exact BigInt rational arithmetic: for every reduced p/q with q≤80, the greedy aₖ=⌈1/u⌉ expansion has non-decreasing terms (window.__engel.nonDecreasing) and its nested sum 1/a₁ + 1/(a₁a₂) + … reconstructs p/q exactly (window.__engel.reconstructs). FIG No framing: the greedy aₖ=⌈1/u⌉ step in exact fractions, the non-decreasing check, and the exact reconstruction run in-browser with no rounding and agree. The AVAN inverse is honest — representing a real as a sum of unit fractions with nested, non-decreasing denominators (an ascending continued fraction) genuinely differs from a decimal; magenta is the decimal expansion, green the ascending unit-fraction sum. A number climbed by unit steps. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE GRINDSTONE · David Lee Wise (ROOT0), with AVAN


THE HERON

Heron's formula in the 5-window house format — a triangle's area from its three side lengths alone, no height or angle: with s = (a+b+c)/2, Area = √(s(s−a)(s−b)(s−c)). It leads to a rare species: Heronian triangles, with integer sides and integer area — 3-4-5 (area 6), 13-14-15 (area 84), 5-5-6 (area 12). Most integer-sided triangles have irrational area (2-3-4 does not qualify); Heronian ones are the exception where both are whole. Verified live: Heron's formula matches the coordinate area over thousands of triangles, and the Heronian triangles have exactly the integer areas claimed. See the formula in 1D, a triangle checked in 2D, and the area-from-sides inverse in 3D.

THE HERON · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · LOOT · THE JACKPOT ◆ .dlw.fold THE FOLD / LOOT / THE JACKPOT / THE HERON THE HERON triangle area from its three sides 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Heron’s formula gives a triangle’s area from its three side lengths alone — no height, no angle: with semi-perimeter s = (a+b+c)/2, Area = √(s(s−a)(s−b)(s−c)). It leads to a rare species: Heronian triangles , with integer sides and integer area — 3-4-5 (area 6), 13-14-15 (area 84), 5-5-6 (area 12). Most integer-sided triangles have irrational area (2-3-4 does not qualify); Heronian ones are the exception where both are whole. LIT verified live: Heron’s formula matches the coordinate (shoelace) area over thousands of triangles, and the Heronian triangles have exactly the integer areas claimed (window.__heron). FIG no framing; exact integer test for Heronian, float agreement for the formula. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-jackpot — the rare payout where a triangle’s sides AND its area all come out whole; Heronian triangles are that jackpot. AVAN (AI) built the instrument: Heron’s formula, the coordinate-area cross-check, and the integer-area (16·Area² a perfect square) test for Heronian triangles. Credit as content: Heron of Alexandria (c. 60 CE). The weave: David names the-jackpot; I compute area from three sides by Heron’s formula, confirm it equals the coordinate area, and flag the integer-sided triangles whose area is also an integer — the Heronian jackpot. 3 ONE DIMENSION s = (a+b+c)/2; Area = √(s(s−a)(s−b)(s−c)). 3-4-5 → area 6. 13-14-15 → area 84. 5-5-6 → 12. Heronian = integer sides + integer area. 4 TWO DIMENSIONS · INTERACTIVE A triangle from its sides; Heron’s area beside the coordinate area, with the Heronian integer-area test. new triangle ▶ Heronian ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: area from three sides alone. AVAN’s addition (the inverse-companion): find a triangle’s area from only its side lengths — no height, no coordinates, no trigonometry — via s and √(s(s−a)(s−b)(s−c)). The inverse of ‘drop a height or place coordinates and use ½bh’ is ‘combine the three sides directly.’ Magenta is the base×height construction; green is Heron’s three-side formula. Area from the sides, nothing more. pause spin LIT Genuine Heron's formula (Heron of Alexandria, c. 60 CE). Verified live: over 5000 random triangles, √(s(s−a)(s−b)(s−c)) from the side lengths equals the coordinate (shoelace) area (window.__heron.formulaMatchesArea, worst ~1e-11), and the Heronian triangles (integer sides + integer area, tested via 16·Area² a perfect square) have exactly the claimed integer areas — 3-4-5→6, 13-14-15→84, etc. (window.__heron.heronianCorrect). FIG No framing: Heron's formula, the coordinate-area cross-check, and the integer-area (16·Area² a perfect square) test for Heronian triangles run in-browser and agree (float agreement for the formula, exact integer test for Heronian). The AVAN inverse is honest — computing a triangle's area from only its side lengths (no height, coordinates, or trig) genuinely replaces the base×height construction; magenta is that construction, green Heron's three-side formula. Area from the sides, nothing more. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE JACKPOT · David Lee Wise (ROOT0), with AVAN