Spaces:
Sleeping
Sleeping
| from typing import Dict, Any, List, Optional | |
| from ..knowledge_base.grounding_truth import GroundingTruth | |
| from ..components.response_templates import get_response_templates | |
| import logging | |
| logger = logging.getLogger(__name__) | |
| class ResponseVerifier: | |
| """Verifies responses using grounding truth while preserving multi-perspective analysis""" | |
| def __init__(self): | |
| self.grounding_truth = GroundingTruth() | |
| self.response_templates = get_response_templates() | |
| self.mode_confidence_thresholds = { | |
| "scientific": 0.9, | |
| "creative": 0.7, | |
| "emotional": 0.6, | |
| "quantum": 0.8, | |
| "philosophical": 0.7 | |
| } | |
| def verify_insight( | |
| self, | |
| insight: str, | |
| mode: str, | |
| context: Optional[Dict[str, Any]] = None | |
| ) -> Dict[str, Any]: | |
| """ | |
| Verify a single insight from a specific perspective mode | |
| Args: | |
| insight: The insight to verify | |
| mode: The perspective mode that generated it | |
| context: Optional additional context | |
| Returns: | |
| Dict containing verification results and confidence | |
| """ | |
| verification = self.grounding_truth.verify_statement(insight, context) | |
| confidence_threshold = self.mode_confidence_thresholds.get(mode, 0.7) | |
| # Adjust verification based on mode characteristics | |
| if mode == "creative": | |
| # Allow more speculative statements in creative mode | |
| verification["confidence"] *= 1.2 | |
| elif mode == "quantum": | |
| # Account for quantum uncertainty | |
| verification["confidence"] = max( | |
| verification["confidence"], | |
| 0.5 # Quantum superposition baseline | |
| ) | |
| return { | |
| "verified": verification["verified"] or verification["confidence"] >= confidence_threshold, | |
| "confidence": verification["confidence"], | |
| "mode": mode, | |
| "original_insight": insight, | |
| "requires_qualifier": verification["confidence"] < confidence_threshold | |
| } | |
| def process_multi_perspective_response( | |
| self, | |
| insights: List[str], | |
| modes: List[str], | |
| consciousness_state: Optional[Dict[str, Any]] = None | |
| ) -> Dict[str, Any]: | |
| """ | |
| Process and verify a multi-perspective response | |
| Args: | |
| insights: List of insights from different perspectives | |
| modes: List of perspective modes that generated the insights | |
| consciousness_state: Optional consciousness state info | |
| Returns: | |
| Processed response with verification metadata | |
| """ | |
| verified_insights = [] | |
| uncertain_insights = [] | |
| for insight, mode in zip(insights, modes): | |
| result = self.verify_insight( | |
| insight, | |
| mode, | |
| {"consciousness": consciousness_state} if consciousness_state else None | |
| ) | |
| if result["verified"]: | |
| verified_insights.append({ | |
| "text": result["original_insight"], | |
| "mode": mode, | |
| "confidence": result["confidence"] | |
| }) | |
| else: | |
| qualified_insight = self._add_qualifier( | |
| result["original_insight"], | |
| result["confidence"], | |
| mode | |
| ) | |
| uncertain_insights.append({ | |
| "text": qualified_insight, | |
| "mode": mode, | |
| "confidence": result["confidence"] | |
| }) | |
| return { | |
| "verified_insights": verified_insights, | |
| "uncertain_insights": uncertain_insights, | |
| "overall_confidence": self._calculate_overall_confidence( | |
| verified_insights, uncertain_insights | |
| ) | |
| } | |
| def _add_qualifier(self, insight: str, confidence: float, mode: str) -> str: | |
| """Add appropriate qualifier based on confidence and mode""" | |
| base_qualifier = self._get_base_qualifier(confidence) | |
| mode_specific = self._get_mode_qualifier(mode) | |
| if mode_specific: | |
| return f"{base_qualifier} {insight} ({mode_specific})" | |
| return f"{base_qualifier} {insight}" | |
| def _get_base_qualifier(self, confidence: float) -> str: | |
| """Get base confidence qualifier""" | |
| if confidence >= 0.8: | |
| return "Evidence suggests that" | |
| elif confidence >= 0.6: | |
| return "It appears that" | |
| elif confidence >= 0.4: | |
| uncertain = self.response_templates.get_uncertain_prefix() | |
| return uncertain.rstrip(',') # Remove trailing comma if present | |
| elif confidence >= 0.2: | |
| return "There is a speculation that" | |
| else: | |
| return "There is an unverified hypothesis that" | |
| def _get_mode_qualifier(self, mode: str) -> Optional[str]: | |
| """Get mode-specific qualifier""" | |
| qualifiers = { | |
| "scientific": "based on available data", | |
| "creative": "from a creative perspective", | |
| "emotional": "from an emotional standpoint", | |
| "quantum": "considering quantum possibilities", | |
| "philosophical": "from a philosophical view" | |
| } | |
| return qualifiers.get(mode) | |
| def _calculate_overall_confidence( | |
| self, | |
| verified: List[Dict[str, Any]], | |
| uncertain: List[Dict[str, Any]] | |
| ) -> float: | |
| """Calculate overall response confidence""" | |
| if not verified and not uncertain: | |
| return 0.0 | |
| total_insights = len(verified) + len(uncertain) | |
| confidence_sum = sum(v["confidence"] for v in verified) | |
| confidence_sum += sum(u["confidence"] for u in uncertain) | |
| return confidence_sum / total_insights |