Update app.py

app.py

@@ -1,4 +1,5 @@
-
+# app.py
+# LanguageBridge — Math Fast Agent (SymPy)  (2025-11-04 修正版)
 import re
 import gradio as gr
 import sympy as sp
@@ -6,94 +7,246 @@ from sympy.parsing.sympy_parser import (
     parse_expr, standard_transformations,
     implicit_multiplication_application, convert_xor
 )
+from sympy import Interval, Union, S, And, Or
+from sympy.solvers.inequalities import solve_univariate_inequality
 
 TITLE = "LanguageBridge — Math Fast Agent (SymPy)"
 
-# ---- 僅做安全正規化：全形→半形、^→**、√→sqrt ----
+# ----------------------------
+# 1) 安全正規化：全形→半形、特殊符號、常見中文習慣
+# ----------------------------
+_ASCII_TABLE = str.maketrans({
+    # 括號與標點
+    "（": "(", "）": ")", "，": ",", "、": ",", "；": ";", "：": ":",
+    "．": ".", "。": ".", "，": ",", "！": "!", "？": "?",
+    # 運算與關係
+    "＋": "+", "－": "-", "～": "~", "＝": "=", "＊": "*", "／": "/",
+    "＜": "<", "＞": ">", "≤": "<=", "≥": ">=",
+    "∧": "&", "∨": "|",
+    # 乘號、根號
+    "×": "*", "√": "sqrt",
+    # 希臘字母/常數
+    "π": "pi", "Π": "pi",
+    "θ": "theta", "Θ": "theta",
+})
+
+# 允許保留的英文單字（其餘中文字會被視為非數學描述）
+_ALLOWED_WORDS = {
+    "sin","cos","tan","cot","sec","csc",
+    "asin","acos","atan","sinh","cosh","tanh","log","ln","exp","sqrt","abs",
+    "diff","integrate","factor","simplify","expand"
+}
+
 def normalize_ascii(s: str) -> str:
-    table = str.maketrans({
-        "（":"(", "）":")", "，":",", "；":";", "：":":",
-        "＝":"=", "－":"-", "＋":"+", "＊":"*", "／":"/", "。":".",
-        "×":"*", "√":"sqrt"
-    })
-    return s.translate(table)
-
-def preprocess(expr: str) -> str:
-    s = (expr or "").strip()
-    s = normalize_ascii(s)
+    s = (s or "").replace("\u00A0", " ").replace("\u3000", " ")  # 不換行空白/全形空白
+    s = s.translate(_ASCII_TABLE)
     s = s.replace("^", "**")  # 2^3 -> 2**3
-    # ⛔ 不再自動補 *，避免把 sin(x) 變成 sin*(x)
+    # 把中文逗號/頓號已轉成 ,；允許拿來分割「等式 + 條件」
     return s
 
-# SymPy 解析：啟用隱式乘法與 ^ 號處理
+# d/dx(...) → diff(..., x)
+_DDX_RE = re.compile(r"d\s*/\s*d([A-Za-z_]\w*)\s*\(\s*(.+)\s*\)\s*$")
+
+def desugar_ddx(s: str) -> str:
+    m = _DDX_RE.match(s.strip())
+    if not m:
+        return s
+    var = m.group(1)
+    inside = m.group(2)
+    return f"diff(({inside}), {var})"
+
+# 基本轉換：隱式乘法、^ 號
 TRANS = standard_transformations + (implicit_multiplication_application, convert_xor)
 
-def to_sympy_expr(s: str):
-    return parse_expr(preprocess(s), transformations=TRANS)
+def to_sympy_expr(raw: str):
+    s = normalize_ascii(raw)
+    s = desugar_ddx(s)
+    return parse_expr(s, transformations=TRANS)
 
-def to_sympy_eq(s: str):
-    s = preprocess(s)
+def to_sympy_eq(raw: str):
+    s = normalize_ascii(raw)
+    # 只取第一個 "=" 左右，避免 a=b=c 之類字串誤用
     if "=" not in s:
         raise ValueError("等式缺少 '='")
     L, R = s.split("=", 1)
     return sp.Eq(parse_expr(L, transformations=TRANS),
                  parse_expr(R, transformations=TRANS))
 
+# ----------------------------
+# 2) 解析「逗號分隔的不等式條件」→ 定義域 (Interval/Set)
+#    例： "0 <= theta < 2*pi" 或 "x>=0" 或 "x in [0,1]"
+# ----------------------------
+def parse_domain_chunks(chunks, var):
+    """
+    將類似 "0 <= theta < 2*pi"、"theta<pi/3"、"x in [0,1]" 轉成 Set
+    以交集的方式逐一收斂 domain。
+    """
+    domain = S.Reals
+    for c in chunks:
+        c = normalize_ascii(c.strip())
+        if not c:
+            continue
+
+        # 支援 x in [a,b] / (a,b) / [a,b) / (a,b]
+        m = re.match(rf"^{var}\s*in\s*([\[\(])\s*(.+)\s*,\s*(.+)\s*([\]\)])$", c)
+        if m:
+            left_open = m.group(1) == "("
+            right_open = m.group(4) == ")"
+            a = parse_expr(m.group(2), transformations=TRANS)
+            b = parse_expr(m.group(3), transformations=TRANS)
+            domain = domain.intersect(Interval(a, b, left_open, right_open))
+            continue
+
+        # 一般不等式/連鎖不等式：交給 solve_univariate_inequality
+        try:
+            ineq = parse_expr(c, transformations=TRANS, evaluate=False)
+            set_part = solve_univariate_inequality(ineq, var, relational=False)
+            domain = domain.intersect(set_part)
+        except Exception:
+            # 不可解析就保留原 domain，不報錯
+            pass
+    return domain
+
+# ----------------------------
+# 3) 輔助：檢查是否混雜太多非數學描述
+# ----------------------------
+_NON_MATH_RE = re.compile(r"[^\dA-Za-z_+\-*/^().,;=<>!&| \[\]{}:]+")
+
+def looks_like_math(s: str) -> bool:
+    # 去除已允許的單字與函數名
+    tmp = s
+    for w in _ALLOWED_WORDS:
+        tmp = re.sub(rf"\b{w}\b", "", tmp)
+    # 若還剩大量非數學符號（尤其中文敘述），視為不適合直接解析
+    return not _NON_MATH_RE.search(tmp)
+
+# ----------------------------
+# 4) 主邏輯
+# ----------------------------
 def solve_math(q: str):
     q = (q or "").strip()
     if not q:
-        return "請輸入算式或方程，例如：3x+7=1；sin(x)^2+cos(x)^2；factor(x^4-1)"
+        return (
+            "請輸入算式（可多行或用分號 ; 分隔）。\n"
+            "例：\n"
+            "  1) 2x + 5 = 11\n"
+            "  2) sin(theta) = sqrt(3)/2 , 0 <= theta < 2*pi\n"
+            "  3) factor(x^2 - 9x + 18)\n"
+            "  4) d/dx ((x^2+1)*(x-3))\n"
+        )
 
-    try:
-        # 多行 / 分號；分隔
-        parts = [s.strip() for seg in q.split(";") for s in seg.split("\n")]
-        parts = [p for p in parts if p]
-
-        # 任何一行有 '=' → 解（可聯立）
-        if any("=" in p for p in parts):
-            eqs, syms = [], set()
-            for s in parts:
-                if "=" in s:
-                    e = to_sympy_eq(s)
-                    eqs.append(e)
-                    syms |= e.free_symbols | getattr(e, "rhs", sp.Integer(0)).free_symbols
-            if not syms:
-                syms = {sp.symbols("x")}
-            sol = sp.solve(eqs, list(syms), dict=True)
-            if not sol:
-                return "無解或需要更多條件。"
-            return "\n".join(
-                f"解 {i}: " + ", ".join([f"{k} = {sp.simplify(v)}" for k, v in d.items()])
-                for i, d in enumerate(sol, 1)
-            )
-
-        # 否則：一般表達式（簡化/因式/微分/積分）
-        expr = to_sympy_expr(q)
-        out = []
-        try: out.append(f"簡化：{sp.simplify(expr)}")
-        except Exception: out.append(f"簡化：{expr}")
-        try:
-            fact = sp.factor(expr)
-            if fact != expr: out.append(f"因式分解：{fact}")
-        except Exception: pass
-        try:
-            x = next(iter(expr.free_symbols)) if expr.free_symbols else sp.symbols("x")
-            out.append(f"對 {x} 微分：{sp.diff(expr, x)}")
-            out.append(f"對 {x} 積分：{sp.integrate(expr, x)}")
-        except Exception: pass
-        return "\n".join(out) if out else f"結果：{expr}"
+    # 允許多行 or 分號
+    segs = [s for line in q.split("\n") for s in line.split(";")]
+    segs = [s.strip() for s in segs if s.strip()]
 
+    # 只要有 '=' 視為求解方程（可聯立）
+    if any("=" in s for s in segs):
+        # 先把「每行的 equation 與 同行後面的不等式/條件」分開
+        equations = []
+        all_symbols = set()
+        per_eq_domains = []
+
+        for line in segs:
+            # 用逗號分出「主等式」與「條件」
+            parts = [p.strip() for p in line.split(",") if p.strip()]
+            if not parts:
+                continue
+            if "=" in parts[0]:
+                eq = to_sympy_eq(parts[0])
+                equations.append(eq)
+                all_symbols |= (eq.lhs.free_symbols | eq.rhs.free_symbols)
+                # 解析該行其餘不等式作為此等式變數的 domain
+                # 僅對「一元」等式給 domain（多元聯立先忽略 domain）
+                per_eq_domains.append(parts[1:] if len(parts) > 1 else [])
+            else:
+                # 這行不是等式，可能是額外條件，先忽略（或日後擴充）
+                pass
+
+        if not equations:
+            return "解析失敗：未偵測到等式。"
+
+        # 多元聯立 → 用 solve（無 domain）
+        # 一元等式（只有一個主要變數）→ 用 solveset + domain
+        # 嘗試偵測「主變數」
+        main_syms = set()
+        for eq in equations:
+            main_syms |= (eq.lhs.free_symbols | eq.rhs.free_symbols)
+        if len(main_syms) == 1:
+            var = next(iter(main_syms))
+            # 匯總所有行的 domain 條件（若有）
+            domain_chunks = []
+            for ch in per_eq_domains:
+                domain_chunks.extend(ch)
+            domain = parse_domain_chunks(domain_chunks, str(var))
+            solset = sp.solveset(sp.Eq(equations[0].lhs - equations[0].rhs, 0), var, domain=domain)
+            if solset is sp.EmptySet:
+                return "無解（考慮定義域後）。"
+            return f"解：{sp.simplify(solset)}"
+        else:
+            # 多元聯立：舊路徑（不支援 domain）
+            try:
+                sol = sp.solve(equations, list(main_syms), dict=True)
+                if not sol:
+                    return "無解或需要更多條件。"
+                lines = []
+                for i, d in enumerate(sol, 1):
+                    items = ", ".join([f"{k} = {sp.simplify(v)}" for k, v in d.items()])
+                    lines.append(f"解 {i}: {items}")
+                return "\n".join(lines)
+            except Exception as e:
+                return f"解析失敗：{e}"
+
+    # 否則當作一般表達式：簡化 / 因式 / 微分 / 積分
+    expr_text = normalize_ascii(q)
+    if not looks_like_math(expr_text):
+        return "偵測到大量非數學描述，請改以純算式輸入（可用逗號加入條件）。\n例：sin(theta)=sqrt(3)/2 , 0<=theta<2*pi"
+
+    try:
+        expr = to_sympy_expr(expr_text)
     except Exception as e:
         return f"解析失敗：{e}"
 
+    out_lines = []
+    try:
+        out_lines.append(f"簡化：{sp.simplify(expr)}")
+    except Exception:
+        out_lines.append(f"簡化：{expr}")
+
+    try:
+        fact = sp.factor(expr)
+        if fact != expr:
+            out_lines.append(f"因式分解：{fact}")
+    except Exception:
+        pass
+
+    try:
+        x = next(iter(expr.free_symbols)) if expr.free_symbols else sp.symbols("x")
+        out_lines.append(f"對 {x} 微分：{sp.diff(expr, x)}")
+        out_lines.append(f"對 {x} 積分：{sp.integrate(expr, x)}")
+    except Exception:
+        pass
+
+    return "\n".join(out_lines) if out_lines else f"結果：{expr}"
+
+# ----------------------------
+# 5) UI
+# ----------------------------
 with gr.Blocks(title=TITLE) as demo:
     gr.Markdown(
-        "## " + TITLE + "\\n"
-        "貼上算式（可多行 / 分號 `;` 分隔）。支援隱式乘法（例：`3x`, `2(x+1)`, `(x+1)(x-1)`, `2sqrt(x)`）與 `^`。"
+        "## " + TITLE + "\n"
+        "貼上算式（可多行 / 分號 `;` 分隔）。支援隱式乘法（例：`3x`, `2(x+1)`, `(x+1)(x-1)`, `2sqrt(x)`）與 `^`。\n\n"
+        "**範例**：\n"
+        "- `2x + 5 = 11`\n"
+        "- `sin(theta) = sqrt(3)/2 , 0 <= theta < 2*pi`\n"
+        "- `factor(x^2 - 9x + 18)`\n"
+        "- `d/dx ((x^2+1)*(x-3))`\n"
+        "※ 若有定義域，請以逗號分隔放在等式後面；可用 `in [a,b]`、`0<=x<1` 等寫法。\n"
     )
-    q = gr.Textbox(lines=6, label="題目 / 算式（可含聯立方程）")
-    out = gr.Textbox(lines=12, label="輸出")
+    q = gr.Textbox(lines=6, label="題目 / 算式（可含聯立方程與條件）")
+    out = gr.Textbox(lines=14, label="輸出")
     gr.Button("送出 🚀").click(fn=solve_math, inputs=q, outputs=out)
 
 if __name__ == "__main__":
+    # Space 內會由 runner 啟動；本地測試可開啟
     demo.launch()
+