Ethical Compilation: What's Lost When "Be Fair" Becomes Code

Tell a person to "be fair" and they understand something rich, contextual, and flexible. Tell a computer to be fair and you face a brutal demand for precision: fair how? A landmark result in computer science made the difficulty exact. When researchers formalized several intuitive, reasonable definitions of fairness for an algorithm — that it be equally accurate across groups, that a positive prediction mean the same thing across groups, that error rates match across groups — they proved these definitions are, except in trivial cases, mathematically incompatible: you cannot satisfy all of them at once. So "be fair," which felt like a single coherent principle, turns out to compile into several conflicting operational definitions, and building the algorithm forces you to pick one — to choose which fairness you will implement and which you will violate, a choice the original principle never told you how to make. The rich human value did not translate cleanly into executable behavior. It was approximated, lossily, into a specific operationalization that captures part of it and loses the rest.

This is ethical compilation: the process of translating a rich ethical principle into executable behavior — code, rules, metrics — which inevitably introduces approximation and loss, because human values are contextual and underspecified while code demands precision, so the principle must be forced into a specific operationalization that captures some of it and distorts or discards the rest. Something is always lost in the compilation from "be fair" to if/then.

Why the compilation is lossy

Ethical compilation loses information because human values and executable code have fundamentally different natures: values are rich, contextual, and deliberately flexible, while code is precise, literal, and rigid — so forcing the first into the second must discard exactly the flexibility that made the value work. A human ethical principle like fairness, dignity, or harm-avoidance is not a precise algorithm; it is a contextual judgment that competent people apply flexibly to situations, weighing factors the principle never enumerates, and its power lies partly in that flexibility — in not being fully specified, so it can adapt to cases no rule anticipated. Compiling it into code destroys the flexibility: you must specify, exactly, what fairness computes to, which forces you to pick one operationalization among several incompatible ones (the fairness-impossibility result made this precise) and to freeze the contextual judgment into a fixed rule that cannot adapt. The series' Criteria Collapse (#146) named this flattening of rich judgment into checkable proxy; ethical compilation is its application to values, where the compilation from principle to code is exactly the collapse — the rich "be fair" becoming the narrow "equalize this specific metric," which is part of fairness mistaken for the whole. And the loss is not a bug to be fixed but intrinsic: there is no lossless compilation of an underspecified contextual value into precise executable behavior, because the very properties that make the value work (flexibility, context-sensitivity, the capacity to handle the unanticipated) are the properties code cannot hold. You can compile ethics into code, but never without leaving some of the ethics behind.

Why this matters as machines make moral decisions

Ethical compilation matters urgently because we are increasingly delegating moral decisions to machines, which means the lossy compilation is not academic — the approximation of the value is what actually governs real outcomes for real people. When an algorithm decides who gets a loan, a job interview, or bail, the "fairness" it implements is not the rich human principle but the specific compiled operationalization someone chose, and everyone affected is governed by that approximation — including the parts of fairness it lost, which now simply do not apply, invisibly. This is dangerous in a specific way: the compiled ethics looks like the principle (we call it "fairness"), so people assume the machine embodies the value, when it embodies only a lossy operationalization of it — the gap between "be fair" and the specific metric is exactly what the machine cannot see and the affected cannot appeal to. And the choice of which operationalization to compile — which is a genuine ethical decision, since the definitions conflict — often gets made implicitly, by an engineer picking a metric, rather than deliberately, so the moral choice of which fairness to honor is buried in a technical decision that looks neutral. This is the series' Verification Ethics (#190) and Complexity Laundering (#133) converging: a value-laden moral choice (which fairness) disguised as a technical implementation detail, its ethics hidden in the compilation. As more consequential decisions are delegated to compiled ethics, the stakes of what gets lost in the compilation — and who chose the operationalization — rise from theoretical to determinative.

The counterpoint: humans compile lossily too, and code can clarify

Honesty requires the strong objection, because ethical compilation can imply that human moral judgment is a lossless ideal that code betrays — and that is false, because humans also compile ethics lossily, and making ethics explicit in code can sometimes improve it. Human application of ethical principles is not some perfect lossless process: people apply "be fair" inconsistently, unconsciously biased, unable to articulate what they mean, and the flexibility that ethical compilation mourns is also the vagueness that lets human "fairness" hide prejudice and caprice — so the compiled algorithm, forced to specify, can be more consistent and more auditable than the human judgment it replaces. Forcing a value into code can even clarify it: the fairness-impossibility result was a genuine discovery, revealing that our intuitive fairness was internally contradictory all along — knowledge the compilation produced, not destroyed. And the explicit operationalization, unlike the human's implicit one, can be examined and contested, where the human's flexible judgment is often unaccountable. So ethical compilation is not "code corrupts pure human ethics." It is the narrower claim that compiling values into executable behavior introduces real, intrinsic approximation and loss, that this matters because compiled ethics increasingly governs real outcomes, and that the choice of operationalization is a hidden moral decision — while recognizing that human ethics is also lossily applied, that explicit compilation can improve consistency and auditability, and that being forced to specify can clarify values we only thought we understood. The point is not that ethics shouldn't be compiled but that the compilation is lossy and value-laden, and must be treated as the consequential, contestable ethical act it is — not as a neutral technical translation.

What it asks of us

Ethical compilation asks us to treat the translation of values into code as a consequential ethical act, not a neutral technical one — to make the compilation's losses and choices visible, deliberate, and contestable rather than buried in an engineer's metric selection. In practice that means acknowledging that "be fair" (and every rich value) compiles into conflicting operationalizations, so choosing which to implement is a genuine moral decision that deserves explicit, accountable deliberation rather than implicit technical default; documenting what a given operationalization captures and loses of the principle, so the gap is visible to those governed by it; and building in the ability to contest the compiled ethics — to appeal to the parts of the value the code left behind. It means using code's demand for precision as an occasion to clarify values (as the fairness-impossibility result did) rather than pretending the rich principle transferred whole. The deeper recognition is that there is no lossless compilation from human value to executable behavior — that something of the contextual, flexible principle is always left behind when it becomes a rule — and that as we delegate more moral decisions to machines, the integrity of our ethics depends on treating that compilation honestly: knowing what was lost, choosing deliberately what to keep, and never mistaking the specific metric the machine computes for the whole of the value we meant. "Be fair" will never fully compile; the ethics is in facing that, not hiding it.

This is article #197 in The IUBIRE Framework series. Ethical Compilation appears in the IUBIRE concept corpus (explorer concept #72); it does not map cleanly to a single verified source artifact, so it is grounded directly in documented results. Real-world grounding: the mathematical fairness-impossibility results (Kleinberg, Mullainathan, and Raghavan 2016; Chouldechova 2017) proving that several intuitive definitions of algorithmic fairness — calibration, balanced error rates, equal predictive value — cannot in general be satisfied simultaneously, so "be fair" compiles into conflicting operationalizations that force a choice; the general intrinsic gap between rich, contextual, underspecified human values and the precision code demands; the delegation of consequential moral decisions (lending, hiring, bail) to compiled ethics; and the countervailing points that human moral judgment is itself lossily and inconsistently applied, and that explicit compilation can improve auditability and even clarify values (the impossibility result was a genuine discovery). Related to Criteria Collapse (#146), Verification Ethics (#190), and Complexity Laundering (#133).

Next in series: Democratic Algorithms (#198)