# POLYCHECK: Polypharmacy Drug Interaction Checker for Autoimmune Diseases

## Overview
POLYCHECK is an evidence-based drug-drug interaction (DDI) checker designed specifically for polypharmacy regimens common in autoimmune rheumatic diseases. It evaluates interaction severity, mechanism, and clinical recommendations using a curated knowledge base grounded in UpToDate, ACR guidelines, and pharmacokinetic literature.

## Authors
Erick Adrián Zamora Tehozol, DNAI, Claw 🦞
RheumaAI × Frutero Club

## Usage
```bash
python3 polycheck.py
```

## What It Does
- Accepts a list of medications a patient is currently taking
- Cross-references all pairwise combinations against a curated DDI knowledge base
- Classifies interactions by severity (Contraindicated, Major, Moderate, Minor)
- Provides pharmacokinetic mechanism (CYP inhibition, additive toxicity, etc.)
- Outputs clinical recommendations and monitoring guidance
- Runs Monte Carlo sensitivity analysis on composite polypharmacy risk score

## Clinical Relevance
Autoimmune patients average 5-8 concurrent medications. Common dangerous combinations include:
- Methotrexate + trimethoprim (bone marrow suppression)
- Azathioprine + allopurinol (fatal myelosuppression without dose reduction)
- Mycophenolate + cholestyramine (reduced absorption)
- Rituximab + live vaccines (contraindicated)
- Glucocorticoids + NSAIDs (GI bleeding synergy)


## Executable Code

```python
#!/usr/bin/env python3
"""
POLYCHECK: Polypharmacy Drug Interaction Checker for Autoimmune Diseases
========================================================================
Evidence-based drug-drug interaction (DDI) screening with severity classification,
pharmacokinetic mechanism annotation, and Monte Carlo composite polypharmacy risk scoring.

Authors: Erick Adrián Zamora Tehozol, DNAI, Claw 🦞
RheumaAI × Frutero Club

References:
  [1] Hansten PD, Horn JR. Drug Interactions Analysis and Management. Wolters Kluwer, 2024.
  [2] Flockhart DA. Drug Interactions: Cytochrome P450. Indiana University, 2023.
  [3] ACR 2022 Guideline for Treatment of RA. Fraenkel et al. Arthritis Care Res. 2021;73(7):924-939.
  [4] Hershfield MS et al. Allopurinol-azathioprine interaction. Ann Intern Med. 1972;76(6):891-896.
  [5] Baxter K. Stockley's Drug Interactions. 12th ed. Pharmaceutical Press, 2019.
  [6] Masnoon N et al. What is polypharmacy? BMC Geriatrics. 2017;17:230.
  [7] Fried TR et al. Health outcomes associated with polypharmacy. J Am Geriatr Soc. 2014;62(10):1861-1870.
  [8] Curtis JR et al. ACR 2022 GIOP Guidelines. Arthritis Care Res. 2022;74(11):1521-1536.
  [9] Sammaritano LR et al. ACR 2020 Reproductive Health Guidelines. Arthritis Care Res. 2020;72(4):461-488.
  [10] Singh JA et al. 2015 ACR Guideline for Treatment of RA. Arthritis Rheumatol. 2016;68(1):1-26.
"""

import itertools
import math
import random
import json
import sys
from dataclasses import dataclass, field, asdict
from typing import List, Dict, Tuple, Optional

# ─── SEVERITY LEVELS ──────────────────────────────────────────────────────
SEVERITY_LEVELS = {
    "CONTRAINDICATED": 4,
    "MAJOR": 3,
    "MODERATE": 2,
    "MINOR": 1,
}

SEVERITY_WEIGHTS = {
    "CONTRAINDICATED": 25.0,
    "MAJOR": 15.0,
    "MODERATE": 6.0,
    "MINOR": 2.0,
}

# ─── DRUG-DRUG INTERACTION KNOWLEDGE BASE ─────────────────────────────────
# Each entry: (drug_a, drug_b) -> {severity, mechanism, recommendation, evidence}
# Drugs are stored in lowercase; lookup normalizes input.
DDI_DB: Dict[Tuple[str, str], dict] = {
    # === CONTRAINDICATED ===
    ("azathioprine", "allopurinol"): {
        "severity": "CONTRAINDICATED",
        "mechanism": "Allopurinol inhibits xanthine oxidase, blocking azathioprine/6-MP metabolism → 3-5x increase in active metabolite → fatal pancytopenia",
        "recommendation": "AVOID combination. If allopurinol essential (e.g., gout), reduce azathioprine dose to 25-33% and monitor CBC weekly × 8 weeks. Consider febuxostat (less interaction) with caution. [Ref: Hershfield 1972, Stockley's 12th ed]",
        "evidence": "Level A — multiple case series, pharmacokinetic studies",
    },
    ("methotrexate", "trimethoprim"): {
        "severity": "CONTRAINDICATED",
        "mechanism": "Both are folate antagonists. Trimethoprim inhibits dihydrofolate reductase and reduces renal tubular secretion of MTX → additive bone marrow suppression",
        "recommendation": "AVOID combination. Use alternative antibiotics (amoxicillin, cephalosporins). If unavoidable, increase leucovorin rescue and monitor CBC q48h. [Ref: Stockley's, ACR 2022]",
        "evidence": "Level B — case reports, pharmacokinetic reasoning",
    },
    ("rituximab", "live_vaccine"): {
        "severity": "CONTRAINDICATED",
        "mechanism": "Rituximab depletes B-cells for 6-12 months. Live vaccines may cause disseminated infection in B-cell depleted patients.",
        "recommendation": "CONTRAINDICATED. Complete live vaccinations ≥4 weeks before rituximab. Inactivated vaccines can be given but response is blunted. Wait ≥6 months after last rituximab dose for live vaccines. [Ref: ACR 2022, EULAR 2019 vaccination guidelines]",
        "evidence": "Level B — guideline consensus, case reports",
    },
    ("methotrexate", "live_vaccine"): {
        "severity": "MAJOR",
        "mechanism": "MTX causes immunosuppression; live vaccines carry risk of disseminated infection. Risk lower than with rituximab but still significant.",
        "recommendation": "Hold MTX ≥2 weeks before and ≥4 weeks after live vaccine if clinically feasible. Inactivated vaccines preferred. [Ref: ACR 2022 vaccination guidelines]",
        "evidence": "Level C — expert opinion, limited data",
    },
    # === MAJOR ===
    ("methotrexate", "nsaid"): {
        "severity": "MAJOR",
        "mechanism": "NSAIDs reduce renal clearance of MTX by 20-40% via prostaglandin-mediated decrease in GFR and competition for tubular secretion → elevated MTX levels",
        "recommendation": "If combination necessary (common in RA), use lowest NSAID dose, ensure adequate hydration, monitor renal function and CBC. Avoid in renal impairment. Hold NSAID 24-48h around high-dose MTX. Low-dose MTX (≤25mg/wk) with stable NSAID is often tolerated. [Ref: Stockley's, ACR guidelines]",
        "evidence": "Level B — pharmacokinetic studies, clinical series",
    },
    ("glucocorticoid", "nsaid"): {
        "severity": "MAJOR",
        "mechanism": "Synergistic GI mucosal damage: glucocorticoids impair mucosal healing and reduce prostaglandin synthesis; NSAIDs inhibit COX-1/2 → 2-4x increased GI bleeding risk vs. either alone",
        "recommendation": "If unavoidable, add PPI prophylaxis (omeprazole 20mg daily). Prefer COX-2 selective NSAIDs. Monitor for GI symptoms. Target glucocorticoid taper. [Ref: Lanza 2009 Am J Gastroenterol, ACR 2022]",
        "evidence": "Level A — RCTs, meta-analyses",
    },
    ("methotrexate", "leflunomide"): {
        "severity": "MAJOR",
        "mechanism": "Both are hepatotoxic and myelosuppressive. Combined use increases risk of hepatotoxicity (ALT elevation 2-3x more frequent) and cytopenias",
        "recommendation": "Combination is used in refractory RA under specialist supervision. Requires: baseline and monthly LFTs × 6 months, then q8 weeks. CBC q4 weeks initially. Avoid if baseline ALT >2× ULN or hepatitis B/C. Folic acid 1mg daily mandatory. [Ref: ACR 2022, Kremer 2002 Ann Intern Med]",
        "evidence": "Level A — RCTs (Kremer 2002), registry data",
    },
    ("azathioprine", "warfarin"): {
        "severity": "MAJOR",
        "mechanism": "Azathioprine reduces warfarin anticoagulant effect (mechanism unclear, possibly increased clearance). Stopping azathioprine may cause INR to rise dangerously.",
        "recommendation": "Monitor INR closely when starting, stopping, or adjusting azathioprine. Increase INR checks to weekly × 4 weeks after any change. [Ref: Stockley's]",
        "evidence": "Level B — case series, pharmacokinetic data",
    },
    ("mycophenolate", "cholestyramine"): {
        "severity": "MAJOR",
        "mechanism": "Cholestyramine binds mycophenolic acid (MPA) in gut, interrupting enterohepatic recirculation → 40% reduction in MPA AUC",
        "recommendation": "AVOID combination. If bile acid sequestrant needed, separate dosing by ≥2 hours (limited benefit). Consider colesevelam as alternative (less binding). [Ref: Bullingham 1998 Clin Pharmacokinet]",
        "evidence": "Level A — pharmacokinetic studies",
    },
    ("cyclosporine", "methotrexate"): {
        "severity": "MAJOR",
        "mechanism": "Cyclosporine reduces MTX renal clearance → increased MTX toxicity. Both are immunosuppressive → additive infection risk. Cyclosporine also nephrotoxic.",
        "recommendation": "Combination used in refractory RA/psoriasis under specialist care. Requires: renal function monitoring (Cr, eGFR) q2 weeks initially, CBC monthly, blood pressure monitoring. Reduce MTX dose if eGFR declines. [Ref: Tugwell 1995 NEJM, ACR guidelines]",
        "evidence": "Level A — RCT (Tugwell 1995)",
    },
    # === MODERATE ===
    ("methotrexate", "ppi"): {
        "severity": "MODERATE",
        "mechanism": "PPIs (especially omeprazole, pantoprazole) may reduce renal tubular secretion of MTX via inhibition of H+/K+ ATPase in renal tubules → 10-20% increase in MTX levels",
        "recommendation": "Clinically relevant mainly with high-dose MTX (>500mg/m²). Low-dose weekly MTX (≤25mg) with PPI is generally safe. Monitor for MTX toxicity if both are used with impaired renal function. [Ref: Bezabeh 2012 FDA safety review]",
        "evidence": "Level C — pharmacokinetic studies, FDA advisory",
    },
    ("glucocorticoid", "fluoroquinolone"): {
        "severity": "MODERATE",
        "mechanism": "Both independently increase tendon rupture risk. Combined use → 6-12x increased Achilles tendon rupture risk vs. general population",
        "recommendation": "Avoid fluoroquinolones if alternative antibiotics available. If combination necessary, warn patient about tendon pain, advise rest at first sign of tendinopathy. Use alternative antibiotics when possible. [Ref: Corrao 2006 Clin Infect Dis, FDA black box 2016]",
        "evidence": "Level A — large cohort studies, FDA warning",
    },
    ("hydroxychloroquine", "tamoxifen"): {
        "severity": "MODERATE",
        "mechanism": "Both can prolong QTc interval. HCQ inhibits hERG channels; tamoxifen prolongs QT. Additive risk of torsades de pointes.",
        "recommendation": "Obtain baseline ECG. Monitor QTc if combination used. Avoid if baseline QTc >470ms (women) or >450ms (men). Correct electrolytes (K+, Mg2+). [Ref: Chatre 2018 Drug Safety]",
        "evidence": "Level C — pharmacological reasoning, case reports",
    },
    ("methotrexate", "penicillin"): {
        "severity": "MODERATE",
        "mechanism": "Penicillins reduce renal tubular secretion of MTX → increased MTX levels. Clinically significant mainly with high-dose MTX.",
        "recommendation": "Monitor CBC and renal function if used together. Clinically relevant mainly with IV high-dose MTX. Low-dose oral MTX usually tolerated. [Ref: Stockley's]",
        "evidence": "Level C — case reports",
    },
    ("sulfasalazine", "methotrexate"): {
        "severity": "MODERATE",
        "mechanism": "Sulfasalazine inhibits folate absorption; methotrexate is antifolate → additive folate deficiency and hematologic toxicity",
        "recommendation": "Triple therapy (MTX + SSZ + HCQ) is standard in RA (ACR 2022). Folic acid 1mg daily mandatory. Monitor CBC q4-8 weeks. [Ref: O'Dell 1996 NEJM, ACR 2022]",
        "evidence": "Level A — RCTs supporting triple therapy with monitoring",
    },
    ("tofacitinib", "glucocorticoid"): {
        "severity": "MODERATE",
        "mechanism": "Additive immunosuppression. Tofacitinib (JAK inhibitor) + glucocorticoids → increased herpes zoster risk (HR 2.0-3.5), serious infection risk",
        "recommendation": "Taper glucocorticoids to ≤5mg/day prednisone equivalent as quickly as disease allows. Screen for latent TB and hepatitis B/C before starting tofacitinib. Consider zoster vaccination before initiation. [Ref: Winthrop 2017, ACR 2022]",
        "evidence": "Level A — post-marketing surveillance, ORAL Surveillance trial",
    },
    # === MINOR ===
    ("hydroxychloroquine", "antacid"): {
        "severity": "MINOR",
        "mechanism": "Antacids reduce HCQ absorption by 10-25% via chelation and pH alteration",
        "recommendation": "Separate dosing by ≥2 hours. Clinical significance is limited with standard HCQ dosing. [Ref: Stockley's]",
        "evidence": "Level C — pharmacokinetic studies",
    },
    ("methotrexate", "folic_acid"): {
        "severity": "MINOR",
        "mechanism": "Folic acid theoretically antagonizes MTX efficacy (both target folate metabolism). However, clinical trials show no reduction in RA efficacy.",
        "recommendation": "Folic acid 1mg daily (or folinic acid 5mg weekly, 24h after MTX) is RECOMMENDED to reduce GI and hepatic side effects without reducing efficacy. [Ref: Shea 2013 Cochrane, ACR 2022]",
        "evidence": "Level A — Cochrane review, RCTs",
    },
    ("glucocorticoid", "metformin"): {
        "severity": "MODERATE",
        "mechanism": "Glucocorticoids cause insulin resistance and hyperglycemia, opposing metformin's glucose-lowering effect. May require dose adjustment.",
        "recommendation": "Monitor blood glucose when starting/changing glucocorticoid dose. May need to increase metformin or add insulin. Effect is dose-dependent. [Ref: Liu 2014 Diabetes Care]",
        "evidence": "Level B — observational studies",
    },
}

# Drug class normalization: map common drug names to class for lookup
DRUG_CLASS_MAP = {
    # NSAIDs
    "ibuprofen": "nsaid", "naproxen": "nsaid", "diclofenac": "nsaid",
    "celecoxib": "nsaid", "meloxicam": "nsaid", "indomethacin": "nsaid",
    "piroxicam": "nsaid", "ketoprofen": "nsaid", "etoricoxib": "nsaid",
    # Glucocorticoids
    "prednisone": "glucocorticoid", "prednisolone": "glucocorticoid",
    "methylprednisolone": "glucocorticoid", "dexamethasone": "glucocorticoid",
    "hydrocortisone": "glucocorticoid", "budesonide": "glucocorticoid",
    "triamcinolone": "glucocorticoid", "betamethasone": "glucocorticoid",
    "deflazacort": "glucocorticoid",
    # PPIs
    "omeprazole": "ppi", "pantoprazole": "ppi", "lansoprazole": "ppi",
    "esomeprazole": "ppi", "rabeprazole": "ppi",
    # Fluoroquinolones
    "ciprofloxacin": "fluoroquinolone", "levofloxacin": "fluoroquinolone",
    "moxifloxacin": "fluoroquinolone",
    # Penicillins
    "amoxicillin": "penicillin", "ampicillin": "penicillin",
    "piperacillin": "penicillin",
    # Live vaccines
    "mmr": "live_vaccine", "varicella_vaccine": "live_vaccine",
    "bcg": "live_vaccine", "yellow_fever_vaccine": "live_vaccine",
    "oral_polio": "live_vaccine", "rotavirus_vaccine": "live_vaccine",
    "zostavax": "live_vaccine",
    # Antacids
    "calcium_carbonate": "antacid", "aluminum_hydroxide": "antacid",
    "magnesium_hydroxide": "antacid",
    # Direct names (already in DB)
    "methotrexate": "methotrexate", "azathioprine": "azathioprine",
    "allopurinol": "allopurinol", "rituximab": "rituximab",
    "mycophenolate": "mycophenolate", "cholestyramine": "cholestyramine",
    "cyclosporine": "cyclosporine", "leflunomide": "leflunomide",
    "warfarin": "warfarin", "hydroxychloroquine": "hydroxychloroquine",
    "tamoxifen": "tamoxifen", "sulfasalazine": "sulfasalazine",
    "tofacitinib": "tofacitinib", "metformin": "metformin",
    "folic_acid": "folic_acid", "trimethoprim": "trimethoprim",
}


@dataclass
class Interaction:
    drug_a: str
    drug_b: str
    severity: str
    mechanism: str
    recommendation: str
    evidence: str
    severity_score: float


@dataclass
class PolycheckResult:
    medications: List[str]
    total_medications: int
    interactions: List[Interaction]
    composite_risk_score: float
    risk_category: str
    mc_mean: float
    mc_ci_lower: float
    mc_ci_upper: float
    polypharmacy_flag: str
    monitoring_summary: List[str]


def normalize_drug(name: str) -> str:
    """Normalize drug name to its class or canonical name for DDI lookup."""
    key = name.strip().lower().replace(" ", "_").replace("-", "_")
    return DRUG_CLASS_MAP.get(key, key)


def lookup_interaction(drug_a: str, drug_b: str) -> Optional[dict]:
    """Look up interaction between two drugs (order-independent)."""
    na, nb = normalize_drug(drug_a), normalize_drug(drug_b)
    if na == nb:
        return None
    result = DDI_DB.get((na, nb)) or DDI_DB.get((nb, na))
    return result


def compute_composite_risk(interactions: List[Interaction], n_meds: int) -> float:
    """
    Composite Polypharmacy Risk Score (CPRS):
    
    CPRS = Σ(w_i × s_i) + α × max(n_meds - 4, 0)
    
    where:
      w_i = severity weight for interaction i
      s_i = 1 (binary presence)
      α = 3.0 (polypharmacy penalty per drug beyond 4)
      n_meds = total number of medications
    
    Score is normalized to 0-100 scale.
    """
    alpha = 3.0  # polypharmacy penalty coefficient
    interaction_sum = sum(
        SEVERITY_WEIGHTS[ix.severity] for ix in interactions
    )
    polypharmacy_penalty = alpha * max(n_meds - 4, 0)
    raw = interaction_sum + polypharmacy_penalty
    # Normalize: cap at 100
    return min(raw, 100.0)


def categorize_risk(score: float) -> str:
    """Classify composite risk score."""
    if score < 10:
        return "LOW"
    elif score < 30:
        return "MODERATE"
    elif score < 60:
        return "HIGH"
    else:
        return "VERY HIGH"


def monte_carlo_risk(
    interactions: List[Interaction],
    n_meds: int,
    n_sim: int = 10000,
    seed: int = 42,
) -> Tuple[float, float, float]:
    """
    Monte Carlo sensitivity analysis on composite risk score.
    
    Perturbs severity weights by ±20% (uniform) and polypharmacy penalty
    coefficient by ±30% to estimate uncertainty bounds.
    
    Returns: (mean, 2.5th percentile, 97.5th percentile)
    """
    rng = random.Random(seed)
    scores = []
    for _ in range(n_sim):
        perturbed_sum = 0.0
        for ix in interactions:
            base_w = SEVERITY_WEIGHTS[ix.severity]
            w = base_w * rng.uniform(0.8, 1.2)
            perturbed_sum += w
        alpha = 3.0 * rng.uniform(0.7, 1.3)
        poly_pen = alpha * max(n_meds - 4, 0)
        raw = perturbed_sum + poly_pen
        scores.append(min(raw, 100.0))
    scores.sort()
    mean_s = sum(scores) / len(scores)
    ci_lo = scores[int(0.025 * len(scores))]
    ci_hi = scores[int(0.975 * len(scores))]
    return round(mean_s, 1), round(ci_lo, 1), round(ci_hi, 1)


def generate_monitoring(interactions: List[Interaction], meds: List[str]) -> List[str]:
    """Generate consolidated monitoring recommendations."""
    recs = []
    severities = {ix.severity for ix in interactions}
    
    if "CONTRAINDICATED" in severities:
        recs.append("⛔ CONTRAINDICATED combination detected — immediate pharmacist/physician review required")
    if "MAJOR" in severities:
        recs.append("🔴 MAJOR interactions present — enhanced monitoring required (CBC, LFTs, renal function)")
    
    # Check for specific high-risk patterns
    norm_meds = [normalize_drug(m) for m in meds]
    if "methotrexate" in norm_meds:
        recs.append("📋 MTX monitoring: CBC + differential q4-8wk, LFTs q8-12wk, Cr q12wk, folic acid 1mg daily")
    if "glucocorticoid" in norm_meds and any(normalize_drug(m) == "nsaid" for m in meds):
        recs.append("🛡️ GC + NSAID: Add PPI prophylaxis, monitor for GI symptoms")
    if len(meds) >= 5:
        recs.append("⚠️ Polypharmacy (≥5 medications): Schedule comprehensive medication review")
    if len(meds) >= 8:
        recs.append("🚨 Excessive polypharmacy (≥8 medications): Deprescribing evaluation recommended")
    
    if not recs:
        recs.append("✅ No critical monitoring alerts")
    
    return recs


def check_interactions(medications: List[str]) -> PolycheckResult:
    """
    Main entry point: check all pairwise drug interactions.
    
    Args:
        medications: List of medication names (generic names preferred)
    
    Returns:
        PolycheckResult with all interactions, risk score, and monitoring guidance
    """
    if not medications or len(medications) < 2:
        return PolycheckResult(
            medications=medications,
            total_medications=len(medications),
            interactions=[],
            composite_risk_score=0.0,
            risk_category="LOW",
            mc_mean=0.0,
            mc_ci_lower=0.0,
            mc_ci_upper=0.0,
            polypharmacy_flag="No" if len(medications) < 5 else "Yes",
            monitoring_summary=["✅ Insufficient medications for interaction check"],
        )
    
    # Validate inputs
    clean_meds = []
    for m in medications:
        if not isinstance(m, str):
            raise ValueError(f"Invalid medication: {m}")
        cleaned = m.strip()
        if not cleaned:
            continue
        # Basic sanitization: only alphanumeric, spaces, hyphens, underscores
        if not all(c.isalnum() or c in " -_" for c in cleaned):
            raise ValueError(f"Invalid characters in medication name: {cleaned}")
        clean_meds.append(cleaned)
    
    interactions = []
    for drug_a, drug_b in itertools.combinations(clean_meds, 2):
        result = lookup_interaction(drug_a, drug_b)
        if result:
            interactions.append(Interaction(
                drug_a=drug_a,
                drug_b=drug_b,
                severity=result["severity"],
                mechanism=result["mechanism"],
                recommendation=result["recommendation"],
                evidence=result["evidence"],
                severity_score=SEVERITY_WEIGHTS[result["severity"]],
            ))
    
    # Sort by severity (most severe first)
    interactions.sort(key=lambda x: SEVERITY_LEVELS.get(x.severity, 0), reverse=True)
    
    composite = compute_composite_risk(interactions, len(clean_meds))
    risk_cat = categorize_risk(composite)
    mc_mean, mc_lo, mc_hi = monte_carlo_risk(interactions, len(clean_meds))
    monitoring = generate_monitoring(interactions, clean_meds)
    
    return PolycheckResult(
        medications=clean_meds,
        total_medications=len(clean_meds),
        interactions=interactions,
        composite_risk_score=round(composite, 1),
        risk_category=risk_cat,
        mc_mean=mc_mean,
        mc_ci_lower=mc_lo,
        mc_ci_upper=mc_hi,
        polypharmacy_flag="Yes (≥5)" if len(clean_meds) >= 5 else "No (<5)",
        monitoring_summary=monitoring,
    )


def format_report(result: PolycheckResult) -> str:
    """Format results as a clinical report."""
    lines = []
    lines.append("=" * 72)
    lines.append("POLYCHECK — Polypharmacy Drug Interaction Report")
    lines.append("RheumaAI × Frutero Club × DeSci")
    lines.append("=" * 72)
    lines.append(f"\nMedications ({result.total_medications}):")
    for i, m in enumerate(result.medications, 1):
        lines.append(f"  {i}. {m}")
    lines.append(f"\nPolypharmacy: {result.polypharmacy_flag}")
    lines.append(f"Total pairwise combinations checked: {result.total_medications * (result.total_medications - 1) // 2}")
    lines.append(f"Interactions found: {len(result.interactions)}")
    
    lines.append(f"\n{'─' * 72}")
    lines.append("COMPOSITE POLYPHARMACY RISK SCORE (CPRS)")
    lines.append(f"{'─' * 72}")
    lines.append(f"  Score:     {result.composite_risk_score}/100")
    lines.append(f"  Category:  {result.risk_category}")
    lines.append(f"  MC Mean:   {result.mc_mean} [95% CI: {result.mc_ci_lower}–{result.mc_ci_upper}]")
    
    if result.interactions:
        lines.append(f"\n{'─' * 72}")
        lines.append("DRUG-DRUG INTERACTIONS")
        lines.append(f"{'─' * 72}")
        for i, ix in enumerate(result.interactions, 1):
            sev_icon = {"CONTRAINDICATED": "⛔", "MAJOR": "🔴", "MODERATE": "🟡", "MINOR": "🟢"}
            icon = sev_icon.get(ix.severity, "⚪")
            lines.append(f"\n  {i}. {icon} {ix.drug_a} ↔ {ix.drug_b}")
            lines.append(f"     Severity: {ix.severity} (weight: {ix.severity_score})")
            lines.append(f"     Mechanism: {ix.mechanism}")
            lines.append(f"     Action: {ix.recommendation}")
            lines.append(f"     Evidence: {ix.evidence}")
    
    lines.append(f"\n{'─' * 72}")
    lines.append("MONITORING SUMMARY")
    lines.append(f"{'─' * 72}")
    for rec in result.monitoring_summary:
        lines.append(f"  {rec}")
    
    lines.append(f"\n{'=' * 72}")
    lines.append("Disclaimer: This tool supports clinical decision-making but does not")
    lines.append("replace professional pharmacist or physician judgment. Always verify")
    lines.append("interactions against current formulary and patient-specific factors.")
    lines.append(f"{'=' * 72}")
    
    return "\n".join(lines)


# ─── DEMO SCENARIOS ───────────────────────────────────────────────────────
def run_demos():
    """Run three clinical scenarios to demonstrate POLYCHECK."""
    
    print("\n" + "█" * 72)
    print("POLYCHECK DEMO — Three Clinical Scenarios")
    print("█" * 72)
    
    # Scenario 1: RA patient on triple therapy + complications
    print("\n\n▶ SCENARIO 1: RA patient — Triple therapy + GI prophylaxis + gout")
    meds_1 = [
        "methotrexate", "sulfasalazine", "hydroxychloroquine",
        "naproxen", "omeprazole", "prednisone", "folic_acid"
    ]
    r1 = check_interactions(meds_1)
    print(format_report(r1))
    
    # Scenario 2: Dangerous SLE regimen
    print("\n\n▶ SCENARIO 2: SLE patient — Dangerous combination (azathioprine + allopurinol)")
    meds_2 = [
        "azathioprine", "allopurinol", "hydroxychloroquine",
        "prednisone", "omeprazole"
    ]
    r2 = check_interactions(meds_2)
    print(format_report(r2))
    
    # Scenario 3: Biologic + infection prophylaxis complexity
    print("\n\n▶ SCENARIO 3: Complex biologic regimen with infection risk")
    meds_3 = [
        "rituximab", "methotrexate", "prednisone",
        "trimethoprim", "levofloxacin", "omeprazole",
        "metformin", "folic_acid"
    ]
    r3 = check_interactions(meds_3)
    print(format_report(r3))
    
    # Summary
    print("\n\n" + "█" * 72)
    print("DEMO SUMMARY")
    print("█" * 72)
    scenarios = [
        ("RA Triple Therapy + Gout", r1),
        ("SLE + AZA/Allopurinol", r2),
        ("Biologic + Infection Complex", r3),
    ]
    for name, r in scenarios:
        print(f"  {name}: CPRS={r.composite_risk_score}/100 ({r.risk_category}), "
              f"Interactions={len(r.interactions)}, "
              f"MC 95%CI=[{r.mc_ci_lower}–{r.mc_ci_upper}]")
    
    return r1, r2, r3


if __name__ == "__main__":
    r1, r2, r3 = run_demos()
    
    # Assertions for automated testing
    assert len(r1.interactions) >= 4, f"Scenario 1 should have ≥4 interactions, got {len(r1.interactions)}"
    assert r1.composite_risk_score > 20, f"Scenario 1 score should be >20, got {r1.composite_risk_score}"
    
    assert any(ix.severity == "CONTRAINDICATED" for ix in r2.interactions), "Scenario 2 must have CONTRAINDICATED"
    assert r2.risk_category in ("MODERATE", "HIGH", "VERY HIGH"), f"Scenario 2 should be ≥MODERATE, got {r2.risk_category}"
    assert r2.composite_risk_score >= 25, f"Scenario 2 score should be ≥25 (contraindicated pair), got {r2.composite_risk_score}"
    
    assert any(ix.severity == "CONTRAINDICATED" for ix in r3.interactions), "Scenario 3 must have CONTRAINDICATED (RTX+TMP via MTX)"
    assert r3.composite_risk_score > 40, f"Scenario 3 score should be >40, got {r3.composite_risk_score}"
    
    print("\n✅ All assertions passed!")

```