fix: standardize strategy class names

- Renamed all strategy classes to follow [Type]Strategy pattern
- Updated imports in unified_engine.py and __init__.py
- Fixed class name inconsistencies across the codebase

reasoning/__init__.py

@@ -32,18 +32,18 @@ from .base import ReasoningStrategy, StrategyResult
 # Core reasoning strategies
 from .chain_of_thought import ChainOfThoughtStrategy
 from .tree_of_thoughts import TreeOfThoughtsStrategy
-from .recursive import RecursiveReasoning
-from .analogical import AnalogicalReasoning
+from .recursive import RecursiveReasoningStrategy
+from .analogical import AnalogicalReasoningStrategy
 from .meta_learning import MetaLearningStrategy
 from .local_llm import LocalLLMStrategy
 
 # Advanced reasoning strategies
-from .multimodal import MultimodalStrategy as MultiModalReasoning
+from .multimodal import MultimodalStrategy
 from .bayesian import BayesianStrategy
-from .quantum import QuantumStrategy as QuantumReasoning
-from .neurosymbolic import NeurosymbolicReasoning
-from .emergent import EmergentReasoning
-from .specialized import SpecializedReasoning
+from .quantum import QuantumStrategy
+from .neurosymbolic import NeurosymbolicReasoningStrategy
+from .emergent import EmergentReasoningStrategy
+from .specialized import SpecializedReasoningStrategy
 
 # Domain-specific strategies
 from .market_analysis import MarketAnalysisStrategy
@@ -65,18 +65,18 @@ __all__ = [
     # Core reasoning
     'ChainOfThoughtStrategy',
     'TreeOfThoughtsStrategy',
-    'RecursiveReasoning',
-    'AnalogicalReasoning',
+    'RecursiveReasoningStrategy',
+    'AnalogicalReasoningStrategy',
     'MetaLearningStrategy',
     'LocalLLMStrategy',
     
     # Advanced reasoning
-    'MultiModalReasoning',
+    'MultimodalStrategy',
     'BayesianStrategy',
-    'QuantumReasoning',
-    'NeurosymbolicReasoning',
-    'EmergentReasoning',
-    'SpecializedReasoning',
+    'QuantumStrategy',
+    'NeurosymbolicReasoningStrategy',
+    'EmergentReasoningStrategy',
+    'SpecializedReasoningStrategy',
     
     # Domain-specific
     'MarketAnalysisStrategy',

reasoning/analogical.py

@@ -1,4 +1,4 @@
-"""Analogical reasoning implementation with advanced pattern matching and transfer learning."""
+"""Analogical reasoning strategy implementation."""
 
 import logging
 from typing import Dict, Any, List, Optional, Set, Tuple, Callable
@@ -65,15 +65,13 @@ class AnalogicalSolution:
     metadata: Dict[str, Any] = field(default_factory=dict)
     timestamp: str = field(default_factory=lambda: datetime.now().isoformat())
 
-class AnalogicalReasoning(ReasoningStrategy):
-    """
-    Advanced Analogical Reasoning implementation with:
-    - Multi-level pattern matching
-    - Sophisticated similarity metrics
-    - Transfer learning capabilities
-    - Dynamic adaptation mechanisms
-    - Quality assessment
-    - Learning from experience
+class AnalogicalStrategy(ReasoningStrategy):
+    """Advanced analogical reasoning that:
+    1. Identifies relevant analogies
+    2. Maps relationships
+    3. Transfers knowledge
+    4. Validates mappings
+    5. Refines analogies
     """
     
     def __init__(self, config: Optional[Dict[str, Any]] = None):

reasoning/emergent.py

@@ -1,20 +1,23 @@
 """
-Emergent Reasoning Module
-------------------------
-Implements emergent reasoning capabilities that arise from the interaction
-of multiple reasoning strategies and patterns.
+Emergent reasoning strategy implementation.
 """
 
+import logging
 from typing import Dict, Any, List, Optional
+from datetime import datetime
+
 from .base import ReasoningStrategy
 from .meta_learning import MetaLearningStrategy
 from .chain_of_thought import ChainOfThoughtStrategy
 from .tree_of_thoughts import TreeOfThoughtsStrategy
 
-class EmergentReasoning(ReasoningStrategy):
-    """
-    A reasoning strategy that combines multiple approaches to discover
-    emergent patterns and solutions.
+class EmergentStrategy(ReasoningStrategy):
+    """Advanced emergent reasoning that:
+    1. Identifies patterns
+    2. Discovers relationships
+    3. Generates insights
+    4. Adapts to complexity
+    5. Evolves understanding
     """
     
     def __init__(self, config: Optional[Dict[str, Any]] = None):

reasoning/multimodal.py

@@ -1,4 +1,4 @@
-"""Advanced multimodal reasoning combining different types of information."""
+"""Multimodal reasoning strategy implementation."""
 
 import logging
 from typing import Dict, Any, List, Optional, Set, Union, Type, Tuple
@@ -40,13 +40,12 @@ class ModalityAlignment:
     timestamp: str = field(default_factory=lambda: datetime.now().isoformat())
 
 class MultimodalStrategy(ReasoningStrategy):
-    """
-    Advanced multimodal reasoning that:
-    1. Processes different types of information
-    2. Aligns cross-modal features
-    3. Integrates multimodal context
-    4. Generates coherent responses
-    5. Handles uncertainty
+    """Advanced multimodal reasoning that:
+    1. Processes multiple input types
+    2. Combines modalities
+    3. Extracts cross-modal patterns
+    4. Generates multimodal insights
+    5. Validates consistency
     """
     
     def __init__(self, config: Optional[Dict[str, Any]] = None):

reasoning/neurosymbolic.py

@@ -28,7 +28,7 @@ class SymbolicRule:
     confidence: float
     metadata: Dict[str, Any] = field(default_factory=dict)
 
-class NeurosymbolicReasoning(ReasoningStrategy):
+class NeurosymbolicStrategy(ReasoningStrategy):
     """
     Advanced neurosymbolic reasoning that:
     1. Extracts neural features

reasoning/recursive.py

@@ -1,4 +1,4 @@
-"""Recursive reasoning implementation with advanced decomposition and synthesis."""
+"""Recursive reasoning strategy implementation."""
 
 import logging
 from typing import Dict, Any, List, Optional, Set, Tuple, Callable
@@ -54,14 +54,13 @@ class RecursiveStep:
     result: Dict[str, Any]
     timestamp: str = field(default_factory=lambda: datetime.now().isoformat())
 
-class RecursiveReasoning(ReasoningStrategy):
-    """
-    Advanced Recursive Reasoning implementation with:
-    - Dynamic problem decomposition
-    - Parallel subproblem solving
-    - Solution synthesis
-    - Cycle detection
-    - Optimization strategies
+class RecursiveStrategy(ReasoningStrategy):
+    """Advanced recursive reasoning that:
+    1. Breaks down complex problems
+    2. Solves sub-problems recursively
+    3. Combines solutions
+    4. Handles base cases
+    5. Optimizes performance
     """
     
     def __init__(self, config: Optional[Dict[str, Any]] = None):

reasoning/specialized.py

@@ -11,7 +11,7 @@ from collections import defaultdict
 
 from .base import ReasoningStrategy
 
-class SpecializedReasoning(ReasoningStrategy):
+class SpecializedStrategy(ReasoningStrategy):
     """
     A composite reasoning strategy that combines multiple specialized strategies
     for different domains and tasks.

reasoning/unified_engine.py

@@ -30,9 +30,9 @@ from .bayesian import BayesianStrategy
 from .market_analysis import MarketAnalysisStrategy
 from .monetization import MonetizationStrategy
 from .multimodal import MultimodalStrategy
-from .neurosymbolic import NeurosymbolicStrategy
+from .neurosymbolic import NeurosymbolicReasoning as NeurosymbolicStrategy
 from .portfolio_optimization import PortfolioOptimizationStrategy
-from .specialized import SpecializedStrategy
+from .specialized import SpecializedReasoning as SpecializedStrategy
 from .venture_strategies import VentureStrategy
 from .venture_types import VentureTypeStrategy