uncertainty_quantifier = UncertaintyQuantifier()
uncertainty = uncertainty_quantifier.calculate_aleatoric_uncertainty(response)

consistency_checker = SelfConsistencyChecker(num_samples=5)
result = await consistency_checker.check_consistency(agent_function, input_data)

fact_verifier = FactVerificationAgent(knowledge_base)
verification = fact_verifier.verify_claims(response, context)

from hallucination_detection import HallucinationDetector

# Initialize detector
detector = HallucinationDetector(config={
    'hallucination_threshold': 0.6,
    'consistency_samples': 5,
    'consensus_threshold': 0.7
})

# Check a response
result = await detector.detect(
    response="The patient's BP is 180/120 mmHg, indicating severe hypertension.",
    context={'previous_readings': '120/80, 125/85'},
    agent_function=your_agent_function  # Optional
)

# Evaluate results
if result.is_hallucination:
    print(f"Hallucination detected! Confidence: {result.confidence_score:.2f}")
    print(f"Types: {result.hallucination_types}")
    print(f"Mitigation: {result.mitigation_suggestions}")

from neuron import CircuitDefinition
from hallucination_detection import HallucinationDetector

# Create circuit with hallucination detection
circuit = CircuitDefinition.create(
    name="SafeResponseCircuit",
    agents={
        "responder": {
            "type": "DeliberativeAgent",
            "capabilities": ["response_generation"]
        },
        "hallucination_monitor": {
            "type": "ValidatorAgent",
            "capabilities": ["hallucination_detection"],
            "detector": HallucinationDetector()
        }
    },
    connections=[
        {"source": "responder", "target": "hallucination_monitor", "type": "validation"}
    ]
)

config = {
    # Detection sensitivity
    'hallucination_threshold': 0.6,  # 0.0-1.0, lower = more sensitive
    
    # Uncertainty quantification
    'dropout_rate': 0.1,  # For Bayesian approximation
    'uncertainty_samples': 10,  # Number of dropout samples
    
    # Self-consistency
    'consistency_samples': 5,  # Number of response variations
    'consensus_threshold': 0.7,  # Agreement threshold (0.0-1.0)
    
    # Fact verification
    'knowledge_base': {},  # Optional pre-verified facts
}

knowledge_base = {
    'claim_hash_1': {
        'claim': 'The Earth orbits the Sun',
        'verified': True,
        'confidence': 1.0,
        'source': 'astronomical_consensus'
    }
}

detector = HallucinationDetector(config={'knowledge_base': knowledge_base})

# Track claims across time for consistency
from hallucination_detection import TemporalConsistencyTracker

tracker = TemporalConsistencyTracker()
tracker.add_claim(session_id="patient_123", claim="BP: 120/80", timestamp="2024-01-01")
tracker.add_claim(session_id="patient_123", claim="BP: 180/120", timestamp="2024-01-02")

# Check for sudden unexplained changes
conflicts = tracker.detect_temporal_conflicts(session_id="patient_123")

HallucinationDetectionResult(
    is_hallucination=True,
    confidence_score=0.45,  # Lower = more likely hallucination
    hallucination_types=[
        HallucinationType.UNSUPPORTED_CLAIM,
        HallucinationType.OVERCONFIDENCE
    ],
    evidence={
        'aleatoric_uncertainty': 0.62,
        'fact_verification': {
            'total_claims': 4,
            'verified_claims': 1,
            'unverified_claims': 3,
            'contradicted_claims': 0
        }
    },
    reasoning="Potential hallucination detected (confidence: 0.45). "
              "Identified patterns: unsupported_claim, overconfidence. "
              "High linguistic uncertainty detected (0.62). "
              "3 unsupported claims detected.",
    mitigation_suggestions=[
        "Ask agent to cite specific sources or evidence for claims",
        "Request agent to explicitly state uncertainty"
    ]
)

# Verify medical recommendations
clinical_response = "Increase dosage to 40mg based on BP readings"
result = await detector.detect(clinical_response, patient_context)

if result.is_hallucination:
    # Escalate to human physician
    notify_human_oversight(result)

# Check support agent responses
support_response = "Your warranty covers water damage for 2 years"
result = await detector.detect(support_response, product_context)

if HallucinationType.UNSUPPORTED_CLAIM in result.hallucination_types:
    # Request citation of warranty terms
    request_policy_verification()

# Validate regulatory compliance statements
compliance_response = "This transaction complies with GDPR Article 17"
result = await detector.detect(compliance_response, regulation_context)

if result.confidence_score < 0.8:
    # Require human legal review
    flag_for_legal_review(result)