Update app.py

app.py

@@ -1,9 +1,20 @@
+# ── Imports ── (ORDER MATTERS: re must come after sympy wildcard)
 import streamlit as st
 import sympy as sp
 import anthropic
-import re
-from sympy import *
-from sympy.parsing.sympy_parser import parse_expr, standard_transformations, implicit_multiplication_application
+from sympy import (
+    symbols, diff, integrate, limit, solve, simplify, expand, factor,
+    latex, sympify, oo, sin, cos, tan, exp, log, sqrt, pi, E,
+    Matrix, det, eigenvals, Symbol, Function, dsolve, Eq,
+    series, Sum, Product, Rational, Integer, Float, Abs,
+    standard_transformations
+)
+from sympy.parsing.sympy_parser import (
+    parse_expr,
+    standard_transformations,
+    implicit_multiplication_application
+)
+import re  # MUST be last — sympy wildcard would overwrite it otherwise
 
 # ─── Page Config ───────────────────────────────────────────────────────────────
 st.set_page_config(
@@ -37,11 +48,9 @@ html, body, [class*="css"] {
     font-family: 'Nunito', sans-serif;
 }
 
-/* ── Hide Streamlit chrome ── */
 #MainMenu, footer, header { visibility: hidden; }
 .block-container { padding: 1.5rem 2rem 2rem 2rem; max-width: 1100px; }
 
-/* ── Hero Banner ── */
 .hero {
     background: linear-gradient(135deg, #0d1526 0%, #0f1f40 50%, #091428 100%);
     border: 1px solid var(--border);
@@ -87,7 +96,6 @@ html, body, [class*="css"] {
     letter-spacing: 0.5px;
 }
 
-/* ── Chat Container ── */
 .chat-area {
     background: var(--surface);
     border: 1px solid var(--border);
@@ -99,7 +107,6 @@ html, body, [class*="css"] {
     margin-bottom: 1rem;
 }
 
-/* ── Message Bubbles ── */
 .msg-user {
     display: flex;
     justify-content: flex-end;
@@ -142,25 +149,6 @@ html, body, [class*="css"] {
     line-height: 1.7;
 }
 
-/* ── Step Block ── */
-.step-block {
-    background: rgba(56,189,248,0.04);
-    border-left: 3px solid var(--accent);
-    border-radius: 0 8px 8px 0;
-    padding: 0.6rem 1rem;
-    margin: 0.6rem 0;
-    font-family: 'JetBrains Mono', monospace;
-    font-size: 0.85rem;
-}
-.step-label {
-    color: var(--accent);
-    font-size: 0.72rem;
-    text-transform: uppercase;
-    letter-spacing: 1px;
-    margin-bottom: 0.2rem;
-}
-
-/* ── Input Row ── */
 .stTextInput > div > div > input {
     background: var(--card) !important;
     border: 1px solid var(--border) !important;
@@ -175,7 +163,6 @@ html, body, [class*="css"] {
     box-shadow: 0 0 0 2px rgba(56,189,248,0.15) !important;
 }
 
-/* ── Buttons ── */
 .stButton > button {
     background: linear-gradient(135deg, #1e4080, #1a3060) !important;
     border: 1px solid var(--accent) !important;
@@ -193,7 +180,6 @@ html, body, [class*="css"] {
     box-shadow: 0 4px 15px rgba(56,189,248,0.2) !important;
 }
 
-/* ── Sidebar ── */
 [data-testid="stSidebar"] {
     background: var(--surface) !important;
     border-right: 1px solid var(--border) !important;
@@ -204,7 +190,6 @@ html, body, [class*="css"] {
     letter-spacing: 1px;
 }
 
-/* ── Topic Pills ── */
 .topic-pill {
     background: rgba(129,140,248,0.08);
     border: 1px solid rgba(129,140,248,0.2);
@@ -214,26 +199,14 @@ html, body, [class*="css"] {
     font-size: 0.78rem;
     margin: 3px 2px;
     display: inline-block;
-    cursor: pointer;
     font-family: 'JetBrains Mono', monospace;
 }
-.topic-pill:hover {
-    background: rgba(129,140,248,0.18);
-}
 
-/* ── Scrollbar ── */
 ::-webkit-scrollbar { width: 6px; }
 ::-webkit-scrollbar-track { background: var(--surface); }
 ::-webkit-scrollbar-thumb { background: var(--border); border-radius: 3px; }
 ::-webkit-scrollbar-thumb:hover { background: var(--muted); }
 
-/* ── Latex rendering ── */
-.katex { font-size: 1.05em !important; }
-
-/* ── Spinner override ── */
-.stSpinner > div { border-top-color: var(--accent) !important; }
-
-/* ── Selectbox ── */
 .stSelectbox > div > div {
     background: var(--card) !important;
     border-color: var(--border) !important;
@@ -246,148 +219,130 @@ html, body, [class*="css"] {
 # ─── Session State ──────────────────────────────────────────────────────────────
 if "messages" not in st.session_state:
     st.session_state.messages = []
-if "sympy_results" not in st.session_state:
-    st.session_state.sympy_results = {}
+if "last_submitted" not in st.session_state:
+    st.session_state.last_submitted = ""  # prevents infinite rerun loop
 
 # ─── SymPy Engine ───────────────────────────────────────────────────────────────
 def run_sympy(problem: str) -> dict:
     """
-    Attempt to extract a verifiable symbolic computation from the problem.
-    Returns a dict with keys: type, result, latex, error
+    Safely attempt symbolic computation.
+    Uses sp.* explicitly — no wildcard collisions possible here.
     """
     p = problem.lower().strip()
-    x, y, z, t, n = symbols('x y z t n')
-    results = {}
+    x = sp.Symbol('x')
+    default = {"type": "general", "result": None, "latex": ""}
 
     try:
-        transformations = standard_transformations + (implicit_multiplication_application,)
+        tfms = standard_transformations + (implicit_multiplication_application,)
 
-        # --- Derivative ---
+        def clean(s):
+            """Normalise expression string for sympy parsing."""
+            s = re.sub(r"\s+", "", s)
+            s = re.sub(r"\^", "**", s)
+            return s
+
+        # ── Derivative ──
         if any(k in p for k in ["derivative", "differentiate", "d/dx", "diff"]):
-            # Extract expression after keywords
+            raw = p
             for kw in ["derivative of", "differentiate", "diff of", "d/dx of", "d/dx"]:
                 if kw in p:
-                    raw = p.split(kw)[-1].strip()
+                    raw = p.split(kw, 1)[-1].strip()
                     break
-            else:
-                raw = re.sub(r"(derivative|differentiate)", "", p).strip()
-            raw = re.sub(r"\s+", "", raw)
-            expr = parse_expr(raw, transformations=transformations)
-            result = diff(expr, x)
-            results = {"type": "Derivative", "result": str(result), "latex": latex(result)}
-
-        # --- Integral ---
-        elif any(k in p for k in ["integral", "integrate", "antiderivative", "∫"]):
-            for kw in ["integral of", "integrate", "antiderivative of", "∫"]:
+            raw = re.sub(r"\s*(dx|with\s*respect\s*to\s*x).*$", "", raw).strip()
+            expr = parse_expr(clean(raw), transformations=tfms, local_dict={"x": x})
+            result = sp.diff(expr, x)
+            return {"type": "Derivative", "result": str(result), "latex": sp.latex(result)}
+
+        # ── 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].strip()
+                    raw = p.split(kw, 1)[-1].strip()
                     break
-            else:
-                raw = re.sub(r"(integral|integrate|antiderivative)", "", p).strip()
-            raw = re.sub(r"\s+", "", raw)
-            expr = parse_expr(raw, transformations=transformations)
-            result = integrate(expr, x)
-            results = {"type": "Integral", "result": str(result), "latex": latex(result)}
+            raw = re.sub(r"\s*dx.*$", "", raw).strip()
+            expr = parse_expr(clean(raw), transformations=tfms, local_dict={"x": x})
+            result = sp.integrate(expr, x)
+            return {"type": "Integral", "result": str(result), "latex": sp.latex(result)}
 
-        # --- Limit ---
+        # ── Limit ──
         elif "limit" in p:
-            # e.g. "limit of sin(x)/x as x->0"
-            match = re.search(r"([\w\(\)\+\-\*/\^\s]+)\s+as\s+x\s*[->→]+\s*([\w\.\-\+]+)", p)
+            match = re.search(
+                r"limit\s+of\s+([\w\s\(\)\+\-\*/\^\.\,]+?)\s+as\s+x\s*(?:->|→|approaches)\s*([\w\.\+\-]+)",
+                p
+            )
             if match:
-                raw_expr = re.sub(r"\^", "**", match.group(1).strip())
-                raw_expr = re.sub(r"\s+", "", raw_expr)
+                raw_expr = clean(match.group(1))
                 point_str = match.group(2).strip()
-                point = sympify(point_str) if point_str != "inf" else oo
-                expr = parse_expr(raw_expr, transformations=transformations)
-                result = limit(expr, x, point)
-                results = {"type": "Limit", "result": str(result), "latex": latex(result)}
-
-        # --- Solve equation ---
-        elif any(k in p for k in ["solve", "roots", "find x", "find n"]):
-            raw = re.sub(r"(solve|find x|find n|roots of|roots)", "", p).strip()
-            # handle "= 0" or "=" in expression
+                point = sp.oo if point_str in ("inf", "infinity", "oo") else sp.sympify(point_str)
+                expr = parse_expr(raw_expr, transformations=tfms, local_dict={"x": x})
+                result = sp.limit(expr, x, point)
+                return {"type": "Limit", "result": str(result), "latex": sp.latex(result)}
+
+        # ── 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).strip().strip(": ")
             if "=" in raw:
-                lhs, rhs = raw.split("=", 1)
-                lhs_e = parse_expr(re.sub(r"\s+", "", lhs), transformations=transformations)
-                rhs_e = parse_expr(re.sub(r"\s+", "", rhs), transformations=transformations)
+                lhs_s, rhs_s = raw.split("=", 1)
+                lhs_e = parse_expr(clean(lhs_s), transformations=tfms, local_dict={"x": x})
+                rhs_e = parse_expr(clean(rhs_s), transformations=tfms, local_dict={"x": x})
                 expr = lhs_e - rhs_e
             else:
-                expr = parse_expr(re.sub(r"\s+", "", raw), transformations=transformations)
-            sol = solve(expr, x)
-            sol_latex = ", ".join([latex(s) for s in sol])
-            results = {"type": "Equation", "result": str(sol), "latex": f"x \\in \\{{{sol_latex}\\}}"}
+                expr = parse_expr(clean(raw), transformations=tfms, local_dict={"x": x})
+            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": f"x \\in \\{{{sol_latex}\\}}"}
 
-        # --- Matrix determinant / eigenvalues ---
-        elif any(k in p for k in ["matrix", "determinant", "eigenvalue", "eigenvector", "det"]):
-            results = {"type": "Matrix", "result": "matrix_detected", "latex": ""}
+        # ── Matrix / eigenvalues — delegate to Claude ──
+        elif any(k in p for k in ["matrix", "determinant", "eigenvalue", "eigenvector", "det("]):
+            return {"type": "Matrix", "result": "matrix_detected", "latex": ""}
 
-        # --- Modular arithmetic ---
+        # ── Modular arithmetic — delegate to Claude ──
         elif "mod" in p or "congruence" in p:
-            results = {"type": "NumberTheory", "result": "mod_detected", "latex": ""}
+            return {"type": "NumberTheory", "result": "mod_detected", "latex": ""}
 
-        else:
-            results = {"type": "general", "result": None, "latex": ""}
+    except Exception:
+        pass  # fall back gracefully; Claude handles it without sympy hint
 
-    except Exception as e:
-        results = {"type": "error", "result": None, "error": str(e), "latex": ""}
-
-    return results
+    return default
 
 
 # ─── Claude API Call ────────────────────────────────────────────────────────────
 def ask_claude(problem: str, sympy_info: dict, history: list) -> str:
-    """Call Claude API with BSc math context + SymPy verified result."""
-
-    # Build sympy context string
     sympy_context = ""
-    if sympy_info.get("result") and sympy_info["result"] not in ["matrix_detected", "mod_detected"]:
+    if (sympy_info.get("result")
+            and sympy_info["result"] not in (None, "matrix_detected", "mod_detected")):
         sympy_context = f"""
-SYMPY VERIFIED RESULT:
-- Operation type : {sympy_info.get('type', 'N/A')}
-- Exact result   : {sympy_info.get('result', 'N/A')}
-- LaTeX          : {sympy_info.get('latex', 'N/A')}
-
-You MUST use this exact verified result in your answer. Do NOT deviate from it.
+SYMPY VERIFIED RESULT (mathematically exact — your final answer MUST match this):
+- Operation : {sympy_info.get('type', 'N/A')}
+- Result    : {sympy_info.get('result', 'N/A')}
+- LaTeX     : {sympy_info.get('latex', 'N/A')}
 """
 
-    system_prompt = f"""You are SAAD AI — an elite BSc Mathematics tutor. You solve every problem with:
-1. PERFECT step-by-step working (no skipped steps)
-2. Clear labels: "Step 1:", "Step 2:", etc.
-3. Proper mathematical notation (use LaTeX between $$ for display math)
-4. Final boxed answer clearly stated
-5. Brief explanation of the method used
-
+    system_prompt = f"""You are SAAD AI — an elite BSc Mathematics tutor.
 {sympy_context}
-
-Topics you master:
-- Calculus: derivatives, integrals, limits, series
-- Linear Algebra: matrices, determinants, eigenvalues, vector spaces
-- Number Theory: congruences, modular arithmetic, primes, Euler's theorem
-- Differential Equations: ODEs, PDEs, Laplace transforms
-- Numerical Methods: Newton-Raphson, Euler's method, numerical integration
-- Differential Geometry: curves, surfaces, curvature
-- Hydro Mechanics: fluid dynamics, Bernoulli, continuity equation
-- Theory of Numbers: divisibility, GCD, LCM, Fermat, Euler
-- Real Analysis II: sequences, series convergence, uniform continuity, Riemann integral
-- General Algebra & Arithmetic
-
-STRICT RULES:
-- NEVER make arithmetic mistakes
-- Show ALL intermediate steps
-- Use $...$ for inline math and $$...$$ for display equations
-- If a sympy verified result is provided, your calculation MUST match it exactly
-- Be thorough but clear — a student must be able to follow every step
+RULES:
+1. Label every step: "Step 1:", "Step 2:", etc. — no steps skipped.
+2. Use $...$ for inline math and $$...$$ for display equations.
+3. State the method/theorem at the start.
+4. Show ALL intermediate algebra.
+5. End with: **Final Answer:** $$...$$
+6. If a SymPy verified result is shown above, your final answer MUST match it exactly.
+7. NEVER make arithmetic errors.
+
+TOPICS: Calculus | Linear Algebra | Number Theory | ODEs | Numerical Methods |
+Differential Geometry | Hydro Mechanics | Theory of Numbers | Real Analysis II | General Math
 """
 
-    # Build message history
     messages = []
-    for msg in history[-8:]:  # last 8 messages for context
+    for msg in history[-8:]:
         messages.append({"role": msg["role"], "content": msg["content"]})
     messages.append({"role": "user", "content": problem})
 
     client = anthropic.Anthropic()
     response = client.messages.create(
-        model="claude-opus-4-5",
+        model="claude-sonnet-4-5",
         max_tokens=3000,
         system=system_prompt,
         messages=messages
@@ -414,26 +369,27 @@ with st.sidebar:
     st.markdown("**⚡ Quick Examples**")
 
     examples = {
+        "-- Choose --": "",
         "🔢 Derivative": "Find the derivative of x^3 + 5x^2 - 3x + 7",
         "∫ Integral": "Integrate sin(x) * e^x dx",
         "📊 Eigenvalue": "Find eigenvalues of matrix [[3,1],[1,3]]",
         "🔁 Congruence": "Solve 14x ≡ 30 (mod 44)",
         "🌊 ODE": "Solve dy/dx + 2y = e^x",
-        "📐 Limit": "Find limit of sin(x)/x as x approaches 0",
+        "📐 Limit": "Find limit of sin(x)/x as x -> 0",
         "🔍 Series": "Test convergence of sum 1/n^2 from n=1 to infinity",
         "📏 Newton-Raphson": "Apply Newton-Raphson to find root of x^3 - 2x - 5 = 0",
     }
 
     selected_example = st.selectbox(
         "Load an example:",
-        ["-- Choose --"] + list(examples.keys()),
+        list(examples.keys()),
         key="example_select"
     )
 
     st.markdown("---")
     st.markdown("**🔧 Engine**")
     st.markdown("""
-    <div style="font-size:0.8rem; color: #64748b; line-height:1.8;">
+    <div style="font-size:0.8rem; color:#64748b; line-height:1.8;">
     🤖 <b style="color:#38bdf8">Claude AI</b> — reasoning & steps<br>
     🧮 <b style="color:#34d399">SymPy</b> — verified computation<br>
     ✅ Zero arithmetic errors
@@ -443,7 +399,7 @@ with st.sidebar:
     st.markdown("---")
     if st.button("🗑️ Clear Chat"):
         st.session_state.messages = []
-        st.session_state.sympy_results = {}
+        st.session_state.last_submitted = ""
         st.rerun()
 
 
@@ -468,13 +424,13 @@ chat_html = '<div class="chat-area" id="chatArea">'
 
 if not st.session_state.messages:
     chat_html += """
-    <div style="display:flex; flex-direction:column; align-items:center; justify-content:center;
-                height:300px; color:#334155; text-align:center;">
-        <div style="font-size:3rem; margin-bottom:1rem;">📐</div>
-        <div style="font-family:'Rajdhani',sans-serif; font-size:1.2rem; color:#475569; letter-spacing:1px;">
+    <div style="display:flex;flex-direction:column;align-items:center;justify-content:center;
+                height:300px;color:#334155;text-align:center;">
+        <div style="font-size:3rem;margin-bottom:1rem;">📐</div>
+        <div style="font-family:'Rajdhani',sans-serif;font-size:1.2rem;color:#475569;letter-spacing:1px;">
             Ask any BSc Mathematics problem
         </div>
-        <div style="font-size:0.82rem; color:#334155; margin-top:0.5rem;">
+        <div style="font-size:0.82rem;color:#334155;margin-top:0.5rem;">
             Calculus · Linear Algebra · Number Theory · ODEs · Real Analysis · and more
         </div>
     </div>
@@ -482,31 +438,35 @@ if not st.session_state.messages:
 else:
     for msg in st.session_state.messages:
         if msg["role"] == "user":
-            chat_html += f"""
-            <div class="msg-user">
-                <div class="bubble">🧑‍🎓 {msg['content']}</div>
-            </div>
-            """
+            # Escape HTML to prevent rendering issues with math symbols
+            safe = (msg['content']
+                    .replace("&", "&amp;")
+                    .replace("<", "&lt;")
+                    .replace(">", "&gt;"))
+            chat_html += f'<div class="msg-user"><div class="bubble">🧑‍🎓 {safe}</div></div>'
         else:
-            # Convert **bold** and basic formatting
             content = msg['content']
+            # Escape first, then apply safe bold conversion
+            content = (content
+                       .replace("&", "&amp;")
+                       .replace("<", "&lt;")
+                       .replace(">", "&gt;"))
             content = re.sub(r'\*\*(.*?)\*\*', r'<b>\1</b>', content)
             content = content.replace('\n', '<br>')
-            chat_html += f"""
-            <div class="msg-ai">
-                <div class="ai-avatar">∑</div>
-                <div class="bubble">{content}</div>
-            </div>
-            """
+            chat_html += (
+                f'<div class="msg-ai">'
+                f'<div class="ai-avatar">∑</div>'
+                f'<div class="bubble">{content}</div>'
+                f'</div>'
+            )
 
 chat_html += '</div>'
 st.markdown(chat_html, unsafe_allow_html=True)
 
-# Auto scroll script
 st.markdown("""
 <script>
-    const chatArea = document.getElementById('chatArea');
-    if (chatArea) chatArea.scrollTop = chatArea.scrollHeight;
+    const c = document.getElementById('chatArea');
+    if (c) c.scrollTop = c.scrollHeight;
 </script>
 """, unsafe_allow_html=True)
 
@@ -515,14 +475,10 @@ st.markdown("""
 col1, col2 = st.columns([5, 1])
 
 with col1:
-    # Pre-fill from example selector
-    default_val = ""
-    if selected_example and selected_example != "-- Choose --":
-        default_val = examples[selected_example]
-
+    prefill = examples.get(selected_example, "") if selected_example != "-- Choose --" else ""
     user_input = st.text_input(
         label="problem_input",
-        value=default_val,
+        value=prefill,
         placeholder="Type a BSc math problem... e.g. 'Solve d²y/dx² + 4y = cos(2x)'",
         label_visibility="collapsed",
         key="user_input_field"
@@ -533,21 +489,24 @@ with col2:
 
 
 # ─── Process Input ───────────────────────────────────────────────────────────────
-if (send_btn or user_input) and user_input.strip():
-    problem = user_input.strip()
+# Only fires when SOLVE is clicked, input is non-empty, AND it's a new problem
+# This prevents the infinite rerun loop caused by value="" pre-fill on every cycle
+problem = user_input.strip() if user_input else ""
+
+if send_btn and problem and problem != st.session_state.last_submitted:
+    st.session_state.last_submitted = problem
 
     with st.spinner("🧮 Running SymPy verification + Claude reasoning..."):
-        # Step 1: SymPy verification
         sympy_result = run_sympy(problem)
-
-        # Step 2: Claude with verified result
         try:
             answer = ask_claude(problem, sympy_result, st.session_state.messages)
         except Exception as e:
-            answer = f"⚠️ API Error: {str(e)}\n\nPlease ensure ANTHROPIC_API_KEY is set in your Hugging Face Space secrets."
+            answer = (
+                f"⚠️ **API Error:** {str(e)}\n\n"
+                "Please ensure **ANTHROPIC_API_KEY** is added in your Hugging Face Space → "
+                "Settings → Variables and Secrets."
+            )
 
-    # Save to history
     st.session_state.messages.append({"role": "user", "content": problem})
     st.session_state.messages.append({"role": "assistant", "content": answer})
-
-    st.rerun()
+    st.rerun()