Upload 2 files

llm_utils.py

@@ -0,0 +1,90 @@
+import requests
+import yaml
+
+# === Load theorems.yaml and render it into clean context text for LLM ===
+def load_theorem_context(yaml_path="theorems.yaml"):
+    with open(yaml_path, 'r') as f:
+        data = yaml.safe_load(f)
+
+    if not isinstance(data, dict):
+        return "⚠️ Invalid theorems format in YAML."
+
+    context_lines = []
+    for idx, th in enumerate(data.get('theorems', []), 1):
+        context_lines.append(
+            f"**Theorem {idx}: {th.get('name', 'Unnamed')}**\n"
+            f"- **Statement**: {th.get('statement', 'N/A')}\n"
+            f"- **Tags**: {', '.join(th.get('tags', []))}\n"
+            f"- **When to Use**: {th.get('when_to_use', 'N/A')}\n"
+            f"- **Short Explanation**: {th.get('short_explanation', 'N/A')}\n"
+        )
+        context_lines.append('---')
+
+    return "\n".join(context_lines)
+
+# === Build prompt using user steps and theorem context ===
+def build_prompt(equation_type, solution_text, theorem_context):
+    return (
+        f"You are a helpful math tutor. Below is a theorem reference database.\n\n"
+        f"Each theorem includes:\n"
+        f"- Name\n- Statement\n- Tags\n- When to use\n- Short Explanation\n\n"
+        f"---\n\n"
+        f"### 📘 Theorem Database:\n\n"
+        f"{theorem_context}\n\n"
+        f"---\n\n"
+        f"### 🧮 User Steps for solving a {equation_type} equation:\n\n"
+        f"{solution_text}\n\n"
+        f"---\n\n"
+        f"### 🎯 Task:\n"
+        f"Explain each solution step clearly.\n"
+        f"Use relevant theorems by number or name.\n"
+        f"Make it understandable to a smart high school student.\n"
+        f"Focus on reasoning, not just restating the steps or theorems."
+    )
+
+# === Request LLM explanation ===
+def explain_with_llm(solution_text, equation_type, llm_url, yaml_path="theorems.yaml"):
+    try:
+        if not llm_url or not llm_url.strip().startswith("http"):
+            return "❌ Invalid or missing LLM URL."
+
+        theorem_context = load_theorem_context(yaml_path)
+        prompt = build_prompt(equation_type, solution_text, theorem_context)
+
+        response = requests.post(
+            f"{llm_url.strip()}/explain",
+            json={"prompt": prompt},
+            timeout=90
+        )
+
+        if response.status_code == 200:
+            result = response.json()
+
+            if isinstance(result, dict):
+                return result.get("explanation", "❌ No explanation returned.")
+            elif isinstance(result, list):
+                return result[0] if result else "❌ Empty response list."
+            else:
+                return f"❌ Unexpected LLM response format: {type(result)}"
+
+        return f"❌ LLM request failed: {response.status_code}"
+
+    except Exception as e:
+        return f"❌ LLM Error: {e}"
+
+# === Request fallback if parsing failed ===
+def request_llm_fallback(bad_input, llm_url):
+    try:
+        response = requests.post(
+            f"{llm_url.strip()}/clean",
+            json={"prompt": bad_input},
+            timeout=20
+        )
+        result = response.json()
+        if isinstance(result, dict):
+            return result.get("cleaned_latex", bad_input)
+        return bad_input
+    except:
+        return bad_input
+
+

theorems.yaml

@@ -0,0 +1,92 @@
+theorems:
+  - name: Fundamental Theorem of Algebra
+    statement: Every non-zero polynomial of degree n with complex coefficients has exactly n complex roots, counted with multiplicity.
+    tags: [roots, complex, algebra]
+    when_to_use: When identifying the total number of complex roots of a polynomial.
+    short_explanation: Guarantees that a polynomial of degree n has n roots in the complex number system.
+
+  - name: Rational Root Theorem
+    statement: Any rational root of a polynomial with integer coefficients is a factor of the constant term divided by a factor of the leading coefficient.
+    tags: [rational, integer, divisibility]
+    when_to_use: To test possible rational roots of polynomials with integer coefficients.
+    short_explanation: Helps guess rational roots based on coefficients; useful before trying numerical methods.
+
+  - name: Complex Conjugate Root Theorem
+    statement: If a polynomial has real coefficients and a complex root a + bi, then its conjugate a - bi is also a root.
+    tags: [complex, conjugate, real]
+    when_to_use: After finding one complex root in real polynomials.
+    short_explanation: Ensures non-real roots appear in conjugate pairs when coefficients are real.
+
+  - name: Remainder Theorem
+    statement: The remainder of f(x) divided by (x - c) is f(c).
+    tags: [evaluation, factor, testing]
+    when_to_use: When checking if (x - c) is a factor of a polynomial.
+    short_explanation: Allows fast testing of values as roots by plugging into the polynomial.
+
+  - name: Factor Theorem
+    statement: (x - c) is a factor of f(x) if and only if f(c) = 0.
+    tags: [roots, factors]
+    when_to_use: After evaluating f(c) and getting 0.
+    short_explanation: Links remainder zero directly to factorization.
+
+  - name: Descartes’ Rule of Signs
+    statement: The number of positive real roots is equal to the number of sign changes or less by an even number.
+    tags: [signs, real, counting]
+    when_to_use: To estimate number of positive or negative real roots.
+    short_explanation: Gives an upper bound on number of real roots based on coefficient signs.
+
+  - name: Vieta’s Formulas (Quadratic Case)
+    statement: For ax² + bx + c = 0, sum of roots is -b/a and product is c/a.
+    tags: [roots, coefficients, relationships]
+    when_to_use: When relating roots to coefficients or vice versa.
+    short_explanation: Encodes root relationships algebraically, useful for reverse-engineering equations.
+
+  - name: Quadratic Formula
+    statement: The solutions to ax² + bx + c = 0 are given by x = [-b ± sqrt(b² - 4ac)] / (2a).
+    tags: [quadratic, formula, solution]
+    when_to_use: To directly solve any quadratic equation.
+    short_explanation: Universal formula for solving second-degree equations, gives real or complex roots.
+
+  - name: Cube Root of Unity Theorem
+    statement: The cube roots of unity are 1, ω, and ω² where ω = -1/2 + sqrt(3)/2 * i.
+    tags: [roots of unity, complex, cubic]
+    when_to_use: To factor or solve x³ + 1 = 0 or similar.
+    short_explanation: Provides structure for solving special cubics using symmetric roots.
+
+  - name: Unique Solution Condition (2x2 Systems)
+    statement: A linear system ax + by = c, dx + ey = f has a unique solution if ae - bd ≠ 0.
+    tags: [linear, determinant, solution condition]
+    when_to_use: To check if a system of two equations in two variables has a unique solution.
+    short_explanation: The determinant must be non-zero for a unique solution to exist.
+
+  - name: Elimination Method
+    statement: Linear combinations of two equations can eliminate a variable to solve the system.
+    tags: [linear, elimination]
+    when_to_use: To reduce a 2-variable system to one equation.
+    short_explanation: Combines equations strategically to remove variables and simplify.
+
+  - name: Substitution Method
+    statement: Solve one equation for a variable and substitute into the other.
+    tags: [substitution, linear]
+    when_to_use: When one variable is easy to isolate.
+    short_explanation: Reduces a system to a single-variable equation by replacement.
+
+  - name: Gauss Elimination (Conceptual)
+    statement: Any system of linear equations can be reduced using row operations to echelon form.
+    tags: [system, reduction, matrix]
+    when_to_use: For solving or analyzing larger systems or performing algorithmic solutions.
+    short_explanation: Encodes the algebraic elimination steps in matrix language. Useful for generalization.
+
+  - name: Imaginary Unit Identity
+    statement: i² = -1 defines the imaginary unit.
+    tags: [complex, imaginary, identity]
+    when_to_use: When solving quadratics with negative discriminant.
+    short_explanation: Enables extension of square roots to negative numbers, yielding complex solutions.
+
+  - name: Root Multiplicity
+    statement: If (x - c)^k divides the polynomial but (x - c)^(k+1) does not, then c is a root of multiplicity k.
+    tags: [multiplicity, roots, factor]
+    when_to_use: To analyze repeated roots.
+    short_explanation: Explains why some roots repeat and how they affect the shape of the graph.
+
+