Update app.py

For Wolfram Verification, added specialized handling for different types of calculus problems and improved answer comparison

app.py

@@ -60,11 +60,32 @@ def parse_questions(content):
 def verify_solution(problem, answer):
     """Verify a mathematical solution using Wolfram Alpha"""
     try:
-        # Clean up the problem for Wolfram Alpha
-        query = problem.replace('$$', '').replace('$', '')
-        # Remove any text instructions, keep only the mathematical expression
-        query = re.sub(r'(?i)find|calculate|solve|evaluate|determine', '', query)
+        # First, determine the type of problem
+        if "lim" in problem.lower():
+            # Format limit problem
+            # Extract the expression and point of evaluation
+            expr = re.search(r'lim.*?(\d+\/[x-]+\d+)', problem)
+            if expr:
+                query = f"limit of {expr.group(1)} as x approaches 2"
+        elif "integral" in problem.lower():
+            # Format integral problem
+            # Extract the integrand and limits
+            expr = re.search(r'\int_0\^1.*?([\dx+]+).*?dx', problem)
+            if expr:
+                query = f"integrate {expr.group(1)} from 0 to 1"
+        elif "derivative" in problem.lower() or "f(x)" in problem:
+            # Format derivative problem
+            # Extract the function to differentiate
+            expr = re.search(r'f\(x\)\s*=\s*([^\s]+)', problem)
+            if expr:
+                query = f"d/dx ({expr.group(1)})"
+        else:
+            # Default cleanup for other types of problems
+            query = problem.replace('$$', '').replace('$', '')
+            query = re.sub(r'(?i)find|calculate|solve|evaluate|determine', '', query)
+            
         query = query.strip()
+        print(f"Sending query to Wolfram Alpha: {query}")  # Debug print
         
         result = wolfram_client.query(query)
         
@@ -77,15 +98,28 @@ def verify_solution(problem, answer):
         
         # Look for numerical results in multiple pods
         for pod in result.pods:
-            if pod.title in ['Result', 'Solution', 'Numerical result', 'Decimal approximation']:
+            if pod.title in ['Result', 'Solution', 'Numerical result', 'Decimal approximation', 'Limit', 'Definite integral', 'Derivative']:
                 wolfram_answer = pod.text
-                # Extract numerical value
-                wolfram_nums = re.findall(r'[-+]?(?:\d*\.)?\d+', wolfram_answer)
-                if wolfram_nums:
-                    wolfram_value = float(wolfram_nums[0])
-                    user_value = float(answer)
-                    # Allow for small numerical differences
-                    is_verified = abs(wolfram_value - user_value) < 0.01
+                print(f"Wolfram Alpha pod {pod.title}: {wolfram_answer}")  # Debug print
+                
+                # For numerical answers
+                if answer.isdigit() or answer.replace('.', '').isdigit():
+                    wolfram_nums = re.findall(r'[-+]?(?:\d*\.)?\d+', wolfram_answer)
+                    if wolfram_nums:
+                        wolfram_value = float(wolfram_nums[0])
+                        user_value = float(answer)
+                        is_verified = abs(wolfram_value - user_value) < 0.01
+                        return {
+                            'verified': is_verified,
+                            'wolfram_solution': wolfram_answer,
+                            'error': None
+                        }
+                # For symbolic answers (like derivatives)
+                else:
+                    # Clean up both answers for comparison
+                    clean_wolfram = re.sub(r'\s+', '', wolfram_answer.lower())
+                    clean_answer = re.sub(r'\s+', '', answer.lower())
+                    is_verified = clean_wolfram == clean_answer
                     return {
                         'verified': is_verified,
                         'wolfram_solution': wolfram_answer,
@@ -95,7 +129,7 @@ def verify_solution(problem, answer):
         return {
             'verified': False,
             'wolfram_solution': None,
-            'error': "No numerical solution found in Wolfram Alpha response"
+            'error': "No suitable solution found in Wolfram Alpha response"
         }
     except Exception as e:
         return {
@@ -104,6 +138,7 @@ def verify_solution(problem, answer):
             'error': f"Error during verification: {str(e)}"
         }
 
+
 def generate_test(subject):
     """Generate and verify a math test"""
     try: