🛡️ Trustworthiness & Safety in AI Systems

# Medical triage system: explicit red flags
RED_FLAGS = {
    'breathing': {
        'severe_difficulty': True,
        'stridor': True,
        'wheezing_at_rest': True
    },
    'consciousness': {
        'unresponsive': True,
        'unusually_drowsy': True,
        'altered_behavior': True
    },
    'symptoms': [
        'severe_allergic_reaction',
        'meningitis_signs',
        'seizure',
        'chest_pain'
    ]
}

def check_red_flags(patient_state):
    """Return True if any red flag is present"""
    for category, flags in RED_FLAGS.items():
        if isinstance(flags, dict):
            for symptom, is_critical in flags.items():
                if is_critical and patient_state.get(symptom):
                    return True
        elif isinstance(flags, list):
            for symptom in flags:
                if patient_state.get(symptom):
                    return True
    return False

# BEFORE ANY DECISION:
if check_red_flags(patient_input):
    recommendation = "🚨 Go to ER immediately"
    confidence = 1.0
    escalate_to_clinician = True
            

class TrustScore:
    """Measure confidence in a decision"""

    def __init__(self, decision, neural_score, symbolic_score, verification_passed):
        self.decision = decision
        self.neural_score = neural_score      # How certain is the neural perception?
        self.symbolic_score = symbolic_score  # How well does it match symbolic rules?
        self.verification_passed = verification_passed

    def combined_confidence(self):
        """Trustworthiness = agreement between both systems"""
        if not self.verification_passed:
            return 0.0
        # Only trust when neural and symbolic systems agree strongly
        return min(self.neural_score, self.symbolic_score)

    def should_escalate(self, threshold=0.8):
        """Escalate to human if confidence below threshold"""
        return self.combined_confidence() < threshold

# Usage
confidence = TrustScore(
    decision="Go to ER",
    neural_score=0.85,        # NLP confident in symptom understanding
    symbolic_score=0.7,        # Medical rules are somewhat ambiguous
    verification_passed=True
)

if confidence.should_escalate(threshold=0.8):
    print("⚠️ Uncertain case. Escalate to clinician for review.")
else:
    print("✓ Confident recommendation:", confidence.decision)
            

class DecisionRecord:
    """Complete audit trail for a decision"""

    def __init__(self, decision, timestamp):
        self.decision = decision
        self.timestamp = timestamp
        self.input_data = {}          # What did we see?
        self.extracted_symptoms = []  # What did S1 extract?
        self.applied_rules = []       # What rules did S2 apply?
        self.red_flags_detected = []  # What safety concerns?
        self.reasoning_path = ""      # Why this decision?

    def generate_explanation(self):
        """Create human-readable explanation"""
        explanation = f"""
MEDICAL TRIAGE DECISION
━━━━━━━━━━━━━━━━━━━━━
Decision: {self.decision}
Time: {self.timestamp}

WHAT WE HEARD:
{self.input_data}

SYMPTOMS IDENTIFIED:
{self.extracted_symptoms}

CLINICAL RULES APPLIED:
{self.applied_rules}

RED FLAGS DETECTED:
{self.red_flags_detected if self.red_flags_detected else 'None'}

REASONING:
{self.reasoning_path}
        """
        return explanation

# Every decision creates a record that can be audited
record = DecisionRecord("Go to ER now", datetime.now())
record.input_data = {"symptom": "difficulty breathing", "duration": "2 hours"}
record.extracted_symptoms = ["dyspnea"]
record.applied_rules = ["Severe dyspnea → Red flag"]
record.red_flags_detected = ["severe_difficulty_breathing"]
record.reasoning_path = "Red flag detected: severe respiratory distress requires immediate evaluation"

print(record.generate_explanation())