Update app.py

app.py

@@ -8,6 +8,8 @@ import logging
 import tempfile
 from pathlib import Path
 from sympy import *
+import json
+from pathlib import Path
 
 # Set up logging
 logging.basicConfig(
@@ -25,8 +27,64 @@ anthropic = Anthropic(
 MAX_REQUESTS_PER_DAY = 25
 request_history = deque(maxlen=1000)
 
-import json
-from pathlib import Path
+SYMPY_GUIDELINES = """
+When writing SymPy code to verify solutions:
+
+SYMPY_GUIDELINES = """
+When writing SymPy code to verify solutions:
+
+1. Imports and Library Usage:
+   - Start with: from sympy import *
+   - DO NOT use NumPy, SciPy, or other libraries
+   - For numerical integration, use integrate() instead of scipy.integrate.quad()
+   - For any numerical computations, use native SymPy functions only
+
+2. Variable Declaration and Functions:
+   - Always define symbolic variables first, for example:
+     ```python
+     x, y, z = symbols('x y z')  # For multiple variables
+     t = Symbol('t')            # For single variables
+     ```
+   - Use Abs() for absolute value (not abs())
+   - Define functions using Function() class when needed
+
+3. Solving and Computing:
+   - Never use strings in solve() or other SymPy functions:
+     CORRECT:   solve(eq, x)
+     INCORRECT: solve(eq, 'x')
+   - Define equations symbolically:
+     CORRECT:   eq = 2*sqrt(h) - sqrt(12) + 5*k
+     INCORRECT: eq = 2*sqrt('h') - sqrt(12) + 5*k
+
+4. Printing and Output:
+   - Include print statements for ALL calculations and results
+   - Print intermediate steps and final answers
+   - Print variable values after they are computed
+   - Use simple print statements instead of f-strings for SymPy expressions
+   - Print expressions with labels on separate lines:
+     ```python
+     print("Expression label:")
+     print(expression)
+     ```
+
+5. Numeric Calculations:
+   - Use Float() for decimal numbers in calculations
+   - Use float() for final printing of results
+   - Avoid evalf() as it may cause errors
+   - For numeric results:
+     ```python
+     result = expression.evalf()
+     print("Result:")
+     print(float(result))
+     ```
+
+6. Working with Series and Sequences:
+   - Use Float() for sequence terms
+   - Convert sums to float() before printing
+   - For series calculations, print intermediate terms
+   """
+
+
 
 def load_proof_repository():
     """Load the proof repository from the repository file"""
@@ -332,64 +390,7 @@ def generate_question(subject, difficulty, question_type):
         difficulty_params = get_difficulty_parameters(difficulty)
         problem_type_addition = get_problem_type_addition(question_type)
 
-        if difficulty == 5:
-            system_prompt = f"""You are an expert mathematics professor creating a graduate-level exam question.
-STRICT REQUIREMENTS:
-1. Write exactly 1 graduate-level {question_type} question on {subject} covering {selected_topic}.
-2. Advanced Difficulty Requirements:
-   This question must be suitable for PhD qualifying exams or advanced competitions.
-   MUST include:
-   - Novel applications of theoretical concepts
-   - Graduate-level mathematical reasoning
-   - Unexpected connections between different areas of {subject}
-   - Creative problem-solving approaches
-   - Rigorous proof requirements where applicable
-   
-   Follow these specific constraints:
-   {chr(10).join(f'   - {c}' for c in difficulty_params['constraints'])}
-   
-   {problem_type_addition}
-3. Style Reference:
-   Question should be {difficulty_params['example_style']}
-4. The question MUST:
-   - Bridge multiple mathematical domains
-   - Require deep theoretical understanding
-   - Test mastery of advanced concepts
-   - Demand innovative solution approaches
-5. For LaTeX formatting:
-   - Make sure that the question statement uses proper LaTeX math mode
-   - Use $ for inline math
-   - Use $$ on separate lines for equations and solutions
-   - Put each solution step on its own line in $$ $$
-   - DO NOT use \\begin{{aligned}} or similar environments
-6. Include a detailed solution with thorough explanations of advanced concepts used
-7. Maintain clear, precise formatting
-8. At the end of the LaTeX solution output, print SymPy code that you would use to solve or verify the main equations in the question.
-9. When writing SymPy code to verify solutions:
-   - Start with essential imports: from sympy import * 
-   - Or use specific imports as needed: from sympy import Symbol, solve, limit, Abs, integrate, Function, diff, sin, cos
-   - DO NOT use NumPy, SciPy, or other libraries
-   - For numerical integration, use integrate() instead of scipy.integrate.quad()
-   - For any numerical computations, use native SymPy functions
-   - Always define symbolic variables using Symbol() before using them
-   - Use Abs() for absolute value (not abs())
-   - Define functions using Function() class when needed
-   - Include print statements for ALL calculations and results
-   - Use simple print statements instead of f-strings for SymPy expressions
-   - Print expressions with labels on separate lines:
-     print("Expression label:")
-     print(expression)
-   - Print intermediate steps and final answers
-   - Print variable values after they are computed
-   - For numeric calculations:
-     * Use Float() for decimal numbers
-     * Use float() for final printing of results
-     * Avoid evalf() as it may cause errors
-    - When working with series/sequences:
-     * Use Float() for sequence terms
-     * Convert sums to float() before printing"""       
-        else:
-            system_prompt = f"""You are an expert mathematics professor creating a {difficulty_params['description']} exam question.
+        system_prompt = f"""You are an expert mathematics professor creating a {difficulty_params['description']} exam question.
 STRICT REQUIREMENTS:
 1. Write exactly 1 {question_type} question on {subject} covering {selected_topic}.
 2. Difficulty Level Guidelines:
@@ -416,38 +417,8 @@ STRICT REQUIREMENTS:
         * ensure integration bounds align with the physical direction of the process being modeled
 6. Maintain clear formatting
 7. At the end of the LaTeX solution output, print SymPy code that you would use to solve or verify the main equations in the question.
-8. When writing SymPy code to verify solutions:
-   - Use ONLY SymPy functions - do not use NumPy, SciPy, or other libraries
-   - For numerical integration, use SymPy's integrate() instead of scipy.integrate.quad()
-   - For any numerical computations, use SymPy's native functions
-   - Always define symbolic variables using Symbol() before using them
-   - Include print statements for ALL calculations and results
-   - Print intermediate steps and final answers
-   - Print variable values after they are computed
-   - Format numerical results using evalf() for decimal
-9. When writing SymPy code to verify solutions:
-   - Start with essential imports: from sympy import * 
-   - Or use specific imports as needed: from sympy import Symbol, symbols, solve, limit, Abs, integrate, Function, diff, sin, cos
-   - DO NOT use NumPy, SciPy, or other libraries
-   - For numerical integration, use integrate() instead of scipy.integrate.quad()
-   - For any numerical computations, use native SymPy functions
-   - Always define symbolic variables using Symbol() before using them
-   - Use Abs() for absolute value (not abs())
-   - Define functions using Function() class when needed
-   - Include print statements for ALL calculations and results
-   - Use simple print statements instead of f-strings for SymPy expressions
-   - Print intermediate steps and final answers
-   - Print variable values after they are computed
-   - Print expressions with labels on separate lines:
-     print("Expression label:")
-     print(expression)
-   - For numeric calculations:
-     * Use Float() for decimal numbers
-     * Use float() for final printing of results
-     * Avoid evalf() as it may cause errors
-   - When working with series/sequences:
-     * Use Float() for sequence terms
-     * Convert sums to float() before printing"""
+8. Observe the folloiwng SymPy Guidelines
+{SYMPY_GUIDELINES}"""
 
 #Consider
    #When writing SymPy code:
@@ -508,8 +479,7 @@ 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 without f-strings.
-    Returns the output exactly as SymPy would produce it.
+    Handles SymPy expression printing safely and ensures proper symbol definition.
     """
     try:
         # Extract code
@@ -524,22 +494,30 @@ def extract_and_run_sympy_code_simple(response_text):
         
         sympy_code = response_text[code_start:code_end].strip()
         
-        # Replace problematic f-strings with safe print statements
-        sympy_code = sympy_code.replace('f"', '"')
-        sympy_code = sympy_code.replace('{', '{{')
-        sympy_code = sympy_code.replace('}', '}}')
-        sympy_code = sympy_code.replace('print(f"', 'print("')
-        
-        # Add safe printing function
-        safe_print_setup = """
-def safe_print_expr(label, expr):
-    print(label)
-    print(expr)
+        # Add wrapper function to ensure proper symbol definitions
+        wrapper_code = """
+def run_sympy_verification():
+    # Import SymPy
+    from sympy import *
+    
+    # Define standard helper functions
+    def safe_print_expr(label, expr):
+        print(label)
+        if expr is not None:
+            try:
+                float_val = float(expr)
+                print(float_val)
+            except:
+                print(expr)
+
+    # Start user code
 """
         
-        # Replace f-string prints with safe prints
-        sympy_code = safe_print_setup + sympy_code
-        sympy_code = sympy_code.replace('print(f"', 'safe_print_expr("')
+        # Indent the original code
+        indented_code = '\n'.join('    ' + line for line in sympy_code.split('\n'))
+        
+        # Add the execution call
+        full_code = wrapper_code + indented_code + "\n\n# Execute verification\nrun_sympy_verification()"
         
         # Set up basic SymPy environment
         import io
@@ -551,7 +529,10 @@ def safe_print_expr(label, expr):
             "sympy": sympy,
             "Symbol": sympy.Symbol,
             "solve": sympy.solve,
+            "sqrt": sympy.sqrt,
+            "pi": sympy.pi,
             "diff": sympy.diff,
+            "integrate": sympy.integrate,
             "simplify": sympy.simplify,
             "print": print,
             "float": float
@@ -560,7 +541,7 @@ def safe_print_expr(label, expr):
         # Capture output
         output_buffer = io.StringIO()
         with redirect_stdout(output_buffer):
-            exec(sympy_code, globals_dict)
+            exec(full_code, globals_dict)
             
         return output_buffer.getvalue().strip() or "No output produced"