Update app.py

app.py

@@ -14,83 +14,87 @@ def parse_questions(content):
     """Parse questions and their solutions from Claude's output"""
     # Split content into questions
     questions = []
-    current_text = ""
-    question_pattern = re.compile(r'\d+\)')
+    parts = re.split(r'\n\s*(\d+)\)', content)
     
-    # Split the content by question numbers
-    parts = re.split(question_pattern, content)
-    if len(parts) > 1:  # Skip the first empty part if it exists
+    # Remove any empty first element
+    if parts[0].strip() == '':
         parts = parts[1:]
     
-    for part in parts:
-        # Try to extract the problem and solution
+    # Process pairs of question numbers and content
+    for i in range(0, len(parts)-1, 2):
+        question_num = parts[i]
+        question_content = parts[i+1]
+        
         try:
-            # Split into problem and solution (assuming "Solution:" marks the divide)
-            problem_solution = part.split("Solution:", 1)
-            if len(problem_solution) == 2:
-                problem = problem_solution[0].strip()
-                solution = problem_solution[1].strip()
-                
-                # Extract the final numerical answer if possible
-                # This is a simple example - you'll need to adjust based on your output format
-                final_answer = re.search(r'=\s*([-+]?\d*\.?\d+)', solution)
-                if final_answer:
-                    final_answer = final_answer.group(1)
-                else:
-                    final_answer = "Not found"
+            # Split into problem and solution
+            if "Solution:" in question_content:
+                problem, solution = question_content.split("Solution:", 1)
+            else:
+                continue
                 
-                questions.append((problem, final_answer))
+            # Clean up the problem and solution
+            problem = problem.strip()
+            solution = solution.strip()
+            
+            # Extract the final answer (look for last equation or stated answer)
+            final_answer_match = re.search(r'(?:final answer|=)\s*[-+]?(?:\d*\.)?\d+', solution.lower())
+            if final_answer_match:
+                final_answer = re.findall(r'[-+]?(?:\d*\.)?\d+', final_answer_match.group())[-1]
+                questions.append({
+                    'number': question_num,
+                    'problem': problem,
+                    'solution': solution,
+                    'final_answer': final_answer
+                })
         except Exception as e:
-            print(f"Error parsing question: {e}")
+            print(f"Error parsing question {question_num}: {e}")
             continue
     
     return questions
 
-def verify_solution(problem, claimed_solution):
+def verify_solution(problem, answer):
     """Verify a mathematical solution using Wolfram Alpha"""
     try:
-        # Clean up the problem and solution for Wolfram Alpha
-        query = f"Solve {problem}"
+        # Format the query for Wolfram Alpha
+        query = problem.replace('$$', '').replace('$', '')  # Remove LaTeX delimiters
         result = wolfram_client.query(query)
         
-        # Extract the solution from Wolfram Alpha
-        wolfram_solution = next(result.results).text
-        
-        # Compare solutions (needs sophisticated parsing based on your problem types)
-        solutions_match = compare_solutions(wolfram_solution, claimed_solution)
+        # Try to get the numerical result
+        for pod in result.pods:
+            if pod.title in ['Result', 'Solution', 'Numerical result']:
+                wolfram_answer = pod.text
+                # Extract numerical value
+                wolfram_nums = re.findall(r'[-+]?(?:\d*\.)?\d+', wolfram_answer)
+                if wolfram_nums:
+                    return {
+                        'verified': abs(float(wolfram_nums[0]) - float(answer)) < 0.001,
+                        'wolfram_solution': wolfram_answer,
+                        'error': None
+                    }
         
         return {
-            'verified': solutions_match,
-            'wolfram_solution': wolfram_solution,
-            'match': solutions_match
+            'verified': False,
+            'wolfram_solution': None,
+            'error': "Could not extract numerical solution from Wolfram Alpha"
         }
     except Exception as e:
         return {
             'verified': False,
-            'error': str(e),
-            'wolfram_solution': None
+            'wolfram_solution': None,
+            'error': str(e)
         }
 
-def compare_solutions(wolfram_sol, claude_sol):
-    """Compare two solutions for mathematical equivalence"""
-    try:
-        # Convert both solutions to floats for comparison
-        w_val = float(wolfram_sol)
-        c_val = float(claude_sol)
-        return abs(w_val - c_val) < 0.001
-    except (ValueError, TypeError):
-        return False
-
 def generate_test(subject):
     """Generate and verify a math test"""
     try:
-        # Generate the test using Claude
-        system_prompt = """Generate 3 university-level math questions with numerical solutions that can be verified.
+        system_prompt = """Generate 3 university-level math questions that can be verified numerically.
         For each question:
-        1. State the problem clearly
-        2. Provide your step-by-step solution
-        3. End each solution with a clear final numerical answer in the format: "Final answer = [number]"
-        Use simple $$ for all math expressions."""
+        1. Number the question as 1), 2), 3)
+        2. State the problem clearly using simple $$ for displayed math
+        3. Include "Solution:" before the solution
+        4. Show step-by-step work
+        5. End each solution with "Final answer = [number]"
+        6. Keep problems relatively simple (basic calculus, algebra, etc.)"""
         
         message = anthropic.messages.create(
             model="claude-3-opus-20240229",
@@ -98,28 +102,30 @@ def generate_test(subject):
             temperature=0.7,
             messages=[{
                 "role": "user",
-                "content": f"{system_prompt}\n\nWrite an exam for {subject}."
+                "content": f"{system_prompt}\n\nWrite an exam for {subject} with simple numerical answers."
             }]
         )
         
-        # Extract questions and solutions
+        # Get the content and parse questions
         content = message.content[0].text
+        questions = parse_questions(content)
         
         # Add verification results
+        verification_note = "\n\n---\n## Solution Verification:\n"
         verification_results = []
         
-        # Parse and verify each question
-        verification_note = "\n\n## Solution Verification:\n"
-        for i, (problem, solution) in enumerate(parse_questions(content)):
-            result = verify_solution(problem, solution)
-            verification_note += f"\nQuestion {i+1}:\n"
+        for q in questions:
+            result = verify_solution(q['problem'], q['final_answer'])
+            verification_results.append(result)
+            verification_note += f"\nQuestion {q['number']}:\n"
             if result['verified']:
                 verification_note += "✅ Solution verified by Wolfram Alpha\n"
             else:
                 verification_note += "⚠️ Solution needs verification\n"
-                if result['wolfram_solution']:
-                    verification_note += f"Wolfram Alpha got: {result['wolfram_solution']}\n"
-            verification_results.append(result)
+            if result['wolfram_solution']:
+                verification_note += f"Wolfram Alpha result: {result['wolfram_solution']}\n"
+            if result['error']:
+                verification_note += f"Note: {result['error']}\n"
         
         # Add usage statistics
         usage_stats = f"""
@@ -133,47 +139,11 @@ def generate_test(subject):
         • Wolfram API calls: {len(verification_results)}
         """
         
-        return content + verification_note + usage_stats
+        # Combine everything with proper spacing
+        final_output = content + "\n\n" + verification_note + usage_stats
+        return final_output
             
     except Exception as e:
         return f"Error: {str(e)}"
 
-# Subject choices and interface configuration remain the same...
-subjects = [
-    "Single Variable Calculus",
-    "Multivariable Calculus", 
-    "Linear Algebra",
-    "Differential Equations",
-    "Real Analysis",
-    "Complex Analysis",
-    "Abstract Algebra",
-    "Probability Theory",
-    "Numerical Analysis",
-    "Topology"
-]
-
-# Create Gradio interface
-interface = gr.Interface(
-    fn=generate_test,
-    inputs=gr.Dropdown(
-        choices=subjects,
-        label="Select Mathematics Subject",
-        info="Choose a subject for the exam questions"
-    ),
-    outputs=gr.Markdown(
-        label="Generated Test",
-        latex_delimiters=[
-            {"left": "$$", "right": "$$", "display": True},
-            {"left": "$", "right": "$", "display": False}
-        ]
-    ),
-    title="Advanced Mathematics Test Generator",
-    description="""Generates university-level mathematics exam questions with solutions using Claude 3 Opus.
-    Limited to 25 requests per day. Please use responsibly.""",
-    theme="default",
-    allow_flagging="never"
-)
-
-# Launch the interface
-if __name__ == "__main__":
-    interface.launch()
+# Rest of your code (subjects and interface) remains the same...