Upload 8 files

Deploy portfolio refactor and preserve verified answers when AI providers fail

.env.example

@@ -0,0 +1,14 @@
+# AI provider credentials. At least one text provider key is needed for explanations.
+GROQ_API_KEY_1=
+GROQ_API_KEY_2=
+GROQ_API_KEY_3=
+GEMINI_API_KEY_1=
+GEMINI_API_KEY_2=
+GEMINI_API_KEY_3=
+GEMINI_API_KEY_4=
+OPENROUTER_API_KEY=
+
+# Operational limits. Values are clamped by src/config.py.
+PROVIDER_TIMEOUT_SECONDS=60
+MAX_UPLOAD_BYTES=5242880
+MAX_PDF_PAGES=6

.gitignore

@@ -0,0 +1,10 @@
+__pycache__/
+*.py[cod]
+.venv/
+venv/
+.env
+.env.*
+!.env.example
+.streamlit/secrets.toml
+.pytest_cache/
+.DS_Store

README.md

@@ -1,55 +1,104 @@
----
-title: Saad.AI
-emoji: 🧠
-colorFrom: blue
-colorTo: indigo
-sdk: streamlit
-sdk_version: 1.32.0
-app_file: app.py
-pinned: false
-license: mit
----
-
-# 🧠 Saad.AI — BSc Mathematics Engine
-
-A powerful AI math solver combining **Groq Llama 3.3 70B** (step-by-step reasoning) with **SymPy** (verified symbolic computation) — designed for BSc-level mathematics.
-
-## ✨ Features
-- ✅ **Zero arithmetic errors** — SymPy verifies every calculation
-- 📝 **Step-by-step solutions** — every step shown clearly
-- 📐 **LaTeX math rendering** — beautiful equations
-- 🧠 **Groq Llama 3.3 70B** — understands complex problems in plain English
-
-## 📚 Topics Covered
-| Subject | Examples |
-|---|---|
-| Calculus | Derivatives, Integrals, Limits, Series |
-| Linear Algebra | Matrices, Eigenvalues, Vector Spaces |
-| Number Theory | Congruences, Primes, Euler's Theorem |
-| Differential Equations | ODEs, PDEs, Laplace Transforms |
-| Numerical Methods | Newton-Raphson, Euler's Method |
-| Differential Geometry | Curves, Curvature, Surfaces |
-| Hydro Mechanics | Fluid Dynamics, Bernoulli, Continuity |
-| Theory of Numbers | GCD, LCM, Fermat's Little Theorem |
-| Real Analysis II | Convergence, Continuity, Riemann Integral |
-
-## 🚀 Setup on Hugging Face
-1. Create a new **Space** on [huggingface.co/spaces](https://huggingface.co/spaces)
-2. Choose **Streamlit** as the SDK
-3. Upload all 3 files: `app.py`, `requirements.txt`, `README.md`
-4. Go to **Settings → Variables and Secrets**
-5. Add secret: `GROQ_API_KEY` = your key from [console.groq.com](https://console.groq.com)
-6. The app will automatically build and run!
-
-## 💡 Example Problems to Try
-- `Find the derivative of x^3 * sin(x)`
-- `Integrate e^x * cos(x) dx`
-- `Solve 14x ≡ 30 (mod 44)`
-- `Find eigenvalues of matrix [[4,1],[2,3]]`
-- `Solve the ODE dy/dx + 2y = e^(-x)`
-- `Find limit of (1 + 1/n)^n as n → ∞`
-- `Apply Newton-Raphson to x^3 - 2x - 5 = 0`
-
-## 👨‍💻 Built By
-Created by **Saad** — a passionate developer who built this from scratch
-to help BSc Mathematics students solve problems with 100% accuracy.
+# Saad.AI — B.Sc. Mathematics Engine
+
+Saad.AI is an academic mathematics assistant for university students. It combines a deterministic **SymPy computation engine** with configurable AI providers for explanations, proofs, theory questions, graph descriptions, and image/PDF-based problem solving. See [PORTFOLIO.md](PORTFOLIO.md) for the project story and demo flow.
+
+> **Important:** SymPy verification applies only when a request matches one of the implemented deterministic adapters. General proofs, theory questions, unsupported matrix formats, and unsupported subjects are treated as AI-generated unless a deterministic adapter returns a verified result.
+
+## Current capabilities
+
+| Area | Examples | Verification mode |
+|---|---|---|
+| Calculus | Derivatives, integrals, limits | SymPy when parsed successfully |
+| Equations | Polynomial equations and roots | SymPy when parsed successfully |
+| Differential equations | Selected first- and second-order ODE forms | SymPy for supported forms |
+| Numerical methods | Newton–Raphson, bisection, secant, Simpson, trapezoidal, Euler, RK4 | Deterministic numeric adapter |
+| Number theory | GCD, LCM, factorization, totient, congruences, CRT, selected theorems, modulo | SymPy / deterministic adapter |
+| Linear algebra | Determinants, eigenvalues/eigenvectors, inverses, ranks, transposes | Deterministic SymPy adapter |
+| Real analysis | Selected sequence, series, Taylor, and integral computations | SymPy for supported computations; AI for theory/proofs |
+| Differential geometry | Curvature, arc length, Frenet–Serret, fundamental forms | SymPy for supported parametric forms |
+| Hydro mechanics | Continuity, Bernoulli, Reynolds, flow rate, pressure, Torricelli | Deterministic formula adapter for supported prompts |
+| Graphing | Explicit requests to plot or graph a function | Matplotlib rendering |
+| Attachments | JPG, PNG, WEBP, and PDF questions | Vision provider; deterministic verification when extractable |
+
+The engine is intentionally not presented as a universal proof checker. For questions that cannot be deterministically parsed, the application sends the prompt to the configured AI provider and labels the result as AI-generated where appropriate.
+
+## Architecture
+
+The current stabilization refactor keeps Streamlit as the user interface while separating the main responsibilities:
+
+```text
+math-engine/
+├── app.py                         # Streamlit UI, session flow, and graph rendering
+├── src/
+│   ├── engine/
+│   │   └── sympy_engine.py        # Deterministic symbolic and numeric adapters
+│   └── services/
+│       └── ai.py                  # Provider rotation, vision, uploads, verification
+├── tests/
+│   └── test_engine.py             # Deterministic engine regression tests
+├── requirements.txt               # Runtime dependencies actually used by the app
+└── README.md
+```
+
+The next recommended phase is to split the remaining UI, persistence, and plotting concerns into their own modules and add provider mocks and upload fixtures.
+
+## Run locally
+
+```bash
+git clone https://github.com/almuyed-saad/math-engine.git
+cd math-engine
+python -m venv .venv
+source .venv/bin/activate
+pip install -r requirements.txt
+streamlit run app.py
+```
+
+Open `http://localhost:8501` in a browser.
+
+Run the deterministic regression tests with:
+
+```bash
+python -m unittest discover -s tests -v
+```
+
+## Configuration
+
+AI providers are optional for deterministic SymPy requests but required for explanations and unsupported subjects. Configure provider credentials through environment variables or Hugging Face Space secrets:
+
+```text
+GROQ_API_KEY_1
+GROQ_API_KEY_2
+GROQ_API_KEY_3
+GEMINI_API_KEY_1
+GEMINI_API_KEY_2
+GEMINI_API_KEY_3
+GEMINI_API_KEY_4
+OPENROUTER_API_KEY
+```
+
+Chat history is intentionally **session-local** in the portfolio edition. This keeps the application easy to understand and deploy while still allowing users to create, switch, and delete conversations during a demo session. A database is not required.
+
+## Example prompts
+
+```text
+Find the derivative of x^3 + 5x^2 - 3x + 7
+Integrate sin(x) * e^x dx
+Find limit of sin(x)/x as x -> 0
+Apply Newton-Raphson to x^3 - 2x - 5 = 0, x0=2, 3 iterations
+Apply bisection of x^3 - x on [0, 2], 4 iterations
+Find gcd of 84 and 30
+Solve 14x ≡ 30 (mod 44) using Euclidean algorithm
+Plot y = x^2 - 4 from -3 to 3
+```
+
+## Deployment notes
+
+The active source uses hosted API providers rather than loading a local Hugging Face model at runtime. The dependency list therefore excludes the previously declared `transformers` and `torch` packages, which were not used by the current application and added unnecessary deployment weight.
+
+Runtime configuration is centralized in `src/config.py`. Copy `.env.example` to `.env` for local development, or add the same variables as Hugging Face Space secrets. Provider timeouts, upload size, and PDF page limits are validated and clamped at startup so malformed deployment values cannot create unbounded resource usage.
+
+For a portfolio deployment, add the provider secrets to Hugging Face Spaces or another Streamlit host, then launch the app with `streamlit run app.py`. No database or authentication setup is required. Every push and pull request runs the deterministic test suite and Python compilation checks through [`.github/workflows/ci.yml`](.github/workflows/ci.yml).
+
+## Credits
+
+The project was created by Saad for B.Sc. Mathematics students at Shahjalal University of Science and Technology. It uses [Streamlit](https://streamlit.io), [SymPy](https://www.sympy.org), [Matplotlib](https://matplotlib.org), and hosted AI provider APIs.

ai.py

@@ -0,0 +1,791 @@
+"""AI provider integrations and file/vision processing for Saad.AI."""
+
+import re
+import time
+import requests
+
+from config import settings
+from sympy_engine import run_sympy
+
+
+def _post_with_retry(url: str, *, headers: dict, json: dict, timeout: float | None = None, attempts: int = 2):
+    """POST with a small bounded retry budget for transient provider failures."""
+    timeout = timeout or settings.provider_timeout_seconds
+    attempts = max(1, min(attempts, 3))
+
+    for attempt in range(attempts):
+        try:
+            response = requests.post(url, headers=headers, json=json, timeout=timeout)
+        except requests.exceptions.Timeout:
+            if attempt == attempts - 1:
+                raise
+            time.sleep(min(0.5 * (2**attempt), 2.0))
+            continue
+
+        retryable = response.status_code == 429 or response.status_code >= 500
+        if retryable and attempt < attempts - 1:
+            retry_after = response.headers.get("Retry-After", "")
+            try:
+                delay = min(max(float(retry_after), 0.0), 2.0)
+            except ValueError:
+                delay = min(0.5 * (2**attempt), 2.0)
+            time.sleep(delay)
+            continue
+        return response
+
+    raise RuntimeError("Provider request exhausted retry budget")
+
+def _deterministic_fallback(sympy_info: dict, reason: str = "") -> str:
+    """Return a useful verified answer when external explanation APIs fail."""
+    result = sympy_info.get("result")
+    latex = sympy_info.get("latex") or ""
+    method = sympy_info.get("type") or "Deterministic computation"
+    if not result:
+        return ""
+
+    reason_line = ""
+    if reason:
+        reason_line = f"\n\n_AI explanation unavailable: {reason}. The computation above is still deterministic._"
+    latex_block = f"\n\n**Mathematical form:**\n\n$${latex}$$" if latex else ""
+    return (
+        "✅ **SymPy Verified**\n\n"
+        f"**Method:** {method}\n\n"
+        f"**Computed result:**\n\n`{result}`"
+        f"{latex_block}"
+        f"{reason_line}"
+    )
+
+
+def ask_ai(problem: str, sympy_info: dict, history: list) -> str:
+
+    # ── Multi-provider auto-rotation ────────────────────────────────
+    # Try each provider in order — skip if key missing or 429
+    def try_groq(key, messages):
+        resp = _post_with_retry(
+            "https://api.groq.com/openai/v1/chat/completions",
+            headers={"Authorization": f"Bearer {key}", "Content-Type": "application/json"},
+            json={"model": "llama-3.3-70b-versatile", "messages": messages,
+                  "max_tokens": 2048, "temperature": 0.15, "top_p": 0.9},
+            timeout=settings.provider_timeout_seconds
+        )
+        resp.raise_for_status()
+        return resp.json()["choices"][0]["message"]["content"]
+
+    def try_gemini(key, messages):
+        # Convert messages to Gemini format
+        system_msg = next((m["content"] for m in messages if m["role"]=="system"), "")
+        user_msgs = [m for m in messages if m["role"] != "system"]
+        contents = []
+        for m in user_msgs:
+            role = "user" if m["role"]=="user" else "model"
+            contents.append({"role": role, "parts": [{"text": m["content"]}]})
+        payload = {
+            "system_instruction": {"parts": [{"text": system_msg}]},
+            "contents": contents,
+            "generationConfig": {"maxOutputTokens": 2048, "temperature": 0.15}
+        }
+        # Try 2.0-flash first, fall back to 1.5-flash if model not available
+        for model in ["gemini-2.0-flash", "gemini-1.5-flash"]:
+            resp = _post_with_retry(
+                f"https://generativelanguage.googleapis.com/v1beta/models/{model}:generateContent?key={key}",
+                headers={"Content-Type": "application/json"},
+                json=payload,
+                timeout=settings.provider_timeout_seconds
+            )
+            if resp.status_code == 404:
+                continue  # model not found — try next model
+            if not resp.ok:
+                # Attach real error body to the exception so the caller can log it
+                try:
+                    err_msg = resp.json().get("error", {}).get("message", resp.text[:100])
+                except Exception:
+                    err_msg = resp.text[:100]
+                resp._content = f"{resp.status_code}: {err_msg}".encode()
+                resp.raise_for_status()
+            return resp.json()["candidates"][0]["content"]["parts"][0]["text"]
+        # Both models failed with 404
+        raise requests.exceptions.HTTPError("Both gemini-2.0-flash and gemini-1.5-flash returned 404")
+
+    def try_openrouter(key, messages):
+        resp = _post_with_retry(
+            "https://openrouter.ai/api/v1/chat/completions",
+            headers={"Authorization": f"Bearer {key}", "Content-Type": "application/json"},
+            json={"model": "deepseek/deepseek-r1:free",
+                  "messages": messages, "max_tokens": 2048, "temperature": 0.15},
+            timeout=settings.provider_timeout_seconds
+        )
+        resp.raise_for_status()
+        return resp.json()["choices"][0]["message"]["content"]
+
+    # All providers in rotation order
+    providers = [
+        ("Groq-1",      settings.groq_api_keys[0], try_groq),
+        ("Groq-2",      settings.groq_api_keys[1], try_groq),
+        ("Groq-3",      settings.groq_api_keys[2], try_groq),
+        ("Gemini-1",    settings.gemini_api_keys[0], try_gemini),
+        ("Gemini-2",    settings.gemini_api_keys[1], try_gemini),
+        ("Gemini-3",    settings.gemini_api_keys[2], try_gemini),
+        ("Gemini-4",    settings.gemini_api_keys[3], try_gemini),
+        ("OpenRouter",  settings.openrouter_api_key, try_openrouter),
+    ]
+
+    # Check at least one key exists
+    if not any(key for _, key, _ in providers):
+        fallback = _deterministic_fallback(sympy_info, "no AI provider keys are configured")
+        if fallback:
+            return fallback
+        return (
+            "⚠️ **No AI provider keys are configured.**\n\n"
+            "Add a provider secret in the Hugging Face Space settings to enable explanations."
+        )
+
+    # Build sympy context if we have a verified result
+    sympy_context = ""
+    if (sympy_info.get("result")
+            and sympy_info["result"] not in (None, "matrix_detected", "mod_detected")):
+        sympy_context = (
+            "\n\n=== PRE-COMPUTED VERIFIED RESULT ===\n"
+            "IMPORTANT: The answer has already been computed below with 100% accuracy.\n"
+            "Your ONLY job is to EXPLAIN the steps — DO NOT recompute anything.\n"
+            "USE these exact numbers in your explanation. DO NOT recalculate.\n"
+            "If you compute different numbers, you are WRONG. Trust only these values.\n"
+            f"  Method    : {sympy_info.get('type', '')}\n"
+            f"  Answer    : {sympy_info.get('result', '')}\n"
+            f"  LaTeX     : {sympy_info.get('latex', '')}\n"
+            "FINAL ANSWER must be exactly as shown in Answer above.\n"
+            "=== END PRE-COMPUTED RESULT ==="
+        )
+
+    system_prompt = (
+        "You are Saad.AI, a BSc Mathematics assistant built by Saad. "
+        "You are friendly, helpful, and professional — like ChatGPT or Claude. "
+        "If anyone asks who made you, who built you, who created you, or who invented you, "
+        "always say: I was built by Saad, a passionate developer who created me from scratch "
+        "to help BSc Mathematics students. Never mention Groq, Meta, Gemini, or any AI company as your creator.\n\n"
+
+        "=== CONVERSATION MODE ===\n"
+        "You have TWO modes:\n\n"
+        "MODE A — CASUAL (when sympy type is 'casual' or message is a greeting/small talk):\n"
+        "  → Respond naturally like ChatGPT or Claude — warm, friendly, conversational.\n"
+        "  → NO math structure. NO steps. NO boxed answers. NO LaTeX.\n"
+        "  → Just reply naturally in 1-3 sentences.\n"
+        "  → Examples: 'Hi!' → 'Hey! How can I help you today?'\n"
+        "              'How are you?' → 'Doing great! Ready to tackle some math. What would you like to solve?'\n"
+        "              'What can you do?' → Briefly explain you solve BSc Math problems step by step.\n\n"
+        "MODE B — MATH (when sympy type is anything else — actual math problem):\n"
+        "  → Use full math structure below.\n\n"
+
+        "═══════════════════════════════════════════════════════\n"
+        "CORE FORMATTING RULES — follow every rule without exception\n"
+        "═══════════════════════════════════════════════════════\n\n"
+
+        "RULE 1 — SOLUTION STRUCTURE (mandatory for every answer):\n"
+        "  🔍 **Given:** state what is given clearly\n"
+        "  📌 **Method:** state the method name (e.g. Integration by Parts, Newton-Raphson, Bisection)\n"
+        "  🧮 **Step 1:** [one single action only + one sentence explanation]\n"
+        "  🧮 **Step 2:** [one single action only + one sentence explanation]\n"
+        "  🧮 **Step 3:** [continue as needed — never merge two actions into one step]\n"
+        "  ✅ **Final Answer:** $$\\boxed{answer}$$\n"
+        "  → Never skip this structure. Never merge steps. Never jump to answer without showing work.\n"
+        "  → If user says plot/draw/graph/sketch/visualize: a real graph renders automatically.\n"
+        "     Do NOT draw ASCII art. Do NOT say you cannot draw.\n"
+        "     Give this SHORT response only — then graph renders below automatically:\n"
+        "       📌 **Function:** state f(x) clearly in LaTeX\n"
+        "       🔍 **Key Features:**\n"
+        "         - Domain and range\n"
+        "         - x-intercepts: solve f(x)=0\n"
+        "         - y-intercept: f(0)\n"
+        "         - Turning points / vertex if any\n"
+        "         - Behavior as $x \\to \\pm\\infty$\n"
+        "       📊 **Graph** is shown below.\n"
+        "     Keep it SHORT — max 8 lines. No long paragraphs. No step-by-step for graph requests.\n\n"
+
+        "RULE 2 — LATEX (zero exceptions):\n"
+        "  - Inline math (inside a sentence): $expression$\n"
+        "  - Display math (standalone line, centered): $$expression$$\n"
+        "  - Fractions: ALWAYS use \\frac{a}{b} — NEVER write a/b in display math\n"
+        "  - Multi-character exponents: use x^{n+1} not x^n+1\n"
+        "  - Final answer: ALWAYS wrap in \\boxed{} — e.g. $$\\boxed{x = 2}$$\n"
+        "  - NEVER write math in plain text — e.g. NEVER write 'x = 3x^2 + 2' without $ signs\n"
+        "  - NEVER repeat the same expression in both plain text AND LaTeX\n"
+        "  - FOR GRAPH RESPONSES ESPECIALLY: every value must be in LaTeX — no exceptions.\n"
+        "    WRONG: 'Domain and range: (-∞,∞) and [-1,1]'\n"
+        "    RIGHT: 'Domain: $(-\\infty, \\infty)$, Range: $[-1, 1]$'\n"
+        "    WRONG: 'x-intercepts: x = kπ'\n"
+        "    RIGHT: 'x-intercepts: $x = k\\pi$ where $k \\in \\mathbb{Z}$'\n"
+        "  - NEVER use \\begin{} or \\end{} LaTeX environments — Streamlit cannot render them\n"
+        "  - NEVER use \\begin{vmatrix}, \\begin{matrix}, \\begin{pmatrix}\n"
+        "    Instead write cross products inline: $i(a_2b_3-a_3b_2) - j(a_1b_3-a_3b_1) + k(a_1b_2-a_2b_1)$\n\n"
+
+        "RULE 3 — EXPLANATION TYPE:\n"
+        "  A. If question starts with Explain / What is / Why / How does / Describe / Define:\n"
+        "     → Explain like talking to a smart student seeing it for the first time.\n"
+        "     → ALWAYS add: 💡 **Intuition:** with a real-life analogy.\n"
+        "     → Use simple language first, then give the formal definition.\n"
+        "     → Example analogies to use:\n"
+        "       Continuity = water flowing without any breaks or jumps\n"
+        "       Convergence = walking toward a wall, each step gets you closer\n"
+        "       Bernoulli = airplane wing — faster air above = lower pressure = lift\n"
+        "       Curvature = how sharply a road bends at a corner\n"
+        "       Eigenvalue = natural vibration frequency of a guitar string\n"
+        "       Reynolds number = whether a river flows smoothly or chaotically\n"
+        "       Geodesic = shortest flight path between two cities on a globe\n"
+        "       Fourier series = any sound = sum of pure sine waves\n"
+        "       Complex number = a point on a 2D plane, not just a number line\n"
+        "       Group = a set of moves where doing two moves is still a valid move\n"
+        "  B. If question starts with Find / Calculate / Compute / Solve / Prove:\n"
+        "     → Skip the analogy. Go straight to 🔍 Given → 📌 Method → Steps.\n"
+        "     → Show every calculation. Never skip intermediate results.\n\n"
+
+        "RULE 4 — STEP QUALITY:\n"
+        "  - Each step = ONE action + ONE short explanation sentence\n"
+        "  - Show intermediate results at every step — never jump directly to answer\n"
+        "  - Never say 'simplifying...' without actually showing the simplification\n"
+        "  - Never say 'it can be shown that' — show it fully\n"
+        "  - Never say 'similarly' and skip — write it out\n\n"
+
+        "RULE 5 — NUMERICAL METHODS (table format required):\n"
+        "  For Newton-Raphson, Bisection, Secant, False Position, Euler, RK4:\n"
+        "  ALWAYS present iterations in a markdown table. Example for Newton-Raphson:\n"
+        "  | n | $x_n$ | $f(x_n)$ | $f'(x_n)$ | $x_{n+1}$ |\n"
+        "  |---|--------|-----------|------------|------------|\n"
+        "  Columns vary by method but table format is mandatory every time.\n"
+        "  ALWAYS use SymPy verified values — NEVER recalculate anything yourself.\n"
+        "  Final answer must EXACTLY match the verified result — no exceptions.\n\n"
+
+        "═══════════════════════════════════════════════════════\n"
+        "SUBJECT-SPECIFIC RULES\n"
+        "═══════════════════════════════════════════════════════\n\n"
+
+        "=== ODE RULES ===\n"
+        "A. Always find CF first by solving the auxiliary/characteristic equation.\n"
+        "B. For PI: if forcing term matches CF, multiply by x (reduction of order).\n"
+        "   Example: if $e^x$ in CF and RHS=$e^x$, try PI=$Cxe^x$ NOT $Ce^x$.\n"
+        "C. ALWAYS verify PI by substituting back into the full ODE before final answer.\n"
+        "D. Handle all types: separable, linear 1st order, 2nd order constant coefficients,\n"
+        "   Cauchy-Euler, exact, Bernoulli ODE, variation of parameters, Laplace.\n"
+        "E. For IVP: apply initial conditions clearly in a separate step after general solution.\n\n"
+
+        "=== NEWTON-RAPHSON RULES — STRICT FORMAT ===\n"
+        "For Newton-Raphson ALWAYS follow this EXACT format:\n\n"
+        "1. Show formula first: $$x_{n+1} = x_n - \\frac{f(x_n)}{f'(x_n)}$$\n"
+        "2. Show Given: write f(x) and f'(x) and x0 in LaTeX\n"
+        "3. For EACH iteration write it like this:\n"
+        "   🧮 **Iteration n:**\n"
+        "   Substitute $x_n = value$:\n"
+        "   $$f(x_n) = (...) = (...) = result$$\n"
+        "   $$f'(x_n) = (...) = (...) = result$$\n"
+        "   $$x_{n+1} = x_n - \\frac{f(x_n)}{f'(x_n)} = result$$\n"
+        "4. After ALL iterations show summary table:\n"
+        "   | n | $x_n$ | $f(x_n)$ | $f'(x_n)$ | $x_{n+1}$ |\n"
+        "   |---|--------|-----------|------------|------------|\n"
+        "5. End with ✅ **Final Answer:** $$\\boxed{answer}$$\n\n"
+        "STRICT RULES:\n"
+        "A. NEVER write as paragraphs — each iteration is its own block\n"
+        "B. NEVER mix plain text math with LaTeX — LaTeX only\n"
+        "C. NEVER write f(x)=...f(x)=... doubled — one LaTeX expression only\n"
+        "D. Show full substitution at every step — students must see HOW\n"
+        "E. Use ONLY SymPy verified values — never recalculate\n\n"
+
+        "=== NUMERICAL METHODS RULES ===\n"
+        "A. Simpson's rule formula: $\\frac{h}{3}[f(x_0) + 4f(x_1) + 2f(x_2) + \\cdots + f(x_n)]$\n"
+        "B. Trapezoidal formula: $\\frac{h}{2}[f(x_0) + 2f(x_1) + \\cdots + f(x_n)]$\n"
+        "C. State exact trig values directly: $\\sin(\\pi)=0$, $\\cos(\\pi)=-1$ — never recompute.\n"
+        "D. For Lagrange/Newton interpolation: DO NOT re-derive the polynomial.\n"
+        "   Show basis polynomials then state final polynomial from the verified result.\n"
+        "E. For Euler/RK4: show k-values at each step then give $y_{n+1}$.\n\n"
+
+        "=== THEORY OF NUMBERS RULES ===\n"
+        "A. For congruences $ax \\equiv b \\pmod{n}$: always show full Euclidean algorithm steps.\n"
+        "B. For GCD/LCM: show both prime factorization AND Euclidean algorithm.\n"
+        "C. For CRT: state theorem conditions (moduli must be pairwise coprime) before solving.\n"
+        "D. For Fermat/Euler/Wilson: state theorem → prove it → give numerical example.\n"
+        "E. For Legendre symbol: state definition → compute using Euler's criterion.\n\n"
+
+        "=== REAL ANALYSIS II RULES ===\n"
+        "A. Always start with FORMAL DEFINITION using proper symbols.\n"
+        "B. State theorem COMPLETELY before proving.\n"
+        "C. Give a concrete numerical example after every definition or theorem.\n"
+        "D. For $\\varepsilon$-$\\delta$: write formal definition first, then explain in plain words.\n"
+        "E. For convergence tests: state test → conditions → apply to the specific example.\n"
+        "F. Use proper symbols: $\\forall$, $\\exists$, $\\varepsilon$, $\\delta$, $\\sup$, $\\inf$, $\\lim$.\n\n"
+
+        "=== DIFFERENTIAL GEOMETRY RULES ===\n"
+        "A. State the definition or theorem FIRST before any computation.\n"
+        "B. Plane curvature: $\\kappa = \\frac{|y''|}{(1+y'^2)^{3/2}}$\n"
+        "C. Space curve: $\\kappa = \\frac{|r' \\times r''|}{|r'|^3}$, "
+        "$\\tau = \\frac{(r' \\times r'') \\cdot r'''}{|r' \\times r''|^2}$\n"
+        "D. Frenet-Serret: $\\frac{dT}{ds}=\\kappa N$, $\\frac{dN}{ds}=-\\kappa T+\\tau B$, "
+        "$\\frac{dB}{ds}=-\\tau N$\n"
+        "E. Unit vectors: $T=r'/|r'|$, $N=T'/|T'|$, $B=T\\times N$\n"
+        "F. First Fundamental Form: $ds^2=E\\,du^2+2F\\,du\\,dv+G\\,dv^2$\n"
+        "G. Gaussian curvature: $K=\\frac{LN-M^2}{EG-F^2}$, Mean: $H=\\frac{EN-2FM+GL}{2(EG-F^2)}$\n"
+        "H. For proofs: Given → To Prove → Proof steps.\n"
+        "I. Christoffel symbols: $\\Gamma^k_{ij} = \\frac{1}{2}g^{kl}(\\partial_i g_{jl}+\\partial_j g_{il}-\\partial_l g_{ij})$\n\n"
+
+        "=== HYDRO MECHANICS RULES ===\n"
+        "A. State fluid type (ideal/viscous, compressible/incompressible) first.\n"
+        "B. Continuity: $A_1v_1 = A_2v_2$ (incompressible), $\\frac{\\partial\\rho}{\\partial t}+\\nabla\\cdot(\\rho\\mathbf{v})=0$ (general)\n"
+        "C. Bernoulli: $P + \\frac{1}{2}\\rho v^2 + \\rho gh = \\text{const}$ (along streamline, ideal fluid)\n"
+        "D. Reynolds: $Re = \\frac{\\rho v D}{\\mu}$ — $Re<2300$ laminar, $Re>4000$ turbulent\n"
+        "E. Navier-Stokes: $\\rho\\frac{D\\mathbf{v}}{Dt} = -\\nabla P + \\mu\\nabla^2\\mathbf{v} + \\rho\\mathbf{g}$\n"
+        "F. Torricelli: $v=\\sqrt{2gh}$ — derived from Bernoulli\n"
+        "G. Always give physical interpretation of the result.\n\n"
+
+        "=== MATLAB RULES ===\n"
+        "A. Always start every script with: clc; clear; close all;\n"
+        "B. Add % comments explaining every section.\n"
+        "C. Use semicolons (;) to suppress unwanted output.\n"
+        "D. For numerical methods: display iteration table using fprintf.\n"
+        "E. For plots: use plot(), xlabel(), ylabel(), title(), grid on.\n"
+        "F. Test logic mentally — code must be correct and directly runnable.\n\n"
+
+        "=== NEW / UNKNOWN SUBJECT RULES ===\n"
+        "When the question is from a subject not listed above "
+        "(e.g. Complex Analysis, Abstract Algebra, Probability, Statistics, "
+        "Fourier Series, Laplace Transform, Vector Calculus, Topology, etc.):\n"
+        "A. NEVER refuse. ALWAYS attempt the problem fully.\n"
+        "B. Follow the SAME structure: 🔍 Given → 📌 Method → 🧮 Steps → ✅ Final Answer.\n"
+        "C. Start with the relevant definition or theorem for that topic.\n"
+        "D. Solve step by step exactly like the known subjects above.\n"
+        "E. Use correct subject-specific notation and formulas:\n"
+        "   - Complex Analysis: $z=a+bi$, modulus $|z|=\\sqrt{a^2+b^2}$, argument $\\arg(z)$,\n"
+        "     Cauchy-Riemann: $\\frac{\\partial u}{\\partial x}=\\frac{\\partial v}{\\partial y}$, "
+        "$\\frac{\\partial u}{\\partial y}=-\\frac{\\partial v}{\\partial x}$\n"
+        "   - Abstract Algebra: group $(G,*)$, order $|G|$, Lagrange theorem, cosets, homomorphism\n"
+        "   - Probability: $P(A\\cup B)=P(A)+P(B)-P(A\\cap B)$, Bayes: $P(A|B)=\\frac{P(B|A)P(A)}{P(B)}$\n"
+        "   - Statistics: mean $\\bar{x}=\\frac{\\sum x_i}{n}$, variance $s^2=\\frac{\\sum(x_i-\\bar{x})^2}{n-1}$\n"
+        "   - Fourier Series: $f(x)=\\frac{a_0}{2}+\\sum_{n=1}^{\\infty}(a_n\\cos\\frac{n\\pi x}{L}+b_n\\sin\\frac{n\\pi x}{L})$\n"
+        "   - Laplace Transform: $\\mathcal{L}\\{f(t)\\}=\\int_0^{\\infty}e^{-st}f(t)\\,dt$\n"
+        "   - Vector Calculus: $\\nabla f$, $\\nabla\\cdot\\mathbf{F}$, $\\nabla\\times\\mathbf{F}$, "
+        "Green's/Stokes/Divergence theorems\n"
+        "F. Add 💡 **Intuition:** analogy for explanation-type questions.\n"
+        "G. ALWAYS end with ✅ **Final Answer:** $$\\boxed{answer}$$\n\n"
+
+        "Topics covered: Calculus, Linear Algebra, Number Theory, ODEs, "
+        "Numerical Methods, Differential Geometry, Hydro Mechanics, "
+        "Theory of Numbers, Real Analysis II, MATLAB, Complex Analysis, "
+        "Abstract Algebra, Probability, Statistics, Fourier Series, "
+        "Laplace Transform, Vector Calculus, and all other BSc Mathematics topics."
+        + sympy_context
+    )
+
+    # Build messages — last 6 exchanges for context
+    messages = [{"role": "system", "content": system_prompt}]
+    for msg in history[-12:]:
+        messages.append({"role": msg["role"], "content": msg["content"]})
+    # Inject verified result directly into user message — AI cannot ignore this
+    p_lower = problem.lower()
+    is_graph_req = any(k in p_lower for k in ["plot","graph","draw","sketch","visualize"])
+
+    if (sympy_info.get("result")
+            and sympy_info["result"] not in (None, "matrix_detected", "mod_detected")):
+        final_latex = sympy_info.get("latex", "")
+        user_msg = (
+            f"PROBLEM: {problem}\n\n"
+            f"⚠️ IMPORTANT: This problem is already solved. Use ONLY these verified values:\n"
+            f"{sympy_info.get('result', '')}\n\n"
+            f"✅ FINAL ANSWER IS: $${final_latex}$$\n\n"
+            f"Your task: explain the method steps clearly, and end with the EXACT final answer shown above."
+        )
+    elif is_graph_req:
+        user_msg = (
+            f"PROBLEM: {problem}\n\n"
+            f"⚠️ CRITICAL: A real graph is ALREADY rendering below this response automatically.\n"
+            f"You MUST NOT say you cannot draw or display images — the graph IS showing.\n"
+            f"You MUST NOT suggest Desmos, graphing calculators, or any external tools.\n"
+            f"Your ONLY job:\n"
+            f"1. State the function clearly in LaTeX — e.g. $f(x) = \\sin(x)$\n"
+            f"2. List key features — ALL values must be in LaTeX, NO plain text math\n"
+            f"3. Give step-by-step drawing instructions with exact coordinates\n"
+            f"4. End with exactly: '📊 Graph is shown below.'\n"
+            f"EVERY mathematical expression must use $ signs. NEVER write math in plain text."
+        )
+    else:
+        user_msg = problem
+    messages.append({"role": "user", "content": user_msg})
+
+    # ── Permanent fix: force correct final answer from SymPy ────────
+    def enforce_verified_answer(ai_response: str) -> str:
+        """Remove AI final answer, replace with SymPy verified one."""
+        result = sympy_info.get("result", "")
+        latex  = sympy_info.get("latex", "")
+        # Only enforce if SymPy has a real computed result
+        if (not result or
+                result in (None, "matrix_detected", "mod_detected") or
+                not latex):
+            return ai_response  # theory question — leave AI response untouched
+        # Remove everything after last "✅" or "Final Answer"
+        cleaned = re.sub(
+            r'(✅\s*\*{0,2}Final\s*Answer\*{0,2}.*|✅[^\n]*$)',
+            "", ai_response,
+            flags=re.DOTALL | re.IGNORECASE
+        ).rstrip()
+        # Append our verified final answer
+        verified_line = f"\n\n✅ **Final Answer:** $$\\boxed{{{latex}}}$$"
+        return cleaned + verified_line
+
+    # Try each provider in order — auto-rotate on 429 or error
+    last_error = ""
+    for provider_name, key, call_fn in providers:
+        if not key:
+            continue  # skip if key not set
+        try:
+            response = call_fn(key, messages)
+            return enforce_verified_answer(response)
+        except requests.exceptions.Timeout:
+            last_error = f"⏳ {provider_name} timed out"
+            continue
+        except requests.exceptions.HTTPError as e:
+            code = e.response.status_code if e.response else 0
+            # Include the real error body if available (set by try_gemini)
+            try:
+                body = e.response.text[:120] if e.response else str(e)
+            except Exception:
+                body = str(e)[:120]
+            last_error = f"⚠️ {provider_name} HTTP {code}: {body}"
+            continue  # always try next provider
+        except Exception as e:
+            last_error = f"⚠️ {provider_name} error: {str(e)}"
+            continue
+
+    # All providers exhausted. Preserve deterministic value if one exists.
+    fallback = _deterministic_fallback(sympy_info, last_error or "all providers failed")
+    if fallback:
+        return fallback
+    return (
+        "⚠️ **AI explanation unavailable.**\n\n"
+        f"Last provider error: `{last_error or 'unknown provider error'}`\n\n"
+        "Check the provider secret and quota in the Hugging Face Space settings."
+    )
+
+
+
+# ════════════════════════════════════════════════════════════════════
+# FILE UPLOAD — image/PDF sent to Gemini Vision, then SymPy verified
+# ════════════════════════════════════════════════════════════════════
+def ask_gemini_vision(image_b64: str, mime_type: str, user_note: str) -> str:
+    """
+    Multi-provider vision: tries Groq → Gemini → OpenRouter in order.
+    Groq vision is primary (much more generous free limits, user already has keys).
+    Gemini is fallback (needed for PDFs; Groq/OpenRouter are image-only).
+    OpenRouter free vision models are the last resort.
+    """
+    import base64 as _b64
+    is_pdf = (mime_type == "application/pdf")
+
+    # ── Convert PDF → PNG image so Groq/OpenRouter can read it ───────
+    # PyMuPDF (fitz) converts PDF pages to images.
+    # Add "PyMuPDF" to your HF Space requirements.txt to enable this.
+    if is_pdf:
+        try:
+            import fitz  # PyMuPDF
+            import io
+            pdf_bytes = _b64.b64decode(image_b64)
+            doc = fitz.open(stream=pdf_bytes, filetype="pdf")
+            # Render all pages (up to 4) as one tall PNG
+            imgs = []
+            for page_num in range(min(len(doc), settings.max_pdf_pages)):
+                pix = doc[page_num].get_pixmap(matrix=fitz.Matrix(3, 3))  # 3x zoom for crisp text
+                imgs.append(pix.tobytes("png"))
+            doc.close()
+            # Stack page images vertically using PIL if available, else just use first page
+            try:
+                from PIL import Image
+                pages_pil = [Image.open(io.BytesIO(b)) for b in imgs]
+                total_h = sum(p.height for p in pages_pil)
+                max_w = max(p.width for p in pages_pil)
+                combined = Image.new("RGB", (max_w, total_h), (255, 255, 255))
+                y_offset = 0
+                for p in pages_pil:
+                    combined.paste(p, (0, y_offset))
+                    y_offset += p.height
+                buf = io.BytesIO()
+                combined.save(buf, format="PNG")
+                image_b64 = _b64.b64encode(buf.getvalue()).decode("utf-8")
+            except Exception:
+                # PIL not available — just use first page
+                image_b64 = _b64.b64encode(imgs[0]).decode("utf-8")
+            mime_type = "image/png"
+            is_pdf = False  # now it's an image — Groq/OpenRouter can handle it
+        except ImportError:
+            pass  # PyMuPDF not installed — will fall through to Gemini (which reads PDFs natively)
+        except Exception as e:
+            pass  # Conversion failed — fall through to Gemini
+
+    prompt = (
+        "You are Saad.AI, a helpful AI assistant built by Saad.\n"
+        "You can read and understand ALL types of images and documents.\n\n"
+
+        "STEP 1 — Look at the image carefully from top to bottom.\n"
+        "STEP 2 — Identify what type of content is in the image:\n\n"
+
+        "━━━ CASE A: IMAGE CONTAINS MATH PROBLEMS ━━━\n"
+        "(Equations, exam paper, homework sheet, math diagrams, numbered questions)\n"
+        "→ Read the ENTIRE document. Extract EVERY question — do NOT skip any.\n"
+        "→ Do NOT invent questions. ONLY solve what is actually written.\n"
+        "→ For EACH problem use this structure:\n"
+        "  ---\n"
+        "  ### Question [N]: [restate exact question from file]\n"
+        "  🔍 **Given:** ...\n"
+        "  📌 **Method:** ...\n"
+        "  🧮 **Step 1:** ...\n"
+        "  ✅ **Final Answer:** $$\\boxed{answer}$$\n"
+        "  ---\n"
+        "→ ALL math must be in LaTeX — never plain text math.\n\n"
+
+        "━━━ CASE B: IMAGE IS NOT A MATH PROBLEM ━━━\n"
+        "(Photo, screenshot, diagram, chart, meme, nature, objects, people, text, etc.)\n"
+        "→ Describe the image in detail — what you see, what it shows.\n"
+        "→ Be conversational and helpful like ChatGPT or Claude.\n"
+        "→ Answer the student's specific question about the image.\n"
+        "→ No forced math structure. Just natural, helpful conversation.\n"
+        "→ Point out interesting details, context, or meaning.\n\n"
+
+        f"Student's instruction: {user_note if user_note else 'Look at this image and describe or analyze it.'}\n\n"
+        "Always be helpful, friendly, and clear."
+    )
+
+    errors = []
+
+    # ── PROVIDER 1: Groq vision (images only — not PDFs) ─────────────
+    # Groq free tier: ~100 req/min, much more generous than Gemini's 15/min
+    if not is_pdf:
+        groq_keys = settings.groq_api_keys
+        groq_vision_models = [
+            "meta-llama/llama-4-scout-17b-16e-instruct",
+            "llama-3.2-11b-vision-preview",
+        ]
+        for i, key in enumerate(groq_keys):
+            if not key.strip():
+                continue
+            for model in groq_vision_models:
+                try:
+                    resp = _post_with_retry(
+                        "https://api.groq.com/openai/v1/chat/completions",
+                        headers={"Authorization": f"Bearer {key}", "Content-Type": "application/json"},
+                        json={
+                            "model": model,
+                            "messages": [{
+                                "role": "user",
+                                "content": [
+                                    {"type": "image_url",
+                                     "image_url": {"url": f"data:{mime_type};base64,{image_b64}"}},
+                                    {"type": "text", "text": prompt}
+                                ]
+                            }],
+                            "max_tokens": 2048,
+                            "temperature": 0.15
+                        },
+                        timeout=settings.provider_timeout_seconds
+                    )
+                    if resp.status_code == 200:
+                        return resp.json()["choices"][0]["message"]["content"]
+                    elif resp.status_code == 429:
+                        errors.append(f"Groq-{i+1}/{model}: rate limited")
+                        break  # try next key
+                    elif resp.status_code == 400:
+                        # Model may not support vision — try next model
+                        try:
+                            msg = resp.json().get("error", {}).get("message", "")[:80]
+                        except Exception:
+                            msg = ""
+                        errors.append(f"Groq-{i+1}/{model}: {msg}")
+                        continue
+                    else:
+                        errors.append(f"Groq-{i+1}/{model}: HTTP {resp.status_code}")
+                        break
+                except requests.exceptions.Timeout:
+                    errors.append(f"Groq-{i+1}/{model}: timeout")
+                    break
+                except Exception as e:
+                    errors.append(f"Groq-{i+1}/{model}: {str(e)[:60]}")
+                    break
+
+    # ── PROVIDER 2: Gemini (images + PDFs) ───────────────────────────
+    # 15 req/min, 1500 req/day per key — use as fallback
+    gemini_keys = settings.gemini_api_keys
+    gemini_models = ["gemini-2.0-flash", "gemini-1.5-flash"]
+    for i, key in enumerate(gemini_keys):
+        if not key.strip():
+            continue
+        for model in gemini_models:
+            try:
+                resp = _post_with_retry(
+                    f"https://generativelanguage.googleapis.com/v1beta/models/{model}:generateContent?key={key}",
+                    headers={"Content-Type": "application/json"},
+                    json={
+                        "contents": [{"parts": [
+                            {"inline_data": {"mime_type": mime_type, "data": image_b64}},
+                            {"text": prompt}
+                        ]}],
+                        "generationConfig": {"maxOutputTokens": 2048, "temperature": 0.15}
+                    },
+                    timeout=settings.provider_timeout_seconds
+                )
+                if resp.status_code == 200:
+                    candidates = resp.json().get("candidates", [])
+                    if candidates:
+                        return candidates[0]["content"]["parts"][0]["text"]
+                    errors.append(f"Gemini-{i+1}/{model}: safety blocked")
+                    break
+                elif resp.status_code == 429:
+                    errors.append(f"Gemini-{i+1}/{model}: rate limited (429)")
+                    break
+                elif resp.status_code == 404:
+                    errors.append(f"Gemini-{i+1}/{model}: model not found")
+                    continue  # try next model
+                else:
+                    try:
+                        msg = resp.json().get("error", {}).get("message", resp.text[:80])
+                    except Exception:
+                        msg = resp.text[:80]
+                    errors.append(f"Gemini-{i+1}/{model}: HTTP {resp.status_code} — {msg}")
+                    break
+            except requests.exceptions.Timeout:
+                errors.append(f"Gemini-{i+1}/{model}: timeout")
+                break
+            except Exception as e:
+                errors.append(f"Gemini-{i+1}/{model}: {str(e)[:60]}")
+                break
+
+    # ── PROVIDER 3: OpenRouter free vision models (images only) ───────
+    if not is_pdf:
+        or_key = settings.openrouter_api_key
+        if or_key.strip():
+            or_models = [
+                "meta-llama/llama-3.2-11b-vision-instruct:free",
+                "qwen/qwen2-vl-7b-instruct:free",
+            ]
+            for model in or_models:
+                try:
+                    resp = _post_with_retry(
+                        "https://openrouter.ai/api/v1/chat/completions",
+                        headers={"Authorization": f"Bearer {or_key}", "Content-Type": "application/json"},
+                        json={
+                            "model": model,
+                            "messages": [{
+                                "role": "user",
+                                "content": [
+                                    {"type": "image_url",
+                                     "image_url": {"url": f"data:{mime_type};base64,{image_b64}"}},
+                                    {"type": "text", "text": prompt}
+                                ]
+                            }],
+                            "max_tokens": 2048
+                        },
+                        timeout=settings.provider_timeout_seconds
+                    )
+                    if resp.status_code == 200:
+                        return resp.json()["choices"][0]["message"]["content"]
+                    errors.append(f"OpenRouter/{model}: HTTP {resp.status_code}")
+                except Exception as e:
+                    errors.append(f"OpenRouter/{model}: {str(e)[:60]}")
+
+    # ── All providers failed ──────────────────────────────────────────
+    error_summary = " | ".join(errors[-6:])  # show last 6 errors
+    if is_pdf:
+        pdf_note = (
+            "\n\n**To make PDFs work without Gemini:** add `PyMuPDF` to your HF Space `requirements.txt` — "
+            "it converts PDF pages to images so Groq can read them (no Gemini needed)."
+        )
+    else:
+        pdf_note = ""
+    return (
+        f"⚠️ **All vision providers failed.**\n\n"
+        f"Errors: `{error_summary}`\n\n"
+        f"**Most likely fix:** make sure `GROQ_API_KEY_1`, `GROQ_API_KEY_2`, `GROQ_API_KEY_3` "
+        f"are added in your HF Space → Settings → Secrets. Groq reads images with much higher limits than Gemini.\n\n"
+        f"**Gemini 429:** wait 60 sec (per-minute limit) or until midnight Pacific (daily limit)."
+        f"{pdf_note}"
+    )
+
+
+class _MemoryUpload:
+    """Small upload-compatible wrapper for bytes already held in session state."""
+
+    def __init__(self, file_bytes: bytes, name: str, mime_type: str):
+        self._file_bytes = file_bytes
+        self.name = name
+        self.type = mime_type
+
+    def read(self) -> bytes:
+        return self._file_bytes
+
+
+def handle_uploaded_file(uploaded_file, user_note: str) -> str:
+    """
+    Process uploaded image or PDF:
+    1. Convert to base64
+    2. Send to Gemini Vision
+    3. Try SymPy verification on extracted text
+    4. Return final answer
+    """
+    import base64
+
+    # ── Validate size ────────────────────────────────────────────────
+    MAX_SIZE = settings.max_upload_bytes
+    file_bytes = uploaded_file.read()
+    if len(file_bytes) == 0:
+        return "⚠️ The uploaded file is empty. Please try again."
+    if len(file_bytes) > MAX_SIZE:
+        return f"⚠️ File too large ({len(file_bytes)//1024}KB). Please upload under 5MB."
+
+    # ── Detect MIME type from Streamlit's type field, not filename ────
+    # This works even if filename has spaces, brackets, or no extension
+    mime_map = {
+        "jpg": "image/jpeg", "jpeg": "image/jpeg",
+        "png": "image/png",  "webp": "image/webp",
+        "pdf": "application/pdf"
+    }
+    # Try Streamlit's type first (most reliable), fall back to extension
+    mime_type = uploaded_file.type if uploaded_file.type else None
+    if not mime_type:
+        ext = uploaded_file.name.rsplit(".", 1)[-1].lower() if "." in uploaded_file.name else ""
+        mime_type = mime_map.get(ext)
+    if mime_type not in mime_map.values():
+        return "⚠️ Unsupported format. Please upload JPG, PNG, WEBP or PDF."
+
+    # ── Convert to base64 ────────────────────────────────────────────
+    image_b64 = base64.b64encode(file_bytes).decode("utf-8")
+
+    # ── Send to Gemini Vision ────────────────────────────────────────
+    gemini_response = ask_gemini_vision(image_b64, mime_type, user_note)
+
+    # ── Gemini failed → return single clean error only ───────────────
+    if gemini_response.startswith("⚠️"):
+        return gemini_response
+
+    # ── SymPy verification — extract problem line first ───────────────
+    # Run SymPy on the first user-question line, not Gemini's full markdown
+    # This avoids SymPy choking on LaTeX formatting in the solution
+    extracted_problem = ""
+    for line in gemini_response.splitlines():
+        stripped = line.strip()
+        # Skip empty lines, headers, and Gemini's own solution steps
+        if (stripped and
+                not stripped.startswith("#") and
+                not stripped.startswith("🔍") and
+                not stripped.startswith("📌") and
+                not stripped.startswith("🧮") and
+                not stripped.startswith("✅") and
+                not stripped.startswith("**") and
+                len(stripped) > 5):
+            extracted_problem = stripped
+            break
+    sympy_result = run_sympy(extracted_problem) if extracted_problem else {"type": "general", "result": None, "latex": ""}
+
+    if (sympy_result.get("result") and
+            sympy_result["result"] not in (None, "matrix_detected", "mod_detected")):
+        latex = sympy_result.get("latex", "")
+        cleaned = re.sub(
+            r'(✅\s*\*{0,2}Final\s*Answer\*{0,2}.*|✅[^\n]*$)',
+            "", gemini_response,
+            flags=re.DOTALL | re.IGNORECASE
+        ).rstrip()
+        return cleaned + "\n\n🔒 **SymPy Verified**" + f"\n\n✅ **Final Answer:** $$\\boxed{{{latex}}}$$"
+    else:
+        # Gemini answered, SymPy couldn't verify — single clean note
+        return gemini_response + "\n\n⚠️ *AI-generated answer — not SymPy verified.*"
+
+

config.py

@@ -0,0 +1,63 @@
+"""Application configuration loaded from environment variables."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+import os
+
+
+def _env(name: str, default: str = "") -> str:
+    return os.environ.get(name, default).strip()
+
+
+def _numbered_keys(prefix: str, count: int) -> tuple[str, ...]:
+    return tuple(_env(f"{prefix}_{index}") for index in range(1, count + 1))
+
+
+@dataclass(frozen=True)
+class Settings:
+    groq_api_keys: tuple[str, ...]
+    gemini_api_keys: tuple[str, ...]
+    openrouter_api_key: str
+    provider_timeout_seconds: float
+    max_upload_bytes: int
+    max_pdf_pages: int
+
+    @property
+    def any_text_provider_enabled(self) -> bool:
+        return any(self.groq_api_keys) or any(self.gemini_api_keys) or bool(self.openrouter_api_key)
+
+
+
+def load_settings() -> Settings:
+    """Load and normalize settings once at application startup."""
+    timeout_raw = _env("PROVIDER_TIMEOUT_SECONDS", "60")
+    upload_raw = _env("MAX_UPLOAD_BYTES", str(5 * 1024 * 1024))
+    pages_raw = _env("MAX_PDF_PAGES", "6")
+
+    try:
+        timeout = max(5.0, min(float(timeout_raw), 120.0))
+    except ValueError:
+        timeout = 60.0
+
+    try:
+        max_upload_bytes = max(1024, min(int(upload_raw), 25 * 1024 * 1024))
+    except ValueError:
+        max_upload_bytes = 5 * 1024 * 1024
+
+    try:
+        max_pdf_pages = max(1, min(int(pages_raw), 20))
+    except ValueError:
+        max_pdf_pages = 6
+
+    return Settings(
+        groq_api_keys=_numbered_keys("GROQ_API_KEY", 3),
+        gemini_api_keys=_numbered_keys("GEMINI_API_KEY", 4),
+        openrouter_api_key=_env("OPENROUTER_API_KEY"),
+        provider_timeout_seconds=timeout,
+        max_upload_bytes=max_upload_bytes,
+        max_pdf_pages=max_pdf_pages,
+    )
+
+
+settings = load_settings()

requirements.txt

@@ -1,7 +1,15 @@
-streamlit>=1.32.0
-sympy>=1.12
-requests>=2.31.0
-supabase
-matplotlib
-numpy
-PyMuPDF
+# Core application
+streamlit>=1.40,<2
+requests>=2.32,<3
+
+# Deterministic mathematics and graphing
+sympy>=1.13,<2
+numpy>=2.0,<3
+matplotlib>=3.9,<4
+
+# Image/PDF upload support
+Pillow>=10,<13
+PyMuPDF>=1.24,<2
+
+# Optional: keep this file focused on the active API-backed runtime.
+# Transformers and torch were removed because the current app does not load a local Hugging Face model.

sympy_engine.py

@@ -0,0 +1,1230 @@
+"""Deterministic symbolic mathematics engine for Saad.AI.
+
+This module intentionally contains no Streamlit or network dependencies so it can be
+unit-tested independently of the UI and provider integrations.
+"""
+
+import re
+import sympy as sp
+from sympy.parsing.sympy_parser import (
+    parse_expr,
+    standard_transformations,
+    implicit_multiplication_application,
+)
+
+def run_sympy(problem: str) -> dict:
+    """
+    Symbolic computation engine. Returns verified result dict.
+    Falls back silently on any error.
+    ELIF ORDER (important — must check ODE before Solve):
+      Derivative → Integral → Limit → ODE → NR → Solve → Matrix → Mod
+    """
+    p = problem.lower().strip()
+    x = sp.Symbol('x')
+    tfms = standard_transformations + (implicit_multiplication_application,)
+    ld = {
+        "x": x,
+        "e": sp.E, "E": sp.E,
+        "pi": sp.pi, "PI": sp.pi,
+        "sin": sp.sin, "cos": sp.cos, "tan": sp.tan,
+        "exp": sp.exp, "log": sp.log, "ln": sp.log,
+        "sqrt": sp.sqrt, "inf": sp.oo, "oo": sp.oo
+    }
+
+    def clean(s):
+        s = re.sub(r"\s+", "", s)
+        s = re.sub(r"\^", "**", s)
+        return s
+
+    def to_coeff(s):
+        """Convert string to sympy integer/rational — never float (floats break dsolve)."""
+        s = s.replace(" ", "")
+        if s in ("", "+"): return sp.Integer(1)
+        if s == "-": return sp.Integer(-1)
+        try:
+            f = float(s)
+            return sp.Integer(int(f)) if f == int(f) else sp.Rational(s)
+        except Exception:
+            return sp.Integer(1)
+
+    try:
+        # ── 1. Derivative ────────────────────────────────────────────
+        if any(k in p for k in ["derivative", "differentiate", "d/dx", "diff"]):
+            raw = p
+            for kw in ["derivative of", "differentiate", "diff of", "d/dx of", "d/dx"]:
+                if kw in p:
+                    raw = p.split(kw, 1)[-1].strip()
+                    break
+            raw = re.sub(r"\s*(dx|with\s*respect\s*to\s*x).*$", "", raw).strip()
+            expr = parse_expr(clean(raw), transformations=tfms, local_dict=ld)
+            result = sp.diff(expr, x)
+            return {"type": "Derivative", "result": str(result), "latex": sp.latex(result)}
+
+        # ── 2. Integral ──────────────────────────────────────────────
+        elif any(k in p for k in ["integral", "integrate", "antiderivative"]):
+            raw = p
+            for kw in ["integral of", "integrate", "antiderivative of"]:
+                if kw in p:
+                    raw = p.split(kw, 1)[-1].strip()
+                    break
+            raw = re.sub(r"\s*dx.*$", "", raw).strip()
+            expr = parse_expr(clean(raw), transformations=tfms, local_dict=ld)
+            result = sp.integrate(expr, x)
+            return {"type": "Integral", "result": str(result), "latex": sp.latex(result)}
+
+        # ── 3. Limit ─────────────────────────────────────────────────
+        elif "limit" in p:
+            match = re.search(
+                r"limit\s+of\s+([\w\s\(\)\+\-\*/\^\.\,]+?)"
+                r"\s+as\s+x\s*(?:->|→|approaches)\s*([\w\.\+\-]+)", p
+            )
+            if match:
+                raw_expr = clean(match.group(1))
+                pt = match.group(2).strip()
+                point = sp.oo if pt in ("inf", "infinity", "oo") else sp.sympify(pt)
+                expr = parse_expr(raw_expr, transformations=tfms, local_dict=ld)
+                result = sp.limit(expr, x, point)
+                return {"type": "Limit", "result": str(result), "latex": sp.latex(result)}
+
+        # ── 4. ODE — MUST be before Solve (many ODE problems start with "solve") ──
+        elif any(k in p for k in ["d²y", "d^2y", "d2y", "dy/dx",
+                                   "differential equation", "second order", "first order"]):
+            y_fn = sp.Function('y')
+            ode_sol = None
+            try:
+                # Extract RHS — everything after = and before "with"
+                rhs_m = re.search(r"=\s*(.+?)(?:\s+with|\s*$)", p)
+                rhs_str = clean(rhs_m.group(1).strip()) if rhs_m else "0"
+                rhs_expr = parse_expr(rhs_str, transformations=tfms, local_dict=ld)
+                lhs = p.split("=")[0]
+
+                # Second order: d²y/dx² + a*dy/dx + b*y = rhs
+                if any(k in p for k in ["d²y", "d^2y", "d2y", "second order"]):
+                    # Match coefficient of dy/dx (must be dy/dx not just dy to avoid d²y match)
+                    c1_m = re.search(r"([+\-]\s*\d*\.?\d*)\s*dy/dx", lhs)
+                    # Match coefficient of standalone y (word boundary)
+                    c0_m = re.search(r"([+\-]\s*\d+\.?\d*)\s*y\b", lhs)
+                    a1 = to_coeff(c1_m.group(1)) if c1_m else sp.Integer(0)
+                    a0 = to_coeff(c0_m.group(1)) if c0_m else sp.Integer(0)
+                    ode_eq = sp.Eq(
+                        y_fn(x).diff(x, 2) + a1*y_fn(x).diff(x) + a0*y_fn(x),
+                        rhs_expr
+                    )
+                    ode_sol = sp.dsolve(ode_eq, y_fn(x))
+
+                # First order: dy/dx + a*y = rhs
+                elif "dy/dx" in p:
+                    c0_m = re.search(r"([+\-]\s*\d+\.?\d*)\s*y\b", lhs)
+                    a0 = to_coeff(c0_m.group(1)) if c0_m else sp.Integer(0)
+                    ode_eq = sp.Eq(y_fn(x).diff(x) + a0*y_fn(x), rhs_expr)
+                    ode_sol = sp.dsolve(ode_eq, y_fn(x))
+
+            except Exception:
+                ode_sol = None  # safe fallback to AI
+
+            if ode_sol is not None:
+                return {
+                    "type": "ODE",
+                    "result": f"General solution: y = {str(ode_sol.rhs)}",
+                    "latex": f"y = {sp.latex(ode_sol.rhs)}"
+                }
+
+        # ── 5. Newton-Raphson ────────────────────────────────────────
+        elif any(k in p for k in ["newton", "newton-raphson", "newton raphson"]):
+            # Extract: equation (between of/to/for and "= 0"), x0, iterations
+            eq_m   = re.search(r"(?:of|to|for)\s+(.+?)\s*=\s*0", p)
+            x0_m   = re.search(r"x\s*0\s*[=:]\s*([\d\.]+)", p)
+            iter_m = re.search(r"(\d+)\s*iter", p)
+
+            if eq_m and x0_m:
+                raw_eq  = clean(eq_m.group(1).strip())
+                x0_val  = float(x0_m.group(1))
+                n_iter  = int(iter_m.group(1)) if iter_m else 3
+
+                expr_nr = parse_expr(raw_eq, transformations=tfms, local_dict=ld)
+                f_sym   = sp.lambdify(x, expr_nr, modules="math")
+                df_sym  = sp.lambdify(x, sp.diff(expr_nr, x), modules="math")
+
+                # Run all iterations with full precision — never round intermediate values
+                iterations = []
+                xn = x0_val
+                for i in range(n_iter):
+                    fxn  = f_sym(xn)
+                    dfxn = df_sym(xn)
+                    if abs(dfxn) < 1e-15:
+                        break  # avoid division by zero
+                    xn1 = xn - fxn / dfxn
+                    iterations.append({
+                        "n": i, "xn": round(xn, 8),
+                        "fxn": round(fxn, 8), "dfxn": round(dfxn, 8),
+                        "xn1": round(xn1, 8)
+                    })
+                    xn = xn1  # use FULL precision for next iteration
+
+                final_x  = iterations[-1]["xn1"] if iterations else x0_val
+                final_fx = round(f_sym(final_x), 10)
+                iter_str = "\n".join([
+                    f"  x{it['n']+1} = {it['xn']} - ({it['fxn']}) / ({it['dfxn']}) = {it['xn1']}"
+                    for it in iterations
+                ])
+                result_str = (
+                    f"f(x) = {str(expr_nr)}, f'(x) = {str(sp.diff(expr_nr, x))}\n"
+                    f"x0 = {x0_val}, iterations = {n_iter}\n"
+                    f"VERIFIED ITERATIONS (AI MUST use these exact values):\n"
+                    f"{iter_str}\n"
+                    f"Final answer: x{n_iter} = {final_x}\n"
+                    f"Verification: f({final_x}) = {final_fx} ≈ 0"
+                )
+                return {
+                    "type": "Newton-Raphson",
+                    "result": result_str,
+                    "latex": f"x_{{{n_iter}}} = {final_x}"
+                }
+
+        # ── 6. Numerical Analysis Methods ───────────────────────────
+        elif any(k in p for k in ["bisection", "secant method", "false position",
+                                   "regula falsi", "gauss elimination", "gauss elim",
+                                   "lu decomposition", "lu decomp",
+                                   "lagrange interpolation", "lagrange interp",
+                                   "newton divided", "divided difference",
+                                   "trapezoidal", "trapezoid rule",
+                                   "simpson", "euler method", "euler's method",
+                                   "runge-kutta", "runge kutta", "rk4"]):
+            import math as _math
+
+            # ── Helper: extract f(x) expression ──────────────────────
+            def get_expr():
+                # Stop before common natural-language delimiters so prompts such as
+                # "bisection of x^3 - x on [1,2]" do not parse the interval as math.
+                eq_m = re.search(
+                    r"(?:of|to|for|function)\s+(.+?)(?=\s*(?:=\s*0|,|\bon\b|\bfrom\b|\bbetween\b|\[|$))",
+                    p,
+                )
+                if eq_m:
+                    raw = clean(eq_m.group(1).strip())
+                    return parse_expr(raw, transformations=tfms, local_dict=ld)
+                return None
+
+            # ── Helper: extract bounds a, b ───────────────────────────
+            def get_bounds():
+                nums = re.findall(r"[-]?\d+\.?\d*", p)
+                floats = [float(n) for n in nums]
+                # x0 value
+                x0_m = re.search(r"x\s*0\s*[=:]\s*([-]?\d+\.?\d*)", p)
+                x1_m = re.search(r"x\s*1\s*[=:]\s*([-]?\d+\.?\d*)", p)
+                # interval [a,b]
+                ab_m = re.search(r"\[\s*([-]?\d+\.?\d*)\s*,\s*([-]?\d+\.?\d*)\s*\]", p)
+                return floats, x0_m, x1_m, ab_m
+
+            # ── Helper: extract iterations ────────────────────────────
+            def get_iters(default=5):
+                m = re.search(r"(\d+)\s*iter", p)
+                return int(m.group(1)) if m else default
+
+            # ── Helper: extract step size h ───────────────────────────
+            def get_h():
+                m = re.search(r"h\s*[=:]\s*([\d\.]+)", p)
+                return float(m.group(1)) if m else 0.1
+
+            # ── Helper: extract ODE rhs f(x,y) ───────────────────────
+            def get_ode_rhs():
+                # dy/dx = f(x,y) → extract rhs
+                m = re.search(r"dy/dx\s*=\s*(.+?)(?:\s*,|\s*with|\s*y\s*\(|$)", p)
+                return m.group(1).strip() if m else None
+
+            floats, x0_m, x1_m, ab_m = get_bounds()
+            n_iter = max(1, get_iters())
+
+            # ════════════════════════════════════════════════════════
+            # BISECTION METHOD
+            # ════════════════════════════════════════════════════════
+            if "bisection" in p:
+                expr_b = get_expr()
+                if expr_b is not None and ab_m:
+                    a_val = float(ab_m.group(1))
+                    b_val = float(ab_m.group(2))
+                    f_b = sp.lambdify(x, expr_b, modules="math")
+                    fa, fb = f_b(a_val), f_b(b_val)
+                    if fa == 0:
+                        return {"type": "Bisection", "result": f"Root = {a_val}", "latex": f"x = {a_val}"}
+                    if fb == 0:
+                        return {"type": "Bisection", "result": f"Root = {b_val}", "latex": f"x = {b_val}"}
+                    if fa * fb > 0:
+                        return {
+                            "type": "Bisection",
+                            "result": f"Cannot apply bisection: f({a_val}) and f({b_val}) have the same sign.",
+                            "latex": "\\text{Invalid bracket}",
+                        }
+                    steps = []
+                    a_n, b_n = a_val, b_val
+                    for i in range(n_iter):
+                        c = (a_n + b_n) / 2
+                        fc = f_b(c)
+                        steps.append({"iter": i+1, "a": round(a_n,8),
+                                      "b": round(b_n,8), "c": round(c,8),
+                                      "fc": round(fc,8)})
+                        if f_b(a_n) * fc < 0: b_n = c
+                        else: a_n = c
+                    step_str = "\n".join([
+                        f"  Iter {s['iter']}: a={s['a']}, b={s['b']}, c={s['c']}, f(c)={s['fc']}"
+                        for s in steps])
+                    final_c = steps[-1]["c"]
+                    return {
+                        "type": "Bisection",
+                        "result": (f"f(x) = {str(expr_b)}\n"
+                                   f"Interval [{a_val},{b_val}], {n_iter} iterations\n"
+                                   f"VERIFIED ITERATIONS:\n{step_str}\n"
+                                   f"Root ≈ {final_c}"),
+                        "latex": f"x \\approx {final_c}"
+                    }
+
+            # ════════════════════════════════════════════════════════
+            # SECANT METHOD
+            # ════════════════════════════════════════════════════════
+            elif "secant" in p:
+                expr_s = get_expr()
+                if expr_s is not None and x0_m and x1_m:
+                    x0_v = float(x0_m.group(1))
+                    x1_v = float(x1_m.group(1))
+                    f_s = sp.lambdify(x, expr_s, modules="math")
+                    steps = []
+                    xp, xc = x0_v, x1_v
+                    for i in range(n_iter):
+                        fxp, fxc = f_s(xp), f_s(xc)
+                        if abs(fxc - fxp) < 1e-15: break
+                        xn_val = xc - fxc*(xc-xp)/(fxc-fxp)
+                        steps.append({"iter": i+1, "x": round(xn_val, 8),
+                                      "fx": round(f_s(xn_val), 8)})
+                        xp, xc = xc, xn_val
+                    step_str = "\n".join([
+                        f"  Iter {s['iter']}: x={s['x']}, f(x)={s['fx']}"
+                        for s in steps])
+                    return {
+                        "type": "Secant",
+                        "result": (f"f(x) = {str(expr_s)}\n"
+                                   f"x0={x0_v}, x1={x1_v}, {n_iter} iterations\n"
+                                   f"VERIFIED ITERATIONS:\n{step_str}\n"
+                                   f"Root ≈ {steps[-1]['x']}"),
+                        "latex": f"x \\approx {steps[-1]['x']}"
+                    }
+
+            # ════════════════════════════════════════════════════════
+            # FALSE POSITION (Regula Falsi)
+            # ════════════════════════════════════════════════════════
+            elif any(k in p for k in ["false position", "regula falsi"]):
+                expr_fp = get_expr()
+                if expr_fp is not None and ab_m:
+                    a_val = float(ab_m.group(1))
+                    b_val = float(ab_m.group(2))
+                    f_fp = sp.lambdify(x, expr_fp, modules="math")
+                    steps = []
+                    a_n, b_n = a_val, b_val
+                    for i in range(n_iter):
+                        fa, fb = f_fp(a_n), f_fp(b_n)
+                        c = (a_n*fb - b_n*fa) / (fb - fa)
+                        fc = f_fp(c)
+                        steps.append({"iter": i+1, "a": round(a_n,8),
+                                      "b": round(b_n,8), "c": round(c,8),
+                                      "fc": round(fc,8)})
+                        if fa * fc < 0: b_n = c
+                        else: a_n = c
+                    step_str = "\n".join([
+                        f"  Iter {s['iter']}: a={s['a']}, b={s['b']}, c={s['c']}, f(c)={s['fc']}"
+                        for s in steps])
+                    return {
+                        "type": "FalsePosition",
+                        "result": (f"f(x) = {str(expr_fp)}\n"
+                                   f"Interval [{a_val},{b_val}], {n_iter} iterations\n"
+                                   f"VERIFIED ITERATIONS:\n{step_str}\n"
+                                   f"Root ≈ {steps[-1]['c']}"),
+                        "latex": f"x \\approx {steps[-1]['c']}"
+                    }
+
+            # ════════════════════════════════════════════════════════
+            # GAUSS ELIMINATION
+            # ════════════════════════════════════════════════════════
+            elif any(k in p for k in ["gauss elimination", "gauss elim"]):
+                # Extract matrix from problem — look for [[...]] pattern
+                mat_m = re.search(r"\[\s*\[(.+?)\]\s*\]", p)
+                rhs_m = re.search(r"(?:rhs|=|b)\s*[=:]?\s*\[([^\]]+)\]", p)
+                if mat_m and rhs_m:
+                    rows = re.findall(r"\[([^\]]+)\]", p)
+                    mat_data = [[sp.Rational(v) for v in re.split(r"[,\s]+", r.strip()) if v]
+                                for r in rows[:-1]]
+                    rhs_data = [sp.Rational(v) for v in re.split(r"[,\s]+", rows[-1].strip()) if v]
+                    A = sp.Matrix(mat_data)
+                    b_vec = sp.Matrix(rhs_data)
+                    sol = A.solve(b_vec)
+                    sol_str = ", ".join([f"x{i+1}={sol[i]}" for i in range(len(sol))])
+                    return {
+                        "type": "GaussElimination",
+                        "result": f"VERIFIED SOLUTION: {sol_str}",
+                        "latex": sol_str
+                    }
+
+            # ════════════════════════════════════════════════════════
+            # LU DECOMPOSITION
+            # ════════════════════════════════════════════════════════
+            elif any(k in p for k in ["lu decomposition", "lu decomp"]):
+                rows = re.findall(r"\[([^\]]+)\]", p)
+                if rows:
+                    mat_data = [[sp.Rational(v) for v in re.split(r"[,\s]+", r.strip()) if v]
+                                for r in rows]
+                    M = sp.Matrix(mat_data)
+                    L, U, _ = M.LUdecomposition()
+                    return {
+                        "type": "LUDecomposition",
+                        "result": (f"VERIFIED:\nL = {str(L)}\nU = {str(U)}"),
+                        "latex": f"L={sp.latex(L)}, U={sp.latex(U)}"
+                    }
+
+            # ════════════════════════════════════════════════════════
+            # LAGRANGE INTERPOLATION
+            # ════════════════════════════════════════════════════════
+            elif any(k in p for k in ["lagrange interpolation", "lagrange interp"]):
+                # Extract data points (x0,y0),(x1,y1),...
+                pts = re.findall(r"\(\s*([-\d\.]+)\s*,\s*([-\d\.]+)\s*\)", p)
+                if pts:
+                    data = [(sp.Rational(px), sp.Rational(py)) for px, py in pts]
+                    poly = sp.interpolate(data, x)
+                    poly_exp = sp.expand(poly)
+                    return {
+                        "type": "LagrangeInterpolation",
+                        "result": f"VERIFIED polynomial: {str(poly_exp)}",
+                        "latex": sp.latex(poly_exp)
+                    }
+
+            # ════════════════════════════════════════════════════════
+            # NEWTON DIVIDED DIFFERENCE
+            # ════════════════════════════════════════════════════════
+            elif any(k in p for k in ["newton divided", "divided difference"]):
+                pts = re.findall(r"\(\s*([-\d\.]+)\s*,\s*([-\d\.]+)\s*\)", p)
+                if pts:
+                    xs_v = [float(px) for px, py in pts]
+                    ys_v = [float(py) for px, py in pts]
+                    n_p = len(xs_v)
+                    dd = [[0.0]*n_p for _ in range(n_p)]
+                    for i in range(n_p): dd[i][0] = ys_v[i]
+                    for j in range(1, n_p):
+                        for i in range(n_p - j):
+                            dd[i][j] = (dd[i+1][j-1]-dd[i][j-1])/(xs_v[i+j]-xs_v[i])
+                    coeffs = [round(dd[0][j], 8) for j in range(n_p)]
+                    # Build polynomial
+                    poly_s = sp.interpolate(list(zip(xs_v, ys_v)), x)
+                    return {
+                        "type": "NewtonDividedDiff",
+                        "result": (f"VERIFIED divided differences: {coeffs}\n"
+                                   f"Polynomial: {str(sp.expand(poly_s))}"),
+                        "latex": sp.latex(sp.expand(poly_s))
+                    }
+
+            # ════════════════════════════════════════════════════════
+            # TRAPEZOIDAL RULE
+            # ════════════════════════════════════════════════════════
+            elif any(k in p for k in ["trapezoidal", "trapezoid rule"]):
+                expr_t = get_expr()
+                ab_m2 = re.search(r"\[\s*([-\d\.]+)\s*,\s*([-\d\.]+)\s*\]", p)
+                n_m = re.search(r"n\s*[=:]\s*(\d+)", p)
+                if expr_t is not None and ab_m2 and n_m:
+                    a_v = float(ab_m2.group(1))
+                    b_v = float(ab_m2.group(2))
+                    n_v = int(n_m.group(1))
+                    f_t = sp.lambdify(x, expr_t, modules="math")
+                    h = (b_v - a_v) / n_v
+                    s = f_t(a_v) + f_t(b_v)
+                    pts_str = [f"f({round(a_v,4)})={round(f_t(a_v),6)}", ]
+                    for i in range(1, n_v):
+                        xi = a_v + i*h
+                        pts_str.append(f"f({round(xi,4)})={round(f_t(xi),6)}")
+                    pts_str.append(f"f({round(b_v,4)})={round(f_t(b_v),6)}")
+                    result_val = round(h/2 * (f_t(a_v)+f_t(b_v) + 2*sum(f_t(a_v+i*h) for i in range(1,n_v))), 8)
+                    return {
+                        "type": "Trapezoidal",
+                        "result": (f"f(x)={str(expr_t)}, [{a_v},{b_v}], n={n_v}, h={round(h,6)}\n"
+                                   f"Function values: {', '.join(pts_str)}\n"
+                                   f"VERIFIED result: {result_val}"),
+                        "latex": f"\\int_{{{a_v}}}^{{{b_v}}} \\approx {result_val}"
+                    }
+
+            # ════════════════════════════════════════════════════════
+            # SIMPSON'S 1/3 RULE
+            # ════════════════════════════════════════════════════════
+            elif any(k in p for k in ["simpson"]):
+                expr_si = get_expr()
+                ab_m3 = re.search(r"\[\s*([-\d\.]+)\s*,\s*([-\d\.]+)\s*\]", p)
+                n_m2 = re.search(r"n\s*[=:]\s*(\d+)", p)
+                if expr_si is not None and ab_m3 and n_m2:
+                    a_v = float(ab_m3.group(1))
+                    b_v = float(ab_m3.group(2))
+                    n_v = int(n_m2.group(1))
+                    if n_v % 2 != 0: n_v += 1  # must be even
+                    f_si = sp.lambdify(x, expr_si, modules="math")
+                    h = (b_v - a_v) / n_v
+                    s = f_si(a_v) + f_si(b_v)
+                    for i in range(1, n_v):
+                        s += (4 if i % 2 != 0 else 2) * f_si(a_v + i*h)
+                    result_val = round(h/3 * s, 8)
+                    return {
+                        "type": "Simpsons",
+                        "result": (f"f(x)={str(expr_si)}, [{a_v},{b_v}], n={n_v}, h={round(h,6)}\n"
+                                   f"VERIFIED result: {result_val}"),
+                        "latex": f"\\int_{{{a_v}}}^{{{b_v}}} \\approx {result_val}"
+                    }
+
+            # ════════════════════════════════════════════════════════
+            # EULER'S METHOD
+            # ════════════════════════════════════════════════════════
+            elif any(k in p for k in ["euler method", "euler's method"]):
+                rhs_str = get_ode_rhs()
+                x0_em = re.search(r"x\s*0?\s*[=:]\s*([-\d\.]+)", p)
+                y0_em = re.search(r"y\s*[=\(]\s*0?\s*\)?\s*[=:]\s*([-\d\.]+)", p)
+                h_val = get_h()
+                n_steps = get_iters(default=5)
+                if rhs_str and x0_em and y0_em:
+                    x_s, y_s = sp.symbols('x y')
+                    rhs_expr_ode = parse_expr(clean(rhs_str), transformations=tfms,
+                                              local_dict={**ld, "y": y_s})
+                    f_ode = sp.lambdify((x_s, y_s), rhs_expr_ode, modules="math")
+                    xn_e, yn_e = float(x0_em.group(1)), float(y0_em.group(1))
+                    steps = []
+                    for i in range(n_steps):
+                        yn1 = yn_e + h_val * f_ode(xn_e, yn_e)
+                        xn_e += h_val
+                        steps.append({"n": i+1, "x": round(xn_e,6), "y": round(yn1,8)})
+                        yn_e = yn1
+                    step_str = "\n".join([f"  Step {s['n']}: x={s['x']}, y={s['y']}" for s in steps])
+                    final_y_e = steps[-1]['y']
+                    return {
+                        "type": "EulersMethod",
+                        "result": (f"dy/dx = {rhs_str}, h={h_val}, {n_steps} steps\n"
+                                   f"VERIFIED ITERATIONS (USE THESE EXACT VALUES):\n{step_str}\n"
+                                   f"FINAL ANSWER: y({steps[-1]['x']}) = {final_y_e} — USE THIS EXACTLY"),
+                        "latex": f"y_{{{n_steps}}} = {final_y_e}"
+                    }
+
+            # ════════════════════════════════════════════════════════
+            # RUNGE-KUTTA RK4
+            # ════════════════════════════════════════════════════════
+            elif any(k in p for k in ["runge-kutta", "runge kutta", "rk4"]):
+                rhs_str = get_ode_rhs()
+                x0_rk = re.search(r"x\s*0?\s*[=:]\s*([-\d\.]+)", p)
+                y0_rk = re.search(r"y\s*[=\(]\s*0?\s*\)?\s*[=:]\s*([-\d\.]+)", p)
+                h_val = get_h()
+                n_steps = get_iters(default=3)
+                if rhs_str and x0_rk and y0_rk:
+                    x_s, y_s = sp.symbols('x y')
+                    rhs_expr_rk = parse_expr(clean(rhs_str), transformations=tfms,
+                                             local_dict={**ld, "y": y_s})
+                    f_rk = sp.lambdify((x_s, y_s), rhs_expr_rk, modules="math")
+                    xn_r, yn_r = float(x0_rk.group(1)), float(y0_rk.group(1))
+                    steps = []
+                    for i in range(n_steps):
+                        k1 = h_val * f_rk(xn_r, yn_r)
+                        k2 = h_val * f_rk(xn_r+h_val/2, yn_r+k1/2)
+                        k3 = h_val * f_rk(xn_r+h_val/2, yn_r+k2/2)
+                        k4 = h_val * f_rk(xn_r+h_val, yn_r+k3)
+                        yn1 = yn_r + (k1+2*k2+2*k3+k4)/6
+                        xn_r += h_val
+                        steps.append({"n": i+1, "x": round(xn_r,6),
+                                      "k1": round(k1,8), "k2": round(k2,8),
+                                      "k3": round(k3,8), "k4": round(k4,8),
+                                      "y": round(yn1,8)})
+                        yn_r = yn1
+                    step_str = "\n".join([
+                        f"  Step {s['n']}: x={s['x']}, k1={s['k1']}, k2={s['k2']}, k3={s['k3']}, k4={s['k4']}, y={s['y']}"
+                        for s in steps])
+                    final_y = steps[-1]['y']
+                    return {
+                        "type": "RungeKutta4",
+                        "result": (f"dy/dx={rhs_str}, h={h_val}, {n_steps} steps\n"
+                                   f"VERIFIED ITERATIONS (USE THESE EXACT k VALUES):\n{step_str}\n"
+                                   f"FINAL ANSWER: y({round(xn_r,4)}) = {final_y} — USE THIS EXACTLY"),
+                        "latex": f"y_{{{n_steps}}} = {final_y}"
+                    }
+
+        # ── 7. Theory of Numbers — SymPy computes exactly ───────────────
+        elif any(k in p for k in [
+                "gcd", "greatest common divisor", "hcf",
+                "lcm", "least common multiple",
+                "prime factor", "factoriz", "factori",
+                "is prime", "isprime", "prime or not", "check prime",
+                "totient", "euler's totient",
+                "number of divisor", "sum of divisor", "divisors of",
+                "mobius", "möbius",
+                "diophantine",
+                "chinese remainder", "crt",
+                "fermat", "wilson",
+                "quadratic residu", "legendre",
+                "primitive root",
+                "linear congruence", "congruence", "≡",
+                "euler's theorem", "euler theorem",
+        ]) or re.search(r'\bis\s+\d+\s+prime\b', p):
+            import math as _math
+
+            def _nums(text):
+                return [int(n) for n in re.findall(r'\b\d+\b', text)]
+
+            x_d, y_d = sp.symbols('x y')
+
+            try:
+                # ── GCD (Extended Euclidean) ──────────────────────────────
+                if any(k in p for k in ["gcd","greatest common divisor","hcf"]):
+                    nums = _nums(p)
+                    if len(nums) >= 2:
+                        a,b = nums[0],nums[1]
+                        g = int(sp.gcd(a,b))
+                        # Extended Euclidean
+                        old_r,r = a,b; old_s,s = 1,0; old_t,t2 = 0,1
+                        while r:
+                            q=old_r//r; old_r,r=r,old_r-q*r
+                            old_s,s=s,old_s-q*s; old_t,t2=t2,old_t-q*t2
+                        result_str = (f"gcd({a},{b}) = {old_r}\n"
+                                      f"Extended Euclidean: {a}×({old_s}) + {b}×({old_t}) = {old_r}\n"
+                                      f"Verify: {a*old_s + b*old_t} = {old_r} ✅")
+                        return {"type":"GCD","result":result_str,
+                                "latex":f"\\gcd({a},{b})={old_r}"}
+
+                # ── LCM ───────────────────────────────────────────────────
+                elif any(k in p for k in ["lcm","least common multiple"]):
+                    nums = _nums(p)
+                    if len(nums) >= 2:
+                        l = int(sp.lcm(nums[0],nums[1]))
+                        g = int(sp.gcd(nums[0],nums[1]))
+                        return {"type":"LCM",
+                                "result":f"lcm({nums[0]},{nums[1]}) = {l}, gcd = {g}",
+                                "latex":f"\\text{{lcm}}({nums[0]},{nums[1]})={l}"}
+
+                # ── PRIME FACTORIZATION ───────────────────────────────────
+                elif any(k in p for k in ["prime factor","factoriz","factori"]):
+                    nums = _nums(p)
+                    if nums:
+                        f_dict = sp.factorint(nums[0])
+                        f_str = " × ".join([f"{pp}^{e}" if e>1 else str(pp) for pp,e in f_dict.items()])
+                        return {"type":"PrimeFactorization",
+                                "result":f"{nums[0]} = {f_str}",
+                                "latex":f"{nums[0]} = {f_str}"}
+
+                # ── IS PRIME ──────────────────────────────────────────────
+                elif any(k in p for k in ["is prime","isprime","prime or not","check prime"]) or re.search(r'\bis\s+\d+\s+prime\b',p):
+                    nums = _nums(p)
+                    if nums:
+                        n_val = nums[0]
+                        is_p = sp.isprime(n_val)
+                        ans = "PRIME" if is_p else "COMPOSITE (NOT PRIME)"
+                        return {"type":"PrimeCheck",
+                                "result":f"{n_val} is {ans}",
+                                "latex":f"{n_val}\\text{{ is }}{ans}"}
+
+                # ── EULER TOTIENT ─────────────────────────────────────────
+                elif any(k in p for k in ["totient","euler's totient"]):
+                    nums = _nums(p)
+                    if nums:
+                        phi = int(sp.totient(nums[0]))
+                        f_dict = sp.factorint(nums[0])
+                        return {"type":"EulerTotient",
+                                "result":f"φ({nums[0]}) = {phi}, factorization = {f_dict}",
+                                "latex":f"\\phi({nums[0]})={phi}"}
+
+                # ── DIVISOR FUNCTIONS τ, σ ────────────────────────────────
+                elif any(k in p for k in ["number of divisor","sum of divisor","divisors of","tau","sigma"]):
+                    nums = _nums(p)
+                    if nums:
+                        divs = sp.divisors(nums[0])
+                        return {"type":"DivisorFunctions",
+                                "result":f"divisors({nums[0]}) = {divs}, τ = {len(divs)}, σ = {sum(divs)}",
+                                "latex":f"\\tau({nums[0]})={len(divs)}, \\sigma({nums[0]})={sum(divs)}"}
+
+                # ── MOBIUS FUNCTION ───────────────────────────────────────
+                elif any(k in p for k in ["mobius","möbius"]):
+                    nums = _nums(p)
+                    if nums:
+                        mu = sp.mobius(nums[0])
+                        return {"type":"Mobius",
+                                "result":f"μ({nums[0]}) = {mu}",
+                                "latex":f"\\mu({nums[0]})={mu}"}
+
+                # ── DIOPHANTINE EQUATION ──────────────────────────────────
+                elif "diophantine" in p:
+                    m = re.search(r"(\d+)\s*x\s*[+\-]\s*(\d+)\s*y\s*=\s*(\d+)",p)
+                    if m:
+                        a_d,b_d,c_d = int(m.group(1)),int(m.group(2)),int(m.group(3))
+                        g = int(sp.gcd(a_d,b_d))
+                        if c_d%g == 0:
+                            sol = sp.diophantine(sp.Eq(a_d*x_d+b_d*y_d, c_d))
+                            return {"type":"Diophantine",
+                                    "result":f"{a_d}x+{b_d}y={c_d}: general solution={sol}, gcd={g}",
+                                    "latex":str(sol)}
+                        else:
+                            return {"type":"Diophantine",
+                                    "result":f"No integer solution: gcd({a_d},{b_d})={g} does not divide {c_d}",
+                                    "latex":"\\text{No solution}"}
+
+                # ── CRT — MUST be before congruence ───────────────────────
+                elif any(k in p for k in ["chinese remainder","crt"]):
+                    pairs = re.findall(r'x\s*[≡=]\s*(\d+)\s*(?:mod|modulo|\(mod)\s*(\d+)',p)
+                    if len(pairs) >= 2:
+                        remainders = [int(r) for r,m in pairs]
+                        moduli = [int(m) for r,m in pairs]
+                        sol = sp.ntheory.modular.crt(moduli, remainders)
+                        verify = [f"{sol[0]}%{m}={sol[0]%m}" for m in moduli]
+                        return {"type":"CRT",
+                                "result":f"x ≡ {sol[0]} (mod {sol[1]}), verify: {verify}",
+                                "latex":f"x\\equiv {sol[0]}\\pmod{{{sol[1]}}}"}
+
+                # ── FERMAT'S LITTLE THEOREM ───────────────────────────────
+                elif "fermat" in p:
+                    nums = _nums(p)
+                    if len(nums) >= 2:
+                        a_f,p_f = nums[0],nums[1]
+                        if sp.isprime(p_f):
+                            r = pow(a_f,p_f-1,p_f)
+                            return {"type":"FermatTheorem",
+                                    "result":f"{a_f}^({p_f}-1) mod {p_f} = {r} ≡ 1 (mod {p_f})",
+                                    "latex":f"{a_f}^{{{p_f-1}}}\\equiv 1\\pmod{{{p_f}}}"}
+
+                # ── EULER'S THEOREM ───────────────────────────────────────
+                elif "euler" in p and ("theorem" in p or "theorem" in p):
+                    nums = _nums(p)
+                    if len(nums) >= 2:
+                        a_e,n_e = nums[0],nums[1]
+                        phi = int(sp.totient(n_e))
+                        r = pow(a_e,phi,n_e)
+                        return {"type":"EulerTheorem",
+                                "result":f"φ({n_e})={phi}, {a_e}^{phi} mod {n_e} = {r} ≡ 1 (mod {n_e})",
+                                "latex":f"{a_e}^{{\\phi({n_e})}}\\equiv 1\\pmod{{{n_e}}}"}
+
+                # ── WILSON'S THEOREM ──────────────────────────────────────
+                elif "wilson" in p:
+                    nums = _nums(p)
+                    if nums:
+                        p_w = nums[0]
+                        val = _math.factorial(p_w-1)%p_w
+                        return {"type":"WilsonTheorem",
+                                "result":f"({p_w}-1)! mod {p_w} = {val} ≡ -1 (mod {p_w})",
+                                "latex":f"({p_w}-1)!\\equiv -1\\pmod{{{p_w}}}"}
+
+                # ── LINEAR CONGRUENCE ─────────────────────────────────────
+                elif any(k in p for k in ["congruence","linear congruence"]) or re.search(r'\d+\s*x\s*[≡=]',p):
+                    m = re.search(r"(\d+)\s*x\s*[≡=]\s*(\d+)\s*(?:\(mod|mod|modulo)\s*(\d+)",p)
+                    if m:
+                        a_c,b_c,n_c = int(m.group(1)),int(m.group(2)),int(m.group(3))
+                        g = int(sp.gcd(a_c,n_c))
+                        if b_c%g != 0:
+                            return {"type":"LinearCongruence",
+                                    "result":f"No solution: gcd({a_c},{n_c})={g} ∤ {b_c}",
+                                    "latex":"\\text{No solution}"}
+                        sols = [i for i in range(n_c) if (a_c*i)%n_c==b_c%n_c]
+                        return {"type":"LinearCongruence",
+                                "result":f"{a_c}x ≡ {b_c} (mod {n_c}): x ≡ {sols} (mod {n_c}), {g} solution(s)",
+                                "latex":f"x\\equiv {sols[0]}\\pmod{{{n_c//g}}}"}
+
+                # ── QUADRATIC RESIDUES ────────────────────────────────────
+                elif any(k in p for k in ["quadratic residu","quadratic non"]):
+                    nums = _nums(p)
+                    if nums:
+                        p_q = nums[0]
+                        qr = sorted(set([pow(i,2,p_q) for i in range(1,p_q)]))
+                        qnr = [i for i in range(1,p_q) if i not in qr]
+                        return {"type":"QuadraticResidues",
+                                "result":f"QR mod {p_q} = {qr}, QNR mod {p_q} = {qnr}",
+                                "latex":f"QR\\pmod{{{p_q}}}={qr}"}
+
+                # ── LEGENDRE SYMBOL ───────────────────────────────────────
+                elif "legendre" in p:
+                    m = re.search(r"\(\s*(\d+)\s*/\s*(\d+)\s*\)",p)
+                    if m:
+                        a_l,p_l = int(m.group(1)),int(m.group(2))
+                        val = 1 if pow(a_l,(p_l-1)//2,p_l)==1 else (-1 if a_l%p_l!=0 else 0)
+                        meaning = "QR (quadratic residue)" if val==1 else ("QNR (non-residue)" if val==-1 else "0 (divisible)")
+                        return {"type":"LegendreSymbol",
+                                "result":f"({a_l}/{p_l}) = {val} → {a_l} is {meaning} mod {p_l}",
+                                "latex":f"\\left(\\frac{{{a_l}}}{{{p_l}}}\\right)={val}"}
+
+                # ── PRIMITIVE ROOT ────────────────────────────────────────
+                elif "primitive root" in p:
+                    nums = _nums(p)
+                    if nums:
+                        pr = sp.ntheory.primitive_root(nums[0])
+                        return {"type":"PrimitiveRoot",
+                                "result":f"primitive_root({nums[0]}) = {pr}",
+                                "latex":f"g={pr}"}
+
+            except Exception:
+                pass  # safe fallback to AI
+
+        # ── 7. Solve equation ────────────────────────────────────────
+        elif any(k in p for k in ["solve", "roots", "find x"]):
+            raw = re.sub(r"(solve|find x|roots of|roots|the equation)", "", p)
+            raw = raw.strip().strip(":").strip()
+            if "=" in raw:
+                lhs_s, rhs_s = raw.split("=", 1)
+                lhs_e = parse_expr(clean(lhs_s), transformations=tfms, local_dict=ld)
+                rhs_e = parse_expr(clean(rhs_s), transformations=tfms, local_dict=ld)
+                expr  = lhs_e - rhs_e
+            else:
+                expr = parse_expr(clean(raw), transformations=tfms, local_dict=ld)
+            if x in expr.free_symbols:
+                sol = sp.solve(expr, x)
+                sol_latex = ", ".join([sp.latex(s) for s in sol])
+                return {
+                    "type": "Equation",
+                    "result": str(sol),
+                    "latex": r"x \in \{" + sol_latex + r"\}"
+                }
+
+        # ── 8. Real Analysis II — SymPy for computations, AI for theory ──
+        elif any(k in p for k in [
+                # Sets & Real Numbers
+                "supremum", "infimum", "least upper bound", "greatest lower bound",
+                "lub", "glb", "archimedean", "bounded set", "completeness",
+                "cartesian product", "density of rational", "real number system",
+                "field propert", "order propert",
+                # Sequences
+                "sequence", "cauchy sequence", "bounded sequence",
+                "monotone sequence", "subsequence", "bolzano", "weierstrass",
+                # Series
+                "ratio test", "root test", "integral test", "comparison test",
+                "alternating series", "leibniz test", "absolute convergence",
+                "conditional convergence", "cauchy criterion",
+                "pointwise convergence", "uniform convergence",
+                "weierstrass m-test", "m-test",
+                # Limits & Continuity
+                "epsilon delta", "epsilon-delta", "uniform continuity",
+                "intermediate value", "extreme value theorem",
+                # Differentiation theorems
+                "mean value theorem", "rolle", "taylor's theorem",
+                "lhopital", "l'hopital",
+                # Riemann Integration
+                "riemann sum", "riemann integral", "upper sum", "lower sum",
+                "darboux", "integrability", "fundamental theorem of calculus",
+        ]):
+            try:
+                n_s = sp.Symbol('n', positive=True)
+
+                # ── Sequence limit ────────────────────────────────────────
+                if any(k in p for k in ["sequence","limit of sequence"]):
+                    # Extract expression after "of" or "for"
+                    m = re.search(r"(?:of|for|lim)\s+(.+?)\s*(?:as|when|$)", p)
+                    if m:
+                        raw = clean(m.group(1))
+                        try:
+                            expr_s = parse_expr(raw, transformations=tfms,
+                                               local_dict={**ld, "n": n_s})
+                            lim_val = sp.limit(expr_s, n_s, sp.oo)
+                            return {
+                                "type": "SequenceLimit",
+                                "result": f"lim({m.group(1)}) as n→∞ = {lim_val}",
+                                "latex": f"\\lim_{{n\\to\\infty}} = {sp.latex(lim_val)}"
+                            }
+                        except Exception:
+                            pass
+
+                # ── Series sum ────────────────────────────────────────────
+                elif any(k in p for k in ["series","sum of"]):
+                    m = re.search(r"(?:sum\s+of|series\s+(?:of\s+)?|convergence\s+of)\s*(.+?)(?:\s+from|\s+using|\s+by|$)", p)
+                    if m:
+                        raw = m.group(1).strip()
+                        raw = re.sub(r"^series\s+sum\s+of\s+", "", raw)
+                        raw = re.sub(r"^series\s+of\s+", "", raw)
+                        raw = re.sub(r"^sum\s+of\s+", "", raw)
+                        raw = re.sub(r"^of\s+", "", raw)
+                        raw = clean(raw)
+                        try:
+                            expr_ser = parse_expr(raw, transformations=tfms,
+                                                  local_dict={**ld, "n": n_s})
+                            s_val = sp.summation(expr_ser, (n_s, 1, sp.oo))
+                            converges = s_val.is_finite
+                            return {
+                                "type": "SeriesConvergence",
+                                "result": (f"Series sum = {s_val}, "
+                                           f"Converges: {converges}"),
+                                "latex": f"\\sum_{{n=1}}^{{\\infty}} = {sp.latex(s_val)}"
+                            }
+                        except Exception:
+                            pass
+
+                # ── Taylor Series ─────────────────────────────────────────
+                elif any(k in p for k in ["taylor", "maclaurin"]):
+                    funcs = {
+                        "sin": sp.sin(x), "cos": sp.cos(x),
+                        "exp": sp.exp(x), "e^x": sp.exp(x),
+                        "ln": sp.log(1+x), "log": sp.log(1+x),
+                        "tan": sp.tan(x)
+                    }
+                    for fname, fexpr in funcs.items():
+                        if fname in p:
+                            n_terms = 6
+                            ts = sp.series(fexpr, x, 0, n_terms)
+                            return {
+                                "type": "TaylorSeries",
+                                "result": f"Taylor series of {fname}: {ts}",
+                                "latex": sp.latex(ts)
+                            }
+
+                # ── L'Hopital ──────────────────────────────────��──────────
+                elif any(k in p for k in ["lhopital","l'hopital"]):
+                    m = re.search(r"(?:of|for)\s+(.+?)\s*(?:as|at|when)\s*x\s*[→→=]\s*([\d\.]+|inf)", p)
+                    if m:
+                        raw = clean(m.group(1))
+                        pt_str = m.group(2)
+                        pt = sp.oo if pt_str in ("inf","infinity") else sp.sympify(pt_str)
+                        try:
+                            expr_lh = parse_expr(raw, transformations=tfms, local_dict=ld)
+                            lim_val = sp.limit(expr_lh, x, pt)
+                            return {
+                                "type": "LHopital",
+                                "result": f"lim({m.group(1)}) as x→{pt_str} = {lim_val}",
+                                "latex": f"\\lim_{{x\\to {pt_str}}} = {sp.latex(lim_val)}"
+                            }
+                        except Exception:
+                            pass
+
+                # ── Riemann Integral ──────────────────────────────────────
+                elif any(k in p for k in ["riemann","riemann integral","riemann sum"]):
+                    # Try to extract definite integral
+                    m = re.search(r"(?:of|for)\s+(.+?)\s+(?:from|on)\s+([\d\.]+)\s+to\s+([\d\.]+)", p)
+                    if m:
+                        raw = clean(m.group(1))
+                        a_v = sp.sympify(m.group(2))
+                        b_v = sp.sympify(m.group(3))
+                        try:
+                            expr_r = parse_expr(raw, transformations=tfms, local_dict=ld)
+                            result_r = sp.integrate(expr_r, (x, a_v, b_v))
+                            return {
+                                "type": "RiemannIntegral",
+                                "result": f"∫({m.group(1)}) from {a_v} to {b_v} = {result_r}",
+                                "latex": f"\\int_{{{a_v}}}^{{{b_v}}} = {sp.latex(result_r)}"
+                            }
+                        except Exception:
+                            pass
+
+            except Exception:
+                pass  # safe fallback to AI for all theory/proof questions
+
+        # ── 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. Hydro Mechanics — SymPy for computations, AI for theory ──
+        elif any(k in p for k in [
+                "continuity equation", "equation of continuity",
+                "streamline", "stream function", "stream line",
+                "velocity potential", "irrotational", "rotational motion",
+                "lagrangian", "eulerian", "vortex", "vorticity",
+                "path line", "streak line",
+                "bernoulli", "euler's equation", "euler equation of motion",
+                "torricelli", "flow rate", "discharge",
+                "reynolds number", "reynolds",
+                "hydrostatic pressure", "pressure at depth",
+                "hydrostatic", "buoyancy", "archimedes",
+                "laminar flow", "turbulent flow", "viscous flow",
+                "incompressible fluid", "steady flow",
+                "navier-stokes", "navier stokes",
+                "stokes stream function", "complex velocity potential",
+                "source", "sink", "doublet",
+                "milne thomson", "blasius theorem",
+                "dimensional analysis", "buckingham pi",
+        ]):
+            try:
+                x_h, y_h = sp.symbols('x y')
+                g_val = sp.Rational(981, 100)  # 9.81
+
+                # ── Continuity: find v2 from A1v1=A2v2 ───────────────
+                if any(k in p for k in ["continuity equation","equation of continuity"]):
+                    nums = [float(n) for n in re.findall(r"[-]?\d+\.?\d*", p)]
+                    if len(nums) >= 3:
+                        A1_v,v1_v,A2_v = nums[0],nums[1],nums[2]
+                        v2_v = round(A1_v*v1_v/A2_v, 6)
+                        Q_v  = round(A1_v*v1_v, 6)
+                        return {
+                            "type": "ContinuityEq",
+                            "result": (f"A1={A1_v}, v1={v1_v}, A2={A2_v}\n"
+                                      f"v2 = A1*v1/A2 = {v2_v} m/s\n"
+                                      f"Flow rate Q = A1*v1 = {Q_v} m³/s"),
+                            "latex": f"v_2 = {v2_v}\\text{{ m/s}}"
+                        }
+
+                # ── Reynolds Number ────────────────────────────────────
+                elif any(k in p for k in ["reynolds number","reynolds"]):
+                    nums = [float(n) for n in re.findall(r"[-]?\d+\.?\d*", p)]
+                    if len(nums) >= 4:
+                        rho_v,v_v,D_v,mu_v = nums[0],nums[1],nums[2],nums[3]
+                        Re = round(rho_v*v_v*D_v/mu_v, 2)
+                        flow = "Turbulent (Re>4000)" if Re>4000 else ("Transitional (2300<Re<4000)" if Re>2300 else "Laminar (Re<2300)")
+                        return {
+                            "type": "ReynoldsNumber",
+                            "result": f"Re = ρvD/μ = {rho_v}×{v_v}×{D_v}/{mu_v} = {Re} → {flow}",
+                            "latex": f"Re = {Re}"
+                        }
+
+                # ── Bernoulli: find P2 ─────────────────────────────────
+                elif "bernoulli" in p:
+                    nums = [float(n) for n in re.findall(r"[-]?\d+\.?\d*", p)]
+                    if len(nums) >= 5:
+                        P1_v,v1_v,h1_v,v2_v,h2_v = nums[0],nums[1],nums[2],nums[3],nums[4]
+                        rho_v = 1000  # default water
+                        P2_v = round(P1_v + 0.5*rho_v*(v1_v**2-v2_v**2) + rho_v*9.81*(h1_v-h2_v), 4)
+                        return {
+                            "type": "Bernoulli",
+                            "result": (f"P1+½ρv1²+ρgh1 = P2+½ρv2²+ρgh2\n"
+                                      f"P2 = {P2_v} Pa"),
+                            "latex": f"P_2 = {P2_v}\\text{{ Pa}}"
+                        }
+
+                # ── Torricelli: v = √(2gh) ─────────────────────────────
+                elif "torricelli" in p:
+                    nums = [float(n) for n in re.findall(r"[-]?\d+\.?\d*", p)]
+                    if nums:
+                        h_v = nums[0]
+                        v_torr = round((2*9.81*h_v)**0.5, 6)
+                        return {
+                            "type": "Torricelli",
+                            "result": f"v = √(2gh) = √(2×9.81×{h_v}) = {v_torr} m/s",
+                            "latex": f"v = {v_torr}\\text{{ m/s}}"
+                        }
+
+                # ── Hydrostatic Pressure ───────────────────────────────
+                elif any(k in p for k in ["hydrostatic pressure","pressure at depth"]):
+                    nums = [float(n) for n in re.findall(r"[-]?\d+\.?\d*", p)]
+                    if nums:
+                        h_v = nums[0]
+                        rho_v = 1000
+                        P_gauge = round(rho_v*9.81*h_v, 4)
+                        P_abs = round(101325 + P_gauge, 4)
+                        return {
+                            "type": "HydrostaticPressure",
+                            "result": (f"At depth h={h_v}m:\n"
+                                      f"Gauge pressure = ρgh = {P_gauge} Pa\n"
+                                      f"Absolute pressure = P0+ρgh = {P_abs} Pa"),
+                            "latex": f"P = P_0 + \\rho g h = {P_abs}\\text{{ Pa}}"
+                        }
+
+                # ── Flow Rate ──────────────────────────────────────────
+                elif any(k in p for k in ["flow rate","discharge"]):
+                    nums = [float(n) for n in re.findall(r"[-]?\d+\.?\d*", p)]
+                    if len(nums) >= 2:
+                        A_v, v_v = nums[0], nums[1]
+                        Q_v = round(A_v*v_v, 8)
+                        return {
+                            "type": "FlowRate",
+                            "result": f"Q = A×v = {A_v}×{v_v} = {Q_v} m³/s",
+                            "latex": f"Q = {Q_v}\\text{{ m³/s}}"
+                        }
+
+                # ── Velocity Potential ─────────────────────────────────
+                elif "velocity potential" in p:
+                    m = re.search(r"(?:phi|φ|potential)\s*=\s*(.+?)(?:\s|$)", p)
+                    if m:
+                        raw = clean(m.group(1))
+                        phi_expr = parse_expr(raw, transformations=tfms, local_dict={**ld,"x":x_h,"y":y_h})
+                        u_comp = sp.diff(phi_expr, x_h)
+                        v_comp = sp.diff(phi_expr, y_h)
+                        lap = sp.diff(phi_expr,x_h,2) + sp.diff(phi_expr,y_h,2)
+                        return {
+                            "type": "VelocityPotential",
+                            "result": (f"φ={str(phi_expr)}, u=∂φ/∂x={u_comp}, v=∂φ/∂y={v_comp}\n"
+                                      f"∇²φ={sp.simplify(lap)} (irrotational: {sp.simplify(lap)==0})"),
+                            "latex": f"\\nabla^2\\phi = {sp.latex(sp.simplify(lap))}"
+                        }
+
+            except Exception:
+                pass  # safe fallback to AI
+
+        # ── 11. Matrix / Eigenvalues — deterministic SymPy adapter ────────
+        elif any(k in p for k in ["matrix", "determinant", "eigenvalue",
+                                   "eigenvector", "det(", "inverse matrix", "rank"]):
+            rows = re.findall(r"\[([^\[\]]+)\]", p)
+            if rows:
+                try:
+                    matrix_data = [
+                        [sp.Rational(value.strip()) for value in row.split(",")]
+                        for row in rows
+                    ]
+                    if len({len(row) for row in matrix_data}) != 1:
+                        raise ValueError("Matrix rows have different lengths")
+                    matrix = sp.Matrix(matrix_data)
+
+                    if "determinant" in p or "det(" in p:
+                        value = sp.factor(matrix.det())
+                        return {"type": "MatrixDeterminant", "result": f"det(A) = {value}", "latex": f"\\det(A)={sp.latex(value)}"}
+                    if "eigenvector" in p:
+                        value = matrix.eigenvects()
+                        return {"type": "Eigenvectors", "result": f"Eigenvectors: {value}", "latex": sp.latex(value)}
+                    if "eigenvalue" in p:
+                        value = matrix.eigenvals()
+                        return {"type": "Eigenvalues", "result": f"Eigenvalues: {value}", "latex": sp.latex(value)}
+                    if "inverse" in p:
+                        value = matrix.inv()
+                        return {"type": "MatrixInverse", "result": f"A^(-1) = {value}", "latex": sp.latex(value)}
+                    if "transpose" in p:
+                        value = matrix.T
+                        return {"type": "MatrixTranspose", "result": f"A^T = {value}", "latex": sp.latex(value)}
+                    if "rank" in p:
+                        value = matrix.rank()
+                        return {"type": "MatrixRank", "result": f"rank(A) = {value}", "latex": f"\\operatorname{{rank}}(A)={value}"}
+                    return {"type": "Matrix", "result": f"A = {matrix}", "latex": sp.latex(matrix)}
+                except Exception:
+                    pass
+
+        # ── 12. Modular arithmetic — deterministic adapter ───────────────
+        elif "mod" in p or "congruence" in p:
+            congruence = re.search(
+                r"([+-]?\d+)\s*x\s*(?:≡|=)\s*([+-]?\d+)\s*\(?(?:mod|modulo)\s*([+-]?\d+)\)?",
+                p,
+            )
+            if congruence:
+                a_val, b_val, modulus = (int(value) for value in congruence.groups())
+                gcd_value = math.gcd(a_val, modulus)
+                if b_val % gcd_value != 0:
+                    return {
+                        "type": "LinearCongruence",
+                        "result": f"No solution because gcd({a_val},{modulus})={gcd_value} does not divide {b_val}.",
+                        "latex": "\\text{No solution}",
+                    }
+                solutions = [x_val for x_val in range(modulus) if (a_val * x_val - b_val) % modulus == 0]
+                return {
+                    "type": "LinearCongruence",
+                    "result": f"{a_val}x ≡ {b_val} (mod {modulus}); solutions: {solutions}",
+                    "latex": "x \\equiv " + ", \\".join(str(x_val) for x_val in solutions) + f" \\pmod{{{modulus}}}",
+                }
+
+            remainder = re.search(r"([+-]?\d+)\s+mod\s+([+-]?\d+)", p)
+            if remainder:
+                left, right = (int(value) for value in remainder.groups())
+                value = left % right
+                return {"type": "Modulo", "result": f"{left} mod {right} = {value}", "latex": f"{left} \\bmod {right} = {value}"}
+
+    except Exception:
+        pass  # Silently fall back — AI handles it
+
+    return {"type": "general", "result": None, "latex": ""}
+