Bet Builder — Selection Compatibility ("Padlock") Rules

Problem

When a user adds a selection to the builder, some other selections must become unavailable ("padlocked") — exactly like bet365 greys-out/suspends cells. A pair (or set) of selections is invalid when:

• Mutually exclusive — same market, pick one only (France win vs Morocco win).
• Logically contradictory — no single match outcome can make both win (Under 0.5 goals + Both Teams To Score).
• Redundant / implied — one selection is guaranteed by another, so adding it is free and pointless (France win ⇒ "France or Draw" double chance). bet365 keeps these selectable but the combined price = the dominant single; we can either allow-and-collapse or hide them.

Everything else is compatible (and, for pricing, may still be correlated — that's a separate concern; see bet365-betbuilder-correlation-findings.md).

Core idea — selections as constraints over the outcome space

Don't hand-code every pair. Model each selection as a predicate over match outcome variables, then:

Two selections are compatible ⟺ there exists at least one match outcome that satisfies all their predicates. Selection B is redundant given A ⟺ every outcome satisfying A also satisfies B (A ⊆ B).

This one rule derives every padlock automatically and correctly, including 3-way and n-way combinations, with no matrix to maintain.

Outcome variables

For a single fixture, an "outcome" is an assignment of:

Enumerate over a bounded grid (e.g. each goal count 0..8, corners 0..25) and test satisfiability. The grid is tiny and the check is instant. Variable families that never interact (goals vs corners vs cards) can be checked independently — a goals selection can only conflict with another goals/result selection, etc.

Selection → predicate (goals / result family)

Corners / cards markets map the same way onto hc,ac / hk,ak.

Worked examples (all fall out of §2)

Player props

Player props live on their own variables and are almost always independent of team/goals markets — a player's shot/tackle/foul count doesn't constrain the scoreline. The few real links:

• Player to score / Anytime scorer ⇒ that team >= 1 goal ⇒ contradicts Under 0.5, Team Total Under 0.5, BTTS No (for that team), Correct Score 0-0, etc. Model as teamGoals >= 1.
• Two lines of the same player+stat (e.g. Player Shots Over 1.5 and Under 1.5) → mutually exclusive.
• Otherwise treat as independent/compatible (correlation handled at pricing).

Redundancy / implication handling

For A ⊆ B (B guaranteed by A):

• Default (match bet365): keep B selectable; when both are in the slip, the combined price = the dominant leg (B contributes odds 1.00). Simplest and least surprising.
• Optional: grey B with a "already covered" hint instead of a hard padlock.

Implication is detected the same way as contradiction: A ⇒ B iff satisfiable(A ∧ ¬B) is false.

Implementation sketch

type Sel = { market: string; predicate: (o: Outcome) => boolean; vars: VarFamily };

// compatible if some outcome in the (bounded) grid satisfies all predicates,
// restricted to the union of the selections' variable families.
function compatible(sels: Sel[]): boolean {
  const families = union(sels.map(s => s.vars));
  for (const o of enumerateOutcomes(families)) {       // small bounded grid
    if (sels.every(s => s.predicate(o))) return true;
  }
  return false;
}

// when user has `picked`, a candidate is padlocked if:
function isLocked(picked: Sel[], candidate: Sel): boolean {
  if (sameMarket(picked, candidate)) return true;       // one-per-market
  return !compatible([...picked, candidate]);           // no joint outcome
}

• Grids stay tiny: goals 0..8 each side (81 outcomes), corners 0..25, etc. Only enumerate the families the current selections actually touch.
• Same-market exclusivity is a cheap short-circuit before the feasibility check.
• Redundancy check (A ⇒ B) reuses the same engine for the "already covered" UI.

Phasing

1. Goals/result family first — highest overlap and the most obvious bad parlays (Match Result, Double Chance, DNB, Total Goals, BTTS, Exact Goals, Number of Goals, Handicaps, Correct Score, HT/FT). One predicate set, one grid.
2. Corners, then cards — same engine, separate variable families.
3. Player-prop links — the teamGoals >= 1 bridge for scorer markets; same-player+stat exclusivity.
4. Half-time / full-time consistency — predicates on *1 vars + FT.

Single-selection fair odds (already shipped) + phase 1 padlocks cover the vast majority of logically-broken bets before any correlation modelling.

Open questions

• Whole-line pushes (e.g. Asian Handicap -1) are void, not lose, on the exact line — for feasibility we treat >=; for pricing the push is handled separately. Confirm this is the right call for padlocking.
• Do we hard-lock redundant selections or show "already covered"? (Recommend the latter — matches bet365 and is less frustrating.)
• Player-prop ⇄ team-goals bridge: is our data rich enough to know which team a player is on at selection time? (Yes — the value-bets-v2 group carries teamId.)