Update app.py

app.py

@@ -5,19 +5,9 @@ import sympy as sp
 from sympy.parsing.latex import parse_latex
 import re
 
-# 👇 ADDITION: A lightweight CPU-compatible LLM for fallback
-from transformers import AutoModelForCausalLM, AutoTokenizer
-import torch
-
-device = "cpu"
-# You can swap this model with any CPU-friendly LLM; this one works well.
-llm_name = "mistralai/Mistral-7B-Instruct-v0.2"  
-llm_tokenizer = AutoTokenizer.from_pretrained(llm_name, trust_remote_code=True)
-llm_model = AutoModelForCausalLM.from_pretrained(llm_name, trust_remote_code=True, device_map={"": device})
-
 # Preprocessing for handwritten image
 def preprocess_handwritten_image(pil_img):
-    return pil_img.convert('RGB')  # Minimal processing
+    return pil_img.convert('RGB')  # Minimal processing, just convert to RGB
 
 # Load Pix2Tex model (once)
 model = LatexOCR()
@@ -26,107 +16,117 @@ model = LatexOCR()
 def clean_latex(latex):
     # Replace \mathcal{X} or \cal X with 'x'
     latex = re.sub(r'\\(cal|mathcal)\s*X', 'x', latex)
-    # Replace \mathcal{Y}, \mathcal{Z}, etc.
+    # Replace \mathcal{Y} or \cal Y with 'y'
     latex = re.sub(r'\\(cal|mathcal)\s*Y', 'y', latex)
+    # Replace \mathcal{Z} or \cal Z with 'z'
     latex = re.sub(r'\\(cal|mathcal)\s*Z', 'z', latex)
 
     # Remove curly braces
     latex = latex.replace('{', '').replace('}', '')
-    latex = latex.strip().rstrip('.,')
-
-    # Replace π and e with numeric constants
+    latex = latex.strip().rstrip(',.')
+    
+    # Replace coefficients like 5\pi with (5*3.1416)
     latex = re.sub(r'(\d+)\s*\\pi', r'(\1*3.1416)', latex)
     latex = latex.replace(r'\pi', '3.1416')
+
+    # Replace coefficients like 5e with (5*2.7183)
     latex = re.sub(r'(\d+)\s*e', r'(\1*2.7183)', latex)
     latex = re.sub(r'(?<![a-zA-Z0-9])e(?![a-zA-Z0-9])', '2.7183', latex)
 
-    # Insert * between number and variable, handle i
+    # Insert * between number and variable (e.g., 45x → 45*x)
     latex = re.sub(r'(\d)([a-zA-Z])', r'\1*\2', latex)
+
+    # Replace number followed by i with number*I
     latex = re.sub(r'(\d+)\s*i', r'\1*I', latex)
+
+    # Replace standalone i with I
     latex = re.sub(r'(?<![a-zA-Z0-9])i(?![a-zA-Z0-9])', 'I', latex)
 
-    # Wrap complex coefficients
+    # Wrap complex coefficients with variables: (a+bI)x^n → (a+b*I)*x^n
     latex = re.sub(r'\(([^()]+?)\)\s*([a-zA-Z](\^\d+)?)', r'(\1)*\2', latex)
 
-    # Additional cleanup
+    # Additional minimal cleanup
     latex = latex.replace(r'\cdot', '*')
-    latex = latex.replace('−', '-')  # Unicode minus
+    latex = latex.replace('−', '-')  # Unicode minus to ASCII
 
-    # Append '=0' if missing
+    # Append '=0' if not already present
     if '=' not in latex:
         latex += '=0'
 
     return latex
 
-# 👇 ADDITION: Function to ask LLM to fix LaTeX for Sympy
-def fix_latex_with_llm(original_latex: str) -> str:
-    prompt = (
-        "Here is a LaTeX equation extracted from an image:\n"
-        f"{original_latex}\n\n"
-        "Fix any errors so it becomes valid LaTeX parsable by Sympy.\n"
-        "Return only the corrected LaTeX expression."
-    )
-    tokens = llm_tokenizer(prompt, return_tensors="pt").to(device)
-    gen = llm_model.generate(**tokens, max_new_tokens=60)
-    out = llm_tokenizer.decode(gen[0], skip_special_tokens=True)
-    return out.strip()
-
 # Main function
 def solve_polynomial(image):
     try:
         img = preprocess_handwritten_image(image)
         latex_result = model(img)
 
+        # Check for empty/invalid OCR output
         if not latex_result or len(latex_result.strip()) < 2:
             return "❌ Could not extract valid LaTeX from image."
 
         cleaned_latex = clean_latex(latex_result)
 
-        # Attempt parsing
         try:
             expr = parse_latex(cleaned_latex)
         except Exception:
             expr = None
 
-        # Fallback to LLM
         if expr is None:
-            fixed = fix_latex_with_llm(latex_result)
-            try:
-                expr = parse_latex(fixed)
-                cleaned_latex = fixed  # update for display
-            except Exception:
-                return (
-                    "❌ Could not parse expression even after LLM correction.\n\n"
-                    f"**Original OCR:** `{latex_result}`"
-                )
-
-        # Build output
+            return (
+                "❌ Could not parse expression from cleaned LaTeX:\n"
+                "
+
+latex\n"
+                f"{cleaned_latex}\n"
+                "
+
+"
+            )
+
         output = (
-            f"## 📄 Extracted LaTeX\n```latex\n{latex_result}\n```\n"
+            f"## 📄 Extracted LaTeX\n
+
+latex\n{latex_result}\n
+
+\n"
             "---\n"
-            f"## 🧹 Cleaned / Fixed LaTeX\n```latex\n{cleaned_latex}\n```\n"
+            f"## 🧹 Cleaned LaTeX Used\n
+
+latex\n{cleaned_latex}\n
+
+\n"
             "---\n"
             f"## 🧠 Parsed Expression\n\n$$ {sp.latex(expr)} $$\n"
             "---\n"
         )
 
-        # Solve or simplify
         if isinstance(expr, sp.Equality):
             lhs = expr.lhs - expr.rhs
-            output += f"## ✏️ Standard Form\n$$ {sp.latex(lhs)} = 0 $$\n---\n"
+
+            output += "## ✏️ Step 1: Standard Form of the Polynomial\n"
+            output += f"$$ {sp.latex(lhs)} = 0 $$\n"
+            output += "---\n"
+
+            output += "## 🧩 Step 2: Factor the Polynomial\n"
             factored = sp.factor(lhs)
-            output += f"## 🧩 Factorization\n$$ {sp.latex(factored)} = 0 $$\n---\n"
-            output += "## ✅ Roots\n"
+            output += f"$$ {sp.latex(factored)} = 0 $$\n"
+            output += "---\n"
+
+            output += "## ✅ Step 3: Solve for Roots\n"
             roots = sp.solve(sp.Eq(lhs, 0), dict=True)
+
             if roots:
-                output += "$$\\begin{aligned}\n"
+                output += "$$\n\\begin{aligned}\n"
                 for i, sol in enumerate(roots, 1):
-                    for v, val in sol.items():
-                        output += f"\\text{{Root {i}}}: {sp.latex(val)} \\\\\n"
-                output += "\\end{aligned}$$\n"
+                    for var, val in sol.items():
+                        output += f"\\text{{Root {i}}}:\\quad {var} &= {sp.latex(val)} \\\\\n"
+                output += "\\end{aligned}\n$$\n"
+
         else:
             simplified = sp.simplify(expr)
-            output += f"## ➕ Simplified\n$$ {sp.latex(simplified)} $$"
+            output += "## ➕ Simplified Expression\n"
+            output += f"$$ {sp.latex(simplified)} $$"
 
         return output
 
@@ -136,11 +136,12 @@ def solve_polynomial(image):
 # Gradio UI
 demo = gr.Interface(
     fn=solve_polynomial,
-    inputs=gr.Image(type="pil", label="📷 Upload Image"),
-    outputs=gr.Markdown(label="📋 Solution"),
+    inputs=gr.Image(type="pil", label="📷 Upload Image of Polynomial"),
+    outputs=gr.Markdown(label="📋 Step-by-step Solution"),
     title="🧠 Polynomial Solver from Image",
-    description="Extract, clean, parse & solve handwritten polynomials with a fallback LLM."
+    description="Upload an image of a polynomial (typed or handwritten). The app will extract, solve, and explain it step-by-step.",
+    allow_flagging="never"
 )
 
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch()