metanum 2.0.0 → 2.0.1

package/README.md

@@ -367,7 +367,7 @@ MetaNum(10).arrow(3.2)(10);   // monotone between 10{3}10 and 10{4}10
 
 The same continuity applies to the ω-and-above operations. Successor levels
 follow `x{α}(m+f) = x{α-1}` applied m times to `x^f`; the ω level matches
-`aperiote` exactly, so the issue's composition identity holds verbatim:
+`aperiote` exactly, so composition identity holds verbatim:
 
 ```javascript
 MetaNum(10).expande(2.1);      // 10{ω+1}2.1 = 10{ω}10{ω}(10^0.1)
@@ -375,9 +375,45 @@ MetaNum(10).expande(2);        // 10{ω}10 (continuous at the integers)
 MetaNum(10).multiexpande(2.1); // (10{ω+1})²(10^0.1)
 ```
 
-Limit levels take the fundamental sequence at `floor(y)`; successor levels
-with an iteration count beyond direct evaluation diagonalize through the
-engine's huge-argument convention (y plus one α-level marker row).
+**Limit levels take the fundamental sequence at the full (fractional) `y`**, so
+the fraction is never dropped (`h20(10,2.1)` ≠ `h20(10,2)`). The sequence can
+then carry fractional coefficients, which resolve against the base x because on
+the diagonal ω reads as x:
+
+- ω^(k)·(c+f) = ω^(k)·c + ω^(k-1)·(x·f), applied top-down (ω^0.1 = x^0.1), so
+  only the constant term can still be fractional;
+- a leftover fractional constant γ+f is one level of interpolation:
+  **x{γ+f}x = x{γ+1}(2·(x/2)^f)** — continuous at f=0 because x{γ+1}2 = x{γ}x.
+
+**Successor levels** keep `x{α}(m+f) = x{α-1}` applied m times to `x^f`, and they
+are stored in the same **expanded** form as the integer arguments: the α-1 row
+carries the m applications (`ceil(y)-2 = m-1`) and the cascade below it is
+generated at the fundamental-sequence index `x^f`, so the value grows with f
+inside the interval and converges to the next integer as f → 1:
+
+```javascript
+MetaNum(10).h21(2.0001);  // Ba2.218Ab9     f → 0: cascade bottoming at ω
+MetaNum(10).h21(2.5);     // Ba1.772Ad9     the cascade deepens with f
+MetaNum(10).h21(2.99);    // Ba2.447Aj9  →  converges to h21(10,3) = Ba1.000Ak9
+```
+
+For the ω+1 / ω+2 / ω+3 levels the applications after the first still have an
+operand inside MSI, so those are evaluated directly by the rule (that is the
+`10{ω}10{ω}(10^0.1)` composition above) — which is also the exact identity.
+An iteration count beyond direct evaluation diagonalizes through the engine's
+huge-argument convention (y plus one α-level marker row). Then we have:
+
+10{ω\*2}2.1=10{ω+2.1}10=10{ω+3}2\*5^0.1 (because 10{ω+2}10=10{ω+3}2)
+
+3{ω\*2}2.1=3{ω+2.1}3=3{ω+3}2\*1.5^0.1
+
+10{ω^2}2.1=10{ω\*2.1}10=10{ω\*2+10\*0.1}10=10{ω\*2+1}10
+
+3{ω^2}2.1=3{ω\*2.1}3=3{ω\*2+3\*0.1}10=3{ω\*2+0.3}3=3{ω\*2+1}2\*1.5^0.3
+
+10{ω^ω}2.1=10{ω^2.1}10=10{ω^2\*10^0.1}10=10{ω^2\*1.258925}10=10{ω^2\*1+ω\*2+5.8925}10=10{ω^2\*1+ω\*2+6}2*5^0.8925
+
+3{ω^ω}2.1=3{ω^2.1}3=3{ω^2\*3^0.1}3=3{ω^2\*1.116123}3=3{ω^2\*1+1.045107}3=3{ω^2\*1+2}2*1.5^0.045107
 
 ## BEAF Operations
 
@@ -555,6 +591,50 @@ where α\[b] denotes the b-th element of the fundamental sequence assign to the
 - (ω^(α_1)+ω^(α_2)+...+ω^(α_k))\[n]=ω^(α_1)+ω^(α_2)+...+ω^(α_k)\[n], where α_1>=α_2>=...>=α_k
 - ε₀\[0]=1 and ε₀\[n+1]=ω^ε₀\[n]
 
+### The application count of each ordinal row
+
+Expanding rules 2-3 all the way down shows that **only the top row depends on
+the argument b** — every row below it is produced by decomposing with the base
+n as the operand:
+
+- successor α: n{α}b = n{α-1}^(b-2) (n{α-1}n), so the α-1 row carries **b-2**
+  applications and every lower row (which comes from n{α-1}n, n{α-2}n, …
+  whose operand is n) carries **n-2**;
+- limit α: rule 3 first rewrites n{α}b = n{α\[b]}n, so the operand is n at
+  every level and **all** rows carry **n-2**.
+
+```javascript
+MetaNum(10).h13(20);   // 10{ω+3}20 = 10{ω+2}^18 10{ω+1}^8 10{ω}^8 10{ω}10
+// array → [[1e10,8,8,8,8,8,8,8,8], [8,0,1], [8,1,1], [18,2,1]]
+//            ω+2 row = 18 = y-2,  ω+1 and ω rows = 8 = x-2
+MetaNum(10).h12(20);   // 10{ω+2}20 → [8,0,1] [18,1,1]
+MetaNum(3).h13(20);    // 3{ω+3}20  → [1,0,1] [1,1,1] [18,2,1]   (x-2 = 1)
+```
+
+The same n-2 count is what the finite r0 coefficients carry (10{10}10 → all-8s),
+so a row below the top one never moves when b changes.
+
+The law is uniform for **every** level from ω+1 to ω^4:
+
+| kind | rows | top row count | lower rows |
+|---|---|---|---|
+| successor α = β+1 | rows of n{β}n, then one β-row | **b-2** | **n-2** |
+| limit α | rows of n{α\[b]}n | **n-2** | **n-2** |
+
+```javascript
+MetaNum(10).h21(20);   // 10{ω*2+1}20 = 10{ω*2}^18 (10{ω*2}10)
+// 10{ω*2}10 = 10{ω+10}10 → the ω..ω+9 cascade, every count x-2 = 8
+// array → [[…,8,…], [8,0,1] … [8,9,1], [18,0,2]]
+MetaNum(10).h22(20);   // … + [8,0,2] + [18,1,2]   (ω*2 row = 8, ω*2+1 row = 18)
+MetaNum(3).h21(20);    // 3{ω*2+1}20 → [1,0,1] [1,1,1] [1,2,1] [18,0,2]  (x-2 = 1)
+```
+
+A limit operation stays **expanded** for every argument up to MSI: rule 3 turns
+b into a fundamental-sequence index, so 100 < b ≤ MSI still yields the largest
+`maxRows-1` fundamental-sequence rows (with the standard truncation marker)
+instead of collapsing to a one-row marker — `h20(10,1000)` keeps 19 rows whose
+top one is ω+999, and `h20(10,MSI)` keeps rows up to ω+(MSI-1).
+
 ## Examples
 
 642663{0}178187=642663×178187=114514191981
@@ -902,8 +982,8 @@ Implementation of dlsdl's letter notation for large number library, currently me
 - **Γ-canonical α/β (bisect law)**: the true α and β of a value v at letter Γ
   are recovered by bisecting 10{L}x = v on the engine's own smooth arrow curve
   (Γ = E,F,G,... single letters, L = level). α = 10^frac(x), β = floor(x):
-  `format(arrow(3,4.1,3))` → `G1.161G897` (not `G1.000G898`),
-  `format(arrow(3,4.3,3))` → `1.285H8` (not `1.000H8`),
+  `format(arrow(3,4.1,3))` → `G1.161G897`,
+  `format(arrow(3,4.3,3))` → `1.285H8`,
   `format(hardy(4166))` → `2.397G5`.
 - **+count collapse**: n operations of level L applied to a Γ^{L+1}-structured
   value collapse to ONE Γ^{L+1} with arg + n (F⁴(G(1.3796)) = G(5.3796)),
@@ -922,7 +1002,7 @@ Implementation of dlsdl's letter notation for large number library, currently me
   22→21, 23→22 stay two-letter (`Y2.376X2`, `Z2.376Y2`), level ≥ 23 cascades
   display as the αΓβ polarize diagonal. Diagonal letter combinations
   (multi-letter tokens whose last lowercase letter is `a`: Aa, Ba, Ca, Aaa,
-  Aaaa, …) use the **pure dlsdl α=2·5^f ∈ [2,10) convention**; the other
+  Aaaa, …) use the **pure dlsdl α=2·5^f ∈[2,10) convention**; the other
   letters (Ab, Bb, …) keep the ordinary α∈[1,10) convention. The polarize
   triple t = log₁₀(bottom)+repeation maps as: t∈[2,10) smooth → α=t,
   β=arrows; discrete integer arguments (10{L}b with 2≤b≤100) all sit at the
@@ -934,7 +1014,7 @@ Implementation of dlsdl's letter notation for large number library, currently me
   nested ordinals prefix the ω-row letter:
   3{3{100}3}3 → `Aa2.376Aa99`, 3{10{10000}10}3 → `Aa2.000Aa10,000`.
   Symbol de-layering follows the same convention: !Aa3 = 10{ω³}10 →
-  `2.000Aaaa10` (layer 0), @Aa3 = 10{ω^{ω³}}10 → `!2.000Aaaa10`.
+  `2.000Aaaa10` (layer 0), @Aa3 = 10{ω^(ω³)}10 → `!2.000Aaaa10`.
 - **multiLetterLimit symbol carry**: a multi-letter combination of k letters
   sits at level ω^(k-1).  Once it would be longer than multiLetterLimit the
   notation switches to the next one instead of growing another letter: the
@@ -952,9 +1032,23 @@ Implementation of dlsdl's letter notation for large number library, currently me
   table the ε form takes over (`format(epsilonate(3,15))` → `1.000Ak10ε14`).
   Diagonal combinations in symbol forms keep the pure dlsdl α = 2·5^f ∈ [2,10)
   mantissa (integer exponents anchor 2.000).
-- **Cascade compression**: a 20-row ordinal cascade that would spell 20 letter
-  types keeps its top two levels and folds the rest into the second letter's
-  repeat count: `format(h10000(3,10))` → `1.000Iccc19`.
+- **Cascade compression**: the ordinal rows are a COMPOSITION, so the top row
+  leads the display and the row below it (which collapses from its repeat count)
+  keeps the single α and β — a 20-row cascade keeps its top two levels:
+  `format(h10000(3,10))` → `Iccc1.000Iccb10`.
+- **Stacking the same function nests the letter** (issue #14): `n{α}(n{α}y)` is
+  one more application of the same level on top of the inner value, so the
+  letter appears twice. `poea(10,poea(10,100))` = Ad(Ad(99)) → `Ad1.000Ad99`
+  (before: the rows were folded into one letter, `1.000Ad114`), and the same
+  holds for ω+1, ω+2, ω*2+1, ω*2+2, ω²+1, ω²+2, ω³+1 —
+  `Ab2.398Ab99`, `Ac1.000Ac99`, `Bb1.000Bb99`, `Bc1.000Bc99`,
+  `Abb1.000Abb99`, `Aac1.000Aac99`, `Aaab1.000Aaab99`; with an operand above
+  MSI, `apea(apea(1e16))` → `BaBa1.000E16`.
+- **A coefficient above 25 has no letter in the grid** (the letters hold
+  ω·d+v with 0 ≤ v ≤ 25), so a ω*2 fundamental-sequence row (ω+81, ω+99, …)
+  clamps down to the largest letter below it instead of wrapping into a higher,
+  wrong letter: `format(apea(10,100))` → `1.000Ba154` (the ω*2 level), not the
+  wrapped ω*4+3 letter.
   Formats are identical at maxRows=maxCols=10/20/50/100.
 
 ### Precision budget (maxRows / maxCols)

package/format-metanum.js

@@ -1472,7 +1472,19 @@ function formatOrdinal(num, precision, precision4) {
                     // as one more symbol with the chain as its argument
                     return tokAa.sym + regularFormat(2, precision4) + tokAa.letter + argStr
                 }
-                return letter.repeat(totalAaCount) + argStr
+                // past the collapse threshold the repeats shift the argument and
+                // advance the letter — a raw repeat would try to build a string
+                // with `count` copies (Aaa repeated 1e9 times cannot be built)
+                let repArgStr = argStr
+                if (totalAaCount > 64) {
+                    let r0Bottom = Math.pow(10, r0[0] - Math.floor(r0[0]))
+                    let repParam = totalAaCount + 1
+                    let mantissa = Math.log10(Math.max(r0Bottom, 0.001)) +
+                        Math.log10(Math.max(repParam, 1)) * 0.4 + 1.6
+                    return regularFormat(mantissa, precision4) +
+                           letterName(baseHeight + 1) + commaFormat(repParam)
+                }
+                return letter.repeat(totalAaCount) + repArgStr
             } else {
                 // Single Aa
                 let tokAa = letterTokenOf(baseHeight)
@@ -1494,11 +1506,16 @@ function formatOrdinal(num, precision, precision4) {
             let collapseAt = effThreshold + 1
 
             if (totalAaCount >= collapseAt) {
-                // Collapse to next letter (Aa→Ab, Ab→Ac, etc.)
-                let mantissa = Math.log10(Math.max(alpha, 0.001)) + totalAaCount
+                // Collapse to next letter (Aa→Ab, Ab→Ac, etc.): the repeats
+                // shift the argument (arg = count+1) and the mantissa keeps
+                // the [1,10) convention (2.398Ab99 — the same α the GRAHAMS
+                // branch above produces), never the raw count as α
+                let arg = totalAaCount + 1
+                let mantVal = Math.log10(Math.max(alpha, 0.001)) +
+                    Math.log10(Math.max(arg, 1)) * 0.4 + 1.6
                 let newHeight = baseHeight + 1
                 let newLetter = letterName(newHeight)
-                return regularFormat(mantissa, precision4) + newLetter + betaStr
+                return regularFormat(mantVal, precision4) + newLetter + formatR0Arg(arg, precision4)
             } else if (totalAaCount > 1) {
                 // Repeated letters: outerLetters + α + lastLetter + β
                 let outerLetters = letter.repeat(totalAaCount - 1)
@@ -1543,8 +1560,12 @@ function formatOrdinal(num, precision, precision4) {
         // Calculate height for this letter
         let height = 0
         if (nVals === 1) {
-            // 2-letter: Aa=23, Ab=24, ..., Az=48, Ba=49, ...
-            height = 23 + (diag - 1) * 26 + vals[0]
+            // 2-letter: Aa=23, Ab=24, ..., Az=48, Ba=49, ...  A coefficient
+            // above 25 (ω+81, ω+99, … from a ω*2 fundamental sequence) has no
+            // letter in the grid — clamp down to the largest letter below it
+            // rather than wrapping into a higher, wrong letter.
+            let v0 = vals[0] > 25 ? 25 : vals[0]
+            height = 23 + (diag - 1) * 26 + v0
         } else {
             // 3+ letters: need to calculate offset
             // vals are stored in reverse letter order (e.g. "bc" -> [2,1]),
@@ -1597,13 +1618,18 @@ function formatOrdinal(num, precision, precision4) {
                        tokAdv.letter + r0Str
             }
             if (totalRepeat >= collapseAt) {
-                // Collapse to next letter
+                // Collapse to next letter — the repeat count shifts the
+                // argument, so the mantissa keeps the [1,10) convention
                 let mantissa = Math.log10(Math.max(alpha, 0.001)) + totalRepeat
+                let mantVal = Math.pow(10, mantissa - Math.floor(mantissa))
+                if (mantVal < 1) mantVal *= 10
                 let newLetter = letterName(baseLetterHeight + 1)
-                return regularFormat(mantissa, precision4) + newLetter + r0Str
+                return regularFormat(mantVal, precision4) + newLetter + r0Str
             } else if (totalRepeat > 1) {
-                // Repeated letters + chain
-                let outerLetters = letter.repeat(totalRepeat - 1)
+                // Repeated letters + chain: one token per application, the
+                // innermost one in front of the chain (Ba(Ba(1e16)) → the
+                // stacked "BaBa1.000E16" — apea(apea(a)) must stay visible)
+                let outerLetters = letter.repeat(totalRepeat)
                 return outerLetters + r0Str
             } else {
                 // Single letter + chain
@@ -1620,9 +1646,18 @@ function formatOrdinal(num, precision, precision4) {
                 return emitLetterToken(tokAdv, regularFormat(tokAdv.mant, precision4), betaStr, precision4)
             }
             let mantissa = Math.log10(Math.max(alpha, 0.001)) + totalRepeat
+            // the repeat count shifts the argument, so the mantissa keeps the
+            // [1,10) convention (the ω-level form recovers the base mantissa
+            // the way the single-row Aa cascade does: 2.398Ab99)
+            let mantVal = (baseLetterHeight === 23)
+                ? Math.log10(Math.max(alpha, 0.001)) +
+                  Math.log10(Math.max(totalRepeat + 1, 1)) * 0.4 + 1.6
+                : Math.pow(10, mantissa - Math.floor(mantissa))
+            if (mantVal < 1) mantVal *= 10
             let newHeight = baseLetterHeight + 1
             let letter = letterName(newHeight)
-            return regularFormat(mantissa, precision4) + letter + betaStr
+            return regularFormat(mantVal, precision4) + letter +
+                   formatR0Arg(totalRepeat + 1, precision4)
         } else if (totalRepeat > 1) {
             // Repeated letters: outerLetters + α + lastLetter + β
             let letter = letterName(baseLetterHeight)
@@ -1678,12 +1713,22 @@ function formatOrdinal(num, precision, precision4) {
                 let vals = row.slice(1, row.length - 1)
                 let nVals = vals.length
                 if (nVals === 1) {
-                    height = 23 + (diag - 1) * 26 + vals[0]
+                    // the letter grid holds ω·d+v with 0 ≤ v ≤ 25; a larger
+                    // coefficient (a ω*2 fundamental sequence produces ω+81,
+                    // ω+99, …) has no letter, so clamp it down to the largest
+                    // letter below the ordinal instead of wrapping into a
+                    // higher, wrong letter (ω+81 must not display as ω*4+3)
+                    let v0 = vals[0] > 25 ? 25 : vals[0]
+                    height = 23 + (diag - 1) * 26 + v0
                 } else {
+                    // vals are the CNF coefficients a1, a2, …, a(x-1) of
+                    // ord = ω^(x-1)·ax + … + ω·a2 + a1 — little-endian, the same
+                    // order letterName()/getOrdinalLetter() decode the letter:
+                    // the LAST val is the first lowercase letter of the token.
                     let offset = 0
                     for (let k = 2; k <= nVals; k++) offset += Math.pow(26, k)
                     let n = (diag - 1) * Math.pow(26, nVals)
-                    for (let j = 0; j < nVals; j++) n += vals[j] * Math.pow(26, nVals - 1 - j)
+                    for (let j = 0; j < nVals; j++) n += vals[j] * Math.pow(26, j)
                     height = 23 + offset + n
                 }
             }
@@ -1694,109 +1739,107 @@ function formatOrdinal(num, precision, precision4) {
             letterCounts[height] = (letterCounts[height] || 0) + count
         }
 
-        if (heights.length >= 2) {
+        if (heights.length >= 1) {
             // Sort heights ascending
             heights.sort((a, b) => a - b)
 
             // README: at most TWO finite letter types survive — a longer
-            // cascade keeps only its top two levels and compresses the rest
-            // into the second letter's binary form (its repeat count).
+            // cascade keeps only its top two levels, every lower row
+            // compresses into the second letter's argument (they are below
+            // display precision, and folding them into its repeat COUNT would
+            // overstate the level: 8 ω's + 8 (ω+1)'s ≠ 16 more (ω+2)'s).
             if (heights.length > 2) {
                 let keepLo = heights[heights.length - 2]
-                for (let i = 0; i < heights.length - 2; i++) {
-                    letterCounts[keepLo] = (letterCounts[keepLo] || 0) + (letterCounts[heights[i]] || 0)
-                    delete letterCounts[heights[i]]
-                }
+                for (let i = 0; i < heights.length - 2; i++) delete letterCounts[heights[i]]
                 heights = Object.keys(letterCounts).map(Number).sort((a, b) => a - b)
             }
 
-            // Collapse from lowest to highest
-            let effThreshold = Math.max(2, FORMAT_OPTIONS.multiLetterRepeatThreshold)
-            let collapseAt = effThreshold + 1
-            let collapseInfo = {} // height -> collapsedFromCount
-
-            for (let h of heights.slice()) {
-                let count = letterCounts[h] || 0
-                if (count >= collapseAt) {
-                    let nextH = h + 1
-                    if (!(nextH in letterCounts) && heights.indexOf(nextH) < 0) heights.push(nextH)
-                    letterCounts[nextH] = (letterCounts[nextH] || 0) + 1
-                    collapseInfo[nextH] = count
-                    delete letterCounts[h]
-                }
-            }
-
-            // Re-sort after collapse
-            heights = Object.keys(letterCounts).map(Number).sort((a, b) => a - b)
-
             if (heights.length >= 1) {
                 // ── Display rules (README "format-metanum rules (v2.0)") ──
-                //   * at most TWO finite letter types survive (VαEβ … VαVβ):
-                //     a longer cascade keeps its top two levels and compresses
-                //     the rest into the second letter's binary form;
-                //   * exactly one α, attached to the innermost (lowest) letter;
+                //   * the rows are a COMPOSITION: the top row is the outermost
+                //     operation, so it leads the display and the row below it
+                //     supplies the single α and β (at most TWO letter types —
+                //     every lower row compresses into that inner argument);
+                //   * "+count collapse": count >= multiLetterRepeatThreshold+1
+                //     repeats of a letter collapse to ONE next letter with
+                //     arg count+1 (F⁴(G(1.3796)) = G(5.3796));
+                //   * stacking the same function therefore nests the letter:
+                //     poea(10,poea(10,100)) = Ad(Ad(99)) → "Ad1.000Ad99";
                 //   * a combination longer than multiLetterLimit carries to the
-                //     symbol notation !αAaβ instead of growing another letter.
+                //     symbol notation !αAaβ.
                 let effTh = Math.max(2, FORMAT_OPTIONS.multiLetterRepeatThreshold)
+                let collapseAt = effTh + 1
 
-                // (1) the single α / β pair
                 let base = r0[0]
                 let r0Alpha = Math.pow(10, base - Math.floor(base))
                 if (r0Alpha < 1) r0Alpha *= 10
                 let frac = base - Math.floor(base)
                 if (frac < 0) frac += 1
 
-                let collapseCount = 0
-                for (let ci = 0; ci < heights.length; ci++) {
-                    collapseCount += collapseInfo[heights[ci]] || 0
+                // α of a "+count collapse" (the ω-level form recovers the base
+                // mantissa the way the single-row Aa cascade does: 2.398Ab99)
+                let collapseMant = function (h, count) {
+                    let arg = count + 1
+                    if (h === 23) {
+                        return regularFormat(Math.log10(Math.max(r0Alpha, 0.001)) +
+                            Math.log10(Math.max(arg, 1)) * 0.4 + 1.6, precision4)
+                    }
+                    return regularFormat(r0Alpha, precision4)
+                }
+                // one collapsed level: α + next letter + (count+1)
+                let collapseStr = function (h, count) {
+                    let tok = letterTokenOf(h + 1)
+                    if (tok.sym) {
+                        return tok.sym + regularFormat(tok.mant, precision4) +
+                               tok.letter + formatR0Arg(count + 1, precision4)
+                    }
+                    return collapseMant(h, count) + tok.letter + formatR0Arg(count + 1, precision4)
                 }
 
-                let alphaStr, betaStr
-                if (collapseCount > 0) {
-                    // Collapsed repeats: α and β come from the mantissa
-                    // α = 10^(fractional part) ∈ [1, 10), β = floor(mantissa)
-                    let mantissa = Math.log10(Math.max(r0Alpha, 0.001)) + collapseCount
-                    let alphaVal = Math.pow(10, mantissa - Math.floor(mantissa))
-                    if (alphaVal < 1) alphaVal *= 10
-                    alphaStr = regularFormat(alphaVal, precision4)
-                    betaStr = commaFormat(Math.floor(mantissa))
-                } else {
-                    alphaStr = regularFormat(r0Alpha, precision4)
-                    betaStr = formatR0Arg(Math.floor(base), precision4)
+                let hTop = heights[heights.length - 1]
+                let cTop = letterCounts[hTop] || 1
+                let hLow = heights.length >= 2 ? heights[heights.length - 2] : -1
+                let cLow = hLow < 0 ? 0 : (letterCounts[hLow] || 1)
+
+                // (1) a single row level: collapse, or repeats with α + letter + β
+                if (hLow < 0) {
+                    if (cTop >= collapseAt) return collapseStr(hTop, cTop)
+                    let tok = letterTokenOf(hTop)
+                    if (tok.sym) return emitLetterToken(tok, regularFormat(r0Alpha, precision4),
+                        formatR0Arg(Math.floor(base), precision4), precision4)
+                    let aStr = (tok.letter.length >= 2 && tok.letter[tok.letter.length - 1] === "a")
+                        ? regularFormat(2 * Math.pow(5, frac), precision4)
+                        : regularFormat(r0Alpha, precision4)
+                    return tok.letter.repeat(Math.max(cTop - 1, 0)) + aStr + tok.letter +
+                           formatR0Arg(Math.floor(base), precision4)
                 }
-                // Diagonal combinations (letters ending in 'a': Aa, Ba, Aaa, …)
-                // use the pure dlsdl mantissa α = 2·5^f ∈ [2, 10) — but only
-                // when the diagonal letter IS the value's canonical letter
-                // (single-type display).  Inside a cascade the α is the inner
-                // value's own mantissa and keeps the ordinary [1,10) form
-                // (AbAa600 → Ab1.000Aa600).
-                let diagMant = function (tok) {
-                    if (collapseCount > 0) return alphaStr
-                    if (descHeights.length > 1) return alphaStr
-                    if (!(tok.letter.length >= 2 && tok.letter[tok.letter.length - 1] === "a")) return alphaStr
-                    return regularFormat(2 * Math.pow(5, frac), precision4)
+
+                // (2) the inner (second) level carries the single α and β
+                let lowTok = letterTokenOf(hLow)
+                let innerStr
+                if (cLow >= collapseAt) {
+                    innerStr = collapseStr(hLow, cLow)
+                } else {
+                    let aStr = regularFormat(r0Alpha, precision4)
+                    innerStr = lowTok.letter.repeat(Math.max(cLow - 1, 0)) + aStr + lowTok.letter +
+                               formatR0Arg(Math.floor(base), precision4)
                 }
 
-                // (3) compose: descending order (highest first = outermost)
-                let descHeights = heights.slice().reverse()
-                let topTok = letterTokenOf(descHeights[0])
+                // (3) the top level leads: collapse when it repeats enough, else
+                //     one token per application (or the symbol-carried !αAaβ)
+                if (cTop >= collapseAt) return collapseStr(hTop, cTop)
+                let topTok = letterTokenOf(hTop)
                 if (topTok.sym) {
-                    // the top level needs the symbol notation — it dwarfs every
-                    // lower level, so the display is the single !αAaβ form
-                    return emitLetterToken(topTok, alphaStr, betaStr, precision4)
-                }
-                let outerLetters = topTok.letter.repeat(
-                    Math.min(letterCounts[descHeights[0]] || 1, effTh))
-                if (descHeights.length >= 2) {
-                    let loH = descHeights[1]
-                    let loTok = letterTokenOf(loH)
-                    let loCnt = letterCounts[loH] || 1
-                    if (loCnt > 1) {
-                        outerLetters += loTok.letter.repeat(Math.min(loCnt - 1, effTh))
+                    // multiLetterLimit carry: !αAaβ, β = the ω-exponent; the
+                    // inner level only survives when it collapses on its own
+                    if (cLow >= collapseAt) {
+                        return topTok.sym + regularFormat(topTok.mant, precision4) +
+                               topTok.letter + collapseStr(hLow, cLow)
                     }
-                    return outerLetters + diagMant(loTok) + loTok.letter + betaStr
+                    return topTok.sym + regularFormat(topTok.mant, precision4) +
+                           topTok.letter + formatR0Arg(topTok.arg, precision4)
                 }
-                return diagMant(topTok) + topTok.letter + betaStr
+                return topTok.letter.repeat(Math.min(cTop, effTh)) + innerStr
             }
         }
     }