Spaces:
Sleeping
Sleeping
| import os | |
| import gradio as gr | |
| from anthropic import Anthropic | |
| import wolframalpha | |
| from datetime import datetime, timedelta | |
| from collections import deque | |
| import re | |
| # Initialize clients | |
| anthropic = Anthropic(api_key=os.environ.get('ANTHROPIC_API_KEY')) | |
| wolfram_client = wolframalpha.Client(os.environ.get('WOLFRAM_APPID')) | |
| def parse_questions(content): | |
| """Parse questions and their solutions from Claude's output""" | |
| questions = [] | |
| current_question = {} | |
| # Split content into lines for more reliable parsing | |
| lines = content.split('\n') | |
| for line in lines: | |
| # Start of new question | |
| if re.match(r'^\s*\d+\)', line): | |
| if current_question: | |
| questions.append(current_question) | |
| current_question = { | |
| 'number': re.match(r'^\s*(\d+)\)', line).group(1), | |
| 'problem': line.split(')', 1)[1].strip(), | |
| 'solution': '', | |
| 'final_answer': None | |
| } | |
| # Solution marker | |
| elif 'Solution:' in line and current_question: | |
| current_question['problem'] = current_question['problem'].strip() | |
| current_question['solution'] = line.split('Solution:', 1)[1].strip() | |
| # Add to current problem or solution | |
| elif current_question: | |
| if current_question['solution']: | |
| current_question['solution'] += '\n' + line | |
| else: | |
| current_question['problem'] += '\n' + line | |
| # Extract final answer | |
| if current_question and 'final answer' in line.lower(): | |
| matches = re.findall(r'[-+]?(?:\d*\.)?\d+', line) | |
| if matches: | |
| current_question['final_answer'] = matches[-1] | |
| # Add last question | |
| if current_question: | |
| questions.append(current_question) | |
| # Clean up questions | |
| for q in questions: | |
| q['problem'] = q['problem'].strip() | |
| q['solution'] = q['solution'].strip() | |
| return questions | |
| def verify_solution(problem, answer): | |
| """Verify a mathematical solution using Wolfram Alpha""" | |
| try: | |
| # Initialize query variable | |
| query = "" | |
| # Clean the problem text first | |
| clean_problem = problem.replace('$$', '').replace('$', '').strip() | |
| # Case 1: Definite Integral | |
| if 'integral' in clean_problem.lower() or '∫' in clean_problem or '\int' in clean_problem: | |
| # Use raw string for regex to avoid escape issues | |
| integrand_match = re.search(r'(?:\int|∫)_(\d+)\^(\d+)\s*\(?([\dx+\s]+)\)?\s*dx', clean_problem, re.UNICODE) | |
| if integrand_match: | |
| lower, upper, integrand = integrand_match.groups() | |
| # Clean up the integrand | |
| integrand = integrand.replace(' ', '') | |
| query = f"integrate {integrand} from {lower} to {upper}" | |
| print(f"Integral query: {query}") | |
| else: | |
| # Fallback for simpler pattern | |
| integrand_match = re.search(r'(?:\int|∫).*?\(([\dx+\s]+)\)\s*dx', clean_problem, re.UNICODE) | |
| if integrand_match: | |
| integrand = integrand_match.group(1).replace(' ', '') | |
| query = f"integrate {integrand} from 0 to 1" # Common default bounds | |
| print(f"Fallback integral query: {query}") | |
| # Case 2: Simple Differentiation | |
| elif 'derivative' in clean_problem.lower() or 'd/dx' in clean_problem: | |
| # Look for function after equals sign or f(x) = | |
| func_match = re.search(r'[f\(x\)\s*=\s*](.*?)$', clean_problem) | |
| if func_match: | |
| func = func_match.group(1).strip() | |
| query = f"derivative of {func}" | |
| print(f"Derivative query: {query}") | |
| # Case 3: Mean Value Theorem | |
| elif 'Mean Value Theorem' in clean_problem: | |
| func_match = re.search(r'f\(x\)\s*=\s*(.*?)\s+on', clean_problem) | |
| interval_match = re.search(r'\[(\d+),\s*(\d+)\]', clean_problem) | |
| if func_match and interval_match: | |
| func = func_match.group(1).strip() | |
| a, b = interval_match.groups() | |
| # Calculate f'(x) first | |
| derivative_query = f"derivative of {func}" | |
| print(f"MVT derivative query: {derivative_query}") | |
| derivative_result = wolfram_client.query(derivative_query) | |
| if derivative_result.success: | |
| for pod in derivative_result.pods: | |
| if pod.title in ['Derivative']: | |
| derivative = pod.text | |
| # Now calculate [f(b) - f(a)]/(b-a) | |
| query = f"solve {derivative} = ({func.replace('x', b)} - {func.replace('x', a)})/({b} - {a})" | |
| print(f"MVT final query: {query}") | |
| break | |
| # Ensure query is not empty | |
| if not query.strip(): | |
| return { | |
| 'verified': False, | |
| 'wolfram_solution': None, | |
| 'error': "Could not generate valid query from problem" | |
| } | |
| print(f"Final query to Wolfram Alpha: {query}") | |
| result = wolfram_client.query(query) | |
| if not result.success: | |
| return { | |
| 'verified': False, | |
| 'wolfram_solution': None, | |
| 'error': f"Wolfram Alpha could not process query: {query}" | |
| } | |
| # Process the result | |
| for pod in result.pods: | |
| if pod.title in ['Result', 'Solution', 'Numerical result', 'Decimal approximation', 'Definite integral', 'Solutions']: | |
| wolfram_answer = pod.text | |
| print(f"Wolfram pod {pod.title}: {wolfram_answer}") | |
| # For MVT problems, handle sqrt expressions | |
| if 'Mean Value Theorem' in clean_problem: | |
| # Convert both answers to decimal for comparison | |
| if 'sqrt' in str(answer).lower(): | |
| # Convert sqrt expression to decimal | |
| sqrt_match = re.search(r'sqrt\((\d+)/(\d+)\)', str(answer)) | |
| if sqrt_match: | |
| num, denom = map(float, sqrt_match.groups()) | |
| user_value = (num/denom)**0.5 | |
| # Look for decimal in Wolfram result | |
| wolfram_nums = re.findall(r'[-+]?(?:\d*\.)?\d+', wolfram_answer) | |
| if wolfram_nums: | |
| wolfram_value = float(wolfram_nums[0]) | |
| is_verified = abs(wolfram_value - user_value) < 0.01 | |
| return { | |
| 'verified': is_verified, | |
| 'wolfram_solution': wolfram_answer, | |
| 'error': None | |
| } | |
| # Handle numerical answers | |
| if str(answer).replace('.', '').isdigit(): | |
| wolfram_nums = re.findall(r'[-+]?(?:\d*\.)?\d+', wolfram_answer) | |
| if wolfram_nums: | |
| wolfram_value = float(wolfram_nums[0]) | |
| user_value = float(answer) | |
| is_verified = abs(wolfram_value - user_value) < 0.01 | |
| return { | |
| 'verified': is_verified, | |
| 'wolfram_solution': wolfram_answer, | |
| 'error': None | |
| } | |
| # Handle symbolic answers | |
| else: | |
| clean_wolfram = re.sub(r'\s+', '', wolfram_answer.lower()) | |
| clean_answer = re.sub(r'\s+', '', str(answer).lower()) | |
| is_verified = clean_wolfram == clean_answer | |
| return { | |
| 'verified': is_verified, | |
| 'wolfram_solution': wolfram_answer, | |
| 'error': None | |
| } | |
| return { | |
| 'verified': False, | |
| 'wolfram_solution': None, | |
| 'error': "No suitable solution found in Wolfram Alpha response" | |
| } | |
| except Exception as e: | |
| error_msg = f"Error during verification: {str(e)}" | |
| if query: | |
| error_msg += f"\nQuery attempted: {query}" | |
| return { | |
| 'verified': False, | |
| 'wolfram_solution': None, | |
| 'error': error_msg | |
| } | |
| def generate_test(subject): | |
| """Generate and verify a math test""" | |
| try: | |
| system_prompt = """Generate 3 university-level math questions that can be verified numerically. | |
| For each question: | |
| 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.) | |
| 7. Make sure problems have clear numerical answers | |
| 8. Avoid word problems - focus on pure mathematical expressions""" | |
| message = anthropic.messages.create( | |
| model="claude-3-opus-20240229", | |
| max_tokens=1500, | |
| temperature=0.7, | |
| messages=[{ | |
| "role": "user", | |
| "content": f"{system_prompt}\n\nWrite an exam for {subject} with simple numerical answers." | |
| }] | |
| ) | |
| # 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 = [] | |
| for q in questions: | |
| if q['final_answer'] is not None: | |
| 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 result: {result['wolfram_solution']}\n" | |
| if result['error']: | |
| verification_note += f"Note: {result['error']}\n" | |
| else: | |
| verification_note += f"\nQuestion {q['number']}:\n⚠️ Could not extract final answer\n" | |
| # Add usage statistics | |
| usage_stats = f""" | |
| \n---\nUsage Statistics: | |
| • Input Tokens: {message.usage.input_tokens:,} | |
| • Output Tokens: {message.usage.output_tokens:,} | |
| • Wolfram Alpha calls: {len(verification_results)} | |
| Cost Breakdown: | |
| • Claude Cost: ${((message.usage.input_tokens / 1000) * 0.015) + ((message.usage.output_tokens / 1000) * 0.075):.4f} | |
| • Wolfram API calls: {len(verification_results)} | |
| """ | |
| # 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)}" | |
| 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() |