Update app.py

app.py

@@ -1,161 +1,10 @@
 import gradio as gr
-import numpy as np
-import matplotlib.pyplot as plt
-import sympy as sp
-import requests
-import yaml
-
-x, y = sp.symbols('x y')
-
-# Load theorem database
-def load_theorem_db():
-    try:
-        with open("theorems.yaml", "r") as f:
-            return yaml.safe_load(f)
-    except:
-        return []
-
-def generate_context(task_type):
-    theorems = load_theorem_db()
-    relevant = []
-    if task_type == "polynomial":
-        relevant = [t for t in theorems if "polynomial" in t["tags"]]
-    elif task_type == "linear":
-        relevant = [t for t in theorems if "linear" in t["tags"]]
-    context = ""
-    for t in relevant:
-        context += f"Theorem: {t['name']}\nExplanation: {t['short_explanation']}\n\n"
-    return context
-
-def explain_with_llm(problem, task_type, llm_url):
-    try:
-        context = generate_context(task_type)
-        payload = {
-            "prompt": f"Using the theorems below, explain this math solution in depth:\n\n{context}\n\nProblem: {problem}"
-        }
-        if llm_url.strip() == "":
-            raise ValueError("No LLM URL provided.")
-        response = requests.post(f"{llm_url}/explain", json=payload)
-        if response.status_code == 200:
-            return response.json().get("explanation", "✅ Processed but no explanation returned.")
-        return f"❌ LLM request failed: {response.status_code}"
-    except Exception as e:
-        return f"❌ LLM request failed: {e}"
-
-# Polynomial Solver
-
-def generate_polynomial_template(degree):
-    terms = [f"a{i}*x^{degree - i}" for i in range(degree)] + [f"a{degree}"]
-    return " + ".join(terms) + " = 0"
-
-def solve_polynomial(degree, coeff_string):
-    try:
-        coeffs = [sp.sympify(s) for s in coeff_string.strip().split()]
-        if len(coeffs) != degree + 1:
-            return f"⚠️ Please enter exactly {degree + 1} coefficients.", None, None, ""
-
-        poly = sum([coeffs[i] * x**(degree - i) for i in range(degree + 1)])
-        simplified = sp.simplify(poly)
-
-        factored_steps = []
-        current_expr = simplified
-        while True:
-            factored = sp.factor(current_expr)
-            if factored == current_expr:
-                break
-            factored_steps.append(factored)
-            current_expr = factored
-
-        roots = sp.solve(sp.Eq(simplified, 0), x)
-        root_display = []
-        for i, r in enumerate(roots):
-            r_simplified = sp.nsimplify(r, rational=True)
-            root_display.append(f"r_{{{i+1}}} = {sp.latex(r_simplified)}")
-
-        steps_output = f"### 🧐 Polynomial Expression\n\n$$ {sp.latex(poly)} = 0 $$\n\n"
-        steps_output += f"### ✏️ Simplified\n\n$$ {sp.latex(simplified)} = 0 $$\n\n"
-
-        if factored_steps:
-            steps_output += f"### 🪜 Step-by-Step Factorization\n\n"
-            for i, step in enumerate(factored_steps, 1):
-                steps_output += f"**Step {i}:** $$ {sp.latex(step)} = 0 $$\n\n"
-        else:
-            steps_output += f"### 🤷 No further factorization possible\n\n"
-
-        steps_output += "### 🥮 Roots\n\n$$ " + " \\quad ".join(root_display) + " $$"
-
-        f_lambdified = sp.lambdify(x, simplified, modules=["numpy"])
-        x_vals = np.linspace(-10, 10, 400)
-        y_vals = f_lambdified(x_vals)
-
-        fig, ax = plt.subplots(figsize=(6, 4))
-        ax.plot(x_vals, y_vals, label="Polynomial")
-        ax.axhline(0, color='black', linewidth=0.5)
-        ax.axvline(0, color='black', linewidth=0.5)
-        ax.grid(True)
-        ax.set_title("📈 Graph of the Polynomial")
-        ax.set_xlabel("x")
-        ax.set_ylabel("f(x)")
-
-        real_roots = [sp.N(r.evalf()) for r in roots if sp.im(r) == 0]
-        for r in real_roots:
-            ax.plot([float(r)], [0], 'ro', label="Real Root")
-
-        ax.legend()
-
-        return steps_output, fig, "", steps_output
-
-    except Exception as e:
-        return f"❌ Error: {e}", None, "", ""
-
-# Linear Solver
-
-def solve_linear_system(eq1_str, eq2_str):
-    try:
-        eq1 = sp.sympify(eq1_str)
-        eq2 = sp.sympify(eq2_str)
-
-        sol = sp.solve((eq1, eq2), (x, y), dict=True)
-
-        steps = "### 🔍 Solving System\n\n"
-        steps += f"**Equation 1:** $$ {sp.latex(eq1)} $$\n\n"
-        steps += f"**Equation 2:** $$ {sp.latex(eq2)} $$\n\n"
-
-        if sol:
-            sol = sol[0]
-            steps += f"**Solution:** $$ x = {sp.latex(sol[x])}, \\ y = {sp.latex(sol[y])} $$\n\n"
-        else:
-            steps += "**No unique solution or inconsistent system**\n"
-
-        x_vals = np.linspace(-10, 10, 400)
-        f1 = sp.solve(eq1, y)
-        f2 = sp.solve(eq2, y)
-
-        fig, ax = plt.subplots(figsize=(6, 4))
-        if f1 and f2:
-            y1 = sp.lambdify(x, f1[0], modules=['numpy'])(x_vals)
-            y2 = sp.lambdify(x, f2[0], modules=['numpy'])(x_vals)
-            ax.plot(x_vals, y1, label='Equation 1')
-            ax.plot(x_vals, y2, label='Equation 2')
-
-            if sol:
-                px = float(sp.N(sol[x]))
-                py = float(sp.N(sol[y]))
-                ax.plot(px, py, 'ro')
-                ax.annotate(f"({px:.2f}, {py:.2f})", (px, py), textcoords="offset points", xytext=(10, 5), ha='center', color='red')
-
-        ax.axhline(0, color='black', linewidth=0.5)
-        ax.axvline(0, color='black', linewidth=0.5)
-        ax.set_title("📉 Graph of the Linear System")
-        ax.set_xlabel("x")
-        ax.set_ylabel("y")
-        ax.grid(True)
-        ax.legend()
-
-        return steps, fig, steps
-
-    except Exception as e:
-        return f"❌ Error: {e}", None, ""
+from solver import (
+    generate_polynomial_template,
+    solve_polynomial,
+    solve_linear_system
+)
+from llm_utils import explain_with_llm
 
 with gr.Blocks() as demo:
     gr.Markdown("## 🔢 Polynomial Solver with Step-by-Step Factorization and Graph")
@@ -164,7 +13,10 @@ with gr.Blocks() as demo:
         degree_slider = gr.Slider(1, 8, value=3, step=1, label="Degree of Polynomial")
         template_display = gr.Textbox(label="Polynomial Template (Fill in Coefficients)", interactive=False)
 
-    coeff_input = gr.Textbox(label="Enter Coefficients (space-separated, supports pi, e, sqrt(2), I)", placeholder="e.g. 1 -3 sqrt(2) -pi")
+    coeff_input = gr.Textbox(
+        label="Enter Coefficients (space-separated, supports pi, e, sqrt(2), I)",
+        placeholder="e.g. 1 -3 sqrt(2) -pi"
+    )
     llm_url = gr.Textbox(label="LLM Microservice URL (optional)", placeholder="https://your-llm.ngrok.app")
 
     steps_md = gr.Markdown()
@@ -176,9 +28,21 @@ with gr.Blocks() as demo:
         solve_button = gr.Button("Plot Polynomial", variant="primary")
         explain_poly = gr.Button("Explain Polynomial with LLM")
 
-    degree_slider.change(fn=generate_polynomial_template, inputs=degree_slider, outputs=template_display)
-    solve_button.click(fn=solve_polynomial, inputs=[degree_slider, coeff_input], outputs=[steps_md, plot_output, error_box, poly_full_solution])
-    explain_poly.click(fn=lambda sol, url: explain_with_llm(sol, "polynomial", url), inputs=[poly_full_solution, llm_url], outputs=steps_md)
+    degree_slider.change(
+        fn=generate_polynomial_template,
+        inputs=degree_slider,
+        outputs=template_display
+    )
+    solve_button.click(
+        fn=solve_polynomial,
+        inputs=[degree_slider, coeff_input],
+        outputs=[steps_md, plot_output, error_box, poly_full_solution]
+    )
+    explain_poly.click(
+        fn=lambda sol, url: explain_with_llm(sol, "polynomial", url),
+        inputs=[poly_full_solution, llm_url],
+        outputs=steps_md
+    )
 
     gr.Markdown("## 📐 Solve Linear System (2 Equations, 2 Variables)")
 
@@ -192,8 +56,15 @@ with gr.Blocks() as demo:
         solve_sys_button = gr.Button("Solve Linear System", variant="primary")
         explain_linear = gr.Button("Explain Linear System with LLM")
 
-    solve_sys_button.click(fn=solve_linear_system, inputs=[eq1_input, eq2_input], outputs=[sys_steps, sys_plot, linear_full_solution])
-    explain_linear.click(fn=lambda sol, url: explain_with_llm(sol, "linear", url), inputs=[linear_full_solution, llm_url], outputs=sys_steps)
+    solve_sys_button.click(
+        fn=solve_linear_system,
+        inputs=[eq1_input, eq2_input],
+        outputs=[sys_steps, sys_plot, linear_full_solution]
+    )
+    explain_linear.click(
+        fn=lambda sol, url: explain_with_llm(sol, "linear", url),
+        inputs=[linear_full_solution, llm_url],
+        outputs=sys_steps
+    )
 
     demo.launch()
-