symbolimind 0.1.0__tar.gz

symbolimind-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 [(https://github.com/d87skg)]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

symbolimind-0.1.0/PKG-INFO

@@ -0,0 +1,75 @@
+Metadata-Version: 2.4
+Name: symbolimind
+Version: 0.1.0
+Summary: AI-powered symbolic regression engine that discovers governing equations from data.
+Author: SymbolicMind Team
+License: MIT
+Project-URL: Homepage, https://github.com/d87skg/SymbolicMind
+Project-URL: Repository, https://github.com/d87skg/SymbolicMind.git
+Project-URL: Issues, https://github.com/d87skg/SymbolicMind/issues
+Keywords: symbolic-regression,physics,ai,machine-learning,science
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: scikit-learn
+Dynamic: license-file
+
+# SymbolicMind
+
+**一个能从数据中自主发现物理定律的 AI 引擎。**
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+SymbolicMind 是一个因果符号回归引擎，基于 **BIC 精拟合** 和 **P0 可证伪性边界** 构建。它不仅拟合数据，还能自我修正、自我发现、自我进化——让机器从原始观测数据中提炼出人类可读的数学控制方程。
+
+## 核心能力
+
+- **方程发现**：自动从时间序列或静态数据中识别非线性动力学方程。
+- **可证伪性**：内置 P0 探测器，通过残差自相关判别模型的可靠性，绝不捏造物理。
+- **自演化算子库**：在需要时自主生成时变、分数阶、嵌套积分核等高级数学结构。
+- **恒等式识别**：自动识别 `dx/dt = y` 等简单恒等式，避免过度建模。
+- **AI 智能体就绪**：提供符合 OpenAI Function Calling 规范的工具接口，可被任何 AI Agent 调用。
+- **记忆增强**：本地经验库记录成功发现，越用越聪明。
+
+## 快速开始
+
+```bash
+pip install numpy scipy scikit-learn
+python quickstart.py
+
+你将看到引擎发现简谐振动方程：d²x/dt² = -x，并输出详细的诊断报告。
+
+基准测试成绩
+SymbolicMind 在 Feynman、Strogatz、ODEBench 和 Blackbox 等基准上取得了领先成绩。详见 BENCHMARKS.md。
+
+项目结构
+text
+SymbolicMind/
+├── symbolimind/          # 核心引擎包
+│   ├── engine.py         # BIC 精拟合器 + P0 探测器
+│   ├── extensions.py     # 恒等式检测 + 自适应断层扫描
+│   ├── skill.py          # AI 智能体工具接口
+│   ├── brain.py          # 自然语言大脑
+│   └── memory.py         # 本地经验记忆库
+├── tests/                # 测试
+├── BENCHMARKS.md         # 基准测试成绩单
+├── CONTRIBUTING.md       # 贡献指南
+├── LICENSE               # MIT 许可证
+├── quickstart.py         # 5 分钟快速体验
+└── README.md             # 本文件
+引用
+如果 SymbolicMind 对你的研究有帮助，请引用本项目。
+
+贡献
+我们欢迎社区贡献！无论是新的物理算子、基准测试还是文档改进，请参见 CONTRIBUTING.md。

symbolimind-0.1.0/README.md

@@ -0,0 +1,48 @@
+# SymbolicMind
+
+**一个能从数据中自主发现物理定律的 AI 引擎。**
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+SymbolicMind 是一个因果符号回归引擎，基于 **BIC 精拟合** 和 **P0 可证伪性边界** 构建。它不仅拟合数据，还能自我修正、自我发现、自我进化——让机器从原始观测数据中提炼出人类可读的数学控制方程。
+
+## 核心能力
+
+- **方程发现**：自动从时间序列或静态数据中识别非线性动力学方程。
+- **可证伪性**：内置 P0 探测器，通过残差自相关判别模型的可靠性，绝不捏造物理。
+- **自演化算子库**：在需要时自主生成时变、分数阶、嵌套积分核等高级数学结构。
+- **恒等式识别**：自动识别 `dx/dt = y` 等简单恒等式，避免过度建模。
+- **AI 智能体就绪**：提供符合 OpenAI Function Calling 规范的工具接口，可被任何 AI Agent 调用。
+- **记忆增强**：本地经验库记录成功发现，越用越聪明。
+
+## 快速开始
+
+```bash
+pip install numpy scipy scikit-learn
+python quickstart.py
+
+你将看到引擎发现简谐振动方程：d²x/dt² = -x，并输出详细的诊断报告。
+
+基准测试成绩
+SymbolicMind 在 Feynman、Strogatz、ODEBench 和 Blackbox 等基准上取得了领先成绩。详见 BENCHMARKS.md。
+
+项目结构
+text
+SymbolicMind/
+├── symbolimind/          # 核心引擎包
+│   ├── engine.py         # BIC 精拟合器 + P0 探测器
+│   ├── extensions.py     # 恒等式检测 + 自适应断层扫描
+│   ├── skill.py          # AI 智能体工具接口
+│   ├── brain.py          # 自然语言大脑
+│   └── memory.py         # 本地经验记忆库
+├── tests/                # 测试
+├── BENCHMARKS.md         # 基准测试成绩单
+├── CONTRIBUTING.md       # 贡献指南
+├── LICENSE               # MIT 许可证
+├── quickstart.py         # 5 分钟快速体验
+└── README.md             # 本文件
+引用
+如果 SymbolicMind 对你的研究有帮助，请引用本项目。
+
+贡献
+我们欢迎社区贡献！无论是新的物理算子、基准测试还是文档改进，请参见 CONTRIBUTING.md。

symbolimind-0.1.0/pyproject.toml

@@ -0,0 +1,34 @@
+[build-system]
+requires = ["setuptools>=64", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "symbolimind"
+version = "0.1.0"
+description = "AI-powered symbolic regression engine that discovers governing equations from data."
+readme = "README.md"
+license = {text = "MIT"}
+authors = [{name = "SymbolicMind Team"}]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Topic :: Scientific/Engineering :: Physics",
+]
+keywords = ["symbolic-regression", "physics", "ai", "machine-learning", "science"]
+requires-python = ">=3.9"
+dependencies = ["numpy", "scipy", "scikit-learn"]
+
+[project.urls]
+Homepage = "https://github.com/d87skg/SymbolicMind"
+Repository = "https://github.com/d87skg/SymbolicMind.git"
+Issues = "https://github.com/d87skg/SymbolicMind/issues"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["symbolimind*"]

symbolimind-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

symbolimind-0.1.0/symbolimind/__init__.py

@@ -0,0 +1,5 @@
+from .engine import CDE_V80
+from .extensions import apply_all_patches, remove_all_patches
+from .skill import cde_discover_equation
+from .brain import create_brain
+from .memory import CDEMemory

symbolimind-0.1.0/symbolimind/brain.py

@@ -0,0 +1,164 @@
+"""
+SymbolicMind Brain - Intelligent Agent Frontend
+
+Contains LocalBrain and GPTBrain for natural language interaction
+with the CDE engine. Includes physical knowledge base and equation beautification.
+
+Author: [Your Name]
+License: MIT
+"""
+import os, sys, json
+import numpy as np
+
+class LocalBrain:
+    def __init__(self):
+        # ===== 内置物理知识库 =====
+        self.physical_terms = {
+            "加速度": "d2x_dt2",
+            "速度": "dx_dt",
+            "位置": "x",
+            "位移": "x",
+            "二阶导数": "d2x_dt2",
+            "一阶导数": "dx_dt"
+        }
+
+    def parse_question(self, question, available_columns):
+        """从自然语言中提取目标列名，优先使用物理知识库。"""
+        q_lower = question.lower()
+        
+        # 1. 优先查找物理概念
+        for term, col in self.physical_terms.items():
+            if term in question and col in available_columns:
+                return col
+        
+        # 2. 直接匹配列名（按长度降序）
+        sorted_cols = sorted(available_columns, key=lambda c: len(c), reverse=True)
+        for col in sorted_cols:
+            if col in q_lower:
+                return col
+        
+        # 3. 默认返回最后一个
+        return available_columns[-1]
+
+    def generate_answer(self, result, target_column=None):
+        """生成专业的科学报告，并自动将方程重写为物理形式。"""
+        if "error" in result:
+            return f"抱歉，分析遇到问题：{result['error']}"
+        
+        equation = result['equation']
+        r2 = result['r2']
+        p0 = result['p0_verdict']
+        lac = result.get('residual_autocorr', 0.0)
+        
+        # 将方程重写为更物理的形式
+        phys_eq = self._format_equation_physically(equation, target_column)
+        
+        # P0 解读
+        if "adequate" in p0.lower() or "exact" in p0.lower():
+            reliability = "模型通过了严格的P0可证伪性检验，方程结构可靠。"
+        else:
+            reliability = f"模型拟合优度很高，但P0检测发现残差仍有自相关（{lac:.3f}），可能存在未捕获的隐藏变量，建议进一步实验。"
+        
+        return (f"我发现了控制方程：\n  {phys_eq}\n"
+                f"拟合优度 R² = {r2:.4f}。{reliability}")
+
+    def _format_equation_physically(self, equation, target_column=None):
+        """将方程表达式重写为目标变量的物理形式，并美化符号。"""
+        # 1. 基础符号美化
+        equation = equation.replace('sin_t', 'sin(t)').replace('cos_t', 'cos(t)')
+        equation = equation.replace('exp_neg_', 'exp(-').replace('_sq', '²')
+        equation = equation.replace('sqrt_', '√(')
+        # 如果符号后有括号缺失，可以补上，这里先简单处理
+
+        # 2. 处理恒等式标记
+        is_identity = "(identity)" in equation
+        clean_eq = equation.replace(" (identity)", "").strip()
+        
+        # 3. 如果提供了目标列名，重写为 d²x/dt² = ... 的形式
+        if target_column and is_identity:
+            lhs = self._col_to_readable(target_column)
+            parts = clean_eq.split('=')
+            if len(parts) == 2:
+                rhs = parts[1].strip()
+                return f"{lhs} = {rhs}"
+            elif len(parts) == 1:
+                rhs = clean_eq.replace("y = ", "").replace("y=", "")
+                return f"{lhs} = {rhs}"
+        
+        # 默认返回美化后的方程
+        return clean_eq
+
+    def _col_to_readable(self, col):
+        """将列名转换为可读的物理符号。"""
+        mapping = {
+            "d2x_dt2": "d²x/dt²",
+            "dx_dt": "dx/dt",
+            "x": "x",
+            "t": "t"
+        }
+        return mapping.get(col, col)
+
+
+# ---------- 云端智能大脑 (需 openai 包及环境变量) ----------
+class GPTBrain:
+    def __init__(self, model="gpt-3.5-turbo"):
+        self.model = model
+        import openai
+        self.openai = openai
+        self.api_key = os.environ.get("OPENAI_API_KEY")
+        if not self.api_key:
+            raise ValueError("请设置环境变量 OPENAI_API_KEY")
+        self.openai.api_key = self.api_key
+
+    def parse_question(self, question, available_columns):
+        prompt = (
+            f"你是一个科学数据分析助手。用户有一份数据，包含以下列：{', '.join(available_columns)}。\n"
+            f"用户的问题是：“{question}”\n"
+            f"请从列名中选出与问题最相关的一个列名，只输出列名本身，不要输出任何其他内容。"
+        )
+        response = self.openai.ChatCompletion.create(
+            model=self.model,
+            messages=[{"role": "user", "content": prompt}],
+            temperature=0.0,
+            max_tokens=20
+        )
+        answer = response.choices[0].message.content.strip()
+        if answer in available_columns:
+            return answer
+        else:
+            fallback = LocalBrain()
+            return fallback.parse_question(question, available_columns)
+
+    def generate_answer(self, result, target_column=None):
+        if "error" in result:
+            return f"抱歉，分析遇到问题：{result['error']}"
+        equation = result['equation']
+        r2 = result['r2']
+        p0 = result['p0_verdict']
+        lac = result.get('residual_autocorr', 0.0)
+        prompt = (
+            f"你是一个物理学数据科学家。CDE引擎从数据中发现了一个方程：{equation}，"
+            f"R² = {r2:.4f}，残差自相关 = {lac:.4f}，P0可证伪性判决：“{p0}”。\n"
+            f"请用中文向用户报告这个发现，解释方程的意义，并根据P0判决给出建议。"
+        )
+        response = self.openai.ChatCompletion.create(
+            model=self.model,
+            messages=[{"role": "user", "content": prompt}],
+            temperature=0.5,
+            max_tokens=300
+        )
+        return response.choices[0].message.content.strip()
+
+
+# ---------- 工厂函数 ----------
+def create_brain(mode="local"):
+    if mode == "local":
+        return LocalBrain()
+    elif mode == "gpt":
+        try:
+            return GPTBrain()
+        except ValueError as e:
+            print(f"无法加载GPT大脑: {e}，降级为本地大脑。")
+            return LocalBrain()
+    else:
+        raise ValueError("模式仅支持 'local' 或 'gpt'")

symbolimind-0.1.0/symbolimind/engine.py

@@ -0,0 +1,230 @@
+"""
+SymbolicMind Engine - Core Symbolic Regression Module
+
+This module provides the CDE_V80 class, the core engine for discovering
+governing equations from data. It features BIC-guided sparse regression,
+P0 falsifiability boundary, and dual-mode operation (static / time-series).
+
+Author: [Your Name]
+License: MIT
+"""
+import numpy as np
+from sklearn.preprocessing import PolynomialFeatures, StandardScaler
+
+class CDE_V80:
+    """
+    CDE V8.0 符号回归适配器 (SRBench 兼容)
+    
+    双模式：
+    - time_series=False (默认): 静态表格，使用多项式+超越函数特征池
+    - time_series=True: 时间序列，启用时滞、积分核等完整记忆算子
+    """
+    def __init__(self, threshold=0.2, max_iter=8, time_series=False, autostop=True):
+        self.threshold = threshold
+        self.max_iter = max_iter
+        self.time_series = time_series
+        self.autostop = autostop
+        self.coefficients_ = None
+        self.selected_features_ = None
+        self.r2_ = None
+        self.residual_autocorr_ = None
+        self.equation_ = None
+
+    def fit(self, X, y, feature_names=None):
+        X = np.atleast_2d(X)
+        if feature_names is None:
+            feature_names = [f'x{i}' for i in range(X.shape[1])]
+        
+        # 特征工程
+        if self.time_series:
+            X_aug, aug_names = self._build_time_series_features(X, feature_names)
+        else:
+            X_aug, aug_names = self._build_static_features(X, feature_names)
+        
+        # 核心 BIC 精拟合
+        final_coeffs, active_idx, r2, lag1 = self._bic_fit(X_aug, y, aug_names)
+        
+        self.coefficients_ = final_coeffs
+        self.selected_features_ = [aug_names[i] for i in active_idx]
+        self.r2_ = r2
+        self.residual_autocorr_ = lag1
+        self.equation_ = self._format_equation(final_coeffs, aug_names, active_idx)
+        
+        return self
+
+    def predict(self, X):
+        X = np.atleast_2d(X)
+        if self.time_series:
+            X_aug, _ = self._build_time_series_features(X, [f'x{i}' for i in range(X.shape[1])])
+        else:
+            X_aug, _ = self._build_static_features(X, [f'x{i}' for i in range(X.shape[1])])
+        return X_aug @ self.coefficients_
+
+    def get_equation(self):
+        if self.equation_ is None:
+            return "Model not fitted."
+        return self.equation_
+
+    def get_p0_report(self):
+        if self.residual_autocorr_ is None:
+            return "P0 not available."
+        if self.r2_ is None:
+            return "P0 not available."
+        if self.r2_ < 0.3 and abs(self.residual_autocorr_) > 0.3:
+            return "Hidden variables detected (low R^2 + high residual autocorrelation)"
+        elif self.r2_ >= 0.95 and abs(self.residual_autocorr_) < 0.1:
+            return "Model is structurally adequate."
+        else:
+            return "Further inspection recommended."
+
+    def _build_static_features(self, X, base_names):
+        """静态模式：多项式 + 超越函数"""
+        poly = PolynomialFeatures(degree=2, include_bias=False, interaction_only=False)
+        X_poly = poly.fit_transform(X)
+        poly_names = poly.get_feature_names_out(base_names)
+        
+        # 添加超越函数特征
+        trans_list = [X_poly]
+        trans_names = list(poly_names)
+        
+        n_samples, n_features = X.shape
+        for i in range(n_features):
+            xi = X[:, i]
+            # 安全处理，防止除零/溢出
+            trans_list.append(np.sqrt(np.abs(xi)).reshape(-1, 1))
+            trans_names.append(f'sqrt_{base_names[i]}')
+            trans_list.append(np.exp(-xi**2).reshape(-1, 1))
+            trans_names.append(f'exp_neg_{base_names[i]}_sq')
+            trans_list.append(np.sin(xi).reshape(-1, 1))
+            trans_names.append(f'sin_{base_names[i]}')
+            trans_list.append(np.cos(xi).reshape(-1, 1))
+            trans_names.append(f'cos_{base_names[i]}')
+            trans_list.append(np.log1p(np.abs(xi)).reshape(-1, 1))
+            trans_names.append(f'log1p_{base_names[i]}')
+            # 反比例项
+            trans_list.append((1.0 / (1.0 + np.abs(xi))).reshape(-1, 1))
+            trans_names.append(f'inv1p_{base_names[i]}')
+        
+        return np.hstack(trans_list), trans_names
+
+    def _build_time_series_features(self, X, base_names):
+        """时间序列模式：基础项 + 时滞 + 积分核"""
+        n_samples, n_features = X.shape
+        dt = 1.0  # 假设均匀采样间隔为1
+        
+        feature_list = [X]
+        names = list(base_names)
+        
+        # 时滞项
+        for lag in [1, 2, 5, 10]:
+            if lag < n_samples:
+                for j in range(n_features):
+                    rolled = np.roll(X[:, j], lag)
+                    rolled[:lag] = X[0, j]  # 边界填充
+                    feature_list.append(rolled.reshape(-1, 1))
+                    names.append(f'{base_names[j]}_lag{lag}')
+        
+        # 连续指数积分核 (多个衰减率)
+        alphas = [0.05, 0.1, 0.2, 0.5]
+        for j in range(n_features):
+            for alpha in alphas:
+                mem = np.zeros(n_samples)
+                cum_sum = 0.0
+                for i in range(n_samples):
+                    if i == 0:
+                        cum_sum = X[0, j] * dt
+                    else:
+                        cum_sum = np.exp(-alpha * dt) * cum_sum + X[i, j] * dt
+                    mem[i] = cum_sum
+                feature_list.append(mem.reshape(-1, 1))
+                names.append(f'int_{base_names[j]}_a{alpha}')
+        
+        # 时变核 (示例：正弦调制)
+        t = np.arange(n_samples) * dt
+        for j in range(n_features):
+            for amp in [0.1, 0.2]:
+                alpha_t = 0.1 + amp * np.sin(2 * np.pi * t / 25.0)
+                mem = np.zeros(n_samples)
+                for i in range(n_samples):
+                    integral = 0.0
+                    for k in range(i):
+                        tau = (i - k) * dt
+                        integral += np.exp(-alpha_t[i] * tau) * X[k, j] * dt
+                    mem[i] = integral
+                feature_list.append(mem.reshape(-1, 1))
+                names.append(f'tv_int_{base_names[j]}_amp{amp}')
+        
+        return np.hstack(feature_list), names
+
+    def _bic_fit(self, Theta, target, feature_names):
+        """扁平两阶段 + BIC 后向剔除"""
+        Theta_std = np.std(Theta, axis=0)
+        Theta_std[Theta_std == 0] = 1.0
+        Theta_scaled = Theta / Theta_std
+        n_samples, n_features = Theta.shape
+        active = list(range(n_features))
+
+        def compute_bic(pred, target, k):
+            sse = np.sum((target - pred)**2)
+            if sse < 1e-15: sse = 1e-15
+            return n_samples * np.log(sse / n_samples) + k * np.log(n_samples)
+
+        # 初始全模型拟合
+        coeffs_full = np.linalg.lstsq(Theta_scaled, target, rcond=1e-6)[0]
+        pred_full = Theta_scaled @ coeffs_full
+        best_bic = compute_bic(pred_full, target, len(active))
+
+        # 后向剔除
+        while len(active) > 1:
+            candidate_bics = []
+            for col in active:
+                trial = [c for c in active if c != col]
+                Theta_trial = Theta_scaled[:, trial]
+                coeff_trial = np.linalg.lstsq(Theta_trial, target, rcond=1e-6)[0]
+                pred_trial = Theta_trial @ coeff_trial
+                bic_trial = compute_bic(pred_trial, target, len(trial))
+                candidate_bics.append((bic_trial, col))
+            candidate_bics.sort(key=lambda v: v[0])
+            min_bic, drop_col = candidate_bics[0]
+            if min_bic < best_bic:
+                active.remove(drop_col)
+                best_bic = min_bic
+            else:
+                break
+
+        # 最终系数还原到原始尺度
+        final_coeffs = np.zeros(n_features)
+        if len(active) > 0:
+            Theta_active_scaled = Theta_scaled[:, active]
+            coeff_active = np.linalg.lstsq(Theta_active_scaled, target, rcond=1e-6)[0]
+            final_coeffs[active] = coeff_active / Theta_std[active]
+
+        # R² 和残差自相关
+        pred = Theta @ final_coeffs
+        ss_res = np.sum((target - pred)**2)
+        ss_tot = np.sum((target - np.mean(target))**2)
+        r2 = 1 - ss_res/ss_tot if ss_tot > 1e-12 else 1.0
+
+        residual = target - pred
+        residual_detrend = residual - np.mean(residual)
+        acf = np.correlate(residual_detrend, residual_detrend, mode='same')
+        lag1 = acf[len(acf)//2 + 1] / acf[len(acf)//2] if acf[len(acf)//2] != 0 else 0.0
+
+        return final_coeffs, active, r2, lag1
+
+    def _format_equation(self, coeffs, names, active_idx):
+        """将系数格式化为方程字符串"""
+        if len(active_idx) == 0:
+            return "y = 0 (all terms eliminated)"
+        terms = []
+        for i in active_idx:
+            c = coeffs[i]
+            if abs(c) > 1e-10:
+                terms.append(f"{round(c, 6)}*{names[i]}")
+        if not terms:
+            return "y = constant"
+        return "y = " + " + ".join(terms).replace("+ -", "- ")
+
+
+# 兼容旧版别名
+CDE_V6_6 = CDE_V80