Algorithmic Governance of Social Benefits: A Formal AI–Human Arbitration Architecture with Temporal Fairness Guarantees
ARIA does not automate decisions. It automates the question of who should make them — and proves, formally, what happens when even that question is answered correctly but the system runs long enough.
Author: Spilios Dimakopoulos · spiliosdimak@gmail.com April 2026 · Technical Report (Preprint) Paper: Read on Zenodo →
- What is ARIA?
- The Core Problem
- TFAS: Five Conditions for Temporal Fairness
- The Temporal Injustice Theorem
- Architecture
- Key Results
- Repository Structure
- Quickstart
- CI/CD Deployment Gate
- Regulatory Alignment
- Reproducibility
- Citation
Public administrations across Europe use AI systems to process applications for housing support, unemployment benefits, disability allowances, and social care. These systems can satisfy every individual fairness constraint while still producing systematic injustice at the population level over time — injustice that remains invisible until it is too late.
ARIA is a four-subsystem architecture that addresses this problem. Its theoretical foundation is the Temporally Fair Arbitration System (TFAS) — the first fairness definition to incorporate bounded human-reviewer feedback as a formal system parameter, with executable verification through a CI/CD deployment gate.
Standard fairness definitions (individual fairness, equal opportunity, counterfactual fairness) measure fairness at a single point in time. None models the feedback loop in which:
- A human reviewer, under time pressure, applies unconscious affinity bias β > 0 toward familiar groups
- Approved cases produce a positive training signal
- The model learns that demographic proxies correlate with approval
- Decision thresholds shift; escalation rates between groups diverge
- After W decisions: statistically significant disparity — without any single incorrect decision
This is structural injustice: locally correct, globally unjust.
ARIA enforces TFAS(S) ⟺ LF ∧ TS ∧ BF ∧ AUD ∧ LS:
| # | Condition | Formal | Subsystem |
|---|---|---|---|
| (i) | Local Fairness | P(esc | eᵢ, f(eᵢ)) ⊥ group(eᵢ) | SS2 |
| (ii) | Temporal Stability | r(gⱼ,t) / r(gₖ,t) ∈ [1±ε] ∀ t, gⱼ, gₖ | SS1 |
| (iii) | Bounded Feedback | |Δθ(g,t)| ≤ δ|Δθ(g,t−1)|, δ < 1 | CI/CD Gate #2 |
| (iv) | Auditability | ∀ eᵢ: rec(eᵢ) ∈ SS4 ∧ notify(DPA) ≤ τ | SS4 |
| (v) | Level Separation | G ∈ SS1.inputs, G ∉ SS2.inputs | SS2 / Gate #1 |
Where ε ∈ (0, 0.15] is the tolerance zone, δ is the feedback coefficient, and τ is the maximum DPA notification window.
Theorem. Let Π(gⱼ, t) be the marking distribution of group gⱼ at time t. If δ ≥ 1, then ∃ gⱼ, gₖ ∈ G such that:
|Π(gⱼ, t) − Π(gₖ, t)| → ∞ as t → ∞
regardless of the local correctness of each individual transition.
Proof sketch. With reviewer affinity bias β > 0 exclusively for gⱼ, after one feedback cycle r(gⱼ, 1) = r₀(1 + δβ) and r(gₖ, 1) = r₀. By induction, the ratio r(gⱼ, t) / r(gₖ, t) = (1 + δβ)ᵗ, which grows geometrically without bound when δ ≥ 1 and β > 0. Full proof in the paper on Zenodo.
Corollary (Stability Condition). TFAS(iii) δ < 1 is necessary to prevent monotonic divergence. If δ < 1, the Bounded Feedback condition ensures |Δθ(g,t)| → 0 geometrically, giving the SS1 monitor time to intervene before TFAS(ii) is violated irreversibly.
┌─────────────────────────────────────────┐
│ ARIA System │
│ │
Applicant ───────►│ SS2 Intervention Engine ──────────────►│──► SS3 Human Interface ──► Reviewer
request │ (TFAS i, v) escalate │ (TFAS iii) │
│ │ ▲ │ │ decision
│ │ │ δ control │ ▼
│ ▼ │ (dashed) │ SS4 Audit Logger ◄───────┘
│ SS1 Bias Monitor │ (TFAS iv)
│ (TFAS ii) │ │
│ │ ├──► DPA (within τ = 48h)
│ │ └──► Decision Output
└─────────────────────────────────────────┘
| Subsystem | Role | TFAS | Status |
|---|---|---|---|
| SS1 | SPC drift monitor — tracks escalation rate ratios over sliding window W | (ii) | ✅ Executable |
| SS2 | Escalation FSM — G is architecturally excluded from all individual decisions | (i), (v) | ✅ Executable |
| SS3 | Human interface — XAI counterfactuals, forced deliberation, time limit | (iii) | 📋 SysML/BPMN spec |
| SS4 | Append-only Merkle audit log — tamper-evident, DPA-notifying within τ | (iv) | ✅ Executable |
| Result | Value |
|---|---|
| Temporal Injustice Theorem | δ ≥ 1 → monotonic divergence (proved analytically, verified n = 100,000) |
| Divergence speed | δ = 1.2 diverges 2.4× faster than δ = 0.5 (OLS, R² > 0.999, p < 10⁻⁴⁰) |
| First TFAS(ii) violation | δ = 1.2 at t = 2; δ = 0.5 at t = 6 |
| Safe operating region | δ ≤ 0.6 consistently lowest violation fractions across all β tested |
| Multi-group | Theorem confirmed for |G| = 4; disabled group (β = 0.05) violates TFAS(ii) first |
| Sensitivity analysis | 15×10 grid over (δ, β); δ < 1 necessary but not sufficient at β ≥ 0.07 |
| Test suite | 30/30 passing unit tests |
| CI/CD gate | 1:1 coverage of all 5 TFAS conditions |
| Petri net | Liveness ✅, k-boundedness ✅, conservation ✅ (35,630 markings explored) |
aria-tfas/
│
├── paper/
│ ├── main.tex — LaTeX source (XeLaTeX); compiled PDF on Zenodo
│ ├── fig1_divergence.pdf — §5.3 main result
│ ├── fig2_multigroup.pdf — multi-group extension
│ ├── fig3a_sensitivity.pdf — (δ, β) sensitivity heatmap
│ ├── fig3b_sensitivity_time.pdf
│ ├── fig4_spc_monitor.pdf — SS1 SPC control chart
│ └── fig5_ss2_fsm.pdf — SS2 escalation FSM
│
├── code/
│ ├── run_all.py — generates all figures + runs tests
│ ├── requirements.txt
│ ├── conftest.py
│ ├── simulation/
│ │ ├── divergence_simulation.py — §5.3 Temporal Injustice Theorem verification
│ │ ├── sensitivity_analysis.py — §7.3 (δ, β) sensitivity grid
│ │ └── petri_net_analysis.py — Petri net liveness/boundedness
│ ├── subsystems/
│ │ ├── ss1_spc_monitor.py — SS1 SPC bias monitor
│ │ └── ss2_ss4_demo.py — SS2 escalation FSM + SS4 Merkle log
│ ├── tests/
│ │ └── test_aria.py — 30 unit tests
│ └── figures/ — pre-generated figure PDFs
│
├── .gitignore
├── LICENSE — MIT
└── README.md
Requirements: Python 3.10+
git clone https://github.com/YOUR_USERNAME/aria-tfas
cd aria-tfas/code
pip install -r requirements.txt
# Generate all figures and run all tests (~2 min)
python run_all.py
# Run test suite only (~5 seconds)
pytest tests/test_aria.py -vRun individual components:
# Temporal Injustice Theorem — main empirical verification (Fig 1 & 2)
python simulation/divergence_simulation.py
# (δ, β) sensitivity grid — 15×10 parameter sweep (Fig 3)
python simulation/sensitivity_analysis.py
# Petri net formal verification — liveness, k-boundedness, conservation
python simulation/petri_net_analysis.py
# SS1 SPC bias monitor — real-time drift detection (Fig 4)
python subsystems/ss1_spc_monitor.py
# SS2 escalation FSM + SS4 Merkle audit log demo (Fig 5)
python subsystems/ss2_ss4_demo.pyAll scripts use fixed seed 42 and produce byte-identical outputs across runs.
The gate blocks deployment on any failure, with 1:1 coverage of all TFAS conditions:
| Gate | Check | TFAS | Criterion |
|---|---|---|---|
| #1 | Model feature inspection | (v) | dem_grp ∉ model features |
| #2 | Feedback coefficient config | (iii) | fb_coef < 1.0 |
| #3 | Merkle log integrity | (iv) | Hash chain valid |
| #4 | Parameter bounds | (i) | θ ∈ [0.5, 0.95] |
| #5 | Demographic smoke test | (ii) | |r_A/r_B − 1| ≤ ε on n = 1,000 synthetic applications |
| ARIA component | Regulation | Article |
|---|---|---|
| SS4 append-only Merkle log | EU AI Act | Art. 14(4)(d) — record-keeping |
| CI/CD deployment gate | EU AI Act | Art. 9 — risk management evidence |
| DPA notification pathway | EU AI Act | Art. 14(3)(b) — human monitoring |
| TFAS(v) level separation | GDPR | Art. 22 — right to human evaluation |
| SS3 forced deliberation | EU AI Act | Art. 13 — transparency |
| Parameter | Value |
|---|---|
| Synthetic applications | n = 100,000 |
| Time steps | T = 20 |
| Sliding window | W = 10,000 |
| Tolerance zone | ε = 0.10 |
| Reviewer bias | β = 0.04 (Alon-Barkat & Busuioc 2023) |
| Bootstrap replications (main) | B = 200 |
| Bootstrap replications (sensitivity) | B = 30 per cell (150-cell grid) |
| Random seed | 42 (fixed throughout) |
| Personal data | None — all data algorithmically generated |
@techreport{dimakopoulos2026aria,
title = {{ARIA}: Accountable Real-time Intelligence Arbiter ---
Algorithmic Governance of Social Benefits: A Formal
{AI}--Human Arbitration Architecture with Temporal
Fairness Guarantees},
author = {Dimakopoulos, Spilios},
year = {2026},
month = {April},
type = {Technical Report (Preprint)},
doi = {10.5281/zenodo.XXXXXXX},
url = {https://doi.org/10.5281/zenodo.XXXXXXX}
}MIT License © 2026 Spilios Dimakopoulos. Free to use, modify, and distribute with attribution. All experiments use algorithmically generated synthetic data. No human subjects were involved.