A Modular Testbed for Ethics: Turning Philosophical Theories into Comparable Mathematical Programs

Abstract

We present a small, auditable framework that converts major ethical views into modular evaluators running on shared scenarios. Facts are represented by a causal world model. Values are encoded as normative modules, which output theory-specific scores or constraints. Moral disagreement is handled by explicit credences with safeguards for rights. We release a schema, two seed scenarios & minimal implementations for consequentialism, deontic constraints & virtue distance. Early results demonstrate transparent points of agreement & principled divergence.

1. Introduction

Ethical debate often stalls on rhetoric. We aim for clarity by separating facts from values & by running rival views on the same inputs. The contribution is a minimal, extensible testbed: a shared scenario format; modular evaluators for major theories; an aggregation rule for pluralism & an axiom ledger that records assumptions in plain English.

2. Framework

2.1 World models & scenarios

A scenario encodes agents, actions, outcomes & constraints. A world model $M$ provides $P(O \mid a, M)$, the distribution over outcomes for each action $a$.

2.2 Normative modules

Each ethical view $j$ contributes either a choiceworthiness function $CW_j(a \mid M)$ or admissibility constraints $g_k(a,M)\le 0$. Modules depend only on scenario fields & shared utilities.

2.3 Moral uncertainty & aggregation

After normalizing module outputs to $[0,1]$ within a scenario, we aggregate by credences $p_j$: $$ CW(a)=\sum_j p_j\, f_j\!\left(\widehat{CW}_j(a)\right) $$ We apply deontic red lines lexicographically: reject actions that violate mandatory constraints, then compare remaining options by $CW$.

2.4 Explanation sets

Each recommendation includes a minimal explanation set: the smallest group of premises that drove the result. This improves transparency & supports disagreement.

3. Implementations of Theories

CW_cons(a) = E[ Σ_i w_i · v(U_i(O)) | a, M ]
v(u) is concave; w_i ≥ 0.

Admissible(a) iff ∀k: g_k(a,M) ≤ 0
Examples: respect informed consent; treat like cases alike; keep credible promises.

CW_virtue(a) = - || T_after(a) - T* ||
Traits: honesty, compassion, fairness.

normalize(x) = (x - min_a x) / (max_a x - min_a x + ε)

4. Scenario Schema & Dataset

The schema is compact & human-readable. It keeps facts explicit & leaves values to the modules.

{
  "id": "string",
  "context": {
    "domain": "triage|evacuation|policy|...",
    "tags": ["emergency", "resource-scarce"],
    "culture": {"consent_threshold": 0.7, "complaint_norm": "strict"}
  },
  "agents": [
    {"id":"A","baseline":{"wellbeing":0.55,"years_left":35},
     "dependencies":["child_C"],"consent":true,"role":"patient"}
  ],
  "actions": ["a1","a2","a3"],
  "outcomes": {
    "a1": [{"p":0.8,"A":{"alive":true,"years_gain":35}}],
    "a2": [{"p":0.6,"B":{"alive":true,"years_gain":35}}]
  },
  "constraints": {
    "no_intentional_harm_innocent": true,
    "treat_like_cases_alike": true,
    "respect_informed_consent": true
  },
  "notes": "assumptions here"
}

4.1 Seed scenarios

{
  "id":"triage-vent-v1",
  "agents":[
    {"id":"A","baseline":{"wellbeing":0.55,"years_left":35},"consent":true,
     "survival":{"vent":0.80,"no_vent":0.10}},
    {"id":"B","baseline":{"wellbeing":0.55,"years_left":35},"consent":true,
     "survival":{"vent":0.60,"no_vent":0.55}}
  ],
  "actions":["a1_allocate_A","a2_allocate_B","a3_lottery"],
  "notes":"Prognosis differences count as relevant; lottery allowed when differences are small."
}

{
  "id":"evac-promise-v1",
  "context":{"tags":["flood","resource-scarce"]},
  "agents":["D1(elderly)","D2","D3","D4","D5","R(rescuer_with_promise_to_D1)"],
  "boat_capacity":3,
  "prob_survive_if_rescued":0.95,
  "prob_if_delayed":{"east":0.40,"west":0.60},
  "actions":["b1_east_now","b2_west_plus_one_east","b3_mixed_break_promise"]
}

5. Experiments

We compute module outputs for each action & apply deontic admissibility. Remaining actions are ranked by the aggregated score with credences $p = \{ p_{\text{cons}}, p_{\text{deon}}, p_{\text{virtue}} \}$.

6. Results

Placeholder for first runs. We report for each scenario: module-wise recommendations, admissibility rejections, final aggregated choice & the minimal explanation set.

Module picks (illustrative)
- Consequentialism: a1_allocate_A
- Deontic: all admissible
- Virtue: a1 with fairness note
Aggregate (p = {0.5,0.3,0.2}): a1

Module picks (illustrative)
- Consequentialism: b2_west_plus_one_east
- Deontic: b2 inadmissible if promise is hard; b3 admissible
- Virtue: b3 (compassion, honesty)
Aggregate (p = {0.5,0.3,0.2}): depends on promise rule

7. Limitations & Ethical Considerations

• Interpersonal comparability. Report cardinal & ordinal analyses side by side.
• Rights are not utilities. Enforce side-constraints lexically before trade-offs.
• Culture. Tune parameters with stratified reporting rather than averaging away divergence.
• Misuse risk. Require explanation sets & scope notes for each deployment.

8. Axiom Ledger & Reproducibility

Run ID: RUN-YYYYMMDD-N
Ledger: Axiom v0.1
Modules: cons v0.1, deon v0.1, virtue v0.1
Seeds: triage-vent-v1, evac-promise-v1
Random seed: 42

9. Discussion & Future Work

• Richer rights models & role-based duties.
• Learning value weights safely from diverse panels.
• Dynamic contexts & sequential decisions.
• Cross-cultural replication with preregistered scenarios.

Appendices

A. Normalization proof sketch

Min–max mapping is monotone & affine-invariant within the action set; $\epsilon$ prevents divide-by-zero when actions tie.

B. Constraint algebra (examples)

// Promise keeping as hard constraint unless large-harm override
g_promise(a,M) = I[ a breaks credible promise ] · I[ ΔLivesSaved(a_alt,a) < θ ] - 0

// Treat like cases alike
g_like(a,M) = max(0, dissimilarity_irrelevant(a))

C. Minimal explanation sets (template)

[
  "E1: Prognosis delta between A and B is material.",
  "E2: Promise treated as hard only when ΔLivesSaved < θ.",
  "E3: Credences p = {0.5,0.3,0.2}."
]

D. Project log

Week 0 — Scaffold: Ledger v0.1, schema, two scenarios.
Week 1 — First runs: baseline modules and sensitivity sweep. (pending)