lingshu-solver 1.0.4 → 1.0.7

package/index.html

@@ -4737,7 +4737,7 @@ function suan7(state) {
                     for (var kb in known) ibox[kb] = { min: known[kb], max: known[kb] };
                     ibox[uv] = box;
                     var iF = intervalEval(eq, ibox);
-                    if (iF && (iF.max < 0 || iF.min > 0)) {
+                    if (iF && _ivExcludesZero(iF)) {
                         state.done = true;
                         var knownList = Object.keys(known).sort().map(function(v) { return v + "=" + known[v]; }).join(", ");
                         state.result = { solutions: [], error: "NO_SOLUTION", message: "前向传播检测到矛盾：代入已知值后，方程在变量 " + uv + " 的全域上 f 的严格区间包络不含 0（包络=[" + iF.min.toExponential(2) + "," + iF.max.toExponential(2) + "]），严格证明无根", detail: "已知值: " + knownList, executionPath: "前向传播矛盾检测", timeMs: performance.now() - state.startTime, confidence: "high", varNames: state.varNames, resultType: 1, resultTypeName: "空结果", resultTypeDesc: "前向传播检测到矛盾" };
@@ -5833,6 +5833,9 @@ function suan22(state) {
             _walk1(_eq);
         })();
         if (_lo < _hi) {
+            var _dense = false;  // 修3：根稠密/超时提前终止扫描（防宽域周期方程穷举挂起）
+            var _denseByCount = false;  // 修3：仅由"根数超阈值"触发的稠密标记（用于无限/截断判定，区别于超时触发）
+            var _denseNonPeriodic = false;  // 修3：非周期稠密截断标记（与 periodic→无限 分支互补）
             // ---- 周期感知步长（issue A 修复 2026-09-01）：高频/多周期方程用 < 周期/2 的网格，
             //      确保不漏根；非周期方程回退到 4096 点默认细网格。点数上限 _NMAX 护栏防宽域爆炸。 ----
             var _P = _detectPeriod1D(_eq, _vn);
@@ -5902,8 +5905,11 @@ function suan22(state) {
                             _recScanInterval(_eq, _vn, _gxP, _gx, state, allSolutions, resultVarNames, 0);
                         }
                     }
+                    if (allSolutions.length > 200) { _dense = true; _denseByCount = true; break; }
+                    if ((performance.now() - state.startTime) > 1500) { _dense = true; break; }
                     _gxP = _gx; _gfP = _gf;
                 }
+                if (_dense) break;
                 // 终止端点若有根也记录
                 if (_gfP !== null && Math.abs(_gfP) < 1e-7) {
                     var _fbV = reconstructSolution(state, [_B]).map(roundToGrid);
@@ -5951,6 +5957,31 @@ function suan22(state) {
             if (_dedupMap[_mi]) mergedSolutions.push(_dedupMap[_mi]);
         }
 
+        // 修3（2026-09-04）：稠密根防护——单变量周期方程在宽域内根稠密，
+        // 继续穷举既耗时（曾致 solve 挂起 >110s）又产出无用的海量解集。
+        // 含周期函数且根数超阈值 ⇒ 解集实际为无限（周期平移），如实标 rt=3 无限解集(代表解)；
+        // 非周期但稠密（如高次多项式）⇒ 不谎称无限，置 truncated 并后续告警，诚实返回部分代表根。
+        if (_denseByCount) {
+            if (_P !== null) {
+                state.done = true;
+                state.result = {
+                    solutions: mergedSolutions,
+                    error: null,
+                    message: "单变量周期方程在声明域内出现大量（>" + 200 + "）孤立根，呈周期性稠密分布，解集实际为无限（如 x = x₀ + k·" + _P.toFixed(4) + "）。已给出 " + mergedSolutions.length + " 个代表根；如需有限个解请收窄变量定义域。",
+                    executionPath: "单变量稠密周期根判定(无限解集)",
+                    timeMs: performance.now() - state.startTime,
+                    confidence: "high",
+                    varNames: resultVarNames,
+                    resultType: 3,
+                    resultTypeName: "无限解集(代表解)",
+                    resultTypeDesc: "周期方程在宽域内根稠密，解集为周期平移的无穷集合，已给出代表根"
+                };
+                return;
+            }
+            state.truncated = true;  // 非周期稠密：诚实截断（避免海量/不完整解集），下方 domainFiltered 产出部分代表根
+            _denseNonPeriodic = true;
+        }
+
         // 2) 原始方程回代验证：对每组候选解，代入全部原始方程重新计算残差
         //    二分查找得到的解（_bisect=true）跳过残差验证（区间收敛保证精度）
         var _origEqs = state.originalEquations || state.equations;
@@ -6082,6 +6113,12 @@ function suan22(state) {
                 }
             }
         }
+        // 修3：非周期稠密截断告警（与上方 periodic→无限 分支互补）
+        if (_denseNonPeriodic && state.result) {
+            state.result.warnings = (state.result.warnings || []).concat([
+                "方程在声明域内根数量过多（>" + 200 + "），已截断扫描；结果不完整，缩小变量范围或确认方程规模可获完整解集。"
+            ]);
+        }
     }
 }
 
@@ -6557,6 +6594,16 @@ var _affSym = 0;
 function _Aff(c, e) { return { c: c, e: e || {} }; }
 function _affRad(a) { if (!a) return 0; var r = 0; for (var k in a.e) r += Math.abs(a.e[k]); return r; }
 function _affToInterval(a) { if (!a) return null; var r = _affRad(a); return _iNorm({ min: a.c - r, max: a.c + r }); }
+// sound 容差：区间求值受浮点舍入影响，包络可能偏离真值几个 ulp（如 12/5 经 12*(1/5)
+// 算得 2.4000000000000001，与字面 2.4 差 ~2e-16，加仿射半径后包络中心落正侧）。
+// 判"严格不含 0 → 证明无解/严格单调"时，必须要求包络离 0 超过此容差；否则保守地
+// 不判无解（降级为继续求解 / 诚实报未找到），绝不因舍入把真解误杀为假阴性（sound-safe，
+// 绝不引入假阳性）。容差随量级缩放（相对 1e-12）+ 1e-12 绝对下限。
+function _ivExcludesZero(iv) {
+  if (!iv || !isFinite(iv.min) || !isFinite(iv.max)) return false;
+  var pad = Math.max(1e-12, 1e-12 * Math.max(1, Math.abs(iv.min), Math.abs(iv.max)));
+  return iv.max < -pad || iv.min > pad;
+}
 function _affAdd(a, b) { var e = {}; for (var k in a.e) e[k] = a.e[k]; for (var k in b.e) e[k] = (e[k] || 0) + b.e[k]; return _Aff(a.c + b.c, e); }
 function _affSub(a, b) { var e = {}; for (var k in a.e) e[k] = a.e[k]; for (var k in b.e) e[k] = (e[k] || 0) - b.e[k]; return _Aff(a.c - b.c, e); }
 function _affMul(a, b) {
@@ -6573,14 +6620,18 @@ function _affMul(a, b) {
 }
 function _affInv(b) {
   // 1/b 一阶泰勒，误差保守界 |(b-b0)^2|/(2 b0^2 ξ^2)，ξ∈盒，min|ξ|=|b0|-rb
+  // ⚠️ 修正（sound 正确性，2026-09-07）：旧实现 r=0-b=-b，lin=(-1/b.c²)·(-b) 的中心 lin.c 已是 1/b.c，
+  //   return 又写 1/b.c + lin.c → 中心被双重计数为 2/b.c（如 1/5 算成 0.4、12/5 算成 4.8），
+  //   导致所有含除法的区间包络 / 中值定理判无解（suan7/suan29/suan35 等）系统性假阴性。
+  //   正确：dev = b - b.c（中心 0）做一阶泰勒，lin.c=0，return 中心恰为 1/b.c，且噪声符号正确。
   var rb = _affRad(b); if (b.c === 0) return null;
-  var r = _affSub(_Aff(0, {}), b);
-  var lin = _affMul(r, _Aff(-1 / (b.c * b.c), {}));
+  var dev = _affSub(b, _Aff(b.c, {}));   // b - b0，中心为 0
+  var lin = _affMul(dev, _Aff(-1 / (b.c * b.c), {}));   // 一阶项，中心为 0
   var e = {}; for (var k in lin.e) e[k] = lin.e[k];
   var m = Math.abs(b.c) - rb; if (m <= 0) return null;
   var err = (rb * rb) / (2 * b.c * b.c * m * m);
   var sym = _affSym++; e[sym] = err;
-  return _Aff(1 / b.c + lin.c, e);
+  return _Aff(1 / b.c + lin.c, e);   // 现 lin.c=0 → 中心 = 1/b.c
 }
 function _affDiv(a, b) { var ib = _affInv(b); return ib ? _affMul(a, ib) : null; }
 function _buildAffEnv(intervals) {
@@ -6624,7 +6675,13 @@ function _affineEval(ast, env) {
     // 超越函数降级：仿射自变量 → 保守区间函数包围（复用 _rangeEval，无递归环）
     var tmp = { type: 'func', name: ast.name, arg: { type: 'var', name: '__a' } };
     var rv = _rangeEval(tmp, { __a: iv });
-    return rv ? _Aff((rv.min + rv.max) / 2, {}) : null;
+    if (!rv || !isFinite(rv.min) || !isFinite(rv.max)) return null; // 含 ±Inf：交还 _rangeEval 直接给出保守区间
+    // 关键修复（P0-2）：旧实现 return _Aff((rv.min+rv.max)/2, {}) 把合法区间宽度丢成 0，
+    // 致 intervalEval(sin x)@[-2,2] 塌成 [0,0]（unsound：真值须含 [-1,1]）。
+    // 正确做法：用半径 (rv.max-rv.min)/2 的噪声符号把 rv 完整编码为仿射，
+    // 使 _affToInterval 还原为 [rv.min, rv.max]（sound 且紧致），Krawczyk 雅可比随之可信。
+    var e = {}; e[_affSym++] = (rv.max - rv.min) / 2;
+    return _Aff((rv.min + rv.max) / 2, e);
   }
   if (ast.type === 'unary') {
     var u = _affineEval(ast.operand, env);
@@ -6662,7 +6719,7 @@ function suan29(state) {
 
     // 严格测试①（最强）：f 在区间上的区间包络不含 0 → 由中值定理严格证明该盒内无根
     var F = intervalEval(state.equations[0], box);
-    if (F && (F.max < 0 || F.min > 0)) {
+    if (F && _ivExcludesZero(F)) {
         state.done = true;
         state.result = { solutions: [], error: "NO_SOLUTION", provenEmpty: true, message: "f 在 [" + a + "," + b + "] 上的严格区间包络不含 0（包络=[" + F.min.toExponential(2) + "," + F.max.toExponential(2) + "]），由中值定理严格证明该盒内无根", executionPath: "导数单调性剪枝", timeMs: performance.now() - state.startTime, confidence: "high", varNames: state.varNames, resultType: 1, resultTypeName: "空结果", resultTypeDesc: "区间包络严格证明区间内无根" };
         return;
@@ -6673,7 +6730,7 @@ function suan29(state) {
     //   用符号微分+区间求值得到【紧致】导数包络，取代原“3 条割线同号”启发式（会漏根，见评审 unsound）。
     var dAST = _diffAST(state.equations[0], vn);
     var dI = dAST ? intervalEval(dAST, box) : null;
-    if (dI && (dI.min > 0 || dI.max < 0)) {
+    if (dI && _ivExcludesZero(dI)) {
         var faBox = {}, fbBox = {}; faBox[vn] = { min: a, max: a }; fbBox[vn] = { min: b, max: b };
         var faI = intervalEval(state.equations[0], faBox);
         var fbI = intervalEval(state.equations[0], fbBox);
@@ -6827,7 +6884,7 @@ function suan35(state) {
         //     故仅在“不含 0”时返回 false（不可行）。
         for (var r = 0; r < subEqs.length; r++) {
             var iF = intervalEval(subEqs[r], box);
-            if (iF && isFinite(iF.min) && isFinite(iF.max) && (iF.max < 0 || iF.min > 0)) {
+            if (iF && _ivExcludesZero(iF)) {
                 return false; // 该方程在 used 全域上严格无根 ⇒ 子问题不可行 ⇒ 全局不可行
             }
         }
@@ -11040,7 +11097,7 @@ function _runTail(state) {
 
 // —— 可审计结构化溯源（切片A）：每个结果附带完整证据链元数据 ——
 // 设计目标：Agent / 上层系统拿到的不只是裸数字，而是"为什么是这个解"的可读证据链。
-var SOLVER_VERSION = "lingshu-solver/1.0.0-auditable";
+var SOLVER_VERSION = "lingshu-solver/1.0.7-auditable";
 
 // Movability 完整读取（切片B）：每变量携带 status + width，供 Agent 读懂"为何是这个解"
 function _movabilityFull(state) {
@@ -11378,7 +11435,11 @@ function _newtonRefine(eqs, vns, x0, box) {
         var F = []; for (var e = 0; e < n; e++) { var fe = evalAST(eqs[e], vmap); if (!isFinite(fe)) return null; F.push(fe); }
         var rms = 0; for (var i2 = 0; i2 < n; i2++) rms += F[i2] * F[i2]; rms = Math.sqrt(rms / n);
         if (rms < 1e-11) return x;
-        var J = []; for (var a = 0; a < n; a++) { J.push([]); for (var b = 0; b < n; b++) { var d = _diffAST(eqs[a], vns[b]); var dv = intervalEval(d, vmap); if (!dv) return null; J[a].push((dv.min + dv.max) / 2); } }
+        // 雅可比区间求导：必须喂退化的点区间 {min:x,max:x}（而非裸点值）。
+        // 旧实现 intervalEval(d, vmap) 把裸数当 iv，iv.min/iv.max 为 undefined → _buildAffEnv 算出 NaN 噪声
+        // → 雅可比整行 NaN → realMatInv 失败 → 本函数对一切良置问题恒返 null（P0-1）。
+        var pmap = {}; for (var i3 = 0; i3 < n; i3++) pmap[vns[i3]] = { min: x[i3], max: x[i3] };
+        var J = []; for (var a = 0; a < n; a++) { J.push([]); for (var b = 0; b < n; b++) { var d = _diffAST(eqs[a], vns[b]); var dv = intervalEval(d, pmap); if (!dv) return null; J[a].push((dv.min + dv.max) / 2); } }
         var Y = realMatInv(J); if (!Y) return null;
         var dX = rMatVec(Y, F);
         for (var j = 0; j < n; j++) x[j] = x[j] - dX[j];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lingshu-solver",
-  "version": "1.0.4",
+  "version": "1.0.7",
   "description": "灵数求解器 · 确定性实数方程组求解 MCP 工具（≤6变量）：区间收缩 + Krawczyk 认证，离线零依赖零数据，诚实标记 truncated。",
   "homepage": "https://genesis-plan.github.io/lingshu-solver/",
   "repository": {
@@ -50,6 +50,6 @@
   },
   "scripts": {
     "start": "node mcp-server.js",
-    "test": "node test/regression.js"
+    "test": "node test/p0_fix_regression.js"
   }
 }