Upload app.py

app.py

@@ -1074,7 +1074,140 @@ def run_sympy(problem: str) -> dict:
             except Exception:
                 pass  # safe fallback to AI for all theory/proof questions
 
-        # ── 9. Matrix / Eigenvalues — delegate to AI ─────────────────
+        # ── 9. Differential Geometry — SymPy for computations ──────────
+        elif any(k in p for k in [
+                "curvature", "torsion", "tangent vector", "normal vector",
+                "binormal", "serret-frenet", "frenet", "osculating",
+                "arc length", "space curve", "plane curve", "helix", "helices",
+                "evolute", "involute", "rectifying plane",
+                "first fundamental form", "second fundamental form",
+                "fundamental form", "gaussian curvature", "mean curvature",
+                "principal curvature", "geodesic",
+                "parametric surface", "christoffel", "covariant derivative",
+                "contravariant", "metric tensor",
+        ]):
+            t_s = sp.Symbol('t')
+            u_s, v_s = sp.symbols('u v')
+            try:
+
+                # ── Curvature of plane curve y=f(x) ──────────────────────
+                if "curvature" in p and not any(k in p for k in ["gaussian","mean","space","torsion"]):
+                    # Extract function and point
+                    m = re.search(r"(?:of|for)\s+y\s*=\s*(.+?)(?:\s+at|\s*$)", p)
+                    pt_m = re.search(r"at\s+x\s*[=:]\s*([-\d\.]+)", p)
+                    if m:
+                        raw = clean(m.group(1).strip())
+                        expr_c = parse_expr(raw, transformations=tfms, local_dict=ld)
+                        dy  = sp.diff(expr_c, x)
+                        d2y = sp.diff(expr_c, x, 2)
+                        kappa_expr = sp.Abs(d2y) / (1 + dy**2)**sp.Rational(3,2)
+                        if pt_m:
+                            pt_val = float(pt_m.group(1))
+                            kappa_val = sp.simplify(kappa_expr.subs(x, pt_val))
+                            return {
+                                "type": "Curvature",
+                                "result": f"κ at x={pt_val}: y'={dy.subs(x,pt_val)}, y''={d2y.subs(x,pt_val)}, κ={kappa_val}",
+                                "latex": f"\\kappa = {sp.latex(kappa_val)}"
+                            }
+                        else:
+                            return {
+                                "type": "Curvature",
+                                "result": f"κ(x) = {sp.simplify(kappa_expr)}",
+                                "latex": f"\\kappa = {sp.latex(sp.simplify(kappa_expr))}"
+                            }
+
+                # ── Arc Length ────────────────────────────────────────────
+                elif "arc length" in p:
+                    m = re.search(r"(?:of|for)\s+y\s*=\s*(.+?)\s+from\s+([-\d\.]+)\s+to\s+([-\d\.]+)", p)
+                    if m:
+                        raw = clean(m.group(1).strip())
+                        a_v = sp.sympify(m.group(2))
+                        b_v = sp.sympify(m.group(3))
+                        expr_al = parse_expr(raw, transformations=tfms, local_dict=ld)
+                        dy = sp.diff(expr_al, x)
+                        integrand = sp.sqrt(1 + dy**2)
+                        L = sp.integrate(integrand, (x, a_v, b_v))
+                        L_simplified = sp.simplify(L)
+                        return {
+                            "type": "ArcLength",
+                            "result": f"L = ∫√(1+y'²)dx from {a_v} to {b_v} = {L_simplified}",
+                            "latex": f"L = {sp.latex(L_simplified)}"
+                        }
+
+                # ── Space Curve: Curvature + Torsion ─────────────────────
+                elif any(k in p for k in ["space curve","torsion","frenet","serret"]):
+                    # Extract parametric curve r(t) = (x(t), y(t), z(t))
+                    pts = re.findall(r"\(\s*(.+?)\s*,\s*(.+?)\s*,\s*(.+?)\s*\)", p)
+                    pt_m = re.search(r"at\s+t\s*[=:]\s*([-\d\.]+)", p)
+                    if pts:
+                        rx = parse_expr(clean(pts[0][0]), transformations=tfms, local_dict={**ld, "t": t_s})
+                        ry = parse_expr(clean(pts[0][1]), transformations=tfms, local_dict={**ld, "t": t_s})
+                        rz = parse_expr(clean(pts[0][2]), transformations=tfms, local_dict={**ld, "t": t_s})
+                        r_vec = sp.Matrix([rx, ry, rz])
+                        dr = r_vec.diff(t_s)
+                        d2r = dr.diff(t_s)
+                        d3r = d2r.diff(t_s)
+                        speed = sp.sqrt(dr.dot(dr))
+                        cross = dr.cross(d2r)
+                        kappa = sp.simplify(sp.sqrt(cross.dot(cross)) / speed**3)
+                        torsion_val = sp.simplify(cross.dot(d3r) / cross.dot(cross))
+                        t_val = float(pt_m.group(1)) if pt_m else 0
+                        k_at = sp.simplify(kappa.subs(t_s, t_val))
+                        tau_at = sp.simplify(torsion_val.subs(t_s, t_val))
+                        T_vec = sp.simplify(dr / speed)
+                        return {
+                            "type": "FrenetSerret",
+                            "result": (f"r(t)={pts[0]}, at t={t_val}:\n"
+                                      f"κ = {k_at}, τ = {tau_at}\n"
+                                      f"T = {T_vec.subs(t_s,t_val).T}"),
+                            "latex": f"\\kappa={sp.latex(k_at)}, \\tau={sp.latex(tau_at)}"
+                        }
+
+                # ── First Fundamental Form ────────────────────────────────
+                elif "first fundamental form" in p:
+                    pts = re.findall(r"\(\s*(.+?)\s*,\s*(.+?)\s*,\s*(.+?)\s*\)", p)
+                    if pts:
+                        rx = parse_expr(clean(pts[0][0]), transformations=tfms, local_dict={**ld, "u": u_s, "v": v_s})
+                        ry = parse_expr(clean(pts[0][1]), transformations=tfms, local_dict={**ld, "u": u_s, "v": v_s})
+                        rz = parse_expr(clean(pts[0][2]), transformations=tfms, local_dict={**ld, "u": u_s, "v": v_s})
+                        r_vec = sp.Matrix([rx, ry, rz])
+                        ru = r_vec.diff(u_s)
+                        rv = r_vec.diff(v_s)
+                        E = sp.simplify(ru.dot(ru))
+                        F = sp.simplify(ru.dot(rv))
+                        G = sp.simplify(rv.dot(rv))
+                        return {
+                            "type": "FirstFundamentalForm",
+                            "result": f"E={E}, F={F}, G={G}, ds²={E}du²+{2*F}dudv+{G}dv²",
+                            "latex": f"E={sp.latex(E)}, F={sp.latex(F)}, G={sp.latex(G)}"
+                        }
+
+                # ── Gaussian + Mean Curvature ─────────────────────────────
+                elif any(k in p for k in ["gaussian curvature","mean curvature"]):
+                    pts = re.findall(r"\(\s*(.+?)\s*,\s*(.+?)\s*,\s*(.+?)\s*\)", p)
+                    if pts:
+                        rx = parse_expr(clean(pts[0][0]), transformations=tfms, local_dict={**ld, "u": u_s, "v": v_s})
+                        ry = parse_expr(clean(pts[0][1]), transformations=tfms, local_dict={**ld, "u": u_s, "v": v_s})
+                        rz = parse_expr(clean(pts[0][2]), transformations=tfms, local_dict={**ld, "u": u_s, "v": v_s})
+                        r_vec = sp.Matrix([rx, ry, rz])
+                        ru = r_vec.diff(u_s); rv = r_vec.diff(v_s)
+                        E = sp.simplify(ru.dot(ru)); F = sp.simplify(ru.dot(rv)); G = sp.simplify(rv.dot(rv))
+                        n = ru.cross(rv); N = sp.simplify(n / sp.sqrt(n.dot(n)))
+                        L = sp.simplify(N.dot(ru.diff(u_s)))
+                        M = sp.simplify(N.dot(ru.diff(v_s)))
+                        Nv = sp.simplify(N.dot(rv.diff(v_s)))
+                        K = sp.simplify((L*Nv - M**2)/(E*G - F**2))
+                        H = sp.simplify((E*Nv - 2*F*M + G*L)/(2*(E*G - F**2)))
+                        return {
+                            "type": "GaussianCurvature",
+                            "result": f"K (Gaussian) = {K}, H (Mean) = {H}",
+                            "latex": f"K={sp.latex(K)}, H={sp.latex(H)}"
+                        }
+
+            except Exception:
+                pass  # safe fallback to AI
+
+        # ── 10. Matrix / Eigenvalues — delegate to AI ────────────────────
         elif any(k in p for k in ["matrix", "determinant", "eigenvalue",
                                    "eigenvector", "det("]):
             return {"type": "Matrix", "result": "matrix_detected", "latex": ""}
@@ -1217,6 +1350,20 @@ def ask_ai(problem: str, sympy_info: dict, history: list) -> str:
         "D. NEVER recompute sin(pi), cos(pi) etc — sin(pi)=0 exactly, always.\n"
         "E. For Lagrange/Newton interpolation: the polynomial is already given above — DO NOT re-expand or re-derive it. Just show the basis polynomials and state the final polynomial from the verified result.\n"
         "F. Your final answer must EXACTLY match the verified result — no exceptions.\n\n"
+        "=== DIFFERENTIAL GEOMETRY RULES (follow exactly) ===\n"
+        "For ANY Differential Geometry question:\n"
+        "A. ALWAYS state the definition or theorem FIRST before computing.\n"
+        "B. Plane curve curvature: κ = |y''| / (1+y'²)^(3/2).\n"
+        "C. Space curve: κ = |r'×r''| / |r'|³, τ = (r'×r'')·r''' / |r'×r''|².\n"
+        "D. Frenet-Serret formulas: dT/ds=κN, dN/ds=-κT+τB, dB/ds=-τN.\n"
+        "E. Unit vectors: T=r'/|r'|, N=T'/|T'|, B=T×N.\n"
+        "F. First Fundamental Form: ds²=Edu²+2Fdudv+Gdv², where E=ru·ru, F=ru·rv, G=rv·rv.\n"
+        "G. Second Fundamental Form: L=N·ruu, M=N·ruv, N_coeff=N·rvv.\n"
+        "H. Gaussian curvature: K=(LN-M²)/(EG-F²), Mean curvature: H=(EN-2FM+GL)/(2(EG-F²)).\n"
+        "I. For proofs: state Given → To Prove → Proof steps clearly.\n"
+        "J. For mixed questions: definition first → formula → computation → geometric meaning.\n"
+        "K. Christoffel symbols: Γᵢⱼᵏ = (1/2)gᵏˡ(∂gᵢˡ/∂xʲ + ∂gⱼˡ/∂xⁱ - ∂gᵢⱼ/∂xˡ).\n"
+        "L. For tensors: always specify contravariant (upper) vs covariant (lower) indices.\n\n"
         "=== REAL ANALYSIS II RULES (follow exactly) ===\n"
         "For ANY Real Analysis II question:\n"
         "A. Always start with the FORMAL DEFINITION using proper mathematical notation.\n"