Update app.py

app.py

@@ -73,7 +73,75 @@ When writing SymPy code to verify solutions:
    - Use Float() for sequence terms
    - Convert sums to float() before printing
    - For series calculations, print intermediate terms   
-   """
+
+6. Matrix Operations and Systems of Equations:
+   - For systems of equations that might be linearly dependent, use row reduction instead of matrix inversion
+   - Here's the template for handling such systems:
+
+```python
+from sympy import Matrix, symbols, solve
+
+def analyze_system(A, b):
+    """
+    Analyze a system Ax = b using row reduction.
+    Returns whether solution exists and if it's unique.
+    """
+    # Augmented matrix [A|b]
+    aug = Matrix(A.row_join(b))
+    
+    # Get row echelon form
+    rref, pivots = aug.rref()
+    
+    print("Row reduced augmented matrix:")
+    print(rref)
+    print("\\nPivot columns:", pivots)
+    
+    # Get rank of coefficient matrix and augmented matrix
+    rank_A = Matrix(A).rank()
+    rank_aug = aug.rank()
+    
+    print(f"\\nRank of coefficient matrix: {rank_A}")
+    print(f"Rank of augmented matrix: {rank_aug}")
+    
+    if rank_aug > rank_A:
+        print("\\nNo solution exists")
+        return None
+    elif rank_A < A.cols:
+        print("\\nInfinitely many solutions exist")
+        return "infinite"
+    else:
+        print("\\nUnique solution exists")
+        return "unique"
+
+# When solving a system Ax = b:
+A = Matrix([[...], [...], [...]])  # coefficient matrix
+b = Matrix([[...], [...], [...]])  # right-hand side
+
+# Analyze system
+result = analyze_system(A, b)
+
+if result == "infinite":
+    # Get parametric form of solution
+    aug = Matrix(A.row_join(b))
+    rref, pivots = aug.rref()
+    
+    # Get free variables
+    vars = symbols('x y z')  # adjust variable names as needed
+    free_vars = [var for i, var in enumerate(vars) if i not in pivots]
+    
+    print("\\nParametric solution (t is free parameter):")
+    for i, var in enumerate(vars):
+        if i in pivots:
+            row = pivots.index(i)
+            expr = rref[row, -1]
+            for j, free_var in enumerate(free_vars):
+                expr -= rref[row, pivots[-1] + 1 + j] * free_var
+            print(f"{var} = {expr}")
+        else:
+            print(f"{var} = t")  # use different parameter names for multiple free variables
+```
+
+Always use this template when working with systems of equations to handle potential linear dependence correctly. """
 
 
 
@@ -470,7 +538,6 @@ STRICT REQUIREMENTS:
 def extract_and_run_sympy_code_simple(response_text):
     """
     Extract SymPy code from the response and execute it.
-    Handles SymPy expression printing safely and ensures proper symbol definition.
     """
     try:
         # Extract code
@@ -490,7 +557,7 @@ def extract_and_run_sympy_code_simple(response_text):
         
         # Create globals dict with all SymPy functions
         globals_dict = {}
-        globals_dict.update(vars(sympy))  # This adds all SymPy functions
+        globals_dict.update(vars(sympy))
         globals_dict.update({
             'print': print,
             'float': float,
@@ -502,6 +569,7 @@ def extract_and_run_sympy_code_simple(response_text):
             'diff': sympy.diff,
             'integrate': sympy.integrate,
             'simplify': sympy.simplify,
+            'Matrix': sympy.Matrix
         })
         
         # Remove the sympy import line from the code if present
@@ -514,58 +582,37 @@ def extract_and_run_sympy_code_simple(response_text):
         from contextlib import redirect_stdout
         
         output_buffer = io.StringIO()
-        try:
-            with redirect_stdout(output_buffer):
-                exec(modified_code, globals_dict)
-            return output_buffer.getvalue().strip() or "No output produced"
-        except NonInvertibleMatrixError:
-            return "ERROR_NONINVERTIBLE_MATRIX: The system of equations has either no solution or infinitely many solutions. Matrix is singular (determinant = 0)."
-        except Exception as e:
-            if "det == 0" in str(e) or "not invertible" in str(e):
-                return "ERROR_NONINVERTIBLE_MATRIX: The system of equations has either no solution or infinitely many solutions. Matrix is singular (determinant = 0)."
-            return f"Error executing SymPy code: {str(e)}"
+        with redirect_stdout(output_buffer):
+            exec(modified_code, globals_dict)
+        return output_buffer.getvalue().strip() or "No output produced"
     
     except Exception as e:
-        return f"Error in code extraction: {str(e)}"
-        
+        return f"Error executing SymPy code: {str(e)}"
+
 def check_and_resolve_discrepancy(initial_response, sympy_output):
     """
     Compare the SymPy output with the initial response and resolve any discrepancies.
-    Now handles singular matrix cases specifically.
     """
     try:
-        if "ERROR_NONINVERTIBLE_MATRIX" in sympy_output:
-            resolution_prompt = f"""The original solution claims to solve a system of linear equations, but SymPy indicates the coefficient matrix is not invertible (singular). This means:
-1. The system has either no solution or infinitely many solutions
-2. The vectors are linearly dependent
-3. The solution given cannot be unique
-
-Please:
-1. Verify if the system has no solutions or infinitely many solutions
-2. If solutions exist, express them in parametric form
-3. Provide a complete revised solution that correctly addresses this case
+        resolution_prompt = f"""Here is a mathematics question with two answers.
+        The first, called Original solution, is a complete solution.
+        The second, called SymPy Verification, will only provide the final answer.
+        
+        If the SymPy Verification answer is consistent with the final answer Original solution,
+        then please say that they are consistent and briefly explain why. 
+        
+        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
 
 Original solution:
 {initial_response}
 
-Please maintain the same LaTeX formatting as the original solution and include correct SymPy code that uses row reduction instead of matrix inversion."""
-        else:
-            resolution_prompt = f"""Here is a mathematics question with two answers.
-            The first, called Original solution, is a complete solution.
-            The second, called SymPy Verification, will only provide the final answer.
-            
-            If the SymPy Verification answer is consistent with the final answer Original solution,
-            then please say that they are consistent and briefly explain why. 
-            
-            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 mention SymPy
-    Original solution:
-    {initial_response}
-    SymPy Verification Results:
-    {sympy_output}
-    Please maintain the same LaTeX formatting as the original solution."""
+SymPy Verification Results:
+{sympy_output}
+
+Please maintain the same LaTeX formatting as the original solution."""
 
         # Make API call for resolution
         message = anthropic.messages.create(