Update app.py

fix the verification function to handle some specific types of calculus problems that come up in the single-variable case:

For definite integrals:

Fixed the regex pattern to properly handle the integral symbol ∫
Better extraction of integrand and limits
Properly formatted query for Wolfram Alpha

For implicit differentiation:

Added specific handling for dy/dx problems
Better extraction of the equation after the equals sign
Proper formatting for derivative queries

For Mean Value Theorem:

Added specific handling for MVT problems
Extracts function and interval
Formats the query to solve for the MVT value

app.py

@@ -60,32 +60,47 @@ def parse_questions(content):
 def verify_solution(problem, answer):
     """Verify a mathematical solution using Wolfram Alpha"""
     try:
-        # 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)})"
+        # Clean the problem text first
+        clean_problem = problem.replace('$$', '').replace('$', '').strip()
+        
+        # Case 1: Definite Integral
+        if '∫' in clean_problem or 'integral' in clean_problem.lower():
+            # Extract the integrand and limits using regex
+            integrand_match = re.search(r'\int_(\d+)\^(\d+)\s*\(?(.*?)\)?\s*dx', clean_problem)
+            if integrand_match:
+                lower, upper, integrand = integrand_match.groups()
+                # Format the query properly
+                query = f"integrate {integrand} from {lower} to {upper}"
+                print(f"Integral query: {query}")
+        
+        # Case 2: Implicit Differentiation
+        elif 'dy/dx' in clean_problem or 'dy' in clean_problem:
+            # Extract the equation after the = sign
+            equation_match = re.search(r'=\s*(.*?)$', clean_problem)
+            if equation_match:
+                equation = equation_match.group(1)
+                query = f"d/dx of {equation}"
+                print(f"Differentiation query: {query}")
+        
+        # Case 3: Mean Value Theorem
+        elif 'Mean Value Theorem' in clean_problem:
+            # Extract function and interval
+            func_match = re.search(r'f\(x\)\s*=\s*(.*?)\s+on', clean_problem)
+            interval_match = re.search(r'\[([\d.]+),\s*([\d.]+)\]', clean_problem)
+            if func_match and interval_match:
+                func = func_match.group(1)
+                a, b = interval_match.groups()
+                # Format query to find derivative and then solve f'(c) = [f(b)-f(a)]/(b-a)
+                query = f"solve (d/dx({func})) = ({func.replace('x', str(b))} - {func.replace('x', str(a))})/{b} - {a}"
+                print(f"MVT query: {query}")
+        
+        # Default case
         else:
-            # Default cleanup for other types of problems
-            query = problem.replace('$$', '').replace('$', '')
+            query = clean_problem
             query = re.sub(r'(?i)find|calculate|solve|evaluate|determine', '', query)
             
         query = query.strip()
-        print(f"Sending query to Wolfram Alpha: {query}")  # Debug print
+        print(f"Final query to Wolfram Alpha: {query}")
         
         result = wolfram_client.query(query)
         
@@ -93,17 +108,17 @@ def verify_solution(problem, answer):
             return {
                 'verified': False,
                 'wolfram_solution': None,
-                'error': "Wolfram Alpha could not process the query"
+                'error': f"Wolfram Alpha could not process query: {query}"
             }
         
-        # Look for numerical results in multiple pods
+        # Process the result
         for pod in result.pods:
-            if pod.title in ['Result', 'Solution', 'Numerical result', 'Decimal approximation', 'Limit', 'Definite integral', 'Derivative']:
+            if pod.title in ['Result', 'Solution', 'Numerical result', 'Decimal approximation', 'Definite integral']:
                 wolfram_answer = pod.text
-                print(f"Wolfram Alpha pod {pod.title}: {wolfram_answer}")  # Debug print
+                print(f"Wolfram pod {pod.title}: {wolfram_answer}")
                 
-                # For numerical answers
-                if answer.isdigit() or answer.replace('.', '').isdigit():
+                # Handle numerical answers
+                if str(answer).replace('.', '').isdigit():
                     wolfram_nums = re.findall(r'[-+]?(?:\d*\.)?\d+', wolfram_answer)
                     if wolfram_nums:
                         wolfram_value = float(wolfram_nums[0])
@@ -114,11 +129,10 @@ def verify_solution(problem, answer):
                             'wolfram_solution': wolfram_answer,
                             'error': None
                         }
-                # For symbolic answers (like derivatives)
+                # Handle symbolic answers
                 else:
-                    # Clean up both answers for comparison
                     clean_wolfram = re.sub(r'\s+', '', wolfram_answer.lower())
-                    clean_answer = re.sub(r'\s+', '', answer.lower())
+                    clean_answer = re.sub(r'\s+', '', str(answer).lower())
                     is_verified = clean_wolfram == clean_answer
                     return {
                         'verified': is_verified,
@@ -135,10 +149,9 @@ def verify_solution(problem, answer):
         return {
             'verified': False,
             'wolfram_solution': None,
-            'error': f"Error during verification: {str(e)}"
+            'error': f"Error during verification: {str(e)}\nQuery attempted: {query}"
         }
 
-
 def generate_test(subject):
     """Generate and verify a math test"""
     try: