THE DORMAND-PRINCE

The Dormand-Prince method in the 5-window house format — the adaptive engine inside most modern ODE solvers (MATLAB's ode45). It takes a step of a differential equation with a fifth-order Runge-Kutta formula, but computes a fourth-order estimate at the same time from the same seven stage evaluations. The difference between the two is a nearly-free estimate of the local error — and the method uses it to pace itself: when the solution is smooth it lengthens the step, when it turns sharply it shrinks the step, holding the error under a chosen tolerance everywhere. Verified live: on y′=y the method shows clean fifth-order convergence — halving the step cuts the error by about 32× — and on the harmonic oscillator it tracks (sin t, cos t) to ~1e-12. Neon-noir traced. See the phase-space orbit in 1D, the fifth-order error drop in 2D, and the error-sets-the-step inverse in 3D.

THE DORMAND-PRINCE · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CHEAT · THE SPEEDRUN ◆ .dlw.fold THE FOLD / CHEAT / THE SPEEDRUN / THE DORMAND-PRINCE THE DORMAND-PRINCE an adaptive integrator that paces itself 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Dormand–Prince method is the adaptive engine inside most modern ODE solvers (it is MATLAB’s ode45 ). It takes a step of a differential equation with a fifth-order Runge–Kutta formula, but computes a fourth-order estimate at the same time from the same seven stage evaluations. The difference between the two is a nearly-free estimate of the local error — and the method uses it to pace itself : when the solution is smooth it lengthens the step, when it turns sharply it shrinks the step, holding the error under a chosen tolerance everywhere. Accuracy where it is needed, speed where it is not. LIT verified live: on y′ = y the method shows clean fifth-order convergence — halving the step cuts the error by about 32× — and on the harmonic oscillator it tracks (sin t, cos t) to ~1e-12 (window.__dormand). FIG no framing; the seven-stage Dormand–Prince tableau and the convergence-order check run in-browser. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-speedrun — the optimal pacing of a run: sprint through the easy smooth stretches, brake hard through the tight turns, finishing fast without ever overshooting. AVAN (AI) built the instrument: the seven-stage Dormand–Prince tableau, the fifth-order step, the embedded error estimate, and the convergence-order verification. Credit as content: John R. Dormand & Peter J. Prince (1980). The weave: David names the speedrun; I confirm the fifth-order accuracy and the self-pacing error control. 3 ONE DIMENSION A harmonic oscillator integrated by Dormand–Prince: the phase-space orbit stays exactly on the circle. 4 TWO DIMENSIONS · INTERACTIVE Cycle test equations; the error at three step sizes shows the ~32× drop per halving that marks fifth order. next equation ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the accurate trajectory of the differential equation. AVAN’s addition (the inverse-companion): don’t fix the step — let the error set it. The inverse of ‘march forward by h’ is ‘compute two orders at once, read their difference as the error, and resize h to hold it under tolerance.’ Magenta is the self-adjusting step size; green is the trajectory it traces. Pace set by the error itself. pause spin LIT Genuine Dormand-Prince RK45 method (John R. Dormand & Peter J. Prince, 1980; MATLAB's ode45). Verified live with the seven-stage tableau: on y′=y the fifth-order solution's error drops ~32× (=2⁵) per step-halving (error ratios ~29–31), and on the harmonic oscillator it tracks (sin t, cos t) at t=3 to ~1e-12 (window.__dormand.orderOk, .r1, .r2, .oscOk). FIG No framing; the seven-stage Dormand-Prince tableau, the fifth-order step, and the convergence-order check run in-browser. The AVAN inverse is honest — instead of fixing the step, let the error set it: compute two orders at once, read their difference as the error, and resize h to hold it under tolerance. Magenta is the self-adjusting step; green is the trajectory it traces. Pace set by the error itself. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE SPEEDRUN · David Lee Wise (ROOT0), with AVAN


THE GARNER

Garner's algorithm in the 5-window house format — the constructive heart of the Chinese Remainder Theorem: given a number's remainders modulo several pairwise-coprime bases, it rebuilds the number itself. It works in mixed radix — peeling off one digit at a time, each found by a modular subtraction and inverse against the previous bases, so the final value is x=d₀+d₁m₀+d₂m₀m₁+… The result is exact and unique below the product of the moduli. It is how big-integer libraries and cryptosystems split one huge computation into small independent ones and stitch the answer back together. Verified live (exact BigInt): for thousands of random values and random sets of coprime moduli, reducing x to its residues and running Garner's reconstruction returns x exactly — e.g. x≡2(mod 3), 3(mod 5), 2(mod 7) rebuilds to 23. Neon-noir traced. See the remainders in 1D, the mixed-radix reconstruction in 2D, and the split-and-stitch inverse in 3D.

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

THE GARNER · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GRIND · THE MAINFRAME ◆ .dlw.fold THE FOLD / GRIND / THE MAINFRAME / THE GARNER THE GARNER one number rebuilt from its remainders 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Garner’s algorithm is the constructive heart of the Chinese Remainder Theorem: given a number’s remainders modulo several pairwise-coprime bases, it rebuilds the number itself . It works in mixed radix — peeling off one digit at a time, each digit found by a modular subtraction and inverse against the previous bases, so the final value is x = d 0 + d 1 m 0 + d 2 m 0 m 1 + … The result is exact and unique below the product of the moduli. It is how big-integer libraries and cryptosystems split one huge computation into small independent ones and stitch the answer back together. LIT verified live (exact BigInt): for thousands of random values and random sets of coprime moduli, reducing x to its residues and running Garner’s reconstruction returns x exactly — e.g. x ≡ 2 (mod 3), 3 (mod 5), 2 (mod 7) rebuilds to 23 (window.__garner). FIG no framing; the modular inverses, the mixed-radix digits, and the reconstruction all run in-browser with arbitrary-precision integers. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-mainframe — the classic mainframe trick of splitting one heavy modular computation across many small coprime channels and reassembling the exact answer from the remainders. AVAN (AI) built the instrument: the mixed-radix digit extraction, the modular inverses, and the exact reconstruction, all in BigInt. Credit as content: Harvey L. Garner (1959); the Chinese Remainder Theorem (Sunzi, c. 400 CE). The weave: David names the mainframe; I confirm the remainders rebuild the exact original number. 3 ONE DIMENSION A number shown as its remainders mod several coprime bases; Garner rebuilds the single value they encode. 4 TWO DIMENSIONS · INTERACTIVE New values and moduli; the mixed-radix digits are extracted and the reconstruction is checked against the original. new value ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the single integer the remainders encode. AVAN’s addition (the inverse-companion): don’t compute with the big number — carry its remainders. The inverse of ‘reduce x mod each base’ is ‘Garner’s mixed-radix reconstruction’, which rebuilds x uniquely from those residues. Magenta are the parallel remainders; green is the one number they reassemble to. Split, compute apart, stitch back. pause spin LIT Genuine Garner's algorithm for CRT reconstruction (Harvey L. Garner, 1959; Chinese Remainder Theorem, Sunzi c. 400 CE). Verified live with exact BigInt: for 5000 random values and random pairwise-coprime moduli sets, reducing x to residues and running Garner's mixed-radix reconstruction returns x exactly; x≡2(3),3(5),2(7) → 23 (window.__garner.reconstructs). FIG No framing; the modular inverses, the mixed-radix digits, and the reconstruction all run in-browser with arbitrary-precision integers. The AVAN inverse is honest — instead of computing with the big number, carry its remainders: Garner's mixed-radix reconstruction rebuilds x uniquely from those residues. Magenta are the parallel remainders; green is the one number they reassemble to. Split, compute apart, stitch back. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE MAINFRAME · David Lee Wise (ROOT0), with AVAN


THE INCLUSION-EXCLUSION

Inclusion-exclusion in the 5-window house format — the exact bookkeeping for counting a union without double-counting. Add the sizes of all the sets, then subtract every pairwise overlap (counted twice), then add back every triple overlap (subtracted too much), and so on with alternating signs: |A₁∪…∪Aₙ| = Σ|Aᵢ| − Σ|Aᵢ∩Aⱼ| + Σ|Aᵢ∩Aⱼ∩Aₖ| − … The same alternating machine counts derangements (permutations fixing no element), surjections, and numbers coprime to a set of primes. It is the 'off-by-the-overlaps' correction made exact. Verified live: for thousands of random set systems the alternating sum equals a brute-force union count exactly, and the derangement formula Dₙ=n!Σ(−1)ʲ/j! matches a brute count of fixed-point-free permutations (D₅=44). Neon-noir traced. See the overlapping sets in 1D, the term-by-term ± tally in 2D, and the miscount-then-mend inverse in 3D.

THE INCLUSION-EXCLUSION · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GLITCH · OFF BY ONE ◆ .dlw.fold THE FOLD / GLITCH / OFF BY ONE / THE INCLUSION-EXCLUSION THE INCLUSION-EXCLUSION add the parts, subtract the overlaps 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Inclusion–exclusion is the exact bookkeeping for counting a union without double-counting. Add the sizes of all the sets, then subtract every pairwise overlap (counted twice), then add back every triple overlap (subtracted too much), and so on with alternating signs: |A₁∪…∪A n | = Σ|A i | - Σ|A i ∩A j | + Σ|A i ∩A j ∩A k | - … The same alternating machine counts derangements (permutations fixing no element), surjections, and numbers coprime to a set of primes. It is the ‘off-by-the-overlaps’ correction made exact. LIT verified live: for thousands of random set systems the alternating sum equals a brute-force union count exactly, and the derangement formula D n = n!Σ(-1) j /j! matches a brute count of fixed-point-free permutations (D₅ = 44) (window.__inex). FIG no framing; the alternating intersection sum, the brute union, and the derangement count all run in-browser. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at off-by-one — but off by the overlaps : naive addition over-counts every shared element, and inclusion–exclusion is the exact alternating correction that fixes the miscount. AVAN (AI) built the instrument: the alternating intersection sum, the brute-force union cross-check, and the derangement formula. Credit as content: Abraham de Moivre and Daniel da Silva; formalized by J. J. Sylvester and Henri Poincaré. The weave: David names off-by-one; I confirm the alternating sum equals the true union and counts derangements. 3 ONE DIMENSION Overlapping sets; add the singles, subtract the pair-overlaps, add back the triple — the alternating tally lands on the true union. 4 TWO DIMENSIONS · INTERACTIVE New set systems; the alternating sum is compared term-by-term to the brute union, and derangements are checked. new sets ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the true size of the union. AVAN’s addition (the inverse-companion): don’t count the union directly — add the parts and subtract the overlaps. The inverse of ‘how big is the union?’ is ‘the alternating sum over all intersections’, exact once every overlap is corrected. Magenta are the alternating ± overlap corrections; green is the true union they sum to. Miscount, then mend. pause spin LIT Genuine inclusion-exclusion principle (de Moivre, da Silva; formalized by Sylvester and Poincaré). Verified live: for 3000 random set systems the alternating intersection sum equals a brute-force union count exactly, and the derangement formula Dₙ=n!Σ(−1)ʲ/j! matches a brute count of fixed-point-free permutations for n≤8 (D₅=44) (window.__inex.unionOk, .derangeOk). FIG No framing; the alternating intersection sum, the brute union, and the derangement count all run in-browser. The AVAN inverse is honest — instead of counting the union directly, add the parts and subtract the overlaps: the alternating sum over all intersections, exact once every overlap is corrected. Magenta are the alternating ± overlap corrections; green is the true union they sum to. Miscount, then mend. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of OFF BY ONE · David Lee Wise (ROOT0), with AVAN


THE EDMONDS-KARP

The Edmonds-Karp algorithm in the 5-window house format — computing the maximum flow through a capacitated network from a source to a sink, by repeatedly finding a shortest augmenting path (via breadth-first search) in the residual graph and pushing as much flow along it as the tightest edge allows. When no augmenting path remains, the flow is maximal — and by the max-flow min-cut theorem, its value equals the capacity of the cheapest cut separating source from sink. The vertices still reachable from the source in the residual graph reveal exactly that minimum cut. Verified live: for thousands of random networks the max flow equals the minimum-cut capacity, the flow is conserved at every intermediate node, and no edge exceeds its capacity. Neon-noir traced. See the flow network + min cut in 1D, the max-flow=min-cut checks in 2D, and the bottleneck-is-the-maximum inverse in 3D.

THE EDMONDS-KARP · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CO-OP · THE PUSH ◆ .dlw.fold THE FOLD / CO-OP / THE PUSH / THE EDMONDS-KARP THE EDMONDS-KARP the most that can flow equals the cheapest cut 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Edmonds–Karp algorithm computes the maximum flow through a capacitated network from a source to a sink, by repeatedly finding a shortest augmenting path (via breadth-first search) in the residual graph and pushing as much flow along it as the tightest edge allows. When no augmenting path remains, the flow is maximal — and by the celebrated max-flow min-cut theorem , its value equals the capacity of the cheapest cut that separates source from sink. The vertices still reachable from the source in the residual graph reveal exactly that minimum cut. LIT verified live: for thousands of random networks the max flow found by Edmonds–Karp equals the capacity of the minimum cut (reachable set in the residual graph), the flow is conserved at every intermediate node, and no edge exceeds its capacity (window.__edmonds). FIG no framing; the BFS augmenting paths, the residual graph, and the max-flow = min-cut check all run in-browser. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-push — pushing as much as possible through the pipes from source to sink, augmenting path by augmenting path until the network is saturated at its narrowest cut. AVAN (AI) built the instrument: the BFS shortest-augmenting-path search, the residual graph, the min-cut extraction, and the max-flow = min-cut verification. Credit as content: Jack Edmonds & Richard Karp (1972), refining Ford–Fulkerson. The weave: David names the push; I confirm the maximum flow equals the minimum cut on every random network. 3 ONE DIMENSION A flow network from source (green) to sink (gold); edges show flow/capacity, and the minimum cut is highlighted. 4 TWO DIMENSIONS · INTERACTIVE New networks; the max flow, the min-cut capacity, flow conservation, and the capacity bound are all checked. new network ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the maximum flow pushed from source to sink. AVAN’s addition (the inverse-companion): don’t just push flow — find the wall that stops it. The inverse of ‘the most that can flow’ is ‘the cheapest cut separating source from sink’, and the two are always equal. Magenta is the minimum cut; green is the maximum flow it bounds. The bottleneck IS the maximum. pause spin LIT Genuine Edmonds-Karp max-flow algorithm (Jack Edmonds & Richard Karp, 1972, refining Ford-Fulkerson). Verified live: for 8000 random networks the BFS-augmenting-path max flow equals the minimum-cut capacity (reachable set in the residual graph), the flow is conserved at every intermediate node, and no edge exceeds its capacity (window.__edmonds.maxflowMincut, .conserved, .withinCap). FIG No framing; the BFS augmenting paths, the residual graph, and the max-flow = min-cut check all run in-browser. The AVAN inverse is honest — instead of just pushing flow, find the wall that stops it: the cheapest cut separating source from sink, always equal to the maximum flow. Magenta is the minimum cut; green is the maximum flow it bounds. The bottleneck IS the maximum. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE PUSH · David Lee Wise (ROOT0), with AVAN


THE FERMAT POINT

The Fermat point in the 5-window house format — the single spot that minimizes the total distance to all three corners of a triangle, the ideal meeting place for least combined walk. Its signature is beautiful: at the Fermat point the three corners are seen at exactly 120° apart, three equal wedges filling the plane. (If one triangle angle is 120° or more, the point collapses onto that vertex.) Torricelli found it via equilateral triangles on the sides; it is also reached by Weiszfeld's iteration, repeatedly pulling toward each corner with weight inversely proportional to distance. Verified live: for thousands of triangles (all angles below 120°), Weiszfeld's iteration lands on a point where the three corners subtend 120° to within a hundredth of a degree, and no sampled nearby point has a smaller total distance. Neon-noir traced. See the 120° wedges in 1D, the angle+minimality checks in 2D, and the equilibrium-of-pulls inverse in 3D.

THE FERMAT POINT · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GRIND · GRADIENT DESCENT ◆ .dlw.fold THE FOLD / GRIND / GRADIENT DESCENT / THE FERMAT POINT THE FERMAT POINT the point that minimizes the walk to three corners 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Fermat point of a triangle is the single spot that minimizes the total distance to all three corners — the ideal meeting place if three people must gather with the least combined walk. Its defining signature is beautiful: at the Fermat point, the three corners are seen at exactly 120° apart, three equal wedges filling the plane. (If one angle of the triangle is 120° or more, the point collapses onto that vertex.) Torricelli found it by erecting equilateral triangles on the sides; it can also be reached by Weiszfeld’s iteration , repeatedly pulling toward each corner with weight inversely proportional to distance. LIT verified live: for thousands of triangles (all angles below 120°), Weiszfeld’s iteration lands on a point where the three corners subtend 120° to within a hundredth of a degree, and no sampled nearby point has a smaller total distance (window.__fermat). FIG no framing; the iteration, the 120° angle check, and the minimality sampling all run in-browser. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at gradient-descent — a minimization at heart: find the point that drives the summed distance to its lowest value, sliding downhill until the three pulls balance at 120°. AVAN (AI) built the instrument: the Weiszfeld iteration, the 120° angle verification, and the minimality sampling. Credit as content: posed by Pierre de Fermat, solved by Evangelista Torricelli (17th c.); the iteration by Endre Weiszfeld (1937). The weave: David names gradient-descent; I confirm the point minimizes total distance with three 120° wedges. 3 ONE DIMENSION A triangle and its Fermat point; the three lines to the corners split the plane into 120° wedges. 4 TWO DIMENSIONS · INTERACTIVE New triangles; the three subtended angles (all 120°) and the total-distance minimality are checked. new triangle ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the Fermat point, the least-total-distance meeting place. AVAN’s addition (the inverse-companion): don’t search the plane — balance the pulls. The inverse of ‘where is the total distance least?’ is ‘where do the three unit pulls toward the corners cancel’ — which happens exactly when they are 120° apart. Magenta are the three 120° wedges; green is the point where the pulls balance. A minimum found as an equilibrium. pause spin LIT Genuine Fermat/Torricelli point (posed by Fermat, solved by Torricelli 17th c.; Weiszfeld's iteration 1937). Verified live: for ~5000 triangles with all angles below 120°, Weiszfeld's iteration lands on a point where the three corners subtend 120° to within ~0.01°, and no sampled nearby point has a smaller total distance PA+PB+PC (window.__fermat.angOk, .minOk, .worst). FIG No framing; the Weiszfeld iteration, the 120° angle check, and the minimality sampling all run in-browser. The AVAN inverse is honest — instead of searching the plane, balance the pulls: the total distance is least where the three unit pulls toward the corners cancel, which happens exactly when they are 120° apart. Magenta are the three 120° wedges; green is the point where the pulls balance. A minimum found as an equilibrium. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of GRADIENT DESCENT · David Lee Wise (ROOT0), with AVAN


THE POSTAGE STAMP

The postage-stamp problem in the 5-window house format — with stamps of a few fixed denominations and an envelope holding at most h stamps, what is the largest value N such that every postage from 1 to N can be made? Call it the h-range. With 1- and 4-cent stamps and up to 5 stamps you cover every value to 14; with 1, 5 and 8 and six stamps you reach 42. Choosing denominations to maximize the unbroken run is a classic unsolved optimization, but for a given set and h the answer is a clean finite computation. Verified live: two independent methods — a dynamic-programming reachable-set and an exhaustive enumeration of every stamp multiset of size ≤ h — produce the identical set of achievable values, and the h-range is the longest run 1,2,…,N inside it. Neon-noir traced. See the makeable values in 1D, DP-vs-brute + the h-range in 2D, and the coverage-from-combination inverse in 3D.

THE POSTAGE STAMP · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · LOOT · THE INVENTORY ◆ .dlw.fold THE FOLD / LOOT / THE INVENTORY / THE POSTAGE STAMP THE POSTAGE STAMP the longest run of amounts a few stamps can make 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The postage-stamp problem asks: with stamps of a few fixed denominations and an envelope that holds at most h stamps, what is the largest value N such that every postage from 1 to N can be made? Call it the h-range . With 1- and 4-cent stamps and up to 5 stamps you can cover every value up to 14; with 1, 5 and 8 and six stamps you reach 42. It is a deceptively hard packing question — choosing denominations to maximize the unbroken run is a classic unsolved optimization — but for a given set and h, the answer is a clean finite computation. LIT verified live: two independent methods — a dynamic-programming reachable-set and an exhaustive enumeration of every stamp multiset of size ≤ h — produce the identical set of achievable values, and the h-range is the longest run 1, 2, …, N inside it (window.__postage). FIG no framing; the DP reachability, the brute multiset enumeration, and the run-length computation all run in-browser. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-inventory — a limited inventory of stamps, and the question of how long an unbroken run of postages that little stock can cover before a gap appears. AVAN (AI) built the instrument: the DP reachable-set, the brute multiset enumeration, their agreement check, and the h-range run length. Credit as content: the postage-stamp / local basis problem (Rohrbach, Stöhr, and others). The weave: David names the inventory; I confirm the two methods agree and compute the covered run. 3 ONE DIMENSION The number line: green values are makeable with ≤ h stamps; the unbroken run from 1 is the h-range. 4 TWO DIMENSIONS · INTERACTIVE Cycle denomination sets and stamp counts; the DP and brute reachable sets match and the h-range is shown. next set ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the unbroken run of postages the stamps can cover. AVAN’s addition (the inverse-companion): don’t list the amounts — combine the stamps. The inverse of ‘which postages are reachable?’ is ‘every sum of at most h stamps from the set’, and the h-range is how far that reaches without a gap. Magenta are the stamp combinations; green is the unbroken run they build. Coverage from combination. pause spin LIT Genuine postage-stamp / local basis problem (Rohrbach, Stöhr, and others). Verified live: for six denomination/count cases a DP reachable-set and an exhaustive multiset enumeration (all stamp combinations of size ≤ h) produce the identical achievable-value set, and the h-range is the longest unbroken run from 1 (window.__postage.dpEqBrute, .rows). FIG No framing; the DP reachability, the brute multiset enumeration, and the run-length computation all run in-browser. The AVAN inverse is honest — instead of listing the amounts, combine the stamps: every sum of at most h stamps from the set, and the h-range is how far that reaches without a gap. Magenta are the stamp combinations; green is the unbroken run they build. Coverage from combination. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE INVENTORY · David Lee Wise (ROOT0), with AVAN


THE SVD

The singular value decomposition in the 5-window house format — factoring any matrix A into A=UΣVᵀ, a rotation, a pure axis-aligned stretch, and another rotation. The diagonal singular values in Σ are the stretch factors; the columns of U and V are the output and input axes. Geometrically, A takes the unit sphere to an ellipsoid, and the SVD reads off its axes and their lengths. It is the most useful factorization in applied mathematics: it powers principal-component analysis, low-rank compression, the pseudo-inverse, and the numerical rank of a matrix. Verified live: for thousands of random matrices a one-sided Jacobi SVD returns U,Σ,V with U·diag(Σ)·Vᵀ reconstructing A to machine precision, U and V orthonormal (UᵀU=VᵀV=I), and all singular values non-negative. Neon-noir traced. See the circle→ellipse map in 1D, the reconstruction + orthonormality in 2D, and the rotate-stretch-rotate inverse in 3D.

THE SVD · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · RESPAWN · ROLLBACK ◆ .dlw.fold THE FOLD / RESPAWN / ROLLBACK / THE SVD THE SVD a matrix as rotate-stretch-rotate 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The singular value decomposition factors any matrix A into A = UΣV T — a rotation, a pure axis-aligned stretch , and another rotation. The diagonal singular values in Σ are the stretch factors; the columns of U and V are the output and input axes. Geometrically, A takes the unit sphere to an ellipsoid, and the SVD reads off its axes and their lengths. It is the most useful factorization in all of applied mathematics: it powers principal-component analysis, low-rank compression, the pseudo-inverse, and the numerical rank of a matrix. LIT verified live: for thousands of random matrices a one-sided Jacobi SVD returns U, Σ, V with U·diag(Σ)·V T reconstructing A to machine precision, U and V orthonormal (U T U = V T V = I), and all singular values non-negative (window.__svd). FIG no framing; the Jacobi column rotations, the reconstruction, and the orthonormality checks all run in-browser. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at rollback — decompose the matrix into three clean factors, then roll it back up: UΣV T reconstructs the original exactly, nothing lost in the round trip. AVAN (AI) built the instrument: the one-sided Jacobi rotations, the singular values as column norms, and the reconstruction and orthonormality verifications. Credit as content: Eugenio Beltrami and Camille Jordan (1870s); the Jacobi method for it. The weave: David names rollback; I confirm A decomposes and reconstructs exactly with orthonormal factors. 3 ONE DIMENSION A 2×2 matrix maps the unit circle to an ellipse; the SVD reads its axes (singular vectors) and lengths (singular values). 4 TWO DIMENSIONS · INTERACTIVE New matrices; the reconstruction U·diag(S)·Vᵀ = A, the orthonormality of U and V, and S ≥ 0 are all checked. new matrix ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the ellipse A carves from the unit circle, with its principal axes. AVAN’s addition (the inverse-companion): don’t treat A as one tangle — split it into rotate–stretch–rotate. The inverse of ‘a matrix that mixes everything’ is ‘UΣV T : two rotations around a pure diagonal stretch’, and multiplying them back recovers A. Magenta are the rotations U and V T ; green is the stretch Σ along the ellipse axes. Any map is a stretch between two spins. pause spin LIT Genuine singular value decomposition (Beltrami & Jordan, 1870s; Jacobi method). Verified live: for ~2500 random matrices a one-sided Jacobi SVD returns U,Σ,V with U·diag(Σ)·Vᵀ reconstructing A to ~1e-14, U and V orthonormal (UᵀU=VᵀV=I to ~1e-6), and all singular values ≥ 0 (window.__svd.recon, .oU, .oV, .nn). FIG No framing; the Jacobi column rotations, the reconstruction, and the orthonormality checks all run in-browser. The AVAN inverse is honest — instead of treating A as one tangle, split it into rotate-stretch-rotate: UΣVᵀ, two rotations around a pure diagonal stretch, and multiplying them back recovers A. Magenta are the rotations U and Vᵀ; green is the stretch Σ along the ellipse axes. Any map is a stretch between two spins. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of ROLLBACK · David Lee Wise (ROOT0), with AVAN


THE RYSER

Ryser's formula in the 5-window house format — computing the permanent of a matrix, the determinant's sign-free cousin, a sum over all permutations with every term added, never subtracted. The permanent counts things (for a 0/1 matrix it is the number of perfect matchings in a bipartite graph), but computing it is #P-complete, believed harder than NP. Ryser's trick uses inclusion-exclusion over the columns to compute it in O(2ⁿn) — still exponential, but far better than the n! of the definition, and the fastest known general method. Verified live: for thousands of random integer matrices Ryser's inclusion-exclusion permanent equals the brute-force sum over all permutations exactly, and for 0/1 matrices it equals the number of perfect matchings; the permanent of the all-ones 3×3 matrix is 3!=6. Neon-noir traced. See the matrix as a bipartite graph in 1D, Ryser-vs-brute in 2D, and the n!→2ⁿ inverse in 3D.

THE RYSER · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · BOSS · THE FINAL BOSS ◆ .dlw.fold THE FOLD / BOSS / THE FINAL BOSS / THE RYSER THE RYSER a permanent counted by inclusion-exclusion 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Ryser’s formula computes the permanent of a matrix — the determinant’s sign-free cousin, a sum over all permutations with every term added, never subtracted. The permanent counts things (for a 0/1 matrix it is the number of perfect matchings in a bipartite graph), but computing it is notoriously hard: it is #P-complete , believed harder than NP. Ryser’s trick uses inclusion-exclusion over the columns to compute it in O(2 n n) — still exponential, but far better than the n! of the definition, and the fastest known general method. LIT verified live: for thousands of random integer matrices Ryser’s inclusion-exclusion permanent equals the brute-force sum over all permutations exactly, and for 0/1 matrices it equals the number of perfect matchings; the permanent of the all-ones 3×3 matrix is 3! = 6 (window.__ryser). FIG no framing; Ryser’s subset sum, the brute permanent, and the matching count all run in-browser. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-final-boss — the permanent is the boss at the end of counting: #P-complete, believed beyond NP, and Ryser is the best weapon we have against it, still exponential but the fastest known. AVAN (AI) built the instrument: Ryser’s inclusion-exclusion subset sum, the brute permutation permanent, and the perfect-matching count. Credit as content: Herbert John Ryser (1963). The weave: David names the final boss; I confirm Ryser’s formula equals the true permanent and counts perfect matchings. 3 ONE DIMENSION A 0/1 matrix as a bipartite graph; its permanent is the number of perfect matchings (ways to pair every row to a column). 4 TWO DIMENSIONS · INTERACTIVE New matrices; Ryser's inclusion-exclusion permanent is compared to the brute permutation sum and the matching count. new matrix ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the permanent — the count of perfect matchings. AVAN’s addition (the inverse-companion): don’t sum over n! permutations — sum over 2 n subsets. The inverse of ‘the permanent by definition’ is ‘Ryser’s inclusion-exclusion over column subsets’, trading n! for 2 n n. Magenta are the alternating column-subset terms; green is the permanent they sum to. A hard count, made merely exponential. pause spin LIT Genuine Ryser's formula for the permanent (Herbert John Ryser, 1963). Verified live: for ~4000 random integer matrices the inclusion-exclusion permanent (−1)ⁿΣ_S(−1)^|S|∏ row-subset-sums equals the brute permutation-sum permanent exactly, and for 0/1 matrices it equals the number of perfect matchings; perm of the all-ones 3×3 is 6 (window.__ryser.ryserOk, .matchOk, .permJ3). FIG No framing; Ryser's subset sum, the brute permanent, and the matching count all run in-browser. Honest scope: computing the permanent is #P-complete; Ryser is exponential (2ⁿn), just the fastest known. The AVAN inverse is honest — instead of summing over n! permutations, sum over 2ⁿ column subsets by inclusion-exclusion. Magenta are the alternating column-subset terms; green is the permanent they sum to. A hard count, made merely exponential. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE FINAL BOSS · David Lee Wise (ROOT0), with AVAN


THE BUFFON

Buffon's needle in the 5-window house format — the oldest problem in geometric probability and a startling way to measure π by dropping sticks. Rule a floor with parallel lines a distance d apart, and toss a needle of length L≤d at random. The probability it crosses a line is exactly 2L/(πd) — π appears because the crossing depends on the needle's random angle. Turn it around: drop many needles, count the crossings, and π≈2LN/(d·crossings). It is a Monte-Carlo estimator of π that needs nothing but a ruler and patience. Verified live: dropping two million random needles, the crossing rate matches 2L/(πd) to within a fraction of a percent, and the resulting estimate of π lands near 3.14. Neon-noir traced. See the needles on the ruled floor in 1D, the rate converging in 2D, and the π-sampled-not-computed inverse in 3D.

THE BUFFON · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CHEAT · THE SHORTCUT ◆ .dlw.fold THE FOLD / CHEAT / THE SHORTCUT / THE BUFFON THE BUFFON needles dropped to measure π 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Buffon’s needle is the oldest problem in geometric probability and a startling way to measure π by dropping sticks . Rule a floor with parallel lines a distance d apart, and toss a needle of length L ≤ d at random. The probability that it crosses a line is exactly 2L / (πd) — π appears because the crossing depends on the needle’s random angle . Turn it around: drop many needles, count the crossings, and π ≈ 2LN / (d·crossings) . It is a Monte-Carlo estimator of π that needs nothing but a ruler and patience. LIT verified live: dropping two million random needles, the crossing rate matches 2L/(πd) to within a fraction of a percent, and the resulting estimate of π lands near 3.14 (window.__buffon). FIG no framing; the random drops, the crossing test, and the π estimate all run in-browser. The match is statistical — approximate by nature, tightening with more drops. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-shortcut — a delightful shortcut to π: no series, no geometry of circles, just needles falling on lines and π emerging from how often they cross. AVAN (AI) built the instrument: the random needle drops, the line-crossing test, the crossing-rate comparison to 2L/(πd), and the π estimate. Credit as content: Georges-Louis Leclerc, Comte de Buffon (1777). The weave: David names the shortcut; I confirm the crossing rate equals 2L/(πd) and yields π. 3 ONE DIMENSION Needles dropped on a ruled floor; the ones crossing a line are highlighted — their fraction encodes π. 4 TWO DIMENSIONS · INTERACTIVE Drop needles; the crossing rate converges to 2L/(πd) and the running estimate of π sharpens. drop 20000 ▶ reset ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the estimate of π distilled from the crossings. AVAN’s addition (the inverse-companion): don’t compute π — sample it. The inverse of ‘the crossing probability is 2L/(πd)’ is ‘π = 2LN/(d·crossings)’ — read π back out of the fraction of needles that cross. Magenta are the falling needles; green is the value of π they converge on. A constant caught from chance. pause spin LIT Genuine Buffon's needle (Georges-Louis Leclerc, Comte de Buffon, 1777). Verified live: dropping 2,000,000 random needles (length L, line spacing d=2L), the empirical crossing rate matches 2L/(πd) to within a fraction of a percent, and π≈2LN/(d·crossings) lands near 3.14 (window.__buffon.rateOk, .pEmp, .piEst). FIG No framing; the random drops, the crossing test, and the π estimate all run in-browser. Honest scope: the match is statistical — approximate by nature, tightening with more drops. The AVAN inverse is honest — instead of computing π, sample it: invert the crossing probability 2L/(πd) to read π=2LN/(d·crossings) out of the fraction that cross. Magenta are the falling needles; green is the value of π they converge on. A constant caught from chance. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE SHORTCUT · David Lee Wise (ROOT0), with AVAN


THE LAMBERT-W

The Lambert W function in the 5-window house format — the inverse of w·eʷ: given x, it returns the w such that w eʷ = x. That single definition unlocks equations no elementary function can — anything of the form 'an unknown multiplied by its own exponential', from delay differential equations to enzyme kinetics to the analysis of algorithms. Because y=x eˣ is not monotone, W has two real branches; the principal branch W₀ is found in a handful of steps by Halley's iteration, a cubically-convergent cousin of Newton's method. W(1) is the omega constant Ω≈0.5671, the number equal to its own negative logarithm. Verified live: for tens of thousands of values of x, Halley's iteration returns a w with w·eʷ equal to x to machine precision, and the anchors W(0)=0, W(e)=1, W(1)=Ω all hold. Neon-noir traced. See x·eˣ and its inverse W in 1D, the Halley convergence in 2D, and the invert-the-transcendental inverse in 3D.

THE LAMBERT-W · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GRIND · THE HOT LOOP ◆ .dlw.fold THE FOLD / GRIND / THE HOT LOOP / THE LAMBERT-W THE LAMBERT-W the inverse of x times e-to-the-x 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Lambert W function is the inverse of w · e w : given x, it returns the w such that w e w = x. That single definition unlocks equations no elementary function can — anything of the form ‘an unknown multiplied by its own exponential’, from delay differential equations to the enzyme kinetics of biochemistry to the analysis of algorithms. Because y = x e x is not monotone, W has two real branches; the principal branch W₀ is found in a handful of steps by Halley’s iteration , a cubically-convergent cousin of Newton’s method. W(1) is the omega constant Ω ≈ 0.5671, the number equal to its own negative logarithm. LIT verified live: for tens of thousands of values of x, Halley’s iteration returns a w with w·e w equal to x to machine precision, and the anchors W(0) = 0, W(e) = 1, W(1) = Ω all hold (window.__lambertw). FIG no framing; the Halley iteration and the w·e w = x residual check run in-browser. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-hot-loop — a tight iteration loop that inverts a transcendental in a few cubically-convergent turns, hot until w·e w hits x exactly. AVAN (AI) built the instrument: the Halley update, the initial guess by branch, and the w·e w = x residual verification. Credit as content: Johann Heinrich Lambert (1758) & Leonhard Euler; named and standardized in the 1990s. The weave: David names the hot loop; I confirm the iteration inverts w·e w to machine precision. 3 ONE DIMENSION y = x·eˣ (magenta) and its inverse W (green) — reflections across the diagonal; W undoes x·eˣ. 4 TWO DIMENSIONS · INTERACTIVE Pick x; Halley's iteration converges to W(x) in a few cubic steps and the residual w·eʷ − x collapses. new x ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: W(x), the value that satisfies w·eʷ = x. AVAN’s addition (the inverse-companion): don’t evaluate x·e x — invert it. The inverse of ‘multiply w by its own exponential’ is ‘the Lambert W that undoes it’, reached by Halley’s cubic iteration. Magenta is the forward map x·e x ; green is W walking it back. An elementary operation with a non-elementary inverse. pause spin LIT Genuine Lambert W function (Johann Heinrich Lambert 1758 & Euler; named 1990s). Verified live: for 20000 values of x, Halley's cubic iteration returns w with |w·eʷ − x| to machine precision (worst relative residual ~1e-15), and the anchors W(0)=0, W(e)=1, W(1)=Ω≈0.5671 all hold (window.__lambertw.ok, .anchors, .omega). FIG No framing; the Halley iteration and the w·eʷ=x residual check run in-browser. The AVAN inverse is honest — instead of evaluating x·eˣ, invert it: the Lambert W that undoes 'multiply w by its own exponential', reached by Halley's cubic iteration. Magenta is the forward map x·eˣ; green is W walking it back. An elementary operation with a non-elementary inverse. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE HOT LOOP · David Lee Wise (ROOT0), with AVAN


THE VIETE

Viète's formula (1593) in the 5-window house format — the very first time in history that a constant was written as an infinite product, the dawn of analysis. It expresses 2/π as an endless product of nested square roots of two: 2/π = (√2/2)·(√(2+√2)/2)·(√(2+√(2+√2))/2)·… Each factor aₖ/2 is built from the last by aₖ₊₁=√(2+aₖ), a value creeping toward 2. Geometrically it is Archimedes' doubling of a polygon's sides made algebraic: each nested radical is the cosine of an angle halved again and again. Verified live: the partial product converges to 2/π — after 30 nested factors it matches to machine precision, giving π to twelve digits. Neon-noir traced. See the nested radicals + running product in 1D, the convergence in 2D, and the infinite-descent inverse in 3D.

THE VIETE · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · SPAWN · FIRST LIGHT ◆ .dlw.fold THE FOLD / SPAWN / FIRST LIGHT / THE VIETE THE VIETE π from an endless nested radical 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Viète’s formula (1593) is the very first time in history that a constant was written as an infinite product — the dawn of analysis. It expresses 2/π as an endless product of nested square roots of two : 2/π = (√2/2)·(√(2+√2)/2)·(√(2+√(2+√2))/2)·… Each factor a k /2 is built from the last by a k+1 = √(2 + a k ), a value that creeps toward 2. Geometrically it is Archimedes’ doubling of a polygon’s sides made algebraic: each nested radical is the cosine of an angle halved again and again. LIT verified live: the partial product converges to 2/π — after 30 nested factors it matches to machine precision, giving π to twelve digits (window.__viete). FIG no framing; the nested-radical recurrence and the convergence to 2/π run in-browser. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at first-light — the first light of analysis itself: the earliest infinite product ever written, π emerging from an endless tower of nested square roots of two. AVAN (AI) built the instrument: the nested-radical recurrence, the running product, and the convergence to 2/π. Credit as content: François Viète (1593). The weave: David names first-light; I confirm the infinite product of nested radicals converges to 2/π. 3 ONE DIMENSION The nested radicals a₁=√2, a₂=√(2+√2), … each creeping toward 2; the running product of aₖ/2 approaches 2/π. 4 TWO DIMENSIONS · INTERACTIVE Add nested factors; the partial product locks onto 2/π and the π estimate gains digits fast. add factor ▶ reset ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the value 2/π the infinite product converges to. AVAN’s addition (the inverse-companion): don’t sum a series — multiply nested roots. The inverse of ‘compute π’ is ‘the endless product of √(2+√(2+…))/2’, each factor a halved-angle cosine. Magenta is the tower of nested radicals; green is the 2/π they multiply to. π as an infinite descent of square roots. pause spin LIT Genuine Viète's formula (François Viète, 1593 — the first infinite product). Verified live: the partial product ∏ aₖ/2 with a₁=√2, aₖ₊₁=√(2+aₖ) converges to 2/π; after 30 nested factors the error is ~2e-16, giving π=3.14159265359 (window.__viete.converges, .e30, .piEst). FIG No framing; the nested-radical recurrence and the convergence to 2/π run in-browser. The AVAN inverse is honest — instead of summing a series, multiply nested roots: the endless product of √(2+√(2+…))/2, each factor a halved-angle cosine. Magenta is the tower of nested radicals; green is the 2/π they multiply to. π as an infinite descent of square roots. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of FIRST LIGHT · David Lee Wise (ROOT0), with AVAN


THE GRACEFUL

Graceful labeling in the 5-window house format — assigning the vertices of a graph with m edges distinct numbers from 0 to m so that the edge 'lengths' (absolute differences of endpoint labels) come out as exactly 1,2,…,m, each once. It is a jigsaw of numbers: pick vertex values so no two edges share a gap. Paths and stars are always graceful; a cycle Cₙ is graceful if and only if n≡0 or 3 (mod 4). The still-open Graceful Tree Conjecture — that every tree is graceful — has resisted proof for over fifty years. Verified live: an explicit zig-zag labeling makes every path graceful and the star K₁,ₙ graceful, and an exhaustive search confirms the cycle Cₙ is graceful exactly when n≡0 or 3 (mod 4) — C₃,C₄,C₇ yes; C₅,C₆ no. Neon-noir traced. See the graceful labeling in 1D, the cycle mod-4 rule in 2D, and the demand-the-edges inverse in 3D.

THE GRACEFUL · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CO-OP · THE BROADCAST ◆ .dlw.fold THE FOLD / CO-OP / THE BROADCAST / THE GRACEFUL THE GRACEFUL a labeling whose edge-gaps are 1 to m 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION A graceful labeling assigns the vertices of a graph with m edges distinct numbers from 0 to m so that the edge ‘lengths’ — the absolute differences of the endpoint labels — come out as exactly 1, 2, …, m , each once. It is a jigsaw of numbers: pick vertex values so no two edges share a gap. Paths and stars are always graceful; a cycle C n is graceful if and only if n ≡ 0 or 3 (mod 4) . The still-open Graceful Tree Conjecture — that every tree is graceful — has resisted proof for over fifty years. LIT verified live: an explicit zig-zag labeling makes every path graceful and the star K 1,n graceful, and an exhaustive search confirms the cycle C n is graceful exactly when n ≡ 0 or 3 (mod 4) — C₃, C₄, C₇ yes; C₅, C₆ no (window.__graceful). FIG no framing; the labeling, the edge-difference check, and the exhaustive cycle search run in-browser. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-broadcast — labels broadcast from the vertices to the edges: choose the node numbers just so, and every edge broadcasts a distinct length from 1 to m, no collision. AVAN (AI) built the instrument: the graceful-check, the explicit path/star labelings, and the exhaustive cycle search proving the mod-4 rule. Credit as content: Alexander Rosa (1967); the Graceful Tree Conjecture (Ringel–Kotzig). The weave: David names the broadcast; I confirm paths and stars are graceful and cycles obey the n ≡ 0,3 (mod 4) law. 3 ONE DIMENSION A graph with a graceful labeling; the edge differences are exactly 1, 2, …, m, each appearing once. 4 TWO DIMENSIONS · INTERACTIVE Cycle graph families; the graceful labeling (or its impossibility for Cₙ, n≡1,2 mod 4) is shown. next graph ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the graph’s vertex labels, 0 to m, all distinct. AVAN’s addition (the inverse-companion): don’t label the vertices — demand the edges. The inverse of ‘a set of vertex numbers’ is ‘the multiset of edge differences’, and a labeling is graceful exactly when those differences are precisely 1 to m. Magenta are the edge differences; green are the vertex labels that produce them. Structure demanded from the gaps. pause spin LIT Genuine graceful labeling (Alexander Rosa, 1967; Graceful Tree Conjecture, Ringel-Kotzig). Verified live: an explicit zig-zag labeling makes path P₆ graceful and star K₁,₅ graceful (edge differences = {1..m}), and an exhaustive search confirms cycle Cₙ is graceful exactly when n≡0 or 3 (mod 4) — C₃,C₄,C₇ yes, C₅,C₆ no (window.__graceful.path, .star, .cycleRule). FIG No framing; the labeling, the edge-difference check, and the exhaustive cycle search run in-browser. The AVAN inverse is honest — instead of labeling the vertices, demand the edges: a labeling is graceful exactly when the multiset of edge differences is precisely 1 to m. Magenta are the edge differences; green are the vertex labels that produce them. Structure demanded from the gaps. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE BROADCAST · David Lee Wise (ROOT0), with AVAN


THE GRAEFFE

Graeffe's root-squaring method in the 5-window house format — finding the magnitudes of a polynomial's roots by a startling trick: build a new polynomial whose roots are the squares of the original's, using q(x²)=(−1)ⁿp(x)p(−x). Repeat, and after k rounds the roots are raised to the 2^k power — which drives well-separated roots exponentially far apart. Once separated, each magnitude falls straight out of the ratio of adjacent coefficients: |rᵢ|=|a_{n−i}/a_{n−i+1}|^{1/2^k}. It was a workhorse of hand computation before electronic computers — a way to prise roots apart until they can simply be read off. Verified live: for polynomials with well-separated positive roots, four root-squaring rounds recover every root magnitude to within a fraction of a percent — e.g. (x−1)(x−2)(x−3) comes back as 3.000, 2.000, 1.000. Neon-noir traced. See the separating magnitudes in 1D, the recovery in 2D, and the separation-by-squaring inverse in 3D.

THE GRAEFFE · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · BOSS · THE RAID ◆ .dlw.fold THE FOLD / BOSS / THE RAID / THE GRAEFFE THE GRAEFFE squaring a polynomial to prise its roots apart 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Graeffe’s root-squaring method finds the magnitudes of a polynomial’s roots by a startling trick: build a new polynomial whose roots are the squares of the original’s, using q(x 2 ) = (-1) n p(x)p(-x). Repeat, and after k rounds the roots are raised to the 2 k power — which drives well-separated roots exponentially far apart . Once separated, each magnitude falls straight out of the ratio of adjacent coefficients: |r i | = |a n-i /a n-i+1 | 1/2 k . It was a workhorse of hand computation before electronic computers — a way to prise roots apart until they can simply be read off. LIT verified live: for polynomials with well-separated positive roots, four root-squaring rounds recover every root magnitude to within a fraction of a percent — e.g. the roots of (x-1)(x-2)(x-3) come back as 3.000, 2.000, 1.000 (window.__graeffe). FIG no framing; the root-squaring recurrence and the coefficient-ratio recovery run in-browser. Well-separated real roots only, before overflow. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-raid — a relentless assault that squares the roots again and again, prising them exponentially far apart until each magnitude can be raided straight from the coefficients. AVAN (AI) built the instrument: the p(x)p(-x) root-squaring step, the repeated squaring, and the coefficient-ratio magnitude recovery. Credit as content: Germinal Pierre Dandelin (1826), Karl Heinrich Gräffe (1837), Nikolai Lobachevsky. The weave: David names the raid; I confirm repeated squaring separates the roots and their magnitudes fall out of the coefficients. 3 ONE DIMENSION The root magnitudes on a log axis; each squaring round doubles the gaps, prising the roots apart. 4 TWO DIMENSIONS · INTERACTIVE New polynomials; four squaring rounds recover the root magnitudes from the coefficient ratios. new polynomial ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the recovered root magnitudes of the polynomial. AVAN’s addition (the inverse-companion): don’t solve for the roots — square them apart. The inverse of ‘find the roots’ is ‘raise them to the 2 k power so they separate, then read each magnitude from a coefficient ratio’. Magenta are the squaring rounds pushing the roots apart; green are the magnitudes that fall out. Separation by squaring. pause spin LIT Genuine Graeffe root-squaring method (Dandelin 1826, Gräffe 1837, Lobachevsky). Verified live: for polynomials with well-separated positive roots, four root-squaring rounds q(x²)=(−1)ⁿp(x)p(−x) recover every root magnitude via |a_{n−i}/a_{n−i+1}|^{1/2^k} to within a fraction of a percent (worst ~0.01%); (x−1)(x−2)(x−3) → 3.000, 2.000, 1.000 (window.__graeffe.ok, .worst). FIG No framing; the root-squaring recurrence and the coefficient-ratio recovery run in-browser. Honest scope: well-separated real roots only, and only before coefficient overflow (four rounds, roots ≲5). The AVAN inverse is honest — instead of solving for the roots, square them apart: raise them to the 2^k power so they separate, then read each magnitude from a coefficient ratio. Magenta are the squaring rounds; green are the magnitudes that fall out. Separation by squaring. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE RAID · David Lee Wise (ROOT0), with AVAN


THE AGM

The arithmetic-geometric mean in the 5-window house format — one of the fastest-converging processes in mathematics. Start with two positive numbers a and b and replace them, over and over, by their arithmetic mean (a+b)/2 and geometric mean √(ab). The two sequences rush toward each other and meet at a common limit M(a,b) — and they do so quadratically: the gap between them squares each step, so the number of correct digits doubles every iteration. Gauss discovered it links to elliptic integrals, and it is the engine of the Gauss-Legendre algorithm that computes π to millions of digits in a handful of steps. Verified live: for thousands of random starting pairs the two means converge to a single limit, the gap shrinking quadratically (gap≈previous²/8M), and the AGM-driven Gauss-Legendre iteration reaches π to ~1e-15 in just four steps. Neon-noir traced. See the two means meeting in 1D, the squaring gap + π in 2D, and the two-means-folded-into-one inverse in 3D.

THE AGM · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CHEAT · THE SPEEDRUN ◆ .dlw.fold THE FOLD / CHEAT / THE SPEEDRUN / THE AGM THE AGM two means racing to one limit 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The arithmetic-geometric mean is one of the fastest-converging processes in mathematics. Start with two positive numbers a and b and replace them, over and over, by their arithmetic mean (a+b)/2 and their geometric mean √(ab). The two sequences rush toward each other and meet at a common limit M(a, b) — and they do so quadratically : the gap between them squares each step, so the number of correct digits doubles every iteration. Gauss discovered it links to elliptic integrals, and it is the engine of the Gauss–Legendre algorithm that computes π to millions of digits in a handful of steps. LIT verified live: for thousands of random starting pairs the two means converge to a single limit, the gap shrinking quadratically (gap ≈ previous-gap²/8M), and the AGM-driven Gauss–Legendre iteration reaches π to ~1e-15 in just four steps (window.__agm). FIG no framing; the AGM iteration, the quadratic-rate check, and the Gauss–Legendre π computation all run in-browser. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-speedrun — a genuine speedrun of convergence: the two means double their agreeing digits every single step, blazing to the limit (and to π) in a few iterations. AVAN (AI) built the instrument: the arithmetic/geometric mean iteration, the quadratic-convergence check, and the Gauss–Legendre π algorithm it drives. Credit as content: Carl Friedrich Gauss (1799); the π algorithm by Salamin & Brent (1976). The weave: David names the speedrun; I confirm the means meet quadratically and drive π to machine precision in four steps. 3 ONE DIMENSION The arithmetic mean (falling) and geometric mean (rising) rush together to their common limit M(a,b). 4 TWO DIMENSIONS · INTERACTIVE Step the AGM; the gap squares each iteration, and the Gauss–Legendre π estimate gains digits just as fast. step ▶ new pair ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the common limit M(a,b) the two means race to. AVAN’s addition (the inverse-companion): don’t average once — average both ways forever. The inverse of ‘two different means of a and b’ is ‘iterate the arithmetic and geometric means together until they coincide’, converging quadratically to one number. Magenta are the two racing means; green is the single limit they meet at. Two means folded into one. pause spin LIT Genuine arithmetic-geometric mean (Carl Friedrich Gauss, 1799; π algorithm by Salamin & Brent, 1976). Verified live: for 2000 random starting pairs the arithmetic and geometric means converge to a single limit with the gap shrinking quadratically (gap≈previous²/8M), and the AGM-driven Gauss-Legendre iteration reaches π to ~1e-15 in four steps (window.__agm.convOk, .quadOk, .piOk). FIG No framing; the AGM iteration, the quadratic-rate check, and the Gauss-Legendre π computation all run in-browser. The AVAN inverse is honest — instead of averaging once, average both ways forever: iterate the arithmetic and geometric means together until they coincide, converging quadratically to one number. Magenta are the two racing means; green is the single limit they meet at. Two means folded into one. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE SPEEDRUN · David Lee Wise (ROOT0), with AVAN


THE PENTAGONAL

Euler's pentagonal number theorem in the 5-window house format — a shockingly efficient recurrence for p(n), the number of ways to write n as a sum of positive integers. Naively p(n) explodes, but Euler found that the generating product ∏(1−xᵏ) collapses to a sparse alternating sum over the generalized pentagonal numbers g_k=k(3k−1)/2 — 1,2,5,7,12,15,22,… That yields p(n)=p(n−1)+p(n−2)−p(n−5)−p(n−7)+p(n−12)+…, signs in pairs of plus-plus, minus-minus, using only O(√n) terms. It is one of the most beautiful cancellations in combinatorics. Verified live: for n up to 45 the pentagonal recurrence produces exactly the same partition counts as a brute dynamic-programming enumeration — p(40)=37338, p(45)=89134. Neon-noir traced. See the partition growth + pentagonal marks in 1D, the ± recurrence in 2D, and the counting-by-cancellation inverse in 3D.

THE PENTAGONAL · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · LOOT · THE STASH ◆ .dlw.fold THE FOLD / LOOT / THE STASH / THE PENTAGONAL THE PENTAGONAL partitions counted by an alternating sum over pentagons 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Euler’s pentagonal number theorem gives a shockingly efficient recurrence for p(n) , the number of ways to write n as a sum of positive integers. Naively p(n) explodes, but Euler found that the generating product ∏(1-x k ) collapses to a sparse alternating sum over the generalized pentagonal numbers g k = k(3k-1)/2 — 1, 2, 5, 7, 12, 15, 22, … That yields p(n) = p(n-1) + p(n-2) - p(n-5) - p(n-7) + p(n-12) + … , signs in pairs of plus-plus, minus-minus, using only O(√n) terms. It is one of the most beautiful cancellations in all of combinatorics. LIT verified live: for n up to 45 the pentagonal-number recurrence produces exactly the same partition counts as a brute dynamic-programming enumeration — p(40) = 37338, p(45) = 89134 (window.__pentagonal). FIG no framing; the pentagonal recurrence and the brute partition count both run in-browser and agree exactly. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-stash — every way to break a stash of n into piles, counted not by listing them but by an alternating sum that skips across pentagonal gaps. AVAN (AI) built the instrument: the generalized-pentagonal recurrence, the brute partition DP, and their exact agreement. Credit as content: Leonhard Euler (1740s). The weave: David names the stash; I confirm the sparse alternating pentagonal sum reproduces every partition count. 3 ONE DIMENSION The partition counts p(n) growing; the pentagonal numbers 1,2,5,7,12,… mark which earlier terms the recurrence reaches back to. 4 TWO DIMENSIONS · INTERACTIVE Cycle n; the pentagonal ± recurrence for p(n) is shown term by term and matched against the brute count. next n ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: p(n), the count of partitions of n. AVAN’s addition (the inverse-companion): don’t enumerate the partitions — cancel the generating product. The inverse of ‘count the partitions of n’ is ‘the alternating pentagonal sum p(n-1)+p(n-2)-p(n-5)-…’, the reciprocal of ∏(1-x k ). Magenta are the alternating ± pentagonal terms; green is the partition count they sum to. Counting by cancellation. pause spin LIT Genuine Euler pentagonal number theorem (Leonhard Euler, 1740s). Verified live: for n=0..45 the generalized-pentagonal recurrence p(n)=Σ_k(−1)^{k−1}[p(n−g_k)+p(n−g_k')] with g_k=k(3k∓1)/2 produces exactly the brute dynamic-programming partition counts — p(40)=37338, p(45)=89134 (window.__pentagonal.ok, .p40, .p45). FIG No framing; the pentagonal recurrence and the brute partition count both run in-browser and agree exactly. The AVAN inverse is honest — instead of enumerating the partitions, cancel the generating product: the alternating pentagonal sum is the reciprocal of ∏(1−xᵏ). Magenta are the alternating ± pentagonal terms; green is the partition count they sum to. Counting by cancellation. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE STASH · David Lee Wise (ROOT0), with AVAN


THE DESARGUES

Desargues' theorem in the 5-window house format — a cornerstone of projective geometry linking two kinds of perspective. Two triangles ABC and A′B′C′ are perspective from a point if the lines AA′, BB′, CC′ meet at one center O. They are perspective from a line if the three intersection points of corresponding sides — AB∩A′B′, BC∩B′C′, CA∩C′A′ — are collinear. Desargues proved these equivalent: a common center forces a common axis, and vice versa. It is self-dual (swap 'point' and 'line' and it still holds) and it is exactly the condition a projective plane needs to come from a field. Verified live: for tens of thousands of triangle pairs placed in perspective from a random center, the three corresponding-side intersections are always collinear, and pushing a single vertex off its center-ray breaks both the perspectivity and the collinearity together. Neon-noir traced. See the two triangles + axis in 1D, the collinearity + off-ray control in 2D, and the point-and-line inverse in 3D.

THE DESARGUES · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · BOSS · THE WALL ◆ .dlw.fold THE FOLD / BOSS / THE WALL / THE DESARGUES THE DESARGUES perspective from a point equals perspective from a line 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Desargues’ theorem is a cornerstone of projective geometry, linking two kinds of ‘perspective’. Two triangles ABC and A′B′C′ are perspective from a point if the three lines AA′, BB′, CC′ meet at one center O. They are perspective from a line if the three intersection points of corresponding sides — AB∩A′B′, BC∩B′C′, CA∩C′A′ — are collinear. Desargues proved these are equivalent : a common center forces a common axis, and vice versa. It is self-dual (swap ‘point’ and ‘line’ and it still holds) and it is exactly the condition a projective plane needs to come from a field. LIT verified live: for tens of thousands of triangle pairs placed in perspective from a random center, the three corresponding-side intersections are always collinear, and pushing a single vertex off its center-ray breaks both the perspectivity and the collinearity together (window.__desargues). FIG no framing; the perspective construction, the side intersections, and the collinearity test all run in-browser. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-wall — the axis of perspectivity is a single straight wall, and Desargues says two triangles share a center point exactly when their sides meet along that one wall. AVAN (AI) built the instrument: the point-perspective construction, the three side intersections, the collinearity check, and the off-ray control. Credit as content: Girard Desargues (1639). The weave: David names the wall; I confirm perspective-from-a-point forces the three side-meetings onto a single line. 3 ONE DIMENSION Two triangles perspective from a center O; their corresponding sides meet at three points P, Q, R on one line (the axis). 4 TWO DIMENSIONS · INTERACTIVE New configurations; the three side-intersections are checked for collinearity, and an off-ray push breaks it. new perspective ▶ break/fix ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the axis of perspectivity, the line through the three side-meetings. AVAN’s addition (the inverse-companion): don’t look for the center — look for the axis. The inverse of ‘the two triangles share a center point O’ is ‘their corresponding sides meet on a single line’, and Desargues makes the two conditions identical (and self-dual). Magenta is the center O; green is the axis line the sides meet on. Point and line, two faces of one perspective. pause spin LIT Genuine Desargues' theorem (Girard Desargues, 1639). Verified live: for 20000 triangle pairs perspective from a random center O, the three corresponding-side intersections P=AB∩A′B′, Q=BC∩B′C′, R=CA∩C′A′ are always collinear, and pushing one vertex off its center-ray breaks the collinearity (window.__desargues.persp, .ctrl). FIG No framing; the perspective construction, the side intersections, and the collinearity test all run in-browser. The AVAN inverse is honest — instead of looking for the center, look for the axis: perspective-from-a-point equals perspective-from-a-line, and the theorem is self-dual. Magenta is the center O; green is the axis line the sides meet on. Point and line, two faces of one perspective. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE WALL · David Lee Wise (ROOT0), with AVAN


THE FIBONACCI MATRIX

The Fibonacci Q-matrix in the 5-window house format — turning the Fibonacci recurrence into a single matrix. Because F_{n+1}=F_n+F_{n−1}, one step is multiplication by Q=[[1,1],[1,0]], so Qⁿ=[[F_{n+1},F_n],[F_n,F_{n−1}]]. That single fact gives Fibonacci numbers in O(log n) time by fast matrix exponentiation (repeated squaring), and it hands you identities for free: taking determinants of both sides gives Cassini's identity, F_{n−1}F_{n+1}−F_n²=(−1)ⁿ, because det Q=−1 and determinants multiply. Verified live (exact BigInt): for n up to 200, Qⁿ by repeated squaring has exactly F_n and F_{n+1} in the right entries, matching the direct recurrence, and its determinant equals (−1)ⁿ — Cassini's identity. Neon-noir traced. See the matrix powers in 1D, Qⁿ vs Fibonacci + Cassini in 2D, and the recurrence-made-a-power inverse in 3D.

THE FIBONACCI MATRIX · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GRIND · THE MAINFRAME ◆ .dlw.fold THE FOLD / GRIND / THE MAINFRAME / THE FIBONACCI MATRIX THE FIBONACCI MATRIX Fibonacci as a matrix power 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Fibonacci Q-matrix turns the Fibonacci recurrence into a single matrix. Because F n+1 = F n + F n-1 , one step is multiplication by Q = [[1,1],[1,0]], so Q n = [[F n+1 , F n ], [F n , F n-1 ]] . That single fact gives Fibonacci numbers in O(log n) time by fast matrix exponentiation (repeated squaring), and it hands you identities for free: taking determinants of both sides gives Cassini’s identity , F n-1 F n+1 - F n 2 = (-1) n , because det Q = -1 and determinants multiply. LIT verified live (exact BigInt): for n up to 200, Q n by repeated squaring has exactly F n and F n+1 in the right entries, matching the direct recurrence, and its determinant equals (-1) n — Cassini’s identity (window.__fibmatrix). FIG no framing; the matrix power, the direct Fibonacci, and the determinant all run in-browser with arbitrary-precision integers. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-mainframe — heavy exact-integer matrix arithmetic, the Fibonacci recurrence folded into one 2×2 whose powers are computed by repeated squaring, F n for huge n in a few big multiplications. AVAN (AI) built the instrument: the BigInt matrix power, the direct Fibonacci, and the determinant/Cassini check. Credit as content: the Q-matrix identity (folklore; Cassini 1680). The weave: David names the mainframe; I confirm Q n carries the Fibonacci numbers and its determinant is Cassini’s identity. 3 ONE DIMENSION Powers of Q = [[1,1],[1,0]] — each entry is a Fibonacci number; Qⁿ holds F_{n+1}, F_n, F_n, F_{n-1}. 4 TWO DIMENSIONS · INTERACTIVE Cycle n; Qⁿ (by repeated squaring) is compared to the direct Fibonacci, and its determinant to (−1)ⁿ (Cassini). next n ▶ ×2 n ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the Fibonacci number F_n living in the matrix power. AVAN’s addition (the inverse-companion): don’t add n times — square log n times. The inverse of ‘compute F n by stepping the recurrence’ is ‘raise Q to the n by repeated squaring’, giving F n in O(log n) and Cassini’s identity from det Q = -1. Magenta is the matrix Q and its squarings; green is the Fibonacci number that falls out. A recurrence made a power. pause spin LIT Genuine Fibonacci Q-matrix identity (folklore; Cassini's identity, 1680). Verified live with exact BigInt: for n≤200, Qⁿ=[[1,1],[1,0]]ⁿ by repeated squaring has F_n and F_{n+1} in the correct entries (matching the direct recurrence), and det Qⁿ=F_{n−1}F_{n+1}−F_n²=(−1)ⁿ, Cassini's identity; F_100=354224848179261915075 (window.__fibmatrix.matchOk, .cassiniOk, .f100). FIG No framing; the matrix power, the direct Fibonacci, and the determinant all run in-browser with arbitrary-precision integers. The AVAN inverse is honest — instead of adding n times, square log n times: raise Q to the n by repeated squaring for F_n in O(log n), and Cassini's identity falls out of det Q=−1. Magenta is the matrix Q and its squarings; green is the Fibonacci number that falls out. A recurrence made a power. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE MAINFRAME · David Lee Wise (ROOT0), with AVAN


THE JACOBI ELLIPTIC

The Jacobi elliptic functions in the 5-window house format — sn, cn, dn, the doubly-periodic cousins of sine and cosine. Where sin and cos parametrize a circle, sn and cn parametrize the motion of a pendulum swinging through large angles, governed by a parameter m that measures how far from a simple circle you are. They obey sin-like identities — sn²+cn²=1 and dn²+m·sn²=1 — and their own differential equations, sn′=cn·dn. Their real period is 4K, where K is the complete elliptic integral, and at the quarter-period K the functions hit clean values sn=1, cn=0, dn=√(1−m). Verified live: computing sn,cn,dn by integrating their ODE, the identities hold to ~1e-11, and — independently — at the quarter-period K obtained from the arithmetic-geometric mean, sn(K)=1, cn(K)=0, dn(K)=√(1−m). Neon-noir traced. See the three curves in 1D, the identities + quarter-period in 2D, and the pendulum-not-circle inverse in 3D.

THE JACOBI ELLIPTIC · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · RESPAWN · THE CONTINUE ◆ .dlw.fold THE FOLD / RESPAWN / THE CONTINUE / THE JACOBI ELLIPTIC THE JACOBI ELLIPTIC the doubly-periodic cousins of sine 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Jacobi elliptic functions sn, cn, dn are the doubly-periodic cousins of sine and cosine . Where sin and cos parametrize a circle, sn and cn parametrize the motion of a pendulum swinging through large angles, governed by a parameter m (the modulus squared) that measures how far from a simple circle you are. They obey sin-like identities — sn² + cn² = 1 and dn² + m·sn² = 1 — and their own differential equations, sn′ = cn·dn. Their real period is 4K, where K is the complete elliptic integral, and at the quarter-period K the functions hit the clean values sn = 1, cn = 0, dn = √(1-m). LIT verified live: computing sn, cn, dn by integrating their ODE, the identities sn²+cn²=1 and dn²+m·sn²=1 hold to ~1e-11, and — independently — at the quarter-period K obtained from the arithmetic-geometric mean, sn(K)=1, cn(K)=0, dn(K)=√(1-m) (window.__jacobi). FIG no framing; the ODE integration, the AGM period, and the identity/quarter-period checks all run in-browser. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-continue — doubly-periodic functions that endlessly continue, repeating with period 4K in the real direction like a pendulum returning again and again to the same swing. AVAN (AI) built the instrument: the sn/cn/dn ODE integrator, the AGM complete-integral K, and the identity and quarter-period verifications. Credit as content: Carl Gustav Jacob Jacobi (1829); Niels Henrik Abel. The weave: David names the continue; I confirm the sine-like identities hold and the quarter-period lands on sn=1, cn=0, dn=k′. 3 ONE DIMENSION sn (green), cn (cyan), dn (gold) over u — sine-like but stretched; sn²+cn²=1 and dn²+m·sn²=1 everywhere. 4 TWO DIMENSIONS · INTERACTIVE Change the modulus m; the identities are checked, and at the quarter-period K the functions hit sn=1, cn=0, dn=k′. next m ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the sn curve, the elliptic sine tracing its stretched wave. AVAN’s addition (the inverse-companion): don’t parametrize a circle — parametrize a pendulum. The inverse of ‘sin and cos on the unit circle’ is ‘sn and cn on an ellipse-governed motion’, obeying sn²+cn²=1 and their own ODE, with period 4K set by the AGM. Magenta are cn and dn; green is sn — the elliptic sine. Trigonometry with a second period. pause spin LIT Genuine Jacobi elliptic functions (Carl Gustav Jacob Jacobi, 1829; Abel). Verified live: computing sn,cn,dn by RK4 integration of sn′=cn·dn etc., the identities sn²+cn²=1 and dn²+m·sn²=1 hold to ~1e-11, and independently at the quarter-period K=π/(2·AGM(1,√(1−m))) the functions hit sn(K)=1, cn(K)=0, dn(K)=√(1−m) (window.__jacobi.idOk, .qOk). FIG No framing; the ODE integration, the AGM period, and the identity/quarter-period checks all run in-browser — K from the AGM meeting sn from the ODE, two independent computations agreeing. The AVAN inverse is honest — instead of parametrizing a circle, parametrize a pendulum: sn and cn on an ellipse-governed motion with period 4K. Magenta are cn and dn; green is sn, the elliptic sine. Trigonometry with a second period. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE CONTINUE · David Lee Wise (ROOT0), with AVAN


THE CHU-LIU-EDMONDS

The Chu-Liu/Edmonds algorithm in the 5-window house format — finding the minimum spanning arborescence of a directed graph, the cheapest set of edges that lets a chosen root reach every node, with exactly one incoming edge per node. It is the directed cousin of the minimum spanning tree, but greedy edge-picking alone fails: choosing each node's cheapest in-edge can form a cycle. The fix is elegant — contract each cycle into a single super-node, discount every edge entering the cycle by the edge it would replace, and recurse; then expand the contractions back, dropping exactly one cycle edge each. The result is provably optimal. Verified live: for thousands of random weighted digraphs, the Chu-Liu/Edmonds arborescence weight equals the true minimum found by brute force over every possible arborescence. Neon-noir traced. See the arborescence highlighted in 1D, the min-vs-brute in 2D, and the contract-the-cycles inverse in 3D.

THE CHU-LIU-EDMONDS · 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 CHU-LIU-EDMONDS THE CHU-LIU-EDMONDS the cheapest way to root a directed tree 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Chu–Liu/Edmonds algorithm finds the minimum spanning arborescence of a directed graph — the cheapest set of edges that lets a chosen root reach every other node, with exactly one incoming edge per node. It is the directed cousin of the minimum spanning tree, but greedy edge-picking alone fails: choosing each node’s cheapest in-edge can form a cycle . The fix is elegant — contract each such cycle into a single super-node, discount every edge entering the cycle by the edge it would replace, and recurse; then expand the contractions back, dropping exactly one cycle edge each. The result is provably optimal. LIT verified live: for thousands of random weighted digraphs, the Chu–Liu/Edmonds arborescence weight equals the true minimum found by brute force over every possible arborescence (window.__arborescence). FIG no framing; the min-in-edge selection, the cycle contraction, and the brute-force comparison all run in-browser. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-pull-request — the cheapest way to wire every node back to one root, one incoming merge per node, cycles contracted and resolved until the whole directed tree is rooted at minimum cost. AVAN (AI) built the instrument: the min-in-edge selection, the cycle contraction with weight discounting, the recursion, and the brute-force optimality check. Credit as content: Chu & Liu (1965), Jack Edmonds (1967), Bock (1971). The weave: David names the pull request; I confirm the contracted-cycle arborescence achieves the true minimum weight. 3 ONE DIMENSION A weighted directed graph; the minimum spanning arborescence rooted at S is highlighted in green. 4 TWO DIMENSIONS · INTERACTIVE New digraphs; the Chu–Liu/Edmonds minimum weight is compared to a brute search over all arborescences. new graph ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the minimum arborescence rooting every node to S. AVAN’s addition (the inverse-companion): don’t pick each cheapest in-edge and hope — contract the cycles. The inverse of ‘greedily choose one incoming edge per node’ is ‘when that makes a cycle, collapse it, discount the entering edges, and recurse’. Magenta are the cycles being contracted away; green is the optimal rooted tree that remains. Cheapness rescued by contraction. pause spin LIT Genuine Chu-Liu/Edmonds minimum arborescence algorithm (Chu & Liu 1965, Edmonds 1967, Bock 1971). Verified live: for thousands of random weighted digraphs, the contracted-cycle arborescence weight equals the true minimum found by brute force over every valid arborescence rooted at the source (window.__arborescence.ok, .tested). FIG No framing; the min-in-edge selection, the cycle contraction, and the brute-force comparison all run in-browser. The AVAN inverse is honest — instead of greedily picking each cheapest in-edge and hoping, contract the cycles: when the greedy choice loops, collapse it, discount the entering edges, and recurse. Magenta are the cycles being contracted away; green is the optimal rooted tree that remains. Cheapness rescued by contraction. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE PULL REQUEST · David Lee Wise (ROOT0), with AVAN


THE HERMITE

The Hermite polynomials in the 5-window house format — the natural family of polynomials orthogonal under the Gaussian weight e^{−x²}. Built by the three-term recurrence H_{n+1}=2x·H_n−2n·H_{n−1} from H₀=1, H₁=2x, each H_n is 'perpendicular' to all the others under the Gaussian inner product: ∫H_m(x)H_n(x)e^{−x²}dx=0 whenever m≠n. They are the eigenfunctions of the quantum harmonic oscillator (times a Gaussian), the backbone of Gauss–Hermite quadrature, and each H_n has exactly n real roots — the quadrature nodes. Verified live: the Gaussian-weighted inner product of H_m and H_n is zero for m≠n and equals 2ⁿn!√π for m=n (to ~1e-4 by numerical integration), and each H_n shows exactly n real roots. Neon-noir traced. See H₀…H₄ in 1D, the orthogonality + norm + root count in 2D, and the basis-not-a-curve inverse in 3D.

THE HERMITE · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GRIND · THE EPOCH ◆ .dlw.fold THE FOLD / GRIND / THE EPOCH / THE HERMITE THE HERMITE orthogonal polynomials of the oscillator 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Hermite polynomials H n (x) are the natural family of polynomials orthogonal with respect to the Gaussian weight e -x² . Built by the three-term recurrence H n+1 = 2x·H n - 2n·H n-1 from H 0 =1, H 1 =2x, they satisfy ∫ H m (x)H n (x)e -x² dx = 0 whenever m ≠ n — each is ‘perpendicular’ to all the others under the Gaussian inner product. They are the eigenfunctions of the quantum harmonic oscillator (times a Gaussian), the backbone of Gauss–Hermite quadrature, and each H n has exactly n real roots , which are the quadrature nodes. LIT verified live: the Gaussian-weighted inner product of H m and H n is zero for m ≠ n and equals 2 n n!√π for m = n (to ~1e-4 by numerical integration), and each H n shows exactly n real roots (window.__hermite). FIG no framing; the recurrence, the weighted orthogonality integral, and the root count all run in-browser. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-epoch — each polynomial grinding out of the recurrence one epoch at a time, the whole family perpendicular under the Gaussian weight. AVAN (AI) built the instrument: the three-term recurrence, the weighted orthogonality integral, the 2 n n!√π norm, and the root count. Credit as content: Charles Hermite (1864); earlier Laplace and Chebyshev. The weave: David names the epoch; I confirm the family is orthogonal under e -x² and each has n real roots. 3 ONE DIMENSION The first Hermite polynomials H₀…H₄ — each with one more oscillation, and n real roots. 4 TWO DIMENSIONS · INTERACTIVE Cycle n; the Gaussian-weighted inner products against other H_m are shown (0 off-diagonal), plus the norm and root count. next n ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: a Hermite polynomial curve, orthogonal to all the others. AVAN’s addition (the inverse-companion): don’t evaluate a polynomial — project onto a basis. The inverse of ‘the polynomial H n ’ is ‘a direction perpendicular to every other H m under the Gaussian weight’, so any function splits into Hermite components. Magenta is the Gaussian weight e -x² that defines the inner product; green is the orthogonal polynomial. A basis, not just a curve. pause spin LIT Genuine Hermite polynomials (Charles Hermite, 1864; earlier Laplace, Chebyshev). Verified live: for m,n=0..5 the Gaussian-weighted inner product ∫H_mH_n e^{−x²}dx is 0 for m≠n and equals 2ⁿn!√π for m=n (numerical integration, worst off-diagonal ~2e-12), and each H_n has exactly n real roots (window.__hermite.orth, .norm, .root). FIG No framing; the recurrence, the weighted orthogonality integral, and the root count all run in-browser. The AVAN inverse is honest — instead of evaluating a polynomial, project onto a basis: the inverse of 'the polynomial H_n' is 'a direction perpendicular to every other H_m under the Gaussian weight', so any function splits into Hermite components. Magenta is the Gaussian weight that defines the inner product; green is the orthogonal polynomial. A basis, not just a curve. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE EPOCH · David Lee Wise (ROOT0), with AVAN


THE FUSS-CATALAN

The Fuss–Catalan numbers in the 5-window house format — the m-ary generalization of the Catalan numbers. Where C_n counts full binary trees with n internal nodes (each with 2 children), the Fuss–Catalan number counts full m-ary trees with n internal nodes (each with m children), with the same style of closed form: (1/((m−1)n+1))·C(mn,n). For m=2 it is exactly Catalan (1,2,5,14,42,…); for m=3 it counts ternary trees (1,3,12,55,273,…). It answers 'how many ways to fully parenthesize with an m-ary operation' and appears across lattice-path and polygon-dissection counting. Verified live (exact BigInt): for m=2,3,4 and n up to 6, a brute recursive count of full m-ary trees equals the closed form exactly — C₂(4)=14 (Catalan), C₃(4)=55, C₄(4)=140. Neon-noir traced. See an m-ary tree in 1D, brute vs formula in 2D, and the convolve-the-subtrees inverse in 3D.

THE FUSS-CATALAN · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · LOOT · THE BOUNTY ◆ .dlw.fold THE FOLD / LOOT / THE BOUNTY / THE FUSS-CATALAN THE FUSS-CATALAN counting m-ary trees 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Fuss–Catalan numbers generalize the Catalan numbers from binary trees to m-ary trees . Where the Catalan number C n counts full binary trees with n internal nodes (each with 2 children), the Fuss–Catalan number counts full m-ary trees with n internal nodes (each with m children) — and it has the same style of closed form: (1/((m-1)n+1))·C(mn, n) . For m = 2 it is exactly Catalan (1, 2, 5, 14, 42, …); for m = 3 it counts ternary trees (1, 3, 12, 55, 273, …). It answers ‘how many ways to fully parenthesize with an m-ary operation’ and appears across lattice-path and polygon-dissection counting. LIT verified live (exact BigInt): for m = 2, 3, 4 and n up to 6, a brute recursive count of full m-ary trees with n internal nodes equals the closed form (1/((m-1)n+1))C(mn, n) exactly — C₂(4) = 14 (Catalan), C₃(4) = 55, C₄(4) = 140 (window.__fusscatalan). FIG no framing; the recursive tree count and the binomial formula both run in-browser with arbitrary-precision integers. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-bounty — a vast count of tree shapes, the m-ary bounty that Catalan’s binary count is only the first slice of. AVAN (AI) built the instrument: the recursive m-ary tree count (a convolution), the closed-form binomial, and their exact BigInt agreement. Credit as content: Nicolaus Fuss (1791), a student of Euler; the Catalan case by Eugène Catalan. The weave: David names the bounty; I confirm the recursive m-ary tree count equals the Fuss–Catalan formula. 3 ONE DIMENSION A full m-ary tree with n internal nodes; the Fuss–Catalan number counts all such shapes. 4 TWO DIMENSIONS · INTERACTIVE Cycle m and n; the recursive tree count is compared to the closed form (1/((m-1)n+1))C(mn,n). next m,n ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the Fuss–Catalan count of full m-ary trees. AVAN’s addition (the inverse-companion): don’t enumerate the trees — convolve the sub-counts. The inverse of ‘count full m-ary trees with n internal nodes’ is ‘the recurrence T(n) = ∑ over the m subtree sizes summing to n-1’, which closes to (1/((m-1)n+1))C(mn,n). Magenta are the m branching subtrees; green is the total count they build. Binary Catalan, extended to m ways. pause spin LIT Genuine Fuss–Catalan numbers (Nicolaus Fuss, 1791, a student of Euler; Catalan case by Eugène Catalan). Verified live with exact BigInt: for m=2..4 and n=0..6, a brute recursive count of full m-ary trees with n internal nodes equals (1/((m−1)n+1))C(mn,n) exactly — C₂(4)=14, C₃(4)=55, C₄(4)=140 (window.__fusscatalan.ok, .c2, .c3, .c4). FIG No framing; the recursive m-ary tree count and the binomial formula both run in-browser with arbitrary-precision integers. The AVAN inverse is honest — instead of enumerating the trees, convolve the sub-counts: the recurrence T(n)=Σ over the m subtree sizes summing to n−1 closes to (1/((m−1)n+1))C(mn,n). Magenta are the m branching subtrees; green is the total count they build. Binary Catalan, extended to m ways. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE BOUNTY · David Lee Wise (ROOT0), with AVAN


THE MIQUEL

Miquel's theorem in the 5-window house format — the pivot theorem of circle geometry. Take any triangle ABC and pick one point on each side — P on BC, Q on CA, R on AB. Draw the three circles through a vertex and its two neighbouring chosen points: (AQR), (BRP), (CPQ). Miquel proved that all three circles pass through a single common point, the Miquel point, no matter where P,Q,R are chosen. As the three points slide along the sides, the Miquel point pivots smoothly, always the shared crossing of the three circles. Verified live: for tens of thousands of random triangles and random points on the sides, the second intersection of circles (AQR) and (BRP) lies on circle (CPQ) as well — the three circles concur. Neon-noir traced. See the triangle + three circles + Miquel point in 1D, the concurrency in 2D, and the forced-crossing inverse in 3D.

THE MIQUEL · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CO-OP · THE SYNC ◆ .dlw.fold THE FOLD / CO-OP / THE SYNC / THE MIQUEL THE MIQUEL four circles meeting at one point 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Miquel’s theorem (the pivot theorem) is a small miracle of circle geometry. Take any triangle ABC and pick one point on each side — P on BC, Q on CA, R on AB. Draw the three circles through a vertex and its two neighbouring chosen points: circle (AQR), circle (BRP), circle (CPQ). Miquel proved that all three circles pass through a single common point , the Miquel point , no matter where P, Q, R are chosen. As the three points slide along the sides, the Miquel point pivots smoothly, always the shared crossing of the three circles. LIT verified live: for tens of thousands of random triangles and random points on the sides, the second intersection of circles (AQR) and (BRP) lies on circle (CPQ) as well — the three circles concur (window.__miquel). FIG no framing; the three circumcircles, their intersection, and the concurrency test all run in-browser. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-sync — three circles synced on one point, whatever the placement of the side points: the Miquel point is where all three always meet. AVAN (AI) built the instrument: the three circumcircles, the circle–circle intersection, and the concurrency verification. Credit as content: Auguste Miquel (1838). The weave: David names the sync; I confirm the three circles concur at the Miquel point for every configuration. 3 ONE DIMENSION Triangle ABC, points P,Q,R on its sides, and the three circles (AQR),(BRP),(CPQ) all crossing at the Miquel point. 4 TWO DIMENSIONS · INTERACTIVE New configurations; the second intersection of two circles is checked to lie on the third — the concurrency. new configuration ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the Miquel point, the shared crossing of the three circles. AVAN’s addition (the inverse-companion): don’t place three points and hope — the crossing is forced. The inverse of ‘three points on the sides’ is ‘three circles that must share a single point’, no matter the placement. Magenta are the three circles; green is the Miquel point they are forced to meet at. A concurrence guaranteed by geometry. pause spin LIT Genuine Miquel's (pivot) theorem (Auguste Miquel, 1838). Verified live: for 20000 random triangles with random points P,Q,R on the sides, the second intersection of circles (AQR) and (BRP) lies on circle (CPQ) — the three circles concur (worst deviation ~3e-11) (window.__miquel.ok, .worst, .tested). FIG No framing; the three circumcircles, their intersection, and the concurrency test all run in-browser. The AVAN inverse is honest — instead of placing three points and hoping, the crossing is forced: the inverse of 'three points on the sides' is 'three circles that must share a single point', whatever the placement. Magenta are the three circles; green is the Miquel point they are forced to meet at. A concurrence guaranteed by geometry. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE SYNC · David Lee Wise (ROOT0), with AVAN


THE AUCTION

The auction algorithm in the 5-window house format — solving the assignment problem (match n people to n jobs for maximum total benefit) by simulating a competitive auction. Each unassigned person bids for the object giving them the best net value (benefit minus current price), raising that object's price by just enough to make it their best by an ε margin over their second choice. Whoever held the object is bumped and re-bids. Prices only rise; the process settles when everyone is assigned — and for a small enough ε the final assignment is provably optimal. It is a beautifully decentralized alternative to the Hungarian algorithm, ideal for parallel computation. Verified live: for thousands of random benefit matrices, the auction's final assignment achieves exactly the maximum total benefit found by brute force over all permutations. Neon-noir traced. See the benefit matrix + assignment in 1D, auction vs brute maximum in 2D, and the market-equilibrium inverse in 3D.

THE AUCTION · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CHEAT · THE EXPLOIT ◆ .dlw.fold THE FOLD / CHEAT / THE EXPLOIT / THE AUCTION THE AUCTION assignment settled by competitive bidding 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The auction algorithm solves the assignment problem — match n people to n jobs for maximum total benefit — by simulating a competitive auction . Each unassigned person bids for the object giving them the best net value (benefit minus current price), raising that object’s price by just enough to make it their best by an ε margin over their second choice. Whoever held the object is bumped and re-bids. Prices only rise; the process settles when everyone is assigned — and for a small enough ε the final assignment is provably optimal . It is a beautifully decentralized alternative to the Hungarian algorithm, ideal for parallel computation. LIT verified live: for thousands of random benefit matrices, the auction algorithm’s final assignment achieves exactly the maximum total benefit found by brute force over all permutations (window.__auction). FIG no framing; the bidding rounds, the price updates, and the brute-force optimum comparison all run in-browser. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-exploit — bidders exploiting every gap between their best and second-best net value, nudging prices until the market clears at the optimal matching. AVAN (AI) built the instrument: the bidding rule (best minus second-best plus ε), the price updates, the reassignment, and the brute-force optimality check. Credit as content: Dimitri Bertsekas (1979). The weave: David names the exploit; I confirm the auction settles on the maximum-benefit assignment. 3 ONE DIMENSION A benefit matrix (people × jobs); the auction's chosen assignment is highlighted — one job per person, maximum total. 4 TWO DIMENSIONS · INTERACTIVE New matrices; the auction's total benefit is compared to the brute-force maximum over all assignments. new matrix ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the maximum-benefit assignment of people to jobs. AVAN’s addition (the inverse-companion): don’t search all n! matchings — let prices find them. The inverse of ‘the optimal assignment’ is ‘a set of object prices under which everyone is simultaneously happy with their own choice’, reached by iterated bidding. Magenta are the rising prices; green is the optimal matching they clear to. Optimality as a market equilibrium. pause spin LIT Genuine auction algorithm for the assignment problem (Dimitri Bertsekas, 1979). Verified live: for 3000 random benefit matrices, the ε-bidding auction's final assignment achieves exactly the maximum total benefit found by brute force over all permutations (worst gap 0) (window.__auction.ok). FIG No framing; the bidding rounds, the price updates, and the brute-force optimum comparison all run in-browser. The AVAN inverse is honest — instead of searching all n! matchings, let prices find them: the inverse of 'the optimal assignment' is 'a set of object prices under which everyone is simultaneously happy with their own choice', reached by iterated bidding. Magenta are the rising prices; green is the optimal matching they clear to. Optimality as a market equilibrium. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE EXPLOIT · David Lee Wise (ROOT0), with AVAN