Update app.py

app.py

@@ -38,18 +38,57 @@ def load_proof_repository():
         logger.error(f"Error loading proof repository: {str(e)}")
         return None
 
+TOPIC_MAPPINGS = {
+    "integration": ["integral", "integrable", "riemann", "integrate", "antiderivative"],
+    "continuity": ["continuous", "discontinuous", "discontinuity", "uniformly continuous"],
+    "sequences": ["sequence", "convergent", "divergent", "monotone", "subsequence"],
+    "series": ["series", "sum", "convergent series", "power series"],
+    "differentiation": ["derivative", "differentiable", "differential"],
+    "limits": ["limit", "cluster point", "accumulation"],
+    "functions": ["function", "mapping", "surjective", "injective", "bijective"],
+    "bounded": ["bound", "bounded above", "bounded below", "supremum", "infimum"]
+}
+
+def get_related_terms(topic):
+    """Get all related terms for a given topic"""
+    # Get direct mappings
+    related = TOPIC_MAPPINGS.get(topic.lower(), [])
+    # Add the original topic
+    related.append(topic.lower())
+    # Remove duplicates while preserving order
+    return list(dict.fromkeys(related))
+
+def matches_topic(text, topic_terms):
+    """Check if any topic terms appear in the text"""
+    text_lower = text.lower()
+    return any(term in text_lower for term in topic_terms)
+
 def get_relevant_proofs(topic):
     """Get relevant proofs from repository based on topic, randomly selecting examples"""
     repository = load_proof_repository()
     if not repository:
+        logger.error("Failed to load proof repository")
         return []
     
-    # Extract relevant proofs based on topic
+    logger.debug(f"Searching for proofs related to topic: {topic}")
+    topic_terms = get_related_terms(topic)
+    logger.debug(f"Related terms: {topic_terms}")
+    
     relevant_proofs = []
     for theorem in repository.get("dataset", {}).get("theorems", []):
-        # Add proofs that match the topic
-        if any(topic.lower() in content.lower() for content in theorem.get("contents", [])):
-            # Only include if it has both contents and proofs
+        # Check categories
+        categories = theorem.get("categories", [])
+        category_match = any(matches_topic(cat, topic_terms) for cat in categories)
+        
+        # Check contents
+        contents = theorem.get("contents", [])
+        content_match = any(matches_topic(content, topic_terms) for content in contents)
+        
+        # Check title
+        title = theorem.get("title", "")
+        title_match = matches_topic(title, topic_terms)
+        
+        if (category_match or content_match or title_match):
             if theorem.get("contents") and theorem.get("proofs"):
                 proof_content = {
                     "title": theorem.get("title", ""),
@@ -57,32 +96,46 @@ def get_relevant_proofs(topic):
                     "proofs": [p.get("contents", []) for p in theorem.get("proofs", [])]
                 }
                 relevant_proofs.append(proof_content)
+                logger.debug(f"Found matching proof: {proof_content['title']}")
+                logger.debug(f"Matched via: {'categories' if category_match else 'contents' if content_match else 'title'}")
+
+    logger.debug(f"Found {len(relevant_proofs)} relevant proofs before sampling")
     
     # Randomly select 3 proofs if we have more than 3
     if len(relevant_proofs) > 3:
-        return random.sample(relevant_proofs, 3)
+        selected = random.sample(relevant_proofs, 3)
+        logger.debug("Selected proofs for enhancement:")
+        for proof in selected:
+            logger.debug(f"- {proof['title']}")
+        return selected
     return relevant_proofs
-
+    
 def enhance_prompt_with_proofs(system_prompt, subject, topic):
     """Enhance the system prompt with relevant proofs if subject is Real Analysis"""
     if subject != "Real Analysis":
+        logger.debug("Skipping proof enhancement - not Real Analysis")
         return system_prompt
         
     relevant_proofs = get_relevant_proofs(topic)
     if not relevant_proofs:
+        logger.debug(f"No relevant proofs found for topic: {topic}")
         return system_prompt
-        
+    
+    logger.debug(f"Enhancing prompt with {len(relevant_proofs)} proofs")
+    
     # Add proof examples to the prompt
     proof_examples = "\n\nReference these proof examples for style and approach:\n"
-    for proof in relevant_proofs[:3]:  # Limit to 3 examples to manage token usage
+    for proof in relevant_proofs:
+        logger.debug(f"Adding proof: {proof['title']}")
         proof_examples += f"\nTheorem: {proof['title']}\n"
         proof_examples += "Statement: " + " ".join(proof['contents']) + "\n"
         if proof['proofs']:
-            proof_examples += "Proof: " + " ".join(proof['proofs'][0]) + "\n"
-            
+            first_proof = " ".join(proof['proofs'][0])
+            logger.debug(f"Proof length: {len(first_proof)} characters")
+            proof_examples += "Proof: " + first_proof + "\n"
+    
     # Add specific instructions for using the examples
-    enhanced_prompt = f"""
-{system_prompt}
+    enhanced_prompt = f"""{system_prompt}
 
 ADDITIONAL PROOF GUIDELINES:
 1. Consider the following proof examples from established textbooks
@@ -90,9 +143,10 @@ ADDITIONAL PROOF GUIDELINES:
 3. Use similar proof techniques where applicable
 4. Follow similar notation and presentation style
 
-{proof_examples}
-"""
-    return enhanced_prompt            
+{proof_examples}"""
+    
+    return enhanced_prompt
+    
 
 def get_difficulty_parameters(difficulty_level):
     """Return specific parameters and constraints based on difficulty level"""