Update app.py

app.py

@@ -4,6 +4,7 @@ from huggingface_hub import InferenceClient
 from datasets import load_dataset
 import random
 import re
+import sympy as sp  # Added SymPy for symbolic computation and better rendering/verification
 
 # Global datasets - load lazily
 math_samples = None
@@ -109,7 +110,7 @@ def create_math_system_message():
 Always be precise, educational, and encourage mathematical thinking."""
 
 def render_latex(text):
-    """Minimal LaTeX cleanup - let the model do the work"""
+    """Enhanced LaTeX cleanup with support for advanced SymPy outputs"""
     if not text:
         return text
     
@@ -118,17 +119,100 @@ def render_latex(text):
         text = re.sub(r'\\\[(.*?)\\\]', r'$$\1$$', text, flags=re.DOTALL)
         text = re.sub(r'\\\((.*?)\\\)', r'$\1$', text, flags=re.DOTALL)
         
-        # Fix boxed answers ONLY if not already in math mode
+        # Fix boxed answers if not in math mode
         if '\\boxed' in text and not re.search(r'\$.*\\boxed.*\$', text):
-            text = re.sub(r'\\boxed\{([^}]+)\}', r'$\\boxed{\1}$', text)
+            text = re.sub(r'\\boxed\{([^}]+)\}', r'$$\boxed{\1}$$', text)
+        
+        # Handle equation environments for display in Gradio (convert to $$...$$)
+        text = re.sub(r'\\begin\{equation\*\}(.*?)\\end\{equation\*\}', r'$$\1$$', text, flags=re.DOTALL)
+        
+        # Clean up any escaped % or special chars for Markdown compatibility
+        text = re.sub(r'\\%', '%', text)
         
     except Exception as e:
         print(f"⚠️ LaTeX error: {e}")
     
     return text
 
+def try_sympy_compute(message):
+    """Attempt to compute the result using SymPy for verification and better rendering, with advanced LaTeX options."""
+    message_lower = message.lower()
+    
+    x = sp.Symbol('x')
+    
+    # Handle definite integrals
+    if 'integral' in message_lower or '∫' in message:
+        match = re.search(r'(?:integral of|∫) (.+?) from (.+?) to (.+)', message_lower)
+        if match:
+            expr_str, lower, upper = match.groups()
+            try:
+                expr = sp.sympify(expr_str.replace('^', '**'))  # Handle ^ for power
+                result = sp.integrate(expr, (x, sp.sympify(lower), sp.sympify(upper)))
+                # Advanced LaTeX: fold fractions, plain mode, manual box
+                return r'\boxed{' + sp.latex(result, mode='plain', fold_frac_powers=True) + r'}'
+            except Exception as e:
+                print(f"⚠️ SymPy integral error: {e}")
+                return None
+    
+    # Handle derivatives with inv_trig_style
+    elif 'derivative' in message_lower:
+        match = re.search(r'derivative of (.+)', message_lower)
+        if match:
+            expr_str = match.group(1)
+            try:
+                expr = sp.sympify(expr_str.replace('^', '**'))
+                result = sp.diff(expr, x)
+                # Advanced LaTeX: power style for inv trig, fold short frac
+                return r'\boxed{' + sp.latex(result, inv_trig_style='power', fold_short_frac=True) + r'}'
+            except Exception as e:
+                print(f"⚠️ SymPy derivative error: {e}")
+                return None
+    
+    # Handle limits
+    elif 'limit' in message_lower or 'lim' in message_lower:
+        match = re.search(r'(?:limit|lim) (.+?) as (.+?) to (.+)', message_lower)
+        if match:
+            expr_str, var, to_val = match.groups()
+            try:
+                expr = sp.sympify(expr_str.replace('^', '**'))
+                result = sp.limit(expr, sp.Symbol(var), sp.sympify(to_val))
+                # Advanced LaTeX: equation* mode for display
+                return sp.latex(result, mode='equation*')
+            except Exception as e:
+                print(f"⚠️ SymPy limit error: {e}")
+                return None
+    
+    # Handle triangle area (Heron's formula)
+    elif 'area of triangle' in message_lower:
+        match = re.search(r'(\d+)[ -](\d+)[ -](\d+)', message_lower)  # Matches 5-12-13 or 5 12 13
+        if match:
+            a, b, c = map(float, match.groups())
+            try:
+                s = (a + b + c) / 2
+                area = sp.sqrt(s * (s - a) * (s - b) * (s - c))
+                # Advanced LaTeX: inline mode with folding
+                return r'\boxed{' + sp.latex(area, mode='inline', fold_frac_powers=True) + r'}'
+            except Exception as e:
+                print(f"⚠️ SymPy area error: {e}")
+                return None
+    
+    # Handle simple matrices (e.g., "matrix [[1,2],[3,4]]")
+    elif 'matrix' in message_lower:
+        match = re.search(r'matrix \[\[(.+?)\]\]', message_lower)  # Basic parsing; extend as needed
+        if match:
+            try:
+                elements = [list(map(sp.sympify, row.split(','))) for row in match.group(1).split('],[')]
+                m = sp.Matrix(elements)
+                # Advanced LaTeX: custom delimiters and matrix style
+                return sp.latex(m, mat_delim='[', mat_str='bmatrix')
+            except Exception as e:
+                print(f"⚠️ SymPy matrix error: {e}")
+                return None
+    
+    return None
+
 def respond(message, history, system_message, max_tokens, temperature, top_p):
-    """Non-streaming response for stability"""
+    """Non-streaming response for stability, with SymPy verification for supported queries."""
     client = InferenceClient(model="Qwen/Qwen2.5-Math-7B-Instruct")
     
     messages = [{"role": "system", "content": system_message}]
@@ -148,6 +232,12 @@ def respond(message, history, system_message, max_tokens, temperature, top_p):
             top_p=top_p,
         )
         response = completion.choices[0].message.content
+        
+        # Add SymPy verification if applicable (now with advanced LaTeX)
+        sympy_result = try_sympy_compute(message)
+        if sympy_result:
+            response += "\n\n**Verified with SymPy (for exact symbolic computation):** $$" + sympy_result + "$$"
+        
         return render_latex(response)
     except Exception as e:
         return f"❌ Error: {str(e)[:100]}... Try a simpler problem."
@@ -193,7 +283,9 @@ with gr.Blocks(title="🧮 Mathetics AI") as demo:
         examples=[
             ["derivative of x^2 sin(x)"],
             ["area of triangle 5-12-13"],
-            ["∫x^2 dx"]
+            ["∫x^2 dx from 0 to 2"],
+            ["limit sin(x)/x as x to 0"],
+            ["matrix [[1,2],[3,4]]"]
         ],
         inputs=msg
     )