Create app.py

app.py

@@ -0,0 +1,190 @@
+# app.py
+import gradio as gr
+import numpy as np
+import matplotlib.pyplot as plt
+import sympy as sp
+import yaml
+import requests
+
+x, y = sp.symbols('x y')
+
+# Load theorems database
+def load_theorems(file="theorems.yaml"):
+    with open(file, 'r') as f:
+        return yaml.safe_load(f)
+
+theorems_db = load_theorems()
+
+# Helper to construct LLM explanation prompt
+def build_llm_prompt(context, eq_type="polynomial"):
+    selected = [t for t in theorems_db if ("polynomial" in t["tags"] if eq_type == "polynomial" else "linear" in t["tags"])]
+    theory_context = "\n".join([f"{t['name']}: {t['short_explanation']}" for t in selected])
+    return f"Context:\n{theory_context}\n\nQuestion:\nExplain how the following was solved:\n{context}"
+
+# Call LLM microservice
+def get_llm_explanation(context, url, eq_type):
+    try:
+        prompt = build_llm_prompt(context, eq_type)
+        resp = requests.post(f"{url}/explain", json={"prompt": prompt})
+        if resp.status_code == 200:
+            return resp.json().get("explanation", "❌ No explanation returned.")
+        return f"❌ LLM returned status {resp.status_code}"
+    except Exception as e:
+        return f"❌ LLM request failed: {e}"
+
+# Generate polynomial template
+def generate_polynomial_template(degree):
+    terms = [f"a{i}*x^{degree - i}" for i in range(degree)] + [f"a{degree}"]
+    return " + ".join(terms) + " = 0"
+
+# Solve and plot polynomial
+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)
+
+        # Factor step-by-step
+        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, ""
+
+# Solve linear system
+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, ""
+
+# UI
+def build_ui():
+    with gr.Blocks() as demo:
+        gr.Markdown("## 🔢 Polynomial & Linear System Solver with Step-by-Step Explanation")
+
+        with gr.Tab("Polynomial"):
+            with gr.Row():
+                degree_slider = gr.Slider(1, 8, value=3, step=1, label="Degree")
+                template_display = gr.Textbox(label="Template", interactive=False)
+
+            coeff_input = gr.Textbox(label="Coefficients", placeholder="e.g. 1 -3 sqrt(2) -pi")
+            steps_md = gr.Markdown()
+            plot_output = gr.Plot()
+            error_box = gr.Textbox(visible=False)
+            explanation_md = gr.Markdown()
+            llm_url = gr.Textbox(label="LLM URL", placeholder="https://your-llm.ngrok-free.app")
+
+            degree_slider.change(generate_polynomial_template, degree_slider, template_display)
+            solve_btn = gr.Button("Solve Polynomial", variant="primary")
+            solve_btn.click(solve_polynomial, [degree_slider, coeff_input], [steps_md, plot_output, error_box])
+
+            explain_btn = gr.Button("Explain Polynomial Solution", variant="primary")
+            explain_btn.click(lambda context, url: get_llm_explanation(context, url, "polynomial"), [steps_md, llm_url], explanation_md)
+
+        with gr.Tab("Linear System"):
+            eq1_input = gr.Textbox(label="Equation 1", placeholder="2*x + 3*y - 6")
+            eq2_input = gr.Textbox(label="Equation 2", placeholder="-x + y - 2")
+            sys_steps = gr.Markdown()
+            sys_plot = gr.Plot()
+            sys_explain = gr.Markdown()
+
+            solve_sys_btn = gr.Button("Solve Linear System", variant="primary")
+            solve_sys_btn.click(solve_linear_system, [eq1_input, eq2_input], [sys_steps, sys_plot])
+
+            explain_sys_btn = gr.Button("Explain Linear Solution", variant="primary")
+            explain_sys_btn.click(lambda context, url: get_llm_explanation(context, url, "linear"), [sys_steps, llm_url], sys_explain)
+
+        return demo
+
+if __name__ == "__main__":
+    build_ui().launch()