Update app.py

app.py

@@ -523,7 +523,7 @@ The computation question MAY NOT:
     }
     return problem_type_additions.get(question_type, "")
 
-def get_solution_for_verification(response_text, sympy_correct, final_verification=None):
+def get_solution_for_verification(response_text, SYMPY_CONFIRMED, final_verification=None):
     """
     Extract the relevant parts of the solution for verification based on whether
     the original solution was correct or not. Always preserves the original question.
@@ -673,14 +673,14 @@ Format your response with clear headers and bullet points."""
         logger.error(f"Error in ChatGPT verification: {str(e)}")
         return f"Error in ChatGPT verification: {str(e)}"
 
-def append_chatgpt_verification(initial_response, sympy_correct, final_verification=None):
+def append_chatgpt_verification(initial_response, SYMPY_CONFIRMED, final_verification=None):
     """
     Main function to handle the ChatGPT verification process.
     Returns the original response with the ChatGPT verification appended.
     """
     try:
         # Get the appropriate solution text for verification
-        question, solution_text = get_solution_for_verification(initial_response, sympy_correct, final_verification)
+        question, solution_text = get_solution_for_verification(initial_response, SYMPY_CONFIRMED, final_verification)
         
         # Get ChatGPT's verification
         chatgpt_verification = verify_with_chatgpt(question, solution_text)
@@ -894,25 +894,32 @@ make sure the question is CLEAR about what regions you intend to be included in
         # Execute SymPy code and append results
         sympy_output = extract_and_run_sympy_code_simple(response_text)
         has_discrepancy = False  # Initialize outside the if block
-        sympy_correct = None
+        SYMPY_CONFIRMED = None
         revised_solution = None
         final_verification = None
 
-        if sympy_output:
-            if "Error" not in sympy_output:
-                resolution_text, has_discrepancy, revised_solution, sympy_correct = 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}"
-                
-            if has_discrepancy and revised_solution:
-                    logger.debug("Performing final verification for problem with discrepancy")
-                    final_verification = perform_final_verification(revised_solution, sympy_correct)
-                    response_text += "\n\nFinal Expert Verification:\n" + final_verification
-        
+        # Store original response text before modifications
+        original_response = response_text
+
+        # Always do verification analysis
+        if "Error" in sympy_output:
+            verification_text = "SymPy verification failed with error. Manual solution must be verified independently."
+            SYMPY_CONFIRMED = "Inconclusive"
+            response_text = f"{response_text}\n\nSymPy Verification Results:\n```\n{sympy_output}\n```\n\nVerification Analysis:\n{verification_text}"
+        else:
+            resolution_text, has_discrepancy, revised_solution, SYMPY_CONFIRMED = check_and_resolve_discrepancy(original_response, sympy_output)
+            response_text = f"{response_text}\n\nSymPy Verification Results:\n```\n{sympy_output}\n```\n\nVerification Analysis:\n{resolution_text}"
+
+        if has_discrepancy and revised_solution:
+            logger.debug("Performing final verification for problem with discrepancy")
+            final_verification = perform_final_verification(revised_solution, SYMPY_CONFIRMED)
+            response_text += "\n\nFinal Expert Verification:\n" + final_verification
+    
         # add the ChatGPT verification
         if include_chatgpt == "yes":
             response_text = append_chatgpt_verification(
                 response_text, 
-                sympy_correct,
+                SYMPY_CONFIRMED,
                 final_verification if has_discrepancy else None
             )
         
@@ -994,7 +1001,7 @@ def check_and_resolve_discrepancy(initial_response, sympy_output):
     has_discrepancy = False #Initialize
     resolution_text = ""
     revised_solution = None
-    sympy_correct = None  # Initialize at the start
+    SYMPY_CONFIRMED = None  # Initialize at the start
     
     try:
         resolution_prompt = f"""Here is a mathematics question with two answers.
@@ -1015,12 +1022,12 @@ def check_and_resolve_discrepancy(initial_response, sympy_output):
 4. After your analysis, conclude ONE of the following:
 
    If equivalence is PROVEN:
-   - Write "SYMPY_CORRECT: True" on its own line
+   - Write "SYMPY_CONFIRMED: True" on its own line (this means SymPy's output CONFIRMS the original solution)
    - Explain exactly how you proved equivalence
    - Show all steps of the verification
 
    If equivalence CANNOT be proven:
-   - Write "SYMPY_CORRECT: False" on its own line
+   - Write "SYMPY_CONFIRMED: False" on its own line
    - Explain why equivalence cannot be established
    - Write "Here is the revised complete solution:" and then write out an ENTIRE corrected solution from beginning 
            to end, including all parts that were correct and the corrections for any incorrect parts. 
@@ -1031,10 +1038,10 @@ 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. Write "Here is the revised complete solution:" 
-        4. Start with "SYMPY_CORRECT: False" on its own line.
+        4. Start with "SYMPY_CONFIRMED: False" on its own line.
 
    If verification is INCONCLUSIVE:
-   - Write "SYMPY_CORRECT: Inconclusive" on its own line
+   - Write "SYMPY_CONFIRMED: Inconclusive" on its own line
    - Explain why equivalence cannot be determined
    - Request a new SymPy verification with additional checks
 
@@ -1122,22 +1129,22 @@ Please maintain the same LaTeX formatting as the original solution."""
                     logger.error(f"Error in solution recheck: {str(e)}")
 
             # Parse whether SymPy was correct
-                sympy_correct = None
-                if "SYMPY_CORRECT: True" in resolution_text:
-                    sympy_correct = True
-                elif "SYMPY_CORRECT: False" in resolution_text:
-                    sympy_correct = False
+                SYMPY_CONFIRMED = None
+                if "SYMPY_CONFIRMED: True" in resolution_text:
+                    SYMPY_CONFIRMED = True
+                elif "SYMPY_CONFIRMED: False" in resolution_text:
+                    SYMPY_CONFIRMED = False
         
-        return resolution_text, has_discrepancy, revised_solution, sympy_correct
+        return resolution_text, has_discrepancy, revised_solution, SYMPY_CONFIRMED
             
     except Exception as e:
         logger.error(f"Error in discrepancy resolution: {str(e)}")
         resolution_text = f"Error in resolution: {str(e)}"
         has_discrepancy = False  # Explicitly set in error case
         revised_solution = None
-        return resolution_text, has_discrepancy, revised_solution, sympy_correct
+        return resolution_text, has_discrepancy, revised_solution, SYMPY_CONFIRMED
 
-def perform_final_verification(revised_solution, sympy_correct):
+def perform_final_verification(revised_solution, SYMPY_CONFIRMED):
     """
     Perform a final verification of the revised solution.
     """
@@ -1165,7 +1172,7 @@ Please follow these steps exactly:
    - Any missing steps or assumptions
    - Any necessary additional proofs or derivations
 
-4. The answer aligns with the {'SymPy' if sympy_correct else 'original'} answer proven correct
+4. The answer aligns with the {'SymPy' if SYMPY_CONFIRMED else 'original'} answer proven correct
 
 Your complete solution must:
 - Be completely self-contained