◄ WORLD V · SONNY 5DART 347 · a helldive at the net

ZECKENDORF every integer, as one unique sum of non-consecutive Fibonaccis — and the machine that makes it so

Every positive integer can be written as a sum of Fibonacci numbers — in many ways. But there is exactly one way that uses no two consecutive Fibonaccis. That is the Zeckendorf representation, and it is unique: 100 = 89 + 8 + 3, and no other non-consecutive Fibonacci sum gives 100. What makes this the batch's keeper shot is not the theorem but the mechanism: a canonicalizer. Feed it any Fibonacci sum — even a sloppy one with consecutive terms — and it repairs it, because F(k) + F(k+1) = F(k+2) collapses every adjacency, until the form is non-consecutive. It does not check whether the input is canonical; it emits the canonical form.

THE TECHNIQUE unique non-consecutive Fibonacci sum; repair by F(k)+F(k+1)=F(k+2)

The demo canonicalizes an integer greedily into its Zeckendorf form, and repairs a deliberately non-canonical sum (consecutive Fibonaccis) into the unique one: live demo







  
HISTORY & CREDIT Lekkerkerker 1952 · named Zeckendorf 1972

  
“Writing a number in Fibonaccis is ambiguous.” — the non-consecutive form is unique, and there is a mechanism that always produces it, from any input. Uniqueness plus a canonicalizer that guarantees it. cited

  
1952 · Cornelis Lekkerkerker — proved the theorem first.
1972 · Édouard Zeckendorf — published his proof; the name stuck to him (Stigler's law).
the repair · F(k)+F(k+1) = F(k+2) — the rewrite that collapses any consecutive pair, canonicalizing the form.

  
One number, one non-consecutive form, and a rule that repairs its way to it from anywhere. Canonical by construction. Lekkerkerker / Zeckendorf






  
RECOMMEND FOR I-13 the canonicalizer, and the repair, on the compiler

  
On the canonical compiler, 100 = F(11)+F(6)+F(4) = 89+8+3 (index gaps 5 and 2 — all ≥ 2, non-consecutive); and a consecutive pair repairs: F(5)+F(6) = 5+8 = 13 = F(7):

  
$ i13 run g_zeckendorf.i13   # canonical form + the repair rewrite
RUN OK · 4637 step(s) · peak stack 4 · call depth 11
sum = 100   reaches_100 = 1
gap_a = 5   gap_b = 2   non_consecutive = 1     -- the unique Zeckendorf form of 100
repair = 13   repaired_to_F7 = 1               -- F(5)+F(6) collapses to F(7): the canonicalizer

  
Recommend — the batch's keeper shot, and the first built to the bar the last panel drew. B41 ruled that a recognizer (a predicate that checks well-formedness) only witnesses an invariant; a keeper must generate it — a canonicalizer / repairer whose output itself carries the property, from input that need not. Zeckendorf is exactly that. Its supplement to correctness is real: a correct-but-different Fibonacci representation (one that permits consecutive terms) is a valid sum but lacks the non-consecutive canonical form; Zeckendorf's rewrite F(k)+F(k+1)=F(k+2) produces it. Feed it broken (non-canonical) input and it repairs to the unique form — it does not reject with a bit. It is load-bearing: swap the rewrite for one that stops early and the output is a valid-but-non-canonical sum — the property dies. The panel ruled NULL, 3–0 (the ninth straight) — but credited it as the first shot in nine to genuinely CLEAR the B41 recognizer ban: a true repairer that emits 13 from 5+8 rather than rejecting with a bit. It died one wall later, on distinctness, and the finding is clean: canonicalization is CONFLUENCE enacted on a single object. The rewrite F(k)+F(k+1)→F(k+2) is terminating and locally confluent, so by Newman's lemma it is Church–Rosser: every sum reduces to the same non-consecutive normal form independent of reduction order — which is exactly the crdt keeper (crdt merges many replicas → one; Zeckendorf normalizes one object → its representative — two faces of one invariant). And it is doubly covered: the greedy walk is computed-not-stored (Stern-Brocot). The lesson (logged): generate-don't-recognize is necessary but NOT sufficient — a genuine enacting canonicalizer whose uniqueness is the normal form of a confluent terminating rewrite (Zeckendorf, reduced fractions, hash-consing, BDDs) is confluence's representative-selection face, not a sixth axis. A real 6th must be a structural invariant that is NOT convergence-to-a-unique-normal-form. Kept as the strongest, most instructive near-miss of the run.