Update app.py

app.py

@@ -408,7 +408,7 @@ The computation question MAY NOT:
     return problem_type_additions.get(question_type, "")
 
 def generate_question(subject, difficulty, question_type):
-    """Generate a single math question"""
+    """Generate a single math question with additional verification for difficulty 5"""
     try:
         if not os.environ.get('ANTHROPIC_API_KEY'):
             logger.error("Anthropic API key not found")
@@ -508,10 +508,15 @@ STRICT REQUIREMENTS:
         if sympy_output:
             # Check if SymPy ran successfully
             if "Error" not in sympy_output:
-                resolution = check_and_resolve_discrepancy(response_text, sympy_output)
-                response_text = f"{response_text}\n\nSymPy Verification Results:\n```\n{sympy_output}\n```\n\nVerification Analysis:\n{resolution}"
+                resolution_text, has_discrepancy, revised_solution = check_and_resolve_discrepancy(response_text, sympy_output)
+                response_text = f"{response_text}\n\nSymPy Verification Results:\n```\n{sympy_output}\n```\n\nVerification Analysis:\n{resolution_text}"
+                
+                # For difficulty level 5 AND when there's a discrepancy with a revised solution
+                if difficulty == 5 and has_discrepancy and revised_solution:
+                    logger.debug("Performing final verification for difficulty 5 problem with discrepancy")
+                    final_verification = perform_final_verification(revised_solution)
+                    response_text += "\n\nFinal Expert Verification:\n" + final_verification
             else:
-                # Just append SymPy results if there was an error
                 response_text += f"\n\nSymPy Verification Results:\n```\n{sympy_output}\n```"
         
         # Create LaTeX content
@@ -528,8 +533,8 @@ STRICT REQUIREMENTS:
             
     except Exception as e:
         logger.error(f"Error generating question: {str(e)}")
-        return f"Error: {str(e)}", None, Non
-
+        return f"Error: {str(e)}", None, None
+        
 def extract_and_run_sympy_code_simple(response_text):
     """
     Extract SymPy code from the response and execute it.
@@ -587,6 +592,7 @@ def extract_and_run_sympy_code_simple(response_text):
 def check_and_resolve_discrepancy(initial_response, sympy_output):
     """
     Compare the SymPy output with the initial response and resolve any discrepancies.
+    Returns tuple of (resolution_text, has_discrepancy, revised_solution)
     """
     try:
         resolution_prompt = f"""Here is a mathematics question with two answers.
@@ -599,7 +605,8 @@ def check_and_resolve_discrepancy(initial_response, sympy_output):
         If the two answers are inconsistent with each other then please:
         1. Identify which solution is correct
         2. Explain the error in the incorrect solution
-        3. Provide a revised complete solution that fixes any errors and does not refer to SymPy
+        3. Provide a revised COMPLETE solution that fixes any errors, does not refer to SymPy, 
+and does not refer to the Original solution even if this means large parts of the Original solution are repeated.
 
 Original solution:
 {initial_response}
@@ -626,12 +633,76 @@ Please maintain the same LaTeX formatting as the original solution."""
         if "```python" in resolution_text:
             new_sympy_output = extract_and_run_sympy_code_simple(resolution_text)
             resolution_text += "\n\nNew SymPy Verification Results:\n```\n" + new_sympy_output + "\n```"
+        
+        # Determine if there was a discrepancy that required a revised solution
+        has_discrepancy = "revised complete solution" in resolution_text.lower()
+        
+        # Extract revised solution if it exists
+        revised_solution = None
+        if has_discrepancy:
+            # Look for the revised solution after the explanation
+            solution_parts = resolution_text.split("revised complete solution", maxsplit=1)
+            if len(solution_parts) > 1:
+                revised_solution = solution_parts[1].strip()
+        
+        return resolution_text, has_discrepancy, revised_solution
             
-        return resolution_text
     except Exception as e:
         logger.error(f"Error in discrepancy resolution: {str(e)}")
-        return f"Error in resolution: {str(e)}"
+        return f"Error in resolution: {str(e)}", False, None
+
+def perform_final_verification(revised_solution):
+    """
+    Perform a final verification of the revised solution for difficulty level 5 problems.
+    """
+    verification_prompt = f"""As an expert mathematician, please carefully verify this revised solution to an advanced (graduate-level) mathematics problem.
+
+Revised Solution to Verify:
+{revised_solution}
+
+Please:
+1. Verify the mathematical correctness of the solution
+2. Check for any subtle errors or missing cases
+3. Verify that all assumptions are clearly stated
+4. Ensure the solution is complete and rigorous
+5. Check that any series convergence, existence conditions, or boundary cases are properly addressed
+
+If you find any issues:
+1. Clearly explain what is incorrect or missing
+2. Provide a COMPLETE corrected solution
+3. Maintain the same LaTeX formatting as the original
+4. Include any missing assumptions or conditions
+5. If relevant, provide corrected SymPy code
+
+If the solution is correct:
+Briefly explain why the solution is mathematically sound and complete.
+
+Please ensure any corrected solution maintains proper LaTeX formatting with $ for inline math and $$ on separate lines for displayed equations."""
+
+    try:
+        # Make API call for final verification
+        message = anthropic.messages.create(
+            model="claude-3-5-sonnet-20241022",
+            max_tokens=4096,
+            temperature=0.2,
+            messages=[{
+                "role": "user",
+                "content": verification_prompt
+            }]
+        )
+        
+        verification_result = message.content[0].text
         
+        # If verification includes new SymPy code, run it
+        if "```python" in verification_result:
+            new_sympy_output = extract_and_run_sympy_code_simple(verification_result)
+            verification_result += "\n\nFinal SymPy Verification:\n```\n" + new_sympy_output + "\n```"
+        
+        return verification_result
+    except Exception as e:
+        logger.error(f"Error in final verification: {str(e)}")
+        return f"Error in final verification: {str(e)}"
+
 # Create Gradio interface
 with gr.Blocks() as interface:
     gr.Markdown("# Advanced Mathematics Question Generator")