metanum 2.0.0 → 2.0.2

package/metanum.js

@@ -2063,9 +2063,21 @@
           if (other.eq(MetaNum.ONE)) return self.clone();
           if (frac.eq(MetaNum.ZERO)) return self.arrow(nLev)(other);
           var target = self.arrow(nLev)(other);
-          var theta0 = target.hyper_log(self)(nLev.add(MetaNum.ONE));
+          var lev1 = nLev.add(MetaNum.ONE);
+          var theta0 = hyperAnchorReal(self, lev1, target);
+          if (theta0 === null) theta0 = target.hyper_log(self)(lev1);
+          if (theta0.isNaN() || !(theta0.gt(MetaNum.ZERO))) theta0 = MetaNum.ONE.clone();
           var theta = theta0.mul(other.div(theta0).pow(frac));
-          return self.arrow(nLev.add(MetaNum.ONE))(theta);
+          var res = self.arrow(lev1)(theta);
+          if (hasFractionOutsideR00(res)) {
+            // levels that diagonalize into ordinal rows would keep the
+            // interpolated argument as a fractional row count — fall back to the
+            // integer argument so the "only array[0][0] is fractional" contract
+            // holds (floor is exact again at f = 1, where θ = y)
+            var ti = Math.max(1, Math.floor(theta.toNumber()));
+            if (isFinite(ti)) res = self.arrow(lev1)(new MetaNum(ti));
+          }
+          return res;
         };
       }
       return function () { return MetaNum.NaN.clone(); };
@@ -2393,6 +2405,29 @@
     return hi;
   }
 
+  // Continuous inverse used as the interpolation ANCHOR of a fractional level:
+  // the real c with a{b}c = d, searched by bisection on doubles (arrow()
+  // evaluates fractional arguments).  hyperBisect only searches integers and
+  // therefore overshoots (θ0 = 2 where the true value is 1.0414), which makes
+  // the geometric interpolation θ = θ0·(y/θ0)^f run BACKWARDS (y/θ0 < 1) and
+  // breaks the monotonicity of x{y}y — arrow(10,1.5,1.5) came out smaller than
+  // arrow(10,1.1,1.1).  Returns null when d cannot be bracketed.
+  function hyperAnchorReal(a, b, d) {
+    try {
+      var lo = 0, hi = 1, it = 0;
+      while (it++ < 60 && a.arrow(b)(new MetaNum(hi)).lt(d)) { lo = hi; hi = hi * 2; }
+      if (!isFinite(hi) || hi > 1e15) return null;
+      for (var k = 0; k < 80; k++) {
+        var mid = (lo + hi) / 2;
+        if (a.arrow(b)(new MetaNum(mid)).lt(d)) lo = mid; else hi = mid;
+      }
+      var r = new MetaNum((lo + hi) / 2);
+      return r.isNaN() ? null : r;
+    } catch (e) {
+      return null;
+    }
+  }
+
   P.hyper_log = function (a) {
     var d = this.clone();
     a = new MetaNum(a);
@@ -2814,6 +2849,22 @@
     for (var j = 0; j < keep.length; j++) arr.push(keep[j]);
   }
 
+  // Layer marker WITHOUT the standard-form rewrites.  hardy's tower rule needs
+  // the layer to track the input's 10^ levels one-for-one — the standard
+  // de-layer ((b) above) would fold a finite-bracket marker (e.g. the
+  // layer-2 [[3086.036,9×8]] of eee10) down one layer and change the number
+  // the rule is about.  Same shape as _layerMarker, minus the rewrites.
+  Q._rawLayerMarker = function (r0, layer, rows) {
+    var v = new MetaNum(0);
+    v.sign = 1;
+    v.layer = layer > 0 ? layer : 0;
+    v.array = [(r0 && r0.length) ? r0.slice() : [0]];
+    for (var i = 0; i < (rows ? rows.length : 0); i++) {
+      if (rows[i] && rows[i].length > 1) v.array.push(rows[i].slice());
+    }
+    return v;
+  };
+
   Q._standardizeLayerValue = function (v) {
     if (!v || v.layer < 1) return v.normalize();
     var L = v.layer;
@@ -2895,12 +2946,16 @@
     var V = V0.clone();
     var i = 0;
     var guard = 0;
-    while (i < iters) {
-      if (++guard > 200) return Q._applyOrdinalRows(V, beta, iters - i);
+    // a fractional argument (yCnt - 1) still means a whole number of
+    // applications, and the rows must carry INTEGER counts — ceil keeps the
+    // step consistent with the expanded path (count = ceil(y)-2)
+    var total = Math.ceil(iters);
+    while (i < total) {
+      if (++guard > 200) return Q._applyOrdinalRows(V, beta, total - i);
       var vCnt = metaFiniteCount(V);
       if (!(vCnt <= MAX_SAFE_INTEGER)) {
         // V is huge: every further application adds one β-row → fast-forward
-        return Q._applyOrdinalRows(V, beta, iters - i);
+        return Q._applyOrdinalRows(V, beta, total - i);
       }
       V = Q._ordinalHyperop(x, V, beta, (depth || 0) + 1);
       i++;
@@ -2916,7 +2971,7 @@
   //     enumeration representation (one row per ordinal below α, count = y-2)
   //   - everything else (any operand beyond MSI, x = 2, or enumeration too large):
   //     unified ordinal engine (README rules 1-4)
-  Q._hyperopFromOrdinalRaw = function (x, y, coeffs) {
+  Q._hyperopFromOrdinalRaw = function (x, y, coeffs, skipFrac) {
     x = new MetaNum(x);
     y = new MetaNum(y);
     if (x.isNaN() || y.isNaN()) return MetaNum.NaN.clone();
@@ -2924,8 +2979,29 @@
     if (y.lte(MetaNum.ZERO)) return MetaNum.NaN.clone();
     if (x.eq(MetaNum.ONE)) return MetaNum.ONE.clone();
     if (y.eq(MetaNum.ONE)) return x.clone();
+
     var cf0 = trimCoeffs((coeffs || []).slice());
     if (cf0.length === 0) return x.mul(y); // rule 1: x{0}y = x*y
+    // Fractional level coefficients come from a fundamental sequence taken at a
+    // non-integer index.  On the diagonal ω = x, so ω^(k)·(c+f) = ω^(k)·c +
+    // ω^(k-1)·(x·f) — resolve top-down until only the constant term can still be
+    // fractional, then turn that leftover into a fractional argument one level
+    // higher:  x{γ+f}x = x{γ+1}(2·(x/2)^f)   (README: 10{ω*2}2.1 = 10{ω+2.1}10 =
+    // 10{ω+3}2·5^0.1; continuous at f=0 since x{γ+1}2 = x{γ}x).
+    if (coeffsHaveFraction(cf0)) {
+      var xnf = x.toNumber();
+      if (isFinite(xnf) && xnf >= 2) {
+        var rs = Q._resolveFracLevel(cf0, xnf);
+        if (rs.frac > 0) {
+          var up = rs.ord.slice();
+          while (up.length < 1) up.push(0);
+          up[0] = (up[0] || 0) + 1;
+          var argF = 2 * Math.pow(xnf / 2, rs.frac);
+          return Q._hyperopFromOrdinal(x, new MetaNum(argF), trimCoeffs(up));
+        }
+        cf0 = rs.ord;
+      }
+    }
     // Non-integer argument at ordinal levels (issues.md addition 3):
     //   successor level α (c0 > 0):  x{α}(m+f) = x{α-1} applied m times to x^f
     //     (e.g. expa(10,2.1) = 10{ω+1}2.1 = 10{ω}10{ω}(10^0.1); continuous at
@@ -2944,13 +3020,32 @@
       // exactly and composition identities stay stable across paths
       var yf = new MetaNum(Number((yFracNum - ym).toPrecision(15)));
       if ((cf0[0] || 0) > 0) {
+        var xnfS = x.toNumber();
+        var xOkS = isFinite(xnfS) && xnfS >= 3 && xnfS <= MAX_SAFE_INTEGER;
+        // α-1 ≥ ω*2 only: for the ω+1/ω+2/ω+3 levels the applications after the
+        // first still have an operand inside MSI, so the engine evaluates them by
+        // the definition (10{ω}(10{ω}(10^0.1))) and that identity is exact.
+        var pred = succCoeffs(cf0);
+        var bigLevel = (pred[1] || 0) >= 2;
+        for (var bi = 2; bi < pred.length; bi++) if ((pred[bi] || 0) > 0) bigLevel = true;
+        if (xOkS && bigLevel && ym <= 100000) {
+          // successor rule written in the EXPANDED form (the same generator the
+          // integer arguments use): the α-1 row carries the m applications as an
+          // integer count ceil(y)-2 = m-1, and the fraction lives in the cascade
+          // depth — the first fundamental sequence is taken at the fractional
+          // start value x^f (x{α}(m+f) = x{α-1}^m(x^f) — exactly what the finite
+          // levels do: 10{3}2.1 starts from 10^0.1).  Whatever fraction is left
+          // over lands in the base, i.e. in array[0][0].
+          return Q._expandedHyperop(x, new MetaNum(ym + 1), cf0,
+            Math.pow(xnfS, Number((yFracNum - ym).toPrecision(15))));
+        }
         if (ym <= 100000) {
           // successor rule: x{α}(m+f) = x{α-1} applied m times to x^f
           var succ = cf0.slice();
           succ[0] = succ[0] - 1;
           succ = trimCoeffs(succ);
           var v = x.pow(yf);
-          for (var it = 0; it < ym; it++) v = Q._hyperopFromOrdinalRaw(x, v, succ);
+          for (var it = 0; it < ym; it++) v = Q._hyperopFromOrdinalRaw(x, v, succ, true);
           return v;
         }
         // Successor level with an iteration count beyond direct evaluation:
@@ -2959,9 +3054,16 @@
         return Q._ordinalHyperop(x, y, cf0);
       }
       if (ym >= 1) {
-        // limit level: fundamental sequence at m = floor(y); rule 3 puts the
-        // base x as the final operand: x{λ}y = x{λ[m]}x
-        return Q._hyperopFromOrdinalRaw(x, x, fsCoeffs(cf0, ym));
+        // limit level: rule 3 with the FULL (fractional) index — x{λ}y =
+        // x{λ[y]}x.  λ[y] can carry fractional coefficients (10{ω*2}2.1 =
+        // 10{ω+2.1}10), which the fractional-level rule above resolves, so the
+        // fraction of y is never thrown away (flooring it would make
+        // h20(10,2.1) = h20(10,2)).
+        // Nested (skipFrac: the successor rule is already iterating a fractional
+        // start value) the index is floored — otherwise every application would
+        // take another fractional fundamental sequence and recurse forever.
+        var fsIdx = skipFrac ? Math.floor(yFracNum) : yFracNum;
+        return Q._hyperopFromOrdinalRaw(x, x, fsCoeffs(cf0, fsIdx), skipFrac);
       }
     }
     var cf = cf0;
@@ -2970,9 +3072,11 @@
     if (deg >= 1 && x.array.length === 1 && x.layer === 0
         && y.array.length === 1 && y.layer === 0) {
       var xC = metaFiniteCount(x), yC = metaFiniteCount(y);
-      if (xC >= 3 && xC <= MAX_SAFE_INTEGER && yC >= 3 && yC <= MAX_SAFE_INTEGER
-          && Math.pow(yC, deg) <= MetaNum.maxRows) {
-        return Q._enumHyperop(x, y, cf);
+      // Finite operands in [3, MSI] always take the EXPANDED cascade form — a
+      // limit operation keeps its fundamental-sequence rows all the way up to
+      // MSI (100 < y ≤ MSI included), truncated to the largest maxRows-1 rows.
+      if (xC >= 3 && xC <= MAX_SAFE_INTEGER && yC >= 3 && yC <= MAX_SAFE_INTEGER) {
+        return Q._expandedHyperop(x, y, cf);
       }
     }
     return Q._ordinalHyperop(x, y, cf);
@@ -2992,214 +3096,175 @@
     return r;
   };
 
-  // Legacy (HEAD-compatible) enumeration-based hyperoperation for small operands.
-  Q._enumHyperop = function (x, y, coeffs) {
-    var xNum = x.toNumber();
-    var yNum = y.toNumber();
-    var maxRows = MetaNum.maxRows; // 100
-    var baseArrowLevel = Math.max(Math.floor(isFinite(xNum) ? xNum : 3), 3);
-    var baseResult = x.arrow(baseArrowLevel)(x);
-    var rows = Q._generateOrdinalRows(coeffs,
-      isFinite(xNum) ? Math.floor(xNum) : baseArrowLevel,
-      isFinite(yNum) ? Math.floor(yNum) : baseArrowLevel,
-      maxRows);
+  // ---------------------------------------------------------------------------
+  // Expanded (cascade) form of x{α}y for FINITE operands in [3, MSI] — README
+  // rules 1-4 written out row by row.  The rows are generated TOP-DOWN so a
+  // huge fundamental sequence (y up to MSI) costs nothing: generation stops as
+  // soon as the array budget is filled, keeping the LARGEST rows.
+  //
+  //   successor α = β + m  (m = c0 > 0):  x{α}y = x{β+m-1}^(y-2)(x{β+m-1}x),
+  //     so the row at β+m-1 carries y-2 applications and every row below it
+  //     (β+m-2 … β, then the cascade of β) comes from decomposing with the
+  //     BASE x as operand and therefore carries x-2 (h13(10,20) → [8,0,1],
+  //     [8,1,1], [18,2,1] — only the top row follows y).
+  //   limit α (c0 = 0): rule 3 gives x{α}opd = x{α[opd]}x, so the operand turns
+  //     into the base x and every row carries x-2 — including for 100 < y ≤ MSI
+  //     (h20(10,1000) stays an expanded cascade, not a one-row marker).
+  // ---------------------------------------------------------------------------
+  // Only array[0][0] (the base's value slot) may ever be non-integer — the same
+  // contract as arrow(): every row count and every row coefficient is an integer.
+  // A fractional argument therefore enters in two integer-safe places:
+  //   - the outer count is `yn - 2` with yn = ceil(y) (an integer);
+  //   - the rest of the fraction sits in the CASCADE DEPTH: the first
+  //     fundamental sequence is taken at the fractional start value x^f
+  //     (x{α}(m+f) = x{α-1}^m(x^f)), and any fractional constant term left over
+  //     is carried into the base's finite level index (x{10.16}x), so it ends up
+  //     as the fractional array[0][0] exactly like arrow() does.
+  // `fsOpd` is that fractional start value; `.baseIdx` returns the base index.
+  Q._cascadeRows = function (xn, cf, yn, budget, fsOpd) {
+    var rows = [];
+    if (!(budget >= 1)) return rows;
+    var cfs = trimCoeffs((cf || []).slice());
+    var opd = Math.min(yn, MAX_SAFE_INTEGER);
+    var first = (cfs[0] || 0) > 0;      // successor: the outer count is y-2
+    var fracOpd = (fsOpd === undefined) ? null : fsOpd;
+    var baseIdx = xn;
+    var fracRem = 0;                    // fractional constant carried to the base
+    var guard = 0;
+    while (rows.length < budget && guard++ < 10000) {
+      if (!coeffsHaveOmegaPart(cfs)) break;             // finite level: no row
+      if ((cfs[0] || 0) > 0) {
+        var mRaw = cfs[0];
+        var m = Math.floor(mRaw);
+        // a fractional constant term is not a valid CNF coefficient: keep the
+        // integer part as rows and carry the remainder to the base
+        var mFr = Number((mRaw - m).toPrecision(15));
+        if (mFr > 1e-9) fracRem = mFr;
+        var beta = trimCoeffs(cfs.slice());
+        beta[0] = 0;
+        beta = trimCoeffs(beta);
+        var steps = Math.min(m, budget - rows.length + 1);
+        for (var s = 0; s < steps; s++) {
+          var j = m - 1 - s;                            // rows β+m-1 … β
+          var cnt = (first ? opd : xn) - 2;
+          first = false;
+          if (cnt < 1) continue;                        // no application to record
+          if (cnt > MAX_SAFE_INTEGER) cnt = MAX_SAFE_INTEGER;
+          var ord = beta.slice();
+          if (j > 0) ord[0] = (ord[0] || 0) + j;        // β + j
+          ord = trimCoeffs(ord);
+          if (!coeffsHaveOmegaPart(ord)) continue;      // finite: lives in r0
+          var row = [snapInt(cnt)];
+          for (var oi = 0; oi < ord.length; oi++) row.push(snapInt(ord[oi]));
+          rows.push(row);
+        }
+        cfs = beta;                                     // continue below β
+        opd = Math.min(xn, MAX_SAFE_INTEGER);           // everything below the top
+        continue;                                       // row is base-operand
+      }
+      // limit: fundamental sequence at the current operand (rule 3)
+      var idx = (fracOpd !== null) ? fracOpd : opd;
+      fracOpd = null;
+      baseIdx = idx;
+      var nxt = fsCoeffs(cfs, idx);
+      if (coeffsHaveFraction(nxt)) {
+        // a fractional index makes the coefficients fractional (ω^k·(c+f)) —
+        // resolve them against the base so every row coefficient stays an
+        // integer, carrying the leftover constant fraction into the base
+        var rs2 = Q._resolveFracLevel(nxt, xn);
+        cfs = rs2.ord;
+        if (rs2.frac > 0) fracRem = rs2.frac;
+      } else {
+        cfs = trimCoeffs(nxt);
+      }
+      opd = Math.min(xn, MAX_SAFE_INTEGER);             // operand becomes x
+    }
+    rows.baseIdx = baseIdx + fracRem;                   // descending by ordinal
+    return rows;
+  };
+
+  Q._expandedHyperop = function (x, y, cf, fsOpd) {
+    var maxRows = MetaNum.maxRows;
+    var xn = Math.floor(metaFiniteCount(x));
+    // ceil: the outer count must stay an integer (only array[0][0] may be
+    // fractional), so the m applications of x{α}(m+f) give ceil(y)-2 = m-1
+    var yn = Math.ceil(metaFiniteCount(y));
+    var budget = maxRows - 1;                           // ordinal rows the array holds
+    var desc = Q._cascadeRows(xn, cf, yn, budget + 1, fsOpd); // +1 detects truncation
+    var truncated = desc.length > budget;
+    if (truncated) desc = desc.slice(0, budget);   // keep the LARGEST rows
+    var rows = desc.reverse();                          // ascending
+    // base r0 = x{idx}x (rule 3 at the ω level: x{ω}x = x{x}x) — the finite part;
+    // idx is the operand of the descent that bottoms out, i.e. the fractional
+    // start value x^f when the cascade came from the fractional successor rule
+    var baseIdx = (desc.baseIdx === undefined) ? xn : desc.baseIdx;
+    // arrow() evaluates fractional levels too (10{10.2589}10 ≠ 10{10}10), so the
+    // carried fraction survives into the base
+    var baseResult = x.arrow(Math.max(baseIdx, 3))(x);
     var result = baseResult.clone();
-    var maxOrdinalRows = maxRows - 1;
-    if (rows.length > maxOrdinalRows) {
-      // Truncation: keep the largest maxOrdinalRows rows (rows ascend), the
-      // base defaults to [10] and the first kept row's count marks it with +1
-      rows = rows.slice(rows.length - maxOrdinalRows);
+    if (truncated) {
       result.array = [[10]];
-      rows[0][0] = (rows[0][0] || 0) + 1;
+      rows[0][0] = (rows[0][0] || 0) + 1;               // truncation marker
       if (rows[0][0] > MAX_SAFE_INTEGER) rows[0][0] = MAX_SAFE_INTEGER;
     } else {
       result.array = [baseResult.array[0].slice()];
     }
     for (var i = 0; i < rows.length; i++) result.array.push(rows[i]);
-    if (result.array.length > 1) result.layer = 0;
-    return result;
+    result.layer = 0;
+    return result.normalize();
   };
 
-  // Legacy (HEAD-compatible) ordinal row enumeration: one row per ordinal below
-  // `coeffs` (coefficients bounded by `cardinal`), each with count = cardinal-2.
-  Q._generateOrdinalRows = function (coeffs, base, cardinal, maxRows) {
-    var rows = [];
-    var m = base;
-    var n = cardinal;
-
-    function compareOrd(a, b) {
-      var maxLen = Math.max(a.length, b.length);
-      for (var i = maxLen - 1; i >= 0; i--) {
-        var va = (i < a.length) ? (a[i] || 0) : 0;
-        var vb = (i < b.length) ? (b[i] || 0) : 0;
-        if (va < vb) return -1;
-        if (va > vb) return 1;
-      }
-      return 0;
-    }
-
-    function addOrd(a, b) {
-      if (!b || b.length === 0 || (b.length === 1 && b[0] === 0)) return a.slice();
-      if (!a || a.length === 0 || (a.length === 1 && a[0] === 0)) return b.slice();
-      var result = a.slice();
-      var k = 0;
-      while (k < result.length && (result[k] || 0) === 0) k++;
-      if (k >= result.length) {
-        return b.slice();
-      } else if (k === 0) {
-        result[0] = (result[0] || 0) + (b[0] || 0);
-        for (var i = 1; i < b.length; i++) {
-          result[i] = (result[i] || 0) + (b[i] || 0);
-        }
-      } else {
-        result[k] = 0;
-        result = result.slice(0, k);
-        for (var i = 0; i < b.length; i++) {
-          result.push(b[i] || 0);
-        }
-      }
-      while (result.length > 0 && result[result.length - 1] === 0) result.pop();
-      return result;
-    }
-
-    function isZero(ord) {
-      if (!ord || ord.length === 0) return true;
-      for (var i = 0; i < ord.length; i++) {
-        if ((ord[i] || 0) !== 0) return false;
-      }
-      return true;
-    }
-
-    function buildRow(ord, count) {
-      var maxIdx = ord.length - 1;
-      while (maxIdx >= 0 && (ord[maxIdx] || 0) === 0) maxIdx--;
-      if (maxIdx < 0) return null;
-      var row = [count];
-      for (var i = 0; i <= maxIdx - 1; i++) row.push(ord[i] || 0);
-      row.push(ord[maxIdx]);
-      return row;
-    }
+  // Floating-point residue: 2.1e-12 left where the exact value is an integer.
+  // Only array[0][0] may be fractional, so snap everything else.
+  function snapInt(v) {
+    if (!isFinite(v)) return v;
+    var r = Math.round(v);
+    return Math.abs(v - r) < 1e-9 ? r : v;
+  }
 
-    // Enumerate all ordinals below ω^k with coefficients < n
-    function enumBelowOmegaK(k, n) {
-      if (k === 0) {
-        return [[0]];
-      }
-      if (k === 1) {
-        var result = [];
-        for (var i = 0; i < n; i++) {
-          result.push([i]);
-        }
-        return result;
-      }
-      var result = [];
-      for (var a = 0; a < n; a++) {
-        var sub = enumBelowOmegaK(k - 1, n);
-        for (var i = 0; i < sub.length; i++) {
-          var combined = sub[i].slice();
-          while (combined.length < k) combined.push(0);
-          combined[k - 1] = a;
-          result.push(combined);
-        }
+  // Does any entry outside array[0][0] carry a fractional part?
+  function hasFractionOutsideR00(v) {
+    if (!v || !v.array) return false;
+    for (var i = 0; i < v.array.length; i++) {
+      var row = v.array[i];
+      for (var j = 0; j < row.length; j++) {
+        if (i === 0 && j === 0) continue;
+        var c = row[j];
+        if (typeof c === "number" && isFinite(c) && c !== Math.floor(c)) return true;
       }
-      return result;
     }
+    return false;
+  }
 
-    // Enumerate all ordinals below a given ordinal
-    function enumBelow(alpha, n) {
-      if (isZero(alpha)) return [];
-
-      if ((alpha[0] || 0) > 0) {
-        var pred = alpha.slice();
-        pred[0]--;
-        while (pred.length > 0 && pred[pred.length - 1] === 0) pred.pop();
-        if (pred.length === 0) pred = [0];
-        var result = enumBelow(pred, n);
-        result.push(pred.slice());
-        return result;
-      }
-
-      var k = alpha.length - 1;
-      while (k >= 0 && (alpha[k] || 0) === 0) k--;
-      if (k < 0) return [];
-
-      var ck = alpha[k] || 0;
-      var rest = alpha.slice(0, k);
-      while (rest.length > 0 && rest[rest.length - 1] === 0) rest.pop();
-
-      var result = [];
-
-      for (var j = 0; j < ck; j++) {
-        var sub = enumBelowOmegaK(k, n);
-        for (var i = 0; i < sub.length; i++) {
-          var combined = sub[i].slice();
-          while (combined.length <= k) combined.push(0);
-          combined[k] = j;
-          result.push(combined);
-        }
-      }
-
-      if (!isZero(rest)) {
-        var restSub = enumBelow(rest, n);
-        for (var i = 0; i < restSub.length; i++) {
-          var combined = restSub[i].slice();
-          while (combined.length <= k) combined.push(0);
-          combined[k] = ck;
-          result.push(combined);
-        }
-      }
-
-      return result;
+  // Any coefficient with a non-zero fractional part?
+  function coeffsHaveFraction(coeffs) {
+    for (var i = 0; i < coeffs.length; i++) {
+      var c = coeffs[i] || 0;
+      if (c !== Math.floor(c)) return true;
     }
+    return false;
+  }
 
-    var count = n - 2;
-    if (count < 1) return rows;
-
-    var allOrdinals = enumBelow(coeffs, n);
-
-    var seen = {};
-    var uniqueOrdinals = [];
-    for (var i = 0; i < allOrdinals.length; i++) {
-      var ord = allOrdinals[i];
-      if (isZero(ord)) continue;
-
-      // Normalize: remove trailing zeros
-      var normalized = ord.slice();
-      while (normalized.length > 0 && normalized[normalized.length - 1] === 0) {
-        normalized.pop();
+  // Resolve fractional CNF coefficients against the base x (see the comment in
+  // _hyperopFromOrdinalRaw): ω^(k)·(c+f) = ω^(k)·c + ω^(k-1)·(x·f) top-down.
+  // Returns the integer level plus the fractional part left in the constant term.
+  Q._resolveFracLevel = function (cf, xn) {
+    var r = trimCoeffs((cf || []).slice());
+    for (var k = r.length - 1; k >= 1; k--) {
+      var c = r[k] || 0;
+      var fl = Math.floor(c);
+      var fr = Number((c - fl).toPrecision(15));
+      if (fr > 1e-9) {
+        r[k] = fl;
+        r[k - 1] = (r[k - 1] || 0) + xn * fr;
       }
-
-      // Skip ordinals below ω (finite ordinals: only constant term, length <= 1)
-      if (normalized.length <= 1) continue;
-
-      var key = normalized.join(',');
-      if (seen[key]) continue;
-      seen[key] = true;
-      uniqueOrdinals.push(normalized);
-    }
-
-    uniqueOrdinals.sort(function (a, b) {
-      return compareOrd(a, b);
-    });
-
-    var allRows = [];
-    for (var i = 0; i < uniqueOrdinals.length; i++) {
-      var row = buildRow(uniqueOrdinals[i], count);
-      if (row) allRows.push(row);
     }
-
-    // When enumerating more rows than fit, keep the largest maxRows-1
-    // ordinals (rows are sorted ascending, so drop from the front)
-    if (allRows.length > maxRows - 1) {
-      var maxOrdinalRows = maxRows - 1;
-      allRows = allRows.slice(allRows.length - maxOrdinalRows);
-    }
-
-    for (var i = 0; i < allRows.length; i++) {
-      rows.push(allRows[i]);
-    }
-
-    return rows;
+    var c0 = r[0] || 0;
+    var fl0 = Math.floor(c0);
+    var fr0 = Number((c0 - fl0).toPrecision(15));
+    if (!(fr0 > 1e-9)) fr0 = 0;
+    r[0] = fl0;
+    return { ord: trimCoeffs(r), frac: fr0 };
   };
 
   // Helper: number of leading iterate applications (of level `beta`) starting
@@ -3217,6 +3282,26 @@
     return steps + 1;
   }
 
+  // Inverse of a LIMIT level taken through the expanded cascade: x{λ}y = x{λ[y]}x
+  // makes every row depend on y only through the fundamental sequence, so instead
+  // of reading a count row we search the (monotone) forward map.
+  Q._invExpandedLimit = function (base, value, coeffs) {
+    var lo = 3, hi = MAX_SAFE_INTEGER, best = 0;
+    var v3 = Q._expandedHyperop(base, new MetaNum(3), coeffs);
+    if (value.lt(v3)) return base.clone();
+    while (lo <= hi) {
+      var mid = lo + Math.floor((hi - lo) / 2);
+      if (Q._expandedHyperop(base, new MetaNum(mid), coeffs).lte(value)) {
+        best = mid; lo = mid + 1;
+      } else {
+        hi = mid - 1;
+      }
+    }
+    if (best === 0) return base.clone();
+    var vb = Q._expandedHyperop(base, new MetaNum(best), coeffs);
+    return vb.eq(value) ? new MetaNum(best) : base.clone();
+  };
+
   // Helper: generic inverse hyperoperation from ordinal level.
   // Forward paths and the rows they leave:
   //   - small x ∈ [3, MSI] & small y (enumeration path): rows for each ordinal
@@ -3249,14 +3334,29 @@
     }
     if (cf.length === 0) return z;
 
-    // enumeration path (base z is a small finite number ≥ 3): top row count = y-2
+    // expanded cascade path (base z is a small finite number ≥ 3): the forward
+    // operation wrote the rule-1..4 cascade rows.
+    //   successor α: the row at α-1 carries exactly y-2 applications → +2
+    //   limit α: every row carries x-2 and y only appears inside the
+    //     fundamental-sequence rows, so it is recovered from the forward map
     var zC = metaFiniteCount(z);
     if (z.array.length === 1 && z.layer === 0 && zC >= 3 && zC <= MAX_SAFE_INTEGER) {
-      var lastRow = x.array[x.array.length - 1];
-      if (lastRow && lastRow.length >= 2 && (lastRow[0] || 0) > 0) {
-        return new MetaNum((lastRow[0] || 0) + 2);
+      if ((cf[0] || 0) > 0) {
+        var pred = succCoeffs(cf);
+        var predRow = null;
+        for (var pi = x.array.length - 1; pi >= 1; pi--) {
+          var prow = x.array[pi];
+          if (prow && prow.length >= 2 && (prow[0] || 0) > 0 &&
+              cmpCoeffsLevel(rowToCoeffs(prow), pred) === 0) { predRow = prow; break; }
+        }
+        if (predRow) return new MetaNum((predRow[0] || 0) + 2);
+        var lastRow = x.array[x.array.length - 1];
+        if (lastRow && lastRow.length >= 2 && (lastRow[0] || 0) > 0) {
+          return new MetaNum((lastRow[0] || 0) + 2);
+        }
+        return z;
       }
-      return z;
+      return Q._invExpandedLimit(z, x, cf);
     }
 
     // engine path: count row [c | β] with β = α-1 (successor α only)
@@ -3636,8 +3736,32 @@
       return Q._layerMarker([10], 1, [[1, m]]);
     }
     if (yc <= MAX_SAFE_INTEGER) {
-      // fractional y: rule 3 takes the fundamental sequence at floor(y)
-      return P.iterate.call(x, new MetaNum(Math.max(2, Math.floor(yc))));
+      // fractional y: (ω^ω)[y] = ω^y = ω^(m+f) = ω^m·ω^f, and on the diagonal
+      // ω^f reads as x^f — so the level is ω^m·(x^f), whose coefficients carry
+      // x^f at index m (README: 10{ω^ω}2.1 = 10{ω^2.1}10 = 10{ω^2*10^0.1}10).
+      // Flooring y would lose the fraction and make iterate(10,2.1)=iterate(10,2).
+      var mf = Math.max(2, Math.floor(yc));
+      var ff = Number((yc - Math.floor(yc)).toPrecision(15));
+      var xnf = x.toNumber();
+      var cfac = (isFinite(xnf) && xnf >= 2 && ff > 0) ? Math.pow(xnf, ff) : 1;
+      if (mf < MetaNum.maxCols) {
+        var cfw = [];
+        for (var cw = 0; cw < mf; cw++) cfw.push(0);
+        cfw.push(cfac);
+        return Q._hyperopFromOrdinal(x, x, cfw);
+      }
+      // marker form: ω^m·(x^f) — the count must stay an integer, so write the
+      // fractional part out one level down: ω^m·floor(c) + ω^(m-1)·(x·frac),
+      // the same resolution the CNF levels use
+      if (mf >= MetaNum.maxCols) {
+        var cfFl = Math.floor(cfac), cfFr = cfac - cfFl;
+        var mkRows = [];
+        if (cfFl >= 1) mkRows.push([cfFl, mf]);
+        if (cfFr > 1e-9 && mf >= 2) mkRows.push([Math.max(1, Math.round(xnf * cfFr)), mf - 1]);
+        if (mkRows.length === 0) mkRows.push([1, mf]);
+        return Q._layerMarker([10], 1, mkRows);
+      }
+      return Q._layerMarker([10], 1, [[cfac, mf]]);
     }
     // ordinal / out-of-range operand: y plus one ω^ω marker row
     return Q._ordinalOperandOp(y, 1, [1, 0, 1]);
@@ -4088,7 +4212,13 @@
     if (yc <= MAX_SAFE_INTEGER) {
       var m = Math.max(2, Math.floor(yc));
       if (m > MAX_SAFE_INTEGER) m = MAX_SAFE_INTEGER;
-      return Q._layerMarker([10], m, [[1, 1]]);
+      // v2.0.2: a fractional height (hardy of anything between 10^^m and
+      // 10^^(m+1)) interpolates through the base argument 10+f instead of being
+      // flat across the whole range — and only array[0][0] stays fractional
+      var marker = Q._layerMarker([10], m, [[1, 1]]);
+      var mf = Number((yc - Math.floor(yc)).toPrecision(15));
+      if (isFinite(mf) && mf > 0) marker.array[0][0] = 10 + mf;  // stays in array[0][0]
+      return marker;
     }
     // ordinal / out-of-range operand: ε₀ caps the library → the MSI ω-tower
     return Q._layerMarker([10], MAX_SAFE_INTEGER, [[1, 1]]);
@@ -4907,6 +5037,24 @@
       return x;
     }
 
+    // v2.0.2: "1e10+0.5" / "1e10+11" / "1e16+1e13" — the digit paths (hardy)
+    // need the exact decimal value and the plain float parse reads 0 here.
+    // Split the sum and add the parts exactly; the '+' must not be the e+
+    // exponent marker ("1e+21" keeps its old parsing).
+    if (s.indexOf('+') > 0) {
+      var sumParts = s.split('+');
+      if (sumParts.length === 2 && sumParts[0] !== '' && sumParts[1] !== '' &&
+          !/[eE]$/.test(sumParts[0]) && !/[eE]$/.test(sumParts[1])) {
+        var sumA = Q.fromString(sumParts[0].trim());
+        var sumB = Q.fromString(sumParts[1].trim());
+        if (!sumA.isNaN() && !sumB.isNaN()) {
+          var sumV = sumA.add(sumB);
+          if (negateIt) sumV.sign = -sumV.sign;
+          return sumV;
+        }
+      }
+    }
+
     var layerMatch = s.match(/^\u03C9\^(\d+)\s*/);
     if (layerMatch) {
       x.layer = parseInt(layerMatch[1], 10);
@@ -5777,6 +5925,19 @@
         n = nWf;
         continue;
       }
+      if (j >= c.length) return n;       // no positive term left (safety net)
+      // A coefficient can turn FRACTIONAL because the fundamental-sequence step
+      // writes the running base n — and n is 10+f for a fractional hardy input
+      // (hardy(1000.5)).  For 0 < c_j < 1 the "-1" step would go negative and
+      // leave no positive term at all, so take the PARTIAL step instead:
+      //   ω^j·f contributes ω^(j-1)·(n·f)   (continuous — f→1 is the full
+      //   ω^(j-1)·n step of the integer recursion, f→0 contributes nothing)
+      var cjN = c[j].toNumber();
+      if (isFinite(cjN) && cjN > 0 && cjN < 1 && j >= 2) {
+        c[j] = MetaNum.ZERO.clone();
+        c[j - 1] = n.mul(new MetaNum(Number(cjN.toPrecision(15))));
+        continue;
+      }
       if (c[j].gt(HARDY_EXACT_BOUND)) {                    // engine collapse
         // H_{β + ω^j·c}(n) ≈ H_β(2{c}j) — evaluate with the OLD c[j]
         var nCol = new MetaNum(2).arrow(j)(c[j]);
@@ -5795,11 +5956,124 @@
     return n;
   };
 
+  // H_{ω^k}(n) for the from-below base of hardy (n ≥ 1e10).
+  //   The exact expansion writes a tower of level k-1 — H_{ω^10}(10) =
+  //   10{9}(11…21), H_{ω^20}(20) = 10{19}(21…22) — so array[0] holds k entries
+  //   and the step-by-step expansion only fits while k ≤ maxCols.  Above that
+  //   the running base turns structured, the coefficients the limit steps write
+  //   from it turn structured too, and every later comparison / collapse becomes
+  //   meaningless: hardy(1e10+11) (k = n1 = 22) collapsed to [[1],[2,20]] — a
+  //   destroyed base with a bogus row — and hardy(1e16+1e13) (k = 28) likewise.
+  //   There the from-below value is taken from the engine instead: 10{k-1}(n+1)
+  //   is exactly the lower bound the exact expansion stays strictly above, so
+  //   hardy stays monotone and keeps its "strictly below the engine" property.
+  Q._hardyOmegaPower = function (n1) {
+    var n1Num = (n1.layer === 0 && n1.array.length === 1 && n1.array[0].length === 1) ? n1.toNumber() : Infinity;
+    if (isFinite(n1Num) && n1Num >= 2) {
+      var kFit = Math.floor(n1Num);
+      if (kFit <= MetaNum.maxCols + 1) {
+        // exact expansion — a fractional base (hardy("1e10+0.5"), n = 10+f)
+        // flows through the fundamental-sequence steps (the partial-step rule
+        // keeps the coefficients sane) and collapses into ONE plain row: the
+        // fractional hyper-operation result, between hardy(1e10) and
+        // hardy(1e10+1)
+        var ec = [];
+        for (var zi = 0; zi < kFit; zi++) ec.push(0);
+        ec.push(1);
+        return Q._hardyH(ec, n1);
+      }
+      // n1 > maxCols+1: the exact tower [c0, (n1-1)×(n1-2)] no longer fits the
+      // array (22 entries for n1 = 22, maxCols = 20).  Keep the TRUNCATED
+      // cascade instead of the engine value 10{n1-1}(n1+1): the tower level
+      // n1-1 over the definitional base — hardy("1e10+11") =
+      // [3086.036…, 21×19] (the user-visible [非整数, 21, 21, …, 21] shape),
+      // strictly above hardy("1e10+10")'s exact [6313063, 19×18] (the level 21
+      // dominates the level 19) and still far below the matching engine
+      // ordinal op 10{ω^ω+ω+1}10.
+      var lv = Math.floor(n1Num) - 1;
+      var depth = Math.min(Math.floor(n1Num) - 2, MetaNum.maxCols - 1);
+      var r0 = Q._hardyBaseR0();
+      var arr = [r0[0]];
+      for (var di = 0; di < depth; di++) arr.push(lv);
+      var out = new MetaNum(0);
+      out.array = [arr];
+      return out.normalize();
+    }
+    // structured / fractional operand: one ω-diagonal row (engine convention)
+    return Q._applyOrdinalRows(n1, [0, 1], 1);
+  };
+
+  // Decimal digit string of a plain number stored as r0 = [v, 1] (= 10^v),
+  // or null when the value is not in that form / has no finite exponent.
+  // Only an actual POWER TOWER is excluded: 10^^k has the same r0 shape but
+  // v ≥ 1e10, so "1e100000" (= 10^100000, v = 100000) is a plain number and
+  // keeps the ordinary digit path — the old guard rejected exponents above
+  // 1e5 and pushed hardy("1e100000") into the tower branch (layer 1).
+  Q._hardyDigitsOfPowForm = function (r0) {
+    if (!r0 || r0.length !== 2 || r0[1] !== 1 || !isFinite(r0[0])) return null;
+    if (r0[0] >= 1e10) return null;                  // power tower → slog branch
+    var exN = Math.floor(r0[0]);
+    if (exN < 0 || exN > 1000000) return null;       // digit string budget
+    var mantN = Math.pow(10, r0[0] - exN);
+    if (!isFinite(mantN)) return null;
+    // the exponent is stored with ~15 significant digits, so the reconstructed
+    // mantissa carries a rounding tail — 2e1000 is stored as 10^1000.301029995664
+    // and 10^0.301029995664 = 1.9999999999999…, which would spell the digits
+    // "19999…9" instead of "2000…0".  Round the mantissa to the digits the
+    // exponent can actually hold before spelling it out.
+    if (mantN > 0) mantN = Number(mantN.toPrecision(12));
+    if (mantN >= 10 - 1e-9) { mantN /= 10; exN += 1; }
+    var digN = String(mantN).replace('.', '');
+    var zeroN = exN - (digN.length - 1);
+    if (zeroN < 0) return null;
+    return digN + '0'.repeat(zeroN);
+  };
+
+  // r0 of the definitional from-below base H_{ω^10}(10) = 10{9}(11…21) — the
+  // base every hardy(n ≥ 1e10) value is built on.
+  Q._hardyBaseR0 = function () {
+    return Q._hardyOmegaPower(MetaNum.TEN.clone()).array[0].slice();
+  };
+
+  // issues.md truncation marker: once the ordinal rows overflow, the engine
+  // collapses the base to [10].  hardy keeps its definitional base instead —
+  // every level above it is carried by the ordinal rows, so the truncation
+  // loses nothing but the unnameable low levels, and the value stays bigger
+  // than the marker base (hardy is monotone across the truncation point).
+  Q._hardyKeepBase = function (v) {
+    var r0 = v.array[0];
+    if (r0 && r0.length === 1 && r0[0] === 10) v.array[0] = Q._hardyBaseR0();
+    return v;
+  };
+
   // MetaNum.hardy(n): the Hardy level of n.
   //   n < 10 → 10 + n;  otherwise the decimal digits of n become the CNF
   //   coefficients of an ordinal α (hardy(1234) = H_{ω³+ω²·2+ω·3+4}(10)) and
   //   the result is H_α(10).
   Q.hardy = function (n) {
+    // A plain JS number / numeric string keeps its own decimal expansion: from
+    // 1e16 on the library stores the value as 10^v (r0 = [v,1]) and the way
+    // back through the double loses the low digits — hardy(1e16+1e13) =
+    // hardy(10010000000000000) reads back as 10010000000000014, so the digit
+    // path would take 14 instead of 1e13 as the "rest" of the ordinal.
+    var rawNum = (typeof n === 'number') ? n
+      : (typeof n === 'string' ? Number(n) : null);
+    // v2.0.2: "1e10+0.5" / "1e10+11" / "1e16+1e13" — the digit path needs the
+    // exact decimal value, and Number('1e10+0.5') is NaN (the old path read 0 →
+    // hardy(0) = 10 → the [10] base).  Split the sum and add the parts exactly.
+    if (typeof n === 'string' && n.indexOf('+') > 0) {
+      var plusParts = n.split('+');
+      if (plusParts.length === 2 && plusParts[0] !== '' && plusParts[1] !== '' &&
+          !/[eE]$/.test(plusParts[0]) && !/[eE]$/.test(plusParts[1])) {
+        var pvA = new MetaNum(plusParts[0].trim());
+        var pvB = new MetaNum(plusParts[1].trim());
+        if (!pvA.isNaN() && !pvB.isNaN()) {
+          n = pvA.add(pvB);
+          rawNum = null;
+        }
+      }
+    }
+    if (rawNum !== null && !isFinite(rawNum)) rawNum = null;
     n = new MetaNum(n);
     if (n.sign !== 1) {
       throw Error(metaNumError + 'hardy: n must be a non-negative integer');
@@ -5811,9 +6085,23 @@
     //   hardy(10^^MSI) = the MetaNum limit exactly (slog(10^^MSI) = MSI).
     //   Ordinal-row / ε-layer values sit at their own Hardy position
     //   (H_{ω^β}(10) = 10{β}10) and map to themselves.
-    var num = (n.layer === 0 && n.array.length === 1) ? n.toNumber() : Infinity;
+    var num = (rawNum !== null) ? rawNum
+      : ((n.layer === 0 && n.array.length === 1) ? n.toNumber() : Infinity);
+    // r0 = [v, 1] means 10^v — the plain-number form the library uses once a
+    // value leaves the plain-integer range.  Read the decimal expansion off
+    // that mantissa/exponent pair when the double itself is unavailable
+    // (hardy("1.8e308") — beyond Number.MAX_VALUE).
+    var hStr = (rawNum === null && n.layer === 0 && n.array.length === 1)
+      ? Q._hardyDigitsOfPowForm(n.array[0]) : null;
     if (!isFinite(num)) {
       if (n.layer === 0 && n.array.length === 1) {
+        // v2.0.2: a PLAIN number that merely exceeds the double range (hardy
+        // ("1.8e308") — 1.8e308 > Number.MAX_VALUE) is not a power tower, so it
+        // must not fall into the tower branch: read its decimal expansion and
+        // keep the ordinary digit path (hardy(1.8e308) stays layer 0).
+        // (A tower 10^^k has the same shape but v ≥ 1e10, so the size guard
+        // below keeps towers on the slog branch.)
+        if (hStr === null) {
         var hVal = n.slog();
         // a clean power tower shadows to ω^ω^…^ω (k ω's); slog(10^^k) = [[k]]
         // (a plain single number — NOT the structured slog of, say, G600)
@@ -5821,20 +6109,82 @@
           var hNum = hVal.toNumber();
           if (isFinite(hNum) && hNum >= 2 && hNum <= Number.MAX_SAFE_INTEGER) {
             // k ≤ MSI: the tower fits the engine limit (f_ε₀); k > MSI is
-            // beyond ε₀ and the Hardy hierarchy is undefined there → Infinity
-            return MetaNum.TEN.epsilonate(hNum).normalize();
+            // beyond ε₀ and the Hardy hierarchy is undefined there → Infinity.
+            // The ordinal is read off the value itself: V = 10^W gives
+            // α = ω^ord(W), so the result is the ordinary cascade on the
+            // from-below base while the tower height still leaves a readable
+            // exponent (k ≤ 3 — hardy(ee10) = H_{ω^(ω^ω)}(10) = the ω^ω
+            // cascade, layer 0 like iterate(10), not a layer-2 marker).
+            // Above that the level no longer fits into ordinal rows and the
+            // value becomes a layer marker whose layer is ceil(k) - 3:
+            //   ee10 < 10^(1e10+1) < ee20 … eee10  → layer 1
+            //   eee20 … eeee10                     → layer 2, and so on
+            var r0T = n.array[0];
+            // v2.0.2 (issues): clean power towers — EVERY extra 10^ level in
+            // the input raises hardy's layer by ONE, the ordinal rows stay
+            // those of the innermost readable expansion:
+            //   hardy("1e308")   = the layer-0 digit-path cascade (…[8,6,0,3],[8,7,0,3])
+            //   hardy("e1e308")  = the same rows at layer 1
+            //   hardy("ee1e308") = the same rows at layer 2, and so on.
+            // The stored tower r0 = [v, k] is (k-1) further 10^ levels over
+            // 10^v; a layer-L input adds L more levels on top.
+            if (r0T && r0T.length === 2 && r0T[1] >= 1 &&
+                r0T[1] === Math.floor(r0T[1]) &&
+                isFinite(r0T[0]) && r0T[0] >= 10 &&
+                (r0T[1] >= 2 || r0T[0] >= 1e10)) {
+              var towerInner;
+              if (r0T[1] >= 2) {
+                // peel (k-1) levels at once: hardy = layerUp^(k-1)(hardy(10^v))
+                var towerBase = new MetaNum(0);
+                towerBase.sign = 1;
+                towerBase.layer = 0;
+                towerBase.array = [[r0T[0], 1]];
+                towerInner = Q.hardy(towerBase);      // hardy(10^v), layer 0/1
+                return Q._rawLayerMarker(towerInner.array[0],
+                  n.layer + (r0T[1] - 1) + towerInner.layer,
+                  towerInner.array.slice(1));
+              }
+              // single 10^ level over a readable exponent: hardy(10^v) =
+              // layerUp(hardy(v))
+              towerInner = Q.hardy(r0T[0]);
+              return Q._rawLayerMarker(towerInner.array[0], n.layer + 1,
+                towerInner.array.slice(1));
+            }
+            if (hNum <= 3 && r0T && r0T.length === 2 && r0T[1] === 1 &&
+                isFinite(r0T[0]) && r0T[0] >= 10) {
+              return Q._hardyLeading(r0T[0], 1, MetaNum.TEN.clone());
+            }
+            var kc = Math.ceil(hNum - 1e-9);
+            // position inside the band (kc-1, kc]: monotone in the tower height,
+            // kept just below 1 so the layer does not jump at the band edge
+            var kFrac = Math.min(Math.max(hNum - (kc - 1), 0), 0.999999);
+            if (kc <= 4) {
+              // layer 1: 10{ω^y}10 = L1 [[base],[1,y,1]] with y = ω + t, t
+              // growing with the tower height so the band stays monotone —
+              // the base is hardy's definitional from-below base, not the
+              // bare [10] marker (issues: a truncated base keeps
+              // [3086.036,9×8])
+              var tv = Math.max(1, Math.round((hNum - 3) * 1e6));
+              return Q._layerMarker(Q._hardyBaseR0(), 1, [[1, tv, 1]]);
+            }
+            // layer kc-3 ≥ 2: epsilonate(layer+1) carries the fractional tower
+            // height in its base, so the band stays monotone as well
+            // (beyond ~1e15 the fraction is not representable in the exponent)
+            return MetaNum.TEN.epsilonate(
+              kc > 1e15 ? (kc - 2) : (kc - 2 + kFrac)).normalize();
           }
         }
         // layer-0 value beyond a clean 10^^k with k ≤ MSI: finite
         // hyperoperations above tetration (G600, 3{9}3, …) or a tower taller
         // than 10^^MSI exceed the library's ε₀ ceiling → Infinity
         return new MetaNum(Infinity);
+        }
       }
       // ordinal-row / ε-layer / letter-chain values sit at their own Hardy
       // position (H_{ω^β}(10) = 10{β}10): map to themselves
-      return n.clone().normalize();
+      if (hStr === null) return n.clone().normalize();
     }
-    var s = String(num);
+    var s = (hStr !== null) ? hStr : String(num);
     // > 1e20 arrives in scientific notation ('1e+21') — expand to the exact
     // decimal digits so the digit-reading stays monotone (issues.md v2.1:
     // hardy must support > 1e15 inputs)
@@ -5844,6 +6194,17 @@
       var eZeros = Number(eMatch[3]) - eFrac.length;
       if (eZeros > 0) s = eMatch[1] + eFrac + '0'.repeat(eZeros);
     }
+    // v2.0.2: fractional argument.  The ordinal is read from the INTEGER part's
+    // digits while the base argument becomes 10+f, so H stays continuous in n:
+    //   hardy(10.38)  = H_ω(10.38)    = 10.38·2      = 20.76
+    //   hardy(100.1)  = H_{ω²}(10.1)  = 10.1·2^10.1  = 11084.709858935355
+    var hFrac = 0;
+    var hDot = s.indexOf('.');
+    if (hDot >= 0) {
+      hFrac = Number('0.' + s.slice(hDot + 1));
+      s = s.slice(0, hDot);
+    }
+    var hArg = hFrac > 0 ? new MetaNum(10 + hFrac) : MetaNum.TEN.clone();
     if (s.length >= 11) {
       // n ≥ 1e10 (issues.md v2.0): the ordinal is built per definition, then
       // evaluated from below on the engine's own representation:
@@ -5864,41 +6225,62 @@
       var kExp = s.length - 1;
       var dk = s.charCodeAt(0) - 48;
       var restNum = Number(s.slice(1));
-      var n1 = MetaNum.TEN.clone();
-      if (restNum > 0) n1 = Q.hardy(restNum);
-      // from-below base: H_{ω^n1}(n1) — exact for small finite n1, one
-      // ω-diagonal row (engine convention) for huge n1
-      var base;
-      var n1Num = (n1.array.length === 1 && n1.layer === 0) ? n1.toNumber() : Infinity;
-      if (isFinite(n1Num) && n1Num === Math.floor(n1Num) && n1Num >= 2 && n1Num <= 100) {
-        var ec = [];
-        for (var zi = 0; zi < n1Num; zi++) ec.push(0);
-        ec.push(1);
-        base = Q._hardyH(ec, n1);
-      } else {
-        base = Q._applyOrdinalRows(n1, [0, 1], 1);
-      }
+      var n1 = hArg.clone();
+      // the fractional part flows into the rest part too: hardy("1e10+1.5")
+      // = H_{ω^10}(hardy(1.5)) = H_{ω^10}(11.5) — dropping the fraction here
+      // made every 1e10+k.f input behave like 1e10+k
+      if (restNum > 0) n1 = Q.hardy(restNum + hFrac);
+      return Q._hardyLeading(kExp, dk, n1);
+    }
+    if (num < 10) return new MetaNum(10 + num);
+    var coeffs = [];
+    for (var i = s.length - 1; i >= 0; i--) coeffs.push(s.charCodeAt(i) - 48);
+    return Q._hardyH(coeffs, hArg);
+  };
+
+  // The leading term ω^ord(kExp)·dk of hardy's ordinal, evaluated from below
+  // on the already-computed lower part n1 = H_ord(rest)(10).
+  Q._hardyLeading = function (kExp, dk, n1) {
+      // a plain operand still has a single plain number as its whole array[0]
+      var nPlain = (n1.layer === 0 && n1.array.length === 1 && n1.array[0].length === 1);
+      var n1Num = nPlain ? n1.toNumber() : Infinity;
       if (kExp === 10) {
-        return Q._applyOrdinalRows(base, [0, 1], dk - 1).normalize();
-      }
-      // kExp ≥ 11 (ord = ω+c): mirror the engine's own ordinal rows for
-      // 10{ω+c}(9+dk) onto the from-below base — hardy(1e11) keeps
-      // expande(10,10)'s row structure with the strictly smaller
-      // definitional base, so hardy(1e11) < 10{ω+1}10 (issues.md)
+        // H_{ω^ω·dk}(n1): the first ω^ω-segment is H_{ω^n1}(n1) (from below),
+        // every further one adds one ω-row
+        return Q._hardyKeepBase(
+          Q._applyOrdinalRows(Q._hardyOmegaPower(n1), [0, 1], dk - 1)).normalize();
+      }
+      // kExp ≥ 11 (ord = ω+c): β = ord(kExp) and the leading term ω^β·dk is dk
+      // APPLICATIONS of H_{ω^β}, one after the other on the running value:
+      //   hardy(1.1e11) = H_{ω^(ω+1)+ω^ω}(10) = H_{ω^(ω+1)}(H_{ω^ω}(10))
+      //                 = [3086.036,9×8] [1,1,1]          (one row per application)
+      //   hardy(2e11)   = H_{ω^(ω+1)·2}(10) = H_{ω^(ω+1)}(H_{ω^(ω+1)}(10))
+      //                 = [3086.036,9×8] [8,0,1] [1,1,1]
+      //   hardy(1e16+1e13) = H_{ω^(ω+6)}(H_{ω^(ω+3)}(10)) → … [1,6,1]
+      // so an application is a row [1, β] — never a bump of the ω-row count
+      // ([9,0,1] / [16,0,1] conflated dk with the rest-part).  The FIRST
+      // application on a plain operand is still expanded from below: the base
+      // H_{ω^n1}(n1) plus the cascade of 10{β}10 (hardy(1e11) = [3086.036,9×8]
+      // [8,0,1], strictly below 10{ω+1}10 — issues.md).
       var ks = String(kExp);
       var ordCoeffs = [];
       for (var oi = ks.length - 1; oi >= 0; oi--) ordCoeffs.push(ks.charCodeAt(oi) - 48);
-      var mir = Q._hyperopFromOrdinalRaw(MetaNum.TEN.clone(), new MetaNum(9 + dk), ordCoeffs);
-      var out = base.clone();
-      for (var ri = 1; ri < mir.array.length; ri++) {
-        out = Q._applyOrdinalRows(out, mir.array[ri].slice(1), mir.array[ri][0]);
+      var out, extra;
+      if (nPlain && isFinite(n1Num) && n1Num >= 2) {
+        out = Q._hardyOmegaPower(n1);
+        var mir = Q._hyperopFromOrdinalRaw(MetaNum.TEN.clone(), MetaNum.TEN.clone(), ordCoeffs);
+        for (var ri = 1; ri < mir.array.length; ri++) {
+          out = Q._applyOrdinalRows(out, mir.array[ri].slice(1), mir.array[ri][0]);
+        }
+        extra = dk - 1;
+      } else {
+        // structured operand: H_{ω^β} has no room left to expand into, so each
+        // application is one more row [1, β]
+        out = n1.clone();
+        extra = dk;
       }
-      return out.normalize();
-    }
-    if (num < 10) return new MetaNum(10 + num);
-    var coeffs = [];
-    for (var i = s.length - 1; i >= 0; i--) coeffs.push(s.charCodeAt(i) - 48);
-    return Q._hardyH(coeffs, MetaNum.TEN.clone());
+      if (extra > 0) out = Q._applyOrdinalRows(out, ordCoeffs, extra);
+      return Q._hardyKeepBase(out).normalize();
   };
 
   // ==================== BEAF Array Notation ====================