Fairness Constraint

A stricter extension of equal opportunity, requiring that both true positive rates and false positive rates are equal across groups. A classifier satisfies equalized odds if P(Ŷ=1 | Y=y, A=a) = P(Ŷ=1 | Y=y, A=b) for both y = 0 and y = 1. This ensures the classifier's error rates are group-blind.

• Use Case: Criminal justice risk assessment or medical testing, where both types of errors (false positives and false negatives) carry significant consequences that must be balanced fairly.
• Challenge: Satisfying equalized odds is often incompatible with achieving perfect accuracy unless the base rates (P(Y=1 | A)) are also equal.

Also known as outcome test, this metric requires that the precision (positive predictive value) is equal across groups. A classifier satisfies predictive parity if P(Y=1 | Ŷ=1, A=a) = P(Y=1 | Ŷ=1, A=b). It ensures that the likelihood of a positive prediction being correct is the same for everyone selected.

• Use Case: Deploying a model where the cost of a false positive is high and must be uniformly distributed, such as in investigative resource allocation.
• Implication: If base rates differ, predictive parity is often mathematically incompatible with equalized odds (a result known as the fairness impossibility theorem).

This metric focuses on balancing the types of errors made across groups by requiring the ratio of false negatives to false positives to be equal. Formally, a classifier satisfies treatment equality if FN_a / FP_a = FN_b / FP_b, where FN and FP are counts of false negatives and false positives.

• Use Case: Scenarios where the social cost or impact of different error types must be balanced equitably, not just the rates. For example, balancing under-service vs. over-penalization.
• Method: Enforced as a linear constraint on the confusion matrix entries during optimization.

A causal fairness metric that requires a prediction to be the same in the actual world and a counterfactual world where an individual's protected attribute had been different. Formally, P(Ŷ_A←a(U) = y | X=x, A=a) = P(Ŷ_A←a'(U) = y | X=x, A=a) for all y and any a' ≠ a. U represents latent background variables.

• Use Case: High-stakes decisions like lending or insurance, where the goal is to eliminate the direct causal influence of a protected attribute on the outcome.
• Implementation: Requires a causal model of the data-generating process. Constraints are applied by ensuring predictions are based on non-descendants of the protected attribute in the causal graph.

Constrained decoding is an inference-time technique that restricts an AI model's token-generation process to enforce specific rules. It is a direct method for implementing certain types of fairness constraints and other policies during text generation. Unlike training-time methods, it acts on the fly:

• Lexical constraints: Force or ban specific words or phrases.
• Semantic constraints: Guide output toward or away from certain concepts using guided generation or activation steering.
• Structural constraints: Enforce JSON, XML, or other formal grammars. This approach provides precise, immediate control but does not change the underlying model's learned behavior.

Value alignment is the overarching field of AI safety focused on ensuring an AI system's goals and behaviors are compatible with human values and ethical principles. Implementing fairness constraints is a concrete engineering task within the technical pursuit of value alignment. The field addresses:

• Specifying values: Translating vague human ethics into precise, implementable objectives (e.g., fairness metrics).
• Robust alignment: Ensuring aligned behavior persists across novel situations and adversarial inputs.
• Scalable oversight: Developing techniques like RLHF and RLAIF to align systems more capable than their human supervisors. Fairness is one core human value among many (e.g., honesty, harmlessness) that alignment seeks to instill.

Policy-as-code is the engineering practice of formally defining governance rules, safety principles, and compliance requirements in executable, version-controlled code. A fairness constraint is a prime example of policy-as-code—a statistical rule translated into a software test or a loss function term. This approach enables:

• Automated enforcement: Policies are consistently applied without manual review.
• Testing and validation: Policies can be unit-tested and integrated into CI/CD pipelines.
• Auditability: Every policy change is tracked in git, creating a clear compliance trail. It transforms subjective guidelines into objective, verifiable technical artifacts.

Multi-objective optimization is the algorithmic framework for finding solutions that balance competing goals. Implementing a fairness constraint typically transforms model training into a multi-objective problem, where the primary objective (e.g., accuracy) must be optimized alongside fairness metrics (e.g., equality of opportunity). Engineers use techniques like:

• Pareto optimization: Finding the set of solutions where one objective cannot be improved without harming another.
• Scalarization: Combining multiple objectives into a single weighted loss function (a common method for fairness constraints).
• Constraint optimization: Treating fairness as a hard constraint while optimizing for accuracy. This framework is essential for navigating the inherent trade-offs in building equitable AI systems.