Upload folder using huggingface_hub

README.md

@@ -0,0 +1,99 @@
+---
+license: cc-by-4.0
+task_categories:
+  - tabular-classification
+  - regression
+tags:
+  - governance
+  - anti-corruption
+  - accountability
+  - sub-saharan-africa
+  - synthetic
+  - lmic
+  - transparency
+  - enforcement
+  - public-sector
+pretty_name: African Anti-Corruption Enforcement
+size_categories:
+  - 10K<n<100K
+configs:
+  - config_name: baseline
+    data_files: data/baseline.csv
+  - config_name: strengthened_enforcement
+    data_files: data/strengthened_enforcement.csv
+  - config_name: weakened_accountability
+    data_files: data/weakened_accountability.csv
+---
+
+# African Anti-Corruption Enforcement
+
+Synthetic dataset modelling anti-corruption enforcement outcomes across 12 Sub-Saharan African countries under three policy scenarios. Parameters are anchored to real-world statistics from Transparency International, the EFCC (Nigeria), SIU/Zondo Commission (South Africa), EACC (Kenya), the African Union's Common African Position on Asset Recovery, and the G20 2025 Accountability Report on Whistleblower Protection.
+
+## Dataset Summary
+
+| Property | Value |
+|---|---|
+| Total records | 30,000 (10,000 per scenario) |
+| Countries | 12 SSA nations |
+| Variables | 15 per record |
+| Scenarios | baseline, strengthened_enforcement, weakened_accountability |
+
+## Scenarios
+
+- **baseline** – Calibrated to observed 2023–2025 enforcement statistics. Median prosecution rate ~25%, median asset recovery rate ~7%.
+- **strengthened_enforcement** – Simulates higher agency independence (+18), stronger whistleblower protection (+20), increased prosecution (+45%), doubled asset recovery, and +8 CPI points.
+- **weakened_accountability** – Models institutional erosion: agency independence −15, whistleblower protection −15, prosecution −40%, asset recovery −60%, and −10 CPI points.
+
+## Countries
+
+Nigeria, South Africa, Kenya, Ghana, Tanzania, Uganda, Ethiopia, Senegal, Mozambique, Zambia, Rwanda, Botswana.
+
+## Variables
+
+| Variable | Type | Description |
+|---|---|---|
+| `country` | str | Country name |
+| `scenario` | str | Policy scenario |
+| `corruption_perception_index` | float | TI CPI score (0–100, higher = cleaner) |
+| `cases_investigated` | int | Number of corruption cases under investigation |
+| `cases_prosecuted` | int | Cases forwarded to prosecution |
+| `prosecution_rate` | float | cases_prosecuted / cases_investigated |
+| `convictions` | int | Number of convictions secured |
+| `conviction_rate` | float | convictions / cases_prosecuted |
+| `assets_confiscated_usd_millions` | float | Value of confiscated assets (USD millions) |
+| `asset_recovery_rate` | float | Fraction of estimated stolen assets recovered |
+| `whistleblower_reports` | int | Number of whistleblower submissions |
+| `whistleblower_protection_score` | float | Protection framework quality (0–100) |
+| `agency_independence_score` | float | Anti-corruption agency independence (0–100) |
+| `enforcement_effectiveness_score` | float | Composite effectiveness index (0–100) |
+| `enforcement_class` | str | strong / moderate / weak |
+
+## Research Sources
+
+1. **Transparency International CPI 2025** – SSA average score 32/100; Seychelles (68) highest, Somalia/South Sudan (9) lowest.
+2. **EFCC Nigeria 2024** – 15,724 petitions → 12,928 investigated → 5,083 prosecuted → 4,111 convictions; $214.5M recovered.
+3. **South Africa SIU 2023/24** – 1,919 investigations closed, 583 criminal referrals, R8B saved, ~80% conviction rate in commercial cases.
+4. **Kenya EACC 2023/24** – 5,171 reports, 534 files under probe, 26.7% conviction rate, Ksh2.9B recovered.
+5. **AU Common African Position on Asset Recovery** – Africa loses ~$150B annually through illicit financial flows; asset recovery typically <10%.
+6. **G20 2025 Accountability Report on Whistleblower Protection** – Most SSA countries lack dedicated whistleblower legislation; protection gaps in developing countries.
+
+## Usage
+
+```python
+from datasets import load_dataset
+
+ds = load_dataset("electricsheepafrica/african-anti-corruption-enforcement", "baseline")
+df = ds["train"].to_pandas()
+```
+
+## Generation & Validation
+
+```bash
+pip install -r requirements.txt
+python generate_dataset.py --scenario all --n-records 10000
+python validate_dataset.py --data-dir data --plot-dir plots
+```
+
+## License
+
+CC-BY-4.0

generate_dataset.py

@@ -0,0 +1,352 @@
+#!/usr/bin/env python3
+"""
+African Anti-Corruption Enforcement Dataset Generator
+
+Generates synthetic records for 12 Sub-Saharan African countries across
+three enforcement scenarios. Parameters are informed by:
+  - Transparency International CPI 2025 (SSA avg=32, range 9-68)
+  - EFCC Nigeria 2024 statistics (12,928 investigated, 5,083 prosecuted,
+    4,111 convictions, ~$214M recovered)
+  - South Africa SIU 2023/24 (1,919 investigations, 583 referrals,
+    R8B saved, ~80% conviction rate in commercial cases)
+  - Kenya EACC 2023/24 (5,171 reports, 534 under probe, 26.7% conviction
+    rate, Ksh2.9B recovered)
+  - AU Common African Position on Asset Recovery (asset recovery <10%)
+  - G20 2025 Accountability Report on Whistleblower Protection
+"""
+
+import os
+import argparse
+import numpy as np
+import pandas as pd
+from scipy import stats
+
+RNG_SEED = 42
+
+# ── Country parameters ──────────────────────────────────────────────
+# Based on TI CPI 2025, population, anti-corruption agency capacity,
+# whistleblower protection maturity, and typical caseload volumes.
+COUNTRIES = {
+    "Nigeria": {
+        "cpi_mean": 32, "cpi_std": 2.0,
+        "pop_millions": 220,
+        "agency_independence_mean": 42, "agency_independence_std": 8,
+        "whistleblower_protection_mean": 33, "whistleblower_protection_std": 7,
+        "cases_investigated_range": (10000, 18000),  # EFCC 12,928 in 2024
+        "prosecution_rate_base": 0.35,  # EFCC: 5,083/12,928 ≈ 39%
+        "conviction_rate_base": 0.72,   # EFCC high conviction capacity
+        "asset_recovery_rate_base": 0.08,
+        "assets_usd_millions_range": (80, 250),  # EFCC $214M in 2024
+    },
+    "South Africa": {
+        "cpi_mean": 43, "cpi_std": 2.5,
+        "pop_millions": 60,
+        "agency_independence_mean": 55, "agency_independence_std": 10,
+        "whistleblower_protection_mean": 48, "whistleblower_protection_std": 9,
+        "cases_investigated_range": (1800, 2800),  # SIU 1,919 closed in 2023/24
+        "prosecution_rate_base": 0.28,  # SIU 583 referrals from 1,919
+        "conviction_rate_base": 0.75,   # NPA ~80% in commercial cases
+        "asset_recovery_rate_base": 0.12,
+        "assets_usd_millions_range": (100, 350),  # SIU R8B ≈ $430M
+    },
+    "Kenya": {
+        "cpi_mean": 30, "cpi_std": 2.0,
+        "pop_millions": 55,
+        "agency_independence_mean": 38, "agency_independence_std": 7,
+        "whistleblower_protection_mean": 30, "whistleblower_protection_std": 6,
+        "cases_investigated_range": (4000, 6000),  # EACC 5,171 reports
+        "prosecution_rate_base": 0.22,  # EACC forwards to ODPP
+        "conviction_rate_base": 0.45,   # EACC 26.7% (2023/24), improving
+        "asset_recovery_rate_base": 0.06,
+        "assets_usd_millions_range": (15, 40),
+    },
+    "Ghana": {
+        "cpi_mean": 43, "cpi_std": 2.5,
+        "pop_millions": 34,
+        "agency_independence_mean": 50, "agency_independence_std": 8,
+        "whistleblower_protection_mean": 40, "whistleblower_protection_std": 7,
+        "cases_investigated_range": (800, 1500),
+        "prosecution_rate_base": 0.30,
+        "conviction_rate_base": 0.55,
+        "asset_recovery_rate_base": 0.07,
+        "assets_usd_millions_range": (8, 30),
+    },
+    "Tanzania": {
+        "cpi_mean": 38, "cpi_std": 2.0,
+        "pop_millions": 65,
+        "agency_independence_mean": 35, "agency_independence_std": 7,
+        "whistleblower_protection_mean": 25, "whistleblower_protection_std": 6,
+        "cases_investigated_range": (2000, 4000),
+        "prosecution_rate_base": 0.25,
+        "conviction_rate_base": 0.60,
+        "asset_recovery_rate_base": 0.05,
+        "assets_usd_millions_range": (10, 35),
+    },
+    "Uganda": {
+        "cpi_mean": 26, "cpi_std": 2.0,
+        "pop_millions": 48,
+        "agency_independence_mean": 30, "agency_independence_std": 7,
+        "whistleblower_protection_mean": 22, "whistleblower_protection_std": 5,
+        "cases_investigated_range": (1500, 3000),
+        "prosecution_rate_base": 0.18,
+        "conviction_rate_base": 0.40,
+        "asset_recovery_rate_base": 0.04,
+        "assets_usd_millions_range": (5, 20),
+    },
+    "Ethiopia": {
+        "cpi_mean": 30, "cpi_std": 2.5,
+        "pop_millions": 120,
+        "agency_independence_mean": 28, "agency_independence_std": 8,
+        "whistleblower_protection_mean": 18, "whistleblower_protection_std": 5,
+        "cases_investigated_range": (1000, 2500),
+        "prosecution_rate_base": 0.15,
+        "conviction_rate_base": 0.50,
+        "asset_recovery_rate_base": 0.04,
+        "assets_usd_millions_range": (5, 25),
+    },
+    "Senegal": {
+        "cpi_mean": 46, "cpi_std": 2.0,
+        "pop_millions": 18,
+        "agency_independence_mean": 55, "agency_independence_std": 8,
+        "whistleblower_protection_mean": 42, "whistleblower_protection_std": 7,
+        "cases_investigated_range": (600, 1200),
+        "prosecution_rate_base": 0.32,
+        "conviction_rate_base": 0.55,
+        "asset_recovery_rate_base": 0.08,
+        "assets_usd_millions_range": (5, 20),
+    },
+    "Mozambique": {
+        "cpi_mean": 21, "cpi_std": 2.0,
+        "pop_millions": 33,
+        "agency_independence_mean": 22, "agency_independence_std": 6,
+        "whistleblower_protection_mean": 15, "whistleblower_protection_std": 4,
+        "cases_investigated_range": (300, 800),
+        "prosecution_rate_base": 0.12,
+        "conviction_rate_base": 0.35,
+        "asset_recovery_rate_base": 0.03,
+        "assets_usd_millions_range": (2, 10),
+    },
+    "Zambia": {
+        "cpi_mean": 33, "cpi_std": 2.0,
+        "pop_millions": 20,
+        "agency_independence_mean": 40, "agency_independence_std": 7,
+        "whistleblower_protection_mean": 28, "whistleblower_protection_std": 6,
+        "cases_investigated_range": (500, 1200),
+        "prosecution_rate_base": 0.20,
+        "conviction_rate_base": 0.45,
+        "asset_recovery_rate_base": 0.05,
+        "assets_usd_millions_range": (3, 15),
+    },
+    "Rwanda": {
+        "cpi_mean": 58, "cpi_std": 2.5,
+        "pop_millions": 14,
+        "agency_independence_mean": 65, "agency_independence_std": 8,
+        "whistleblower_protection_mean": 55, "whistleblower_protection_std": 8,
+        "cases_investigated_range": (400, 900),
+        "prosecution_rate_base": 0.45,
+        "conviction_rate_base": 0.70,
+        "asset_recovery_rate_base": 0.15,
+        "assets_usd_millions_range": (3, 12),
+    },
+    "Botswana": {
+        "cpi_mean": 58, "cpi_std": 2.5,
+        "pop_millions": 2.6,
+        "agency_independence_mean": 62, "agency_independence_std": 8,
+        "whistleblower_protection_mean": 50, "whistleblower_protection_std": 8,
+        "cases_investigated_range": (200, 500),
+        "prosecution_rate_base": 0.40,
+        "conviction_rate_base": 0.65,
+        "asset_recovery_rate_base": 0.12,
+        "assets_usd_millions_range": (2, 8),
+    },
+}
+
+SCENARIOS = {
+    "baseline": {
+        "cpi_shift": 0,
+        "agency_shift": 0,
+        "whistleblower_shift": 0,
+        "prosecution_multiplier": 1.0,
+        "conviction_multiplier": 1.0,
+        "asset_recovery_multiplier": 1.0,
+        "investigated_multiplier": 1.0,
+    },
+    "strengthened_enforcement": {
+        "cpi_shift": 8,          # +8 points on CPI
+        "agency_shift": 18,       # +18 on independence score
+        "whistleblower_shift": 20, # +20 on protection score
+        "prosecution_multiplier": 1.45,
+        "conviction_multiplier": 1.15,
+        "asset_recovery_multiplier": 2.0,
+        "investigated_multiplier": 1.25,
+    },
+    "weakened_accountability": {
+        "cpi_shift": -10,
+        "agency_shift": -15,
+        "whistleblower_shift": -15,
+        "prosecution_multiplier": 0.60,
+        "conviction_multiplier": 0.80,
+        "asset_recovery_multiplier": 0.40,
+        "investigated_multiplier": 0.70,
+    },
+}
+
+
+def clamp(x, lo, hi):
+    return np.clip(x, lo, hi)
+
+
+def generate_country_scenario(country_name, params, scenario_name, scenario_params, n_records, rng):
+    """Generate n_records for one country under one scenario."""
+
+    # ── Scores derived from scenario ──
+    cpi = rng.normal(
+        params["cpi_mean"] + scenario_params["cpi_shift"],
+        params["cpi_std"], n_records
+    )
+    cpi = clamp(cpi, 0, 100)
+
+    agency_independence = rng.normal(
+        params["agency_independence_mean"] + scenario_params["agency_shift"],
+        params["agency_independence_std"], n_records
+    )
+    agency_independence = clamp(agency_independence, 0, 100)
+
+    whistleblower_protection = rng.normal(
+        params["whistleblower_protection_mean"] + scenario_params["whistleblower_shift"],
+        params["whistleblower_protection_std"], n_records
+    )
+    whistleblower_protection = clamp(whistleblower_protection, 0, 100)
+
+    # ── Cases investigated (population-scaled) ──
+    pop_scale = params["pop_millions"] / 60  # normalise to SA baseline
+    inv_lo, inv_hi = params["cases_investigated_range"]
+    inv_base = rng.uniform(inv_lo * pop_scale, inv_hi * pop_scale, n_records)
+    cases_investigated = np.round(
+        inv_base * scenario_params["investigated_multiplier"]
+    ).astype(int)
+    cases_investigated = np.maximum(cases_investigated, 10)
+
+    # ── Prosecution rate (correlated with agency independence) ──
+    prot_base = params["prosecution_rate_base"] * scenario_params["prosecution_multiplier"]
+    # Agency independence boosts prosecution rate
+    agency_effect = (agency_independence - 50) / 500  # ±0.1 shift
+    prosecution_rate = prot_base + agency_effect + rng.normal(0, 0.04, n_records)
+    prosecution_rate = clamp(prosecution_rate, 0.02, 0.85)
+
+    cases_prosecuted = np.round(cases_investigated * prosecution_rate).astype(int)
+    cases_prosecuted = np.minimum(cases_prosecuted, cases_investigated)
+    cases_prosecuted = np.maximum(cases_prosecuted, 0)
+
+    # ── Conviction rate ─���
+    conv_base = params["conviction_rate_base"] * scenario_params["conviction_multiplier"]
+    conv_rate = conv_base + rng.normal(0, 0.06, n_records)
+    conv_rate = clamp(conv_rate, 0.05, 0.95)
+
+    convictions = np.round(cases_prosecuted * conv_rate).astype(int)
+    convictions = np.minimum(convictions, cases_prosecuted)
+    convictions = np.maximum(convictions, 0)
+
+    # ── Asset confiscation ──
+    asset_lo, asset_hi = params["assets_usd_millions_range"]
+    assets_confiscated = rng.uniform(asset_lo, asset_hi, n_records) * scenario_params["asset_recovery_multiplier"]
+    assets_confiscated = np.maximum(assets_confiscated, 0.1)
+
+    asset_recovery_rate = params["asset_recovery_rate_base"] * scenario_params["asset_recovery_multiplier"]
+    asset_recovery_rate = clamp(
+        asset_recovery_rate + rng.normal(0, 0.02, n_records), 0.01, 0.50
+    )
+
+    # ── Whistleblower reports ──
+    wb_base = cases_investigated * rng.uniform(0.3, 0.8, n_records)
+    wb_effect = 1 + (whistleblower_protection - 30) / 100
+    whistleblower_reports = np.round(wb_base * wb_effect).astype(int)
+    whistleblower_reports = np.maximum(whistleblower_reports, 0)
+
+    # ── Enforcement effectiveness composite ──
+    enforcement_effectiveness = (
+        0.25 * (prosecution_rate / 0.5) +
+        0.25 * (conv_rate / 0.8) +
+        0.20 * (asset_recovery_rate / 0.15) +
+        0.15 * (agency_independence / 100) +
+        0.15 * (whistleblower_protection / 100)
+    ) * 100
+    enforcement_effectiveness = clamp(enforcement_effectiveness, 0, 100)
+
+    # ── Enforcement class ──
+    enforcement_class = np.where(
+        enforcement_effectiveness >= 60, "strong",
+        np.where(enforcement_effectiveness >= 35, "moderate", "weak")
+    )
+
+    # ── Build DataFrame ──
+    df = pd.DataFrame({
+        "country": country_name,
+        "scenario": scenario_name,
+        "corruption_perception_index": np.round(cpi, 1),
+        "cases_investigated": cases_investigated,
+        "cases_prosecuted": cases_prosecuted,
+        "prosecution_rate": np.round(prosecution_rate, 4),
+        "convictions": convictions,
+        "conviction_rate": np.round(conv_rate, 4),
+        "assets_confiscated_usd_millions": np.round(assets_confiscated, 2),
+        "asset_recovery_rate": np.round(asset_recovery_rate, 4),
+        "whistleblower_reports": whistleblower_reports,
+        "whistleblower_protection_score": np.round(whistleblower_protection, 1),
+        "agency_independence_score": np.round(agency_independence, 1),
+        "enforcement_effectiveness_score": np.round(enforcement_effectiveness, 1),
+        "enforcement_class": enforcement_class,
+    })
+    return df
+
+
+def generate_dataset(scenario, n_per_country=834, seed=RNG_SEED):
+    """Generate full dataset for one scenario across all 12 countries."""
+    rng = np.random.default_rng(seed)
+    scenario_params = SCENARIOS[scenario]
+    frames = []
+    for country_name, params in COUNTRIES.items():
+        df = generate_country_scenario(
+            country_name, params, scenario, scenario_params, n_per_country, rng
+        )
+        frames.append(df)
+    full = pd.concat(frames, ignore_index=True)
+    # Shuffle
+    full = full.sample(frac=1, random_state=seed).reset_index(drop=True)
+    return full
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Generate anti-corruption enforcement dataset")
+    parser.add_argument("--scenario", type=str, default="all",
+                        choices=list(SCENARIOS.keys()) + ["all"])
+    parser.add_argument("--n-records", type=int, default=10000,
+                        help="Total records per scenario (split across 12 countries)")
+    parser.add_argument("--output-dir", type=str, default="data")
+    args = parser.parse_args()
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    scenarios = list(SCENARIOS.keys()) if args.scenario == "all" else [args.scenario]
+
+    for scen in scenarios:
+        n_per_country = args.n_records // len(COUNTRIES)
+        remainder = args.n_records - n_per_country * len(COUNTRIES)
+        df = generate_dataset(scen, n_per_country=n_per_country)
+        # Add extra records to first country to hit exact count
+        if remainder > 0:
+            rng = np.random.default_rng(RNG_SEED + 99)
+            extra = generate_country_scenario(
+                list(COUNTRIES.keys())[0],
+                COUNTRIES[list(COUNTRIES.keys())[0]],
+                scen, SCENARIOS[scen], remainder, rng
+            )
+            df = pd.concat([df, extra], ignore_index=True)
+            df = df.sample(frac=1, random_state=RNG_SEED).reset_index(drop=True)
+
+        out_path = os.path.join(args.output_dir, f"{scen}.csv")
+        df.to_csv(out_path, index=False)
+        print(f"Generated {len(df)} records → {out_path}")
+
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -0,0 +1,4 @@
+numpy>=1.24
+pandas>=2.0
+scipy>=1.10
+matplotlib>=3.7

validate_dataset.py

@@ -0,0 +1,251 @@
+#!/usr/bin/env python3
+"""
+Validate African Anti-Corruption Enforcement dataset.
+
+Runs plausibility checks and produces 8-panel diagnostic plots.
+"""
+
+import os
+import sys
+import argparse
+import numpy as np
+import pandas as pd
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+
+DATA_DIR = "data"
+PLOT_DIR = "plots"
+
+SCENARIOS = ["baseline", "strengthened_enforcement", "weakened_accountability"]
+
+
+def load_data(data_dir):
+    frames = {}
+    for scen in SCENARIOS:
+        path = os.path.join(data_dir, f"{scen}.csv")
+        if not os.path.exists(path):
+            print(f"WARNING: {path} not found, skipping")
+            continue
+        frames[scen] = pd.read_csv(path)
+    return frames
+
+
+# ── Plausibility checks ─────────────────────────────────────────────
+
+def run_checks(frames):
+    issues = []
+    for scen, df in frames.items():
+        n = len(df)
+        print(f"\n{'='*60}")
+        print(f"Scenario: {scen}  ({n} records)")
+        print(f"{'='*60}")
+
+        # 1. Record count
+        assert n == 10000, f"Expected 10000 records, got {n}"
+        print(f"  [OK] Record count: {n}")
+
+        # 2. Country coverage
+        countries = df["country"].nunique()
+        assert countries == 12, f"Expected 12 countries, got {countries}"
+        print(f"  [OK] Country coverage: {countries}")
+
+        # 3. CPI range
+        cpi_ok = df["corruption_perception_index"].between(0, 100).all()
+        print(f"  [{'OK' if cpi_ok else 'FAIL'}] CPI in [0,100]: "
+              f"{df['corruption_perception_index'].min():.1f} – "
+              f"{df['corruption_perception_index'].max():.1f}")
+        if not cpi_ok:
+            issues.append(f"{scen}: CPI out of range")
+
+        # 4. Rates in [0, 1]
+        for col in ["prosecution_rate", "conviction_rate", "asset_recovery_rate"]:
+            r_ok = df[col].between(0, 1).all()
+            print(f"  [{'OK' if r_ok else 'FAIL'}] {col} in [0,1]: "
+                  f"{df[col].min():.4f} – {df[col].max():.4f}")
+            if not r_ok:
+                issues.append(f"{scen}: {col} out of range")
+
+        # 5. Scores in [0, 100]
+        for col in ["whistleblower_protection_score", "agency_independence_score",
+                     "enforcement_effectiveness_score"]:
+            s_ok = df[col].between(0, 100).all()
+            print(f"  [{'OK' if s_ok else 'FAIL'}] {col} in [0,100]: "
+                  f"{df[col].min():.1f} – {df[col].max():.1f}")
+            if not s_ok:
+                issues.append(f"{scen}: {col} out of range")
+
+        # 6. Monotonicity: prosecuted <= investigated
+        mono_ok = (df["cases_prosecuted"] <= df["cases_investigated"]).all()
+        print(f"  [{'OK' if mono_ok else 'FAIL'}] cases_prosecuted <= cases_investigated")
+        if not mono_ok:
+            issues.append(f"{scen}: prosecution > investigation")
+
+        # 7. convictions <= cases_prosecuted
+        conv_ok = (df["convictions"] <= df["cases_prosecuted"]).all()
+        print(f"  [{'OK' if conv_ok else 'FAIL'}] convictions <= cases_prosecuted")
+        if not conv_ok:
+            issues.append(f"{scen}: convictions > prosecuted")
+
+        # 8. Enforcement class consistency
+        class_ok = set(df["enforcement_class"].unique()) <= {"strong", "moderate", "weak"}
+        print(f"  [{'OK' if class_ok else 'FAIL'}] enforcement_class values valid")
+
+        # 9. SSA-typical prosecution rate (<60% for most)
+        median_prosec = df["prosecution_rate"].median()
+        print(f"  [INFO] Median prosecution rate: {median_prosec:.3f}")
+
+        # 10. SSA-typical asset recovery (<30%)
+        median_asset = df["asset_recovery_rate"].median()
+        print(f"  [INFO] Median asset recovery rate: {median_asset:.3f}")
+
+        # 11. Summary stats by country
+        print(f"\n  Country-level median CPI:")
+        for c, g in df.groupby("country"):
+            print(f"    {c:15s} CPI={g['corruption_perception_index'].median():5.1f}  "
+                  f"prosec_rate={g['prosecution_rate'].median():.3f}  "
+                  f"conv_rate={g['conviction_rate'].median():.3f}")
+
+    if issues:
+        print(f"\n{'!'*60}")
+        print(f"ISSUES FOUND ({len(issues)}):")
+        for iss in issues:
+            print(f"  - {iss}")
+    else:
+        print(f"\n{'='*60}")
+        print("ALL CHECKS PASSED")
+    return issues
+
+
+# ── Diagnostic plots ────────────────────────────────────────────────
+
+def make_plots(frames, plot_dir):
+    os.makedirs(plot_dir, exist_ok=True)
+    fig, axes = plt.subplots(2, 4, figsize=(24, 12))
+    fig.suptitle("African Anti-Corruption Enforcement – Diagnostic Plots",
+                 fontsize=16, fontweight="bold", y=1.01)
+
+    palette = {"baseline": "#2166ac",
+               "strengthened_enforcement": "#1a9641",
+               "weakened_accountability": "#d73027"}
+
+    # ── Panel 1: CPI distribution by scenario ──
+    ax = axes[0, 0]
+    for scen, df in frames.items():
+        ax.hist(df["corruption_perception_index"], bins=40, alpha=0.5,
+                label=scen.replace("_", " "), color=palette[scen], density=True)
+    ax.set_xlabel("Corruption Perception Index")
+    ax.set_ylabel("Density")
+    ax.set_title("(a) CPI Distribution")
+    ax.legend(fontsize=7)
+
+    # ── Panel 2: Prosecution rate by country ──
+    ax = axes[0, 1]
+    country_order = sorted(frames["baseline"]["country"].unique())
+    data_baseline = [frames["baseline"].loc[frames["baseline"]["country"] == c,
+                     "prosecution_rate"].values for c in country_order]
+    bp = ax.boxplot(data_baseline, labels=[c[:6] for c in country_order],
+                    patch_artist=True, showfliers=False)
+    for patch in bp["boxes"]:
+        patch.set_facecolor("#abd9e9")
+    ax.set_ylabel("Prosecution Rate")
+    ax.set_title("(b) Prosecution Rate (Baseline)")
+    ax.tick_params(axis="x", rotation=45)
+
+    # ── Panel 3: Conviction rate by scenario ──
+    ax = axes[0, 2]
+    conv_data = []
+    labels = []
+    for scen in SCENARIOS:
+        if scen in frames:
+            conv_data.append(frames[scen]["conviction_rate"].values)
+            labels.append(scen.replace("_", "\n"))
+    bp2 = ax.boxplot(conv_data, labels=labels, patch_artist=True, showfliers=False)
+    colors = [palette[s] for s in SCENARIOS if s in frames]
+    for patch, color in zip(bp2["boxes"], colors):
+        patch.set_facecolor(color)
+        patch.set_alpha(0.6)
+    ax.set_ylabel("Conviction Rate")
+    ax.set_title("(c) Conviction Rate by Scenario")
+
+    # ── Panel 4: Asset recovery vs CPI ──
+    ax = axes[0, 3]
+    for scen, df in frames.items():
+        sample = df.sample(min(2000, len(df)), random_state=42)
+        ax.scatter(sample["corruption_perception_index"],
+                   sample["asset_recovery_rate"] * 100,
+                   alpha=0.15, s=8, color=palette[scen], label=scen.replace("_", " "))
+    ax.set_xlabel("CPI")
+    ax.set_ylabel("Asset Recovery Rate (%)")
+    ax.set_title("(d) Asset Recovery vs CPI")
+    ax.legend(fontsize=7)
+
+    # ── Panel 5: Enforcement effectiveness by country ──
+    ax = axes[1, 0]
+    means = frames["baseline"].groupby("country")["enforcement_effectiveness_score"].mean()
+    means = means.sort_values()
+    bars = ax.barh([c[:10] for c in means.index], means.values, color="#4393c3")
+    ax.set_xlabel("Mean Enforcement Effectiveness Score")
+    ax.set_title("(e) Enforcement Effectiveness (Baseline)")
+
+    # ── Panel 6: Whistleblower reports vs protection score ──
+    ax = axes[1, 1]
+    for scen, df in frames.items():
+        sample = df.sample(min(2000, len(df)), random_state=42)
+        ax.scatter(sample["whistleblower_protection_score"],
+                   sample["whistleblower_reports"],
+                   alpha=0.12, s=8, color=palette[scen])
+    ax.set_xlabel("Whistleblower Protection Score")
+    ax.set_ylabel("Whistleblower Reports")
+    ax.set_title("(f) WB Reports vs Protection")
+
+    # ── Panel 7: Prosecution pipeline (log scale) ──
+    ax = axes[1, 2]
+    for scen, df in frames.items():
+        med = df[["cases_investigated", "cases_prosecuted", "convictions"]].median()
+        ax.plot(["Investigated", "Prosecuted", "Convicted"],
+                med.values, marker="o", linewidth=2,
+                color=palette[scen], label=scen.replace("_", " "))
+    ax.set_ylabel("Median Cases (log)")
+    ax.set_yscale("log")
+    ax.set_title("(g) Prosecution Pipeline")
+    ax.legend(fontsize=7)
+
+    # ── Panel 8: Agency independence vs prosecution rate ──
+    ax = axes[1, 3]
+    for scen, df in frames.items():
+        sample = df.sample(min(2000, len(df)), random_state=42)
+        ax.scatter(sample["agency_independence_score"],
+                   sample["prosecution_rate"] * 100,
+                   alpha=0.12, s=8, color=palette[scen])
+    ax.set_xlabel("Agency Independence Score")
+    ax.set_ylabel("Prosecution Rate (%)")
+    ax.set_title("(h) Agency Independence vs Prosecution")
+
+    plt.tight_layout()
+    out_path = os.path.join(plot_dir, "diagnostic_panels.png")
+    fig.savefig(out_path, dpi=150, bbox_inches="tight")
+    plt.close(fig)
+    print(f"\nDiagnostic plots saved → {out_path}")
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--data-dir", default=DATA_DIR)
+    parser.add_argument("--plot-dir", default=PLOT_DIR)
+    args = parser.parse_args()
+
+    frames = load_data(args.data_dir)
+    if not frames:
+        print("No data files found. Run generate_dataset.py first.")
+        sys.exit(1)
+
+    issues = run_checks(frames)
+    make_plots(frames, args.plot_dir)
+
+    if issues:
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()