Fix

app.py

@@ -22,13 +22,13 @@ DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
 @tool
 def serper_search(query: str) -> str:
-    """Enhanced web search using Serper API with better result processing.
+    """Enhanced web search using Serper API with comprehensive result processing.
     
     Args:
         query (str): The search query to be executed.
         
     Returns:
-        str: Formatted search results with relevance scoring.
+        str: Detailed search results with structured information.
     """
     try:
         api_key = os.getenv("SERPER_API_KEY")
@@ -36,51 +36,82 @@ def serper_search(query: str) -> str:
             return "SERPER_API_KEY environment variable not found"
             
         url = "https://google.serper.dev/search"
-        payload = json.dumps({"q": query, "num": 10})
+        payload = json.dumps({
+            "q": query, 
+            "num": 12,
+            "hl": "en",
+            "gl": "us"
+        })
         headers = {
             'X-API-KEY': api_key,
             'Content-Type': 'application/json'
         }
+        
         response = requests.post(url, headers=headers, data=payload, timeout=30)
         response.raise_for_status()
         
         data = response.json()
         results = []
         
+        # Knowledge Graph extraction
         if 'knowledgeGraph' in data:
             kg = data['knowledgeGraph']
-            kg_info = f"KNOWLEDGE GRAPH: {kg.get('title', '')} - {kg.get('description', '')}"
-            if 'attributes' in kg:
-                for key, value in kg['attributes'].items():
-                    kg_info += f"\n{key}: {value}"
+            kg_info = f"KNOWLEDGE GRAPH:\nTitle: {kg.get('title', 'N/A')}\nDescription: {kg.get('description', 'N/A')}"
+            
+            if 'attributes' in kg and kg['attributes']:
+                kg_info += "\nKey Facts:"
+                for key, value in list(kg['attributes'].items())[:5]:
+                    kg_info += f"\n• {key}: {value}"
+            
+            if 'entityType' in kg:
+                kg_info += f"\nType: {kg['entityType']}"
+                
             results.append(kg_info + "\n")
         
+        # Organic search results
         if 'organic' in data:
-            for i, item in enumerate(data['organic'][:7]):
-                title = item.get('title', '')
-                snippet = item.get('snippet', '')
-                link = item.get('link', '')
-                result_text = f"RESULT {i+1}:\nTitle: {title}\nSnippet: {snippet}\nURL: {link}\n"
+            for i, item in enumerate(data['organic'][:8]):
+                title = item.get('title', 'No title')
+                snippet = item.get('snippet', 'No snippet')
+                link = item.get('link', 'No link')
                 
-                if re.search(r'\d{4}', snippet):
+                result_text = f"RESULT {i+1}:\nTitle: {title}\nSnippet: {snippet}\nURL: {link}"
+                
+                # Extract specific data patterns
+                if re.search(r'\b(19|20)\d{2}\b', snippet):
                     years = re.findall(r'\b(19|20)\d{2}\b', snippet)
-                    if years:
-                        result_text += f"Years mentioned: {', '.join(years)}\n"
+                    result_text += f"\nYears mentioned: {', '.join(set(years))}"
+                
+                if re.search(r'\$[\d,]+(?:\.\d{2})?|\d+(?:,\d{3})*(?:\.\d{2})?\s*(?:million|billion|thousand)', snippet, re.IGNORECASE):
+                    amounts = re.findall(r'\$[\d,]+(?:\.\d{2})?|\d+(?:,\d{3})*(?:\.\d{2})?\s*(?:million|billion|thousand)', snippet, re.IGNORECASE)
+                    result_text += f"\nAmounts: {', '.join(amounts[:3])}"
                 
-                if re.search(r'\$[\d,]+', snippet):
-                    amounts = re.findall(r'\$[\d,]+(?:\.\d{2})?', snippet)
-                    if amounts:
-                        result_text += f"Amounts: {', '.join(amounts)}\n"
+                if re.search(r'\b\d+(?:\.\d+)?\s*(?:albums?|songs?|tracks?|records?)\b', snippet, re.IGNORECASE):
+                    music_counts = re.findall(r'\b\d+(?:\.\d+)?\s*(?:albums?|songs?|tracks?|records?)\b', snippet, re.IGNORECASE)
+                    result_text += f"\nMusic counts: {', '.join(music_counts[:3])}"
                 
                 results.append(result_text)
         
+        # People Also Ask section
         if 'peopleAlsoAsk' in data:
-            paa = "\nPEOPLE ALSO ASK:\n"
-            for item in data['peopleAlsoAsk'][:3]:
-                paa += f"Q: {item.get('question', '')}\nA: {item.get('snippet', '')}\n"
+            paa = "\nPEOPLE ALSO ASK:"
+            for item in data['peopleAlsoAsk'][:4]:
+                question = item.get('question', '')
+                answer = item.get('snippet', '')
+                paa += f"\nQ: {question}\nA: {answer[:150]}..."
             results.append(paa)
         
-        return "\n".join(results) if results else "No results found"
+        # News results if available
+        if 'news' in data:
+            news_section = "\nNEWS RESULTS:"
+            for item in data['news'][:3]:
+                title = item.get('title', '')
+                snippet = item.get('snippet', '')
+                date = item.get('date', '')
+                news_section += f"\n• {title} ({date}): {snippet[:100]}..."
+            results.append(news_section)
+        
+        return "\n\n".join(results) if results else "No search results found"
         
     except Exception as e:
         return f"Search error: {str(e)}"
@@ -88,17 +119,19 @@ def serper_search(query: str) -> str:
 
 @tool
 def wikipedia_search(query: str) -> str:
-    """Enhanced Wikipedia search with multiple strategies.
+    """Comprehensive Wikipedia search with multiple API endpoints.
     
     Args:
-        query (str): Wikipedia search query to look up.
+        query (str): Wikipedia search query.
         
     Returns:
-        str: Comprehensive Wikipedia information.
+        str: Detailed Wikipedia information.
     """
     try:
         results = []
-        clean_query = query.replace(" ", "_")
+        
+        # Direct page lookup
+        clean_query = urllib.parse.quote(query.replace(" ", "_"))
         direct_url = f"https://en.wikipedia.org/api/rest_v1/page/summary/{clean_query}"
         
         try:
@@ -106,33 +139,42 @@ def wikipedia_search(query: str) -> str:
             if response.status_code == 200:
                 data = response.json()
                 if data.get('type') != 'disambiguation':
-                    summary = f"WIKIPEDIA DIRECT MATCH:\nTitle: {data.get('title', '')}\n"
-                    summary += f"Extract: {data.get('extract', '')}\n"
+                    summary = f"WIKIPEDIA DIRECT MATCH:\nTitle: {data.get('title', 'N/A')}"
+                    extract = data.get('extract', '')
+                    summary += f"\nExtract: {extract}"
+                    
+                    # Extract key dates and facts
+                    if extract:
+                        birth_dates = re.findall(r'born[^)]*?(\d{1,2}\s+\w+\s+\d{4})', extract, re.IGNORECASE)
+                        if birth_dates:
+                            summary += f"\nBirth: {birth_dates[0]}"
+                        
+                        death_dates = re.findall(r'died[^)]*?(\d{1,2}\s+\w+\s+\d{4})', extract, re.IGNORECASE)
+                        if death_dates:
+                            summary += f"\nDeath: {death_dates[0]}"
+                        
+                        # Extract discography info
+                        album_counts = re.findall(r'(\d+)\s+(?:studio\s+)?albums?', extract, re.IGNORECASE)
+                        if album_counts:
+                            summary += f"\nAlbums mentioned: {', '.join(album_counts)}"
                     
                     if 'coordinates' in data:
                         coords = data['coordinates']
-                        summary += f"Coordinates: {coords.get('lat', '')}, {coords.get('lon', '')}\n"
-                    
-                    extract = data.get('extract', '')
-                    birth_match = re.search(r'born[^)]*(\d{1,2}\s+\w+\s+\d{4})', extract, re.IGNORECASE)
-                    if birth_match:
-                        summary += f"Birth date found: {birth_match.group(1)}\n"
-                    
-                    death_match = re.search(r'died[^)]*(\d{1,2}\s+\w+\s+\d{4})', extract, re.IGNORECASE)
-                    if death_match:
-                        summary += f"Death date found: {death_match.group(1)}\n"
+                        summary += f"\nCoordinates: {coords.get('lat', '')}, {coords.get('lon', '')}"
                     
                     results.append(summary)
         except:
             pass
         
+        # Search API
         search_url = "https://en.wikipedia.org/w/api.php"
         search_params = {
             "action": "query",
             "format": "json",
             "list": "search",
             "srsearch": query,
-            "srlimit": 5
+            "srlimit": 8,
+            "srprop": "snippet|titlesnippet|size|wordcount"
         }
         
         try:
@@ -140,34 +182,42 @@ def wikipedia_search(query: str) -> str:
             data = response.json()
             
             if 'query' in data and 'search' in data['query']:
-                search_results = "WIKIPEDIA SEARCH RESULTS:\n"
-                for item in data['query']['search']:
+                search_results = "WIKIPEDIA SEARCH RESULTS:"
+                for i, item in enumerate(data['query']['search']):
+                    title = item.get('title', '')
                     snippet = re.sub(r'<[^>]+>', '', item.get('snippet', ''))
-                    search_results += f"• {item['title']}: {snippet}\n"
+                    wordcount = item.get('wordcount', 0)
+                    
+                    search_results += f"\n{i+1}. {title} ({wordcount} words)"
+                    if snippet:
+                        search_results += f"\n   {snippet[:200]}..."
+                
                 results.append(search_results)
         except:
             pass
         
-        opensearch_url = "https://en.wikipedia.org/w/api.php"
-        opensearch_params = {
-            "action": "opensearch",
-            "search": query,
-            "limit": 3,
-            "format": "json"
-        }
-        
-        try:
-            response = requests.get(opensearch_url, params=opensearch_params, timeout=10)
-            data = response.json()
-            if len(data) >= 4 and data[1]:
-                suggestions = "WIKIPEDIA SUGGESTIONS:\n"
-                for i, (title, desc, url) in enumerate(zip(data[1], data[2], data[3])):
-                    suggestions += f"{i+1}. {title}: {desc}\n"
-                results.append(suggestions)
-        except:
-            pass
+        # Category search for specific topics
+        if any(term in query.lower() for term in ['dinosaur', 'paleontology', 'fossil']):
+            try:
+                category_params = {
+                    "action": "query",
+                    "format": "json",
+                    "list": "categorymembers",
+                    "cmtitle": "Category:Dinosaurs",
+                    "cmlimit": 5
+                }
+                response = requests.get(search_url, params=category_params, timeout=10)
+                cat_data = response.json()
+                
+                if 'query' in cat_data and 'categorymembers' in cat_data['query']:
+                    cat_results = "\nDINOSAUR CATEGORY RESULTS:"
+                    for item in cat_data['query']['categorymembers']:
+                        cat_results += f"\n• {item.get('title', '')}"
+                    results.append(cat_results)
+            except:
+                pass
         
-        return "\n".join(results) if results else "No Wikipedia results found"
+        return "\n\n".join(results) if results else "No Wikipedia results found"
         
     except Exception as e:
         return f"Wikipedia search error: {str(e)}"
@@ -175,7 +225,7 @@ def wikipedia_search(query: str) -> str:
 
 @tool
 def youtube_analyzer(url: str) -> str:
-    """Enhanced YouTube video analyzer with transcript extraction.
+    """Advanced YouTube video analyzer with transcript and metadata extraction.
     
     Args:
         url (str): YouTube video URL to analyze.
@@ -184,6 +234,7 @@ def youtube_analyzer(url: str) -> str:
         str: Comprehensive video analysis.
     """
     try:
+        # Extract video ID
         video_id_match = re.search(r'(?:v=|/|youtu\.be/)([A-Za-z0-9_-]{11})', url)
         if not video_id_match:
             return "Invalid YouTube URL format"
@@ -191,70 +242,126 @@ def youtube_analyzer(url: str) -> str:
         video_id = video_id_match.group(1)
         results = []
         
+        # Basic video info via oEmbed
         try:
             oembed_url = f"https://www.youtube.com/oembed?url=https://www.youtube.com/watch?v={video_id}&format=json"
             response = requests.get(oembed_url, timeout=15)
             
             if response.status_code == 200:
                 data = response.json()
-                basic_info = f"VIDEO INFO:\nTitle: {data.get('title', '')}\nAuthor: {data.get('author_name', '')}\n"
+                basic_info = f"VIDEO METADATA:\nTitle: {data.get('title', 'N/A')}\nAuthor: {data.get('author_name', 'N/A')}"
                 
+                # Extract duration from title if mentioned
                 title = data.get('title', '').lower()
-                if 'minute' in title or 'min' in title:
-                    duration_match = re.search(r'(\d+)\s*(?:minute|min)', title)
+                duration_patterns = [
+                    r'(\d+)\s*(?:minutes?|mins?)',
+                    r'(\d+)\s*(?:hours?|hrs?)',
+                    r'(\d+:\d+)'
+                ]
+                
+                for pattern in duration_patterns:
+                    duration_match = re.search(pattern, title)
                     if duration_match:
-                        basic_info += f"Duration mentioned: {duration_match.group(1)} minutes\n"
+                        basic_info += f"\nDuration mentioned in title: {duration_match.group(1)}"
+                        break
                 
                 results.append(basic_info)
-        except:
-            pass
+        except Exception as e:
+            results.append(f"oEmbed error: {str(e)}")
         
+        # Enhanced page scraping
         try:
-            video_url = f"https://www.youtube.com/watch?v={video_id}"
             headers = {
-                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+                'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
+                'Accept-Language': 'en-US,en;q=0.5',
+                'Accept-Encoding': 'gzip, deflate',
+                'Connection': 'keep-alive',
+                'Upgrade-Insecure-Requests': '1'
             }
             
-            response = requests.get(video_url, headers=headers, timeout=20)
+            video_url = f"https://www.youtube.com/watch?v={video_id}"
+            response = requests.get(video_url, headers=headers, timeout=25)
+            
             if response.status_code == 200:
                 content = response.text
                 
-                view_match = re.search(r'"viewCount":"(\d+)"', content)
-                if view_match:
-                    views = int(view_match.group(1))
-                    results.append(f"View count: {views:,}")
+                # Extract view count
+                view_patterns = [
+                    r'"viewCount":"(\d+)"',
+                    r'"viewCount":{"simpleText":"([\d,]+)\s+views"}'
+                ]
                 
-                upload_match = re.search(r'"uploadDate":"([^"]+)"', content)
-                if upload_match:
-                    results.append(f"Upload date: {upload_match.group(1)}")
+                for pattern in view_patterns:
+                    view_match = re.search(pattern, content)
+                    if view_match:
+                        views = view_match.group(1).replace(',', '')
+                        try:
+                            view_count = int(views)
+                            results.append(f"VIEW COUNT: {view_count:,}")
+                        except:
+                            results.append(f"VIEW COUNT: {views}")
+                        break
                 
-                content_lower = content.lower()
+                # Extract upload date
+                upload_patterns = [
+                    r'"uploadDate":"([^"]+)"',
+                    r'"publishDate":"([^"]+)"'
+                ]
                 
-                if "bird" in content_lower:
-                    bird_numbers = re.findall(r'\b(\d+)\s+(?:bird|species|individual)', content_lower)
-                    if bird_numbers:
-                        results.append(f"Bird counts found: {', '.join(bird_numbers)}")
+                for pattern in upload_patterns:
+                    upload_match = re.search(pattern, content)
+                    if upload_match:
+                        results.append(f"UPLOAD DATE: {upload_match.group(1)}")
+                        break
                 
-                duration_match = re.search(r'"duration":"PT(\d+)M(\d+)S"', content)
+                # Extract exact duration
+                duration_match = re.search(r'"lengthSeconds":"(\d+)"', content)
                 if duration_match:
-                    minutes = int(duration_match.group(1))
-                    seconds = int(duration_match.group(2))
-                    results.append(f"Exact duration: {minutes}:{seconds:02d}")
+                    seconds = int(duration_match.group(1))
+                    minutes = seconds // 60
+                    secs = seconds % 60
+                    results.append(f"DURATION: {minutes}:{secs:02d} ({seconds} seconds)")
                 
+                # Enhanced description extraction
                 desc_patterns = [
                     r'"description":{"simpleText":"([^"]+)"}',
-                    r'"shortDescription":"([^"]+)"'
+                    r'"shortDescription":"([^"]+)"',
+                    r'"attributedDescription":{"content":"([^"]+)"}'
                 ]
                 
                 for pattern in desc_patterns:
                     desc_match = re.search(pattern, content)
                     if desc_match:
-                        description = desc_match.group(1)[:500]
-                        results.append(f"Description excerpt: {description}")
+                        description = desc_match.group(1)
+                        # Look for specific content patterns
+                        if 'bird' in description.lower():
+                            bird_numbers = re.findall(r'\b(\d+)\s+(?:bird|species|individual)', description.lower())
+                            if bird_numbers:
+                                results.append(f"BIRD COUNTS IN DESCRIPTION: {', '.join(bird_numbers)}")
+                        
+                        results.append(f"DESCRIPTION EXCERPT: {description[:300]}...")
                         break
+                
+                # Look for transcript indicators
+                if 'transcript' in content.lower() or 'captions' in content.lower():
+                    results.append("TRANSCRIPT: Available (captions detected)")
+                
+                # Extract channel info
+                channel_match = re.search(r'"author":"([^"]+)"', content)
+                if channel_match:
+                    results.append(f"CHANNEL: {channel_match.group(1)}")
         
         except Exception as e:
-            results.append(f"Enhanced analysis error: {str(e)}")
+            results.append(f"Enhanced scraping error: {str(e)}")
+        
+        # Attempt to find related content
+        try:
+            search_query = f"site:youtube.com \"{video_id}\" transcript OR captions OR subtitles"
+            # This would be handled by the main search function
+            results.append(f"SEARCH SUGGESTION: {search_query}")
+        except:
+            pass
         
         return "\n".join(results) if results else "Could not analyze video"
         
@@ -264,12 +371,11 @@ def youtube_analyzer(url: str) -> str:
 
 @tool
 def text_processor(text: str, operation: str = "analyze") -> str:
-    """Advanced text processing for various linguistic operations.
+    """Advanced text processing with multiple linguistic operations.
     
     Args:
         text (str): Text to process.
-        operation (str, optional): Operation type (reverse, parse, analyze, extract_numbers, decode). 
-                                  Defaults to "analyze".
+        operation (str): Operation type (reverse, decode, analyze, extract_numbers, parse).
         
     Returns:
         str: Processed text results.
@@ -279,21 +385,32 @@ def text_processor(text: str, operation: str = "analyze") -> str:
             return text[::-1]
         
         elif operation == "decode":
+            # Base64 decoding
             if text.startswith("base64:"):
                 try:
                     decoded = base64.b64decode(text[7:]).decode('utf-8')
                     return f"Base64 decoded: {decoded}"
-                except:
-                    return "Failed to decode base64"
+                except Exception as e:
+                    return f"Base64 decode failed: {str(e)}"
             
+            # URL decoding
             if '%' in text:
                 try:
                     decoded = urllib.parse.unquote(text)
                     return f"URL decoded: {decoded}"
+                except Exception as e:
+                    return f"URL decode failed: {str(e)}"
+            
+            # Hex decoding
+            if re.match(r'^[0-9a-fA-F]+$', text.replace(' ', '')):
+                try:
+                    hex_text = text.replace(' ', '')
+                    decoded = bytes.fromhex(hex_text).decode('utf-8')
+                    return f"Hex decoded: {decoded}"
                 except:
-                    return "Failed to decode URL"
+                    pass
             
-            return f"No encoding detected in: {text[:100]}"
+            return f"No recognized encoding in: {text[:100]}"
         
         elif operation == "extract_numbers":
             patterns = {
@@ -301,39 +418,60 @@ def text_processor(text: str, operation: str = "analyze") -> str:
                 'decimals': re.findall(r'\b\d+\.\d+\b', text),
                 'years': re.findall(r'\b(19|20)\d{2}\b', text),
                 'percentages': re.findall(r'\b\d+(?:\.\d+)?%', text),
-                'currencies': re.findall(r'\$[\d,]+(?:\.\d{2})?', text)
+                'currencies': re.findall(r'\$[\d,]+(?:\.\d{2})?', text),
+                'ranges': re.findall(r'\b\d+[-–]\d+\b', text),
+                'ordinals': re.findall(r'\b\d+(?:st|nd|rd|th)\b', text, re.IGNORECASE)
             }
             
             result = "EXTRACTED NUMBERS:\n"
             for category, matches in patterns.items():
                 if matches:
-                    result += f"{category.title()}: {', '.join(matches)}\n"
+                    unique_matches = list(set(matches))
+                    result += f"{category.title()}: {', '.join(unique_matches)}\n"
             
-            return result
+            return result if any(patterns.values()) else "No numbers found"
         
         elif operation == "parse":
             words = text.split()
             sentences = re.split(r'[.!?]+', text)
+            clean_sentences = [s.strip() for s in sentences if s.strip()]
             
             analysis = f"TEXT ANALYSIS:\n"
             analysis += f"Character count: {len(text)}\n"
             analysis += f"Word count: {len(words)}\n"
-            analysis += f"Sentence count: {len([s for s in sentences if s.strip()])}\n"
+            analysis += f"Sentence count: {len(clean_sentences)}\n"
             
             if words:
-                analysis += f"First word: {words[0]}\n"
-                analysis += f"Last word: {words[-1]}\n"
-                analysis += f"Longest word: {max(words, key=len)}\n"
+                analysis += f"First word: '{words[0]}'\n"
+                analysis += f"Last word: '{words[-1]}'\n"
+                analysis += f"Longest word: '{max(words, key=len)}' ({len(max(words, key=len))} chars)\n"
+                
+                # Word frequency
+                word_freq = {}
+                for word in words:
+                    word_lower = word.lower().strip('.,!?";')
+                    word_freq[word_lower] = word_freq.get(word_lower, 0) + 1
+                
+                if word_freq:
+                    most_common = max(word_freq.items(), key=lambda x: x[1])
+                    analysis += f"Most frequent word: '{most_common[0]}' ({most_common[1]} times)\n"
             
+            # Language detection patterns
             if re.search(r'[А-Яа-я]', text):
-                analysis += "Cyrillic characters detected (Russian/Slavic)\n"
-            if re.search(r'[À-ÿ]', text):
-                analysis += "Extended Latin characters detected\n"
+                analysis += "Language: Cyrillic characters detected (Russian/Slavic)\n"
+            elif re.search(r'[À-ÿ]', text):
+                analysis += "Language: Extended Latin characters detected\n"
+            elif re.search(r'[一-龯]', text):
+                analysis += "Language: Chinese characters detected\n"
+            else:
+                analysis += "Language: Appears to be English/Latin script\n"
             
             return analysis
         
-        else:
-            return f"Text length: {len(text)} characters\nPreview: {text[:200]}{'...' if len(text) > 200 else ''}"
+        else:  # default analyze
+            length = len(text)
+            preview = text[:200] + ('...' if length > 200 else '')
+            return f"TEXT PREVIEW:\nLength: {length} characters\nContent: {preview}"
             
     except Exception as e:
         return f"Text processing error: {str(e)}"
@@ -341,90 +479,185 @@ def text_processor(text: str, operation: str = "analyze") -> str:
 
 @tool
 def math_solver(problem: str) -> str:
-    """Advanced mathematical problem solver with multiple strategies.
+    """Advanced mathematical problem solver with domain-specific strategies.
     
     Args:
         problem (str): Mathematical problem or structure to analyze.
         
     Returns:
-        str: Mathematical analysis and solution approach.
+        str: Mathematical analysis and solution guidance.
     """
     try:
         problem_lower = problem.lower()
         
         if "commutative" in problem_lower:
-            return """COMMUTATIVITY ANALYSIS:
-To check if operation * is commutative:
-1. Test if a*b = b*a for ALL elements in the set
-2. Look for counterexamples in the operation table
-3. Check systematically: compare (i,j) entry with (j,i) entry
-4. If ANY pair fails commutativity, the operation is not commutative
-5. Pay attention to non-symmetric entries in the operation table"""
+            return """COMMUTATIVITY ANALYSIS GUIDE:
+For operation * on set S to be commutative, a*b = b*a must hold for ALL pairs (a,b).
+
+SYSTEMATIC CHECK METHOD:
+1. Create operation table if not given
+2. For each entry (i,j), check if it equals entry (j,i)
+3. The table should be symmetric across the main diagonal
+4. If ANY single pair fails, operation is NOT commutative
+
+COMMON COUNTEREXAMPLE PATTERNS:
+- Look for asymmetric entries: if a*b ≠ b*a
+- Check corner cases and boundary elements
+- Pay attention to identity elements and inverses
+- Matrix multiplication is classic non-commutative example
+
+TO PROVE NON-COMMUTATIVITY: Find ONE counterexample where a*b ≠ b*a
+TO PROVE COMMUTATIVITY: Verify ALL pairs satisfy a*b = b*a"""
         
         elif "chess" in problem_lower:
-            return """CHESS ANALYSIS FRAMEWORK:
-1. IMMEDIATE THREATS: Check for checks, captures, piece attacks
-2. TACTICAL MOTIFS: Look for pins, forks, skewers, discovered attacks
-3. KING SAFETY: Evaluate both kings' positions and escape squares
-4. PIECE ACTIVITY: Consider piece mobility and coordination
-5. MATERIAL BALANCE: Count material and positional advantages
-6. ENDGAME PRINCIPLES: If few pieces, apply endgame theory
-7. CANDIDATE MOVES: Generate and evaluate best move options"""
-        
-        elif "prime" in problem_lower or "factor" in problem_lower:
-            return """NUMBER THEORY APPROACH:
-1. For primality: Check divisibility by primes up to √n
-2. For factorization: Use trial division, then advanced methods
-3. Look for patterns in sequences
-4. Apply modular arithmetic when appropriate
-5. Use greatest common divisor (GCD) for fraction problems"""
-        
-        elif any(word in problem_lower for word in ["triangle", "circle", "area", "volume", "angle"]):
-            return """GEOMETRY SOLUTION STRATEGY:
-1. Draw/visualize the problem if possible
-2. Identify known values and what needs to be found
-3. Apply relevant formulas (area, volume, Pythagorean theorem)
-4. Use coordinate geometry if helpful
-5. Consider similar triangles or congruent figures
-6. Apply trigonometry for angle problems"""
-        
-        elif any(word in problem_lower for word in ["probability", "statistics", "mean", "median"]):
-            return """STATISTICS/PROBABILITY APPROACH:
-1. Identify the type of probability (conditional, independent, etc.)
-2. List all possible outcomes if finite
-3. Use appropriate formulas (combinations, permutations)
-4. For statistics: calculate mean, median, mode as needed
-5. Check if normal distribution applies
-6. Use Bayes' theorem for conditional probability"""
-        
-        elif any(word in problem_lower for word in ["derivative", "integral", "limit", "calculus"]):
-            return """CALCULUS SOLUTION METHOD:
-1. Identify the type of calculus problem
-2. For derivatives: Apply appropriate rules (chain, product, quotient)
-3. For integrals: Try substitution, integration by parts
-4. For limits: Use L'Hôpital's rule if indeterminate form
-5. Check for discontinuities or special points
-6. Verify answers by differentiation/integration"""
-        
-        elif any(word in problem_lower for word in ["algorithm", "sequence", "pattern", "logic"]):
-            return """ALGORITHMIC THINKING:
-1. Identify the pattern or rule governing the sequence
-2. Test the pattern with given examples
-3. Look for mathematical relationships (arithmetic, geometric)
-4. Consider recursive or iterative approaches
-5. Verify solution with edge cases
-6. Optimize for efficiency if needed"""
+            return """CHESS POSITION ANALYSIS FRAMEWORK:
+
+IMMEDIATE ASSESSMENT:
+1. Check for checks/threats to both kings
+2. Identify all possible legal moves
+3. Look for immediate tactical opportunities
+
+TACTICAL PATTERNS TO EXAMINE:
+- Pins: pieces unable to move due to exposing king/valuable piece
+- Forks: single piece attacking multiple targets
+- Skewers: forcing valuable piece to move, exposing less valuable one
+- Discovered attacks: moving one piece reveals attack from another
+- Double attacks: attacking two targets simultaneously
+
+STRATEGIC CONSIDERATIONS:
+- King safety and escape squares
+- Piece activity and coordination
+- Control of key squares (center, weak squares)
+- Pawn structure advantages/disadvantages
+- Material balance and exchanges
+
+MOVE EVALUATION PRIORITY:
+1. Forced moves (checks, captures, threats)
+2. Tactical shots (combinations)
+3. Improving piece positions
+4. Prophylactic moves (preventing opponent threats)"""
+        
+        elif any(term in problem_lower for term in ["prime", "factor", "divisible", "gcd", "lcm"]):
+            return """NUMBER THEORY PROBLEM SOLVING:
+
+PRIMALITY TESTING:
+- Check divisibility by primes up to √n
+- Use divisibility rules (2,3,5,7,11...)
+- For large numbers, use probabilistic tests
+
+FACTORIZATION STRATEGIES:
+1. Trial division by small primes
+2. Look for perfect square factors
+3. Use difference of squares: a² - b² = (a+b)(a-b)
+4. Check for patterns in number sequences
+
+GCD/LCM PROBLEMS:
+- Use Euclidean algorithm for GCD
+- LCM = (a×b)/GCD(a,b)
+- Prime factorization method for multiple numbers
+
+MODULAR ARITHMETIC:
+- Use when dealing with remainders
+- Fermat's Little Theorem for prime moduli
+- Chinese Remainder Theorem for system of congruences"""
+        
+        elif any(term in problem_lower for term in ["triangle", "circle", "area", "volume", "angle", "geometry"]):
+            return """GEOMETRY PROBLEM SOLVING APPROACH:
+
+VISUALIZATION:
+1. Draw accurate diagram if possible
+2. Mark known values and unknowns
+3. Identify geometric relationships
+
+KEY FORMULAS TO CONSIDER:
+- Triangle: Area = ½bh, Pythagorean theorem
+- Circle: Area = πr², Circumference = 2πr
+- Volume formulas for 3D shapes
+- Trigonometric ratios (SOH-CAH-TOA)
+
+SOLUTION STRATEGIES:
+1. Similar triangles and proportions
+2. Coordinate geometry when helpful
+3. Law of sines/cosines for non-right triangles
+4. Circle theorems and properties
+5. Symmetry and transformation properties
+
+COMMON TECHNIQUES:
+- Auxiliary lines and constructions
+- Angle chasing in polygons
+- Using properties of special triangles (30-60-90, 45-45-90)"""
+        
+        elif any(term in problem_lower for term in ["probability", "statistics", "combination", "permutation"]):
+            return """PROBABILITY & STATISTICS SOLUTION GUIDE:
+
+PROBABILITY FUNDAMENTALS:
+- P(A) = favorable outcomes / total outcomes
+- P(A or B) = P(A) + P(B) - P(A and B)
+- P(A and B) = P(A) × P(B|A) for dependent events
+- P(A and B) = P(A) × P(B) for independent events
+
+COUNTING PRINCIPLES:
+- Permutations: P(n,r) = n!/(n-r)! (order matters)
+- Combinations: C(n,r) = n!/(r!(n-r)!) (order doesn't matter)
+- Multiplication principle for sequential choices
+
+STATISTICS MEASURES:
+- Mean: sum of values / count
+- Median: middle value when ordered
+- Mode: most frequent value
+- Standard deviation: measure of spread
+
+COMMON PROBLEM TYPES:
+- Conditional probability (Bayes' theorem)
+- Binomial distribution
+- Normal distribution applications"""
+        
+        elif any(term in problem_lower for term in ["sequence", "series", "pattern", "recursive"]):
+            return """SEQUENCE & PATTERN ANALYSIS:
+
+PATTERN IDENTIFICATION:
+1. Look for arithmetic progression: constant difference
+2. Check for geometric progression: constant ratio
+3. Examine polynomial patterns (quadratic, cubic)
+4. Consider Fibonacci-type recursive relations
+
+ANALYSIS METHODS:
+- First differences, second differences
+- Ratio between consecutive terms
+- Look for alternating patterns
+- Check for periodic behavior
+
+COMMON SEQUENCES:
+- Arithmetic: a, a+d, a+2d, ...
+- Geometric: a, ar, ar², ...
+- Quadratic: differences form arithmetic sequence
+- Fibonacci: F(n) = F(n-1) + F(n-2)
+
+FORMULA DERIVATION:
+- Use known formulas for standard sequences
+- Set up recurrence relations
+- Use generating functions for complex patterns"""
         
         else:
+            # Extract numbers and suggest general approach
             numbers = re.findall(r'-?\d+(?:\.\d+)?', problem)
+            operations = re.findall(r'[+\-*/^=<>]', problem)
+            
+            analysis = f"GENERAL MATHEMATICAL ANALYSIS:\n"
             if numbers:
-                return f"""GENERAL MATHEMATICAL ANALYSIS:
-Numbers found: {', '.join(numbers)}
-Problem type analysis needed for: {problem[:100]}
-Consider: arithmetic operations, algebraic manipulation, 
-pattern recognition, or formula application"""
+                analysis += f"Numbers identified: {', '.join(numbers)}\n"
+            if operations:
+                analysis += f"Operations found: {', '.join(set(operations))}\n"
             
-            return f"Mathematical analysis needed for: {problem[:150]}..."
+            analysis += f"\nProblem excerpt: {problem[:150]}...\n"
+            analysis += "\nSUGGESTED APPROACH:\n"
+            analysis += "1. Identify the mathematical domain (algebra, geometry, etc.)\n"
+            analysis += "2. List known information and what needs to be found\n"
+            analysis += "3. Apply relevant formulas and theorems\n"
+            analysis += "4. Work step-by-step with clear reasoning\n"
+            analysis += "5. Verify the solution makes sense"
+            
+            return analysis
             
     except Exception as e:
         return f"Math solver error: {str(e)}"