Skip to content

Adverse Selection Pool Segmentation

Classification model — instantiates Private Information Asymmetry Governance

Sorts a mixed population into risk classes by observable proxies for the hidden type — so a party who can't see each individual's private risk can still price and pool fairly instead of being cream-skimmed by the worst hidden risks.

Adverse Selection Pool Segmentation governs a hidden-type asymmetry without ever uncovering any individual's private fact. Its distinguishing move is statistical classification from proxies: it partitions a heterogeneous population into risk classes using observable signals that correlate with the hidden type, and prices or pools each class to its own expected risk — so the pool stays robust even though the people who know their true risk are choosing whether to buy in. It does not verify a fact, elicit a confession, or induce self-selection; it makes the pool's economics defensible against the private knowledge it cannot see. Deciding which classification errors to tolerate is the second half of the mechanism.

Example

A health insurer cannot observe any applicant's true future claims, and a single undifferentiated pool invites adverse selection: the people who privately know they are high-risk buy the most coverage, premiums rise to cover them, the healthy leave, and the pool spirals toward collapse. Segmentation heads this off by sorting applicants into classes on observable proxies — age band, geography, a bounded set of underwriting factors — and pricing each class to its expected risk, so no class unknowingly subsidizes another. The insurer also fixes an explicit error stance: it would rather occasionally over-class a genuinely low-risk applicant (a false positive) than systematically under-price a high risk (a false negative) — or the reverse, where a regulator forbids a factor. The asymmetry is governed not by prying into anyone's health but by making the pool resilient to what stays hidden.

How it works

The mechanism selects observable proxies correlated with the hidden type, forms classes, and prices or pools each class separately, refitting as outcome data accrues. Two things distinguish it from verification or self-selection. First, the sorting is statistical and involuntary — the classifier assigns each member from proxies, with no requirement that anyone reveal their private fact. Second, because proxies are imperfect, the model must commit to a false-positive / false-negative policy: which direction of misclassification it will accept, given the cost of each error and the factors it is permitted to use. It contains adverse selection; it does not dissolve the asymmetry.

Tuning parameters

  • Proxy set — which observables define the classes. More proxies sort more finely but invite gaming and can encode unfair or illegal discrimination.
  • Class granularity — a few broad classes versus many fine ones. Fine classes price more accurately but thin each pool and sharpen exclusion.
  • Error stance — which misclassification to prefer — over-classing the innocent or under-pricing the risky — set by the relative cost of each.
  • Permitted factors — which proxies are legally and ethically allowed; banning a predictive-but-prohibited factor deliberately trades accuracy for fairness.
  • Refit cadence — how often class boundaries are re-estimated as fresh outcomes arrive and the underlying mix shifts.

When it helps, and when it misleads

Its strength is keeping a pool solvent under hidden heterogeneity without invading anyone's privacy — it prices to observable risk rather than to a confession. Its failure modes are serious and well known. Proxies are imperfect and can smuggle in unfair or unlawful discrimination under a risk label; fine segmentation can cause the exclusion it means to prevent, pricing a class out entirely; and it induces gaming, as people learn to present the proxies that land them in a cheaper class. The classic misuse is reverse-engineering the classes to exclude a disfavored group under a risk pretext, or setting the error policy to justify a pricing decision already made. The discipline that guards against this is validating proxies against realized outcomes, constraining the permitted factors, and watching for drift rather than trusting a one-time fit.[1]

How it implements the components

  • asymmetry_type_classifier — it assigns each member to a hidden-type class from observable proxies; this classification is the core operation.
  • false_positive_false_negative_policy — it commits to which classification error to tolerate, the tradeoff that governs how the sorting resolves under imperfect proxies.

It classifies and sets the error stance, but does not watch or repair: it does not track how base rates drift over time (base_rate_and_drift_monitor — that's Monitoring and Audit Cycle), give a mis-classed party a route to contest and correct the call (challenge_and_correction_path — that's Challenge Window and Correction Protocol, which enforces reversals under the same error policy), or elicit the hidden type through self-selection (that's Screening Menu or Self-Selection).

References

[1] Adverse selection — the dynamic Akerlof set out in "The Market for 'Lemons'," in which one side's hidden quality drives good risks out of a common pool and can unravel the market entirely. Segmentation is one standard governance response: sort on observable proxies so each pool prices its own risk instead of averaging across a mix the seller understands better than the buyer. ↩