FA-81976 / Poker hand evaluation / Open access

Hold'em evaluated with Omaha two-card rule · case 01

When the board plays, or one hole card plays, the wrong player is paid.

Verified by executionVariant 1 · 8 checks per implementationDownload source bundle ↓JSON ↗

ROOT CAUSE

Candidate hands always use both hole cards plus three board cards, which is the Omaha constraint, not hold'em.

VERIFIED REPAIR

Consider every five-card combination of the seven available cards.

Unsuccessful approach: Adding first-hole-card combinations still never considers the second hole card alone or the board alone.

Case contract

Input: {"board": five community cards, "players": {name: two hole cards}, "folded": [names]}. Each live player uses the best five of their seven cards (zero, one or two hole cards may play). Return the sorted list of live players holding the best hand; ties split.

Why this case matters

Poker engines settle real money pots from these comparisons; a single misranked hand pays the wrong seat.

1 / The failure

Exit 1

"""Failure Map reference implementation. Python standard library only."""
import json
import collections
import itertools
N = 1
observations = []
def solve(x):
    R='23456789TJQKA'
    def key5(h):
        vals=sorted((R.index(c[0])+2 for c in h), reverse=True)
        cnt=collections.Counter(vals)
        order=sorted(cnt, key=lambda v:(cnt[v],v), reverse=True)
        shape=sorted(cnt.values(), reverse=True)
        flush=len({c[1] for c in h})==1
        straight=len(cnt)==5 and (vals[0]-vals[4]==4 or vals==[14,5,4,3,2])
        top=5 if vals==[14,5,4,3,2] else vals[0]
        if straight and flush: return (8,[top])
        if shape==[4,1]: return (7,order)
        if shape==[3,2]: return (6,order)
        if flush: return (5,vals)
        if straight: return (4,[top])
        if shape==[3,1,1]: return (3,order)
        if shape==[2,2,1]: return (2,order)
        if shape==[2,1,1,1]: return (1,order)
        return (0,vals)
    
    board=x['board']; folded=x.get('folded',[])
    scores={}
    for name,hole in x['players'].items():
        if name in folded: continue
        scores[name]=max(key5(c) for c in [tuple(hole)+c for c in itertools.combinations(board,3)])
    best=max(scores.values())
    return sorted(n for n,k in scores.items() if k==best)
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
fixtures = [[('board plays for both',
   {'board': ['Th', 'Jd', 'Qc', 'Ks', 'Ah'],
    'folded': [],
    'players': {'ann': ['2c', '3d'], 'bob': ['4h', '5s']}},
   ['ann', 'bob']),
  ('one hole card plays',
   {'board': ['Ah', 'Kd', '7c', '7s', '2h'],
    'folded': [],
    'players': {'ann': ['Ac', '3d'], 'bob': ['Kc', 'Qs']}},
   ['ann']),
  ('kicker on paired board',
   {'board': ['9h', '9d', '5c', '4s', '2h'],
    'folded': [],
    'players': {'ann': ['Ac', 'Jd'], 'bob': ['Kc', 'Qs']}},
   ['ann']),
  ('folded best hand ignored',
   {'board': ['9h', '9d', '5c', '4s', '2h'],
    'folded': ['ann', 'dee'],
    'players': {'ann': ['9c', '9s'], 'bob': ['Kc', 'Qs'], 'cat': ['Ac', '3s']}},
   ['cat']),
  ('folded first then other',
   {'board': ['2h', '7d', '9c', 'Js', '4h'],
    'folded': ['cat', 'ann'],
    'players': {'ann': ['Jc', 'Jh'], 'bob': ['Kc', 'Qs'], 'cat': ['Ac', '3s']}},
   ['bob']),
  ('flush second card decides',
   {'board': ['2h', '7h', '9h', 'Jd', '4s'],
    'folded': [],
    'players': {'ann': ['Ah', '3h'], 'bob': ['Kh', 'Qh']}},
   ['ann']),
  ('flush fourth card decides',
   {'board': ['Ah', 'Th', '9h', '3h', '4s'],
    'folded': [],
    'players': {'ann': ['7h', '2c'], 'bob': ['8h', '2d']}},
   ['bob']),
  ('flush fifth card decides',
   {'board': ['Ah', 'Th', '9h', '3h', '4s'],
    'folded': [],
    'players': {'ann': ['2h', 'Kc'], 'bob': ['Kd', '2d']}},
   ['ann'])],
 [('board plays for both',
   {'board': ['Th', 'Jd', 'Qc', 'Ks', 'Ah'],
    'folded': [],
    'players': {'ann': ['2c', '3d'], 'bob': ['4h', '5s']}},
   ['ann', 'bob']),
  ('folded first then other',
   {'board': ['2h', '7d', '9c', 'Js', '4h'],
    'folded': ['cat', 'ann'],
    'players': {'ann': ['Jc', 'Jh'], 'bob': ['Kc', 'Qs'], 'cat': ['Ac', '3s']}},
   ['bob']),
  ('flush second card decides',
   {'board': ['2h', '7h', '9h', 'Jd', '4s'],
    'folded': [],
    'players': {'ann': ['Ah', '3h'], 'bob': ['Kh', 'Qh']}},
   ['ann']),
  ('flush fourth card decides',
   {'board': ['Ah', 'Th', '9h', '3h', '4s'],
    'folded': [],
    'players': {'ann': ['7h', '2c'], 'bob': ['8h', '2d']}},
   ['bob']),
  ('flush fifth card decides',
   {'board': ['Ah', 'Th', '9h', '3h', '4s'],
    'folded': [],
    'players': {'ann': ['2h', 'Kc'], 'bob': ['Kd', '2d']}},
   ['ann']),
  ('flush kickers deep',
   {'board': ['Ah', 'Kh', '9h', '3d', '4s'],
    'folded': [],
    'players': {'ann': ['7h', '2h'], 'bob': ['8h', '2c']}},
   ['ann']),
  ('same category different kicker',
   {'board': ['Ah', '8d', '7c', '4s', '2h'],
    'folded': [],
    'players': {'ann': ['8c', 'Kd'], 'bob': ['8s', 'Qd']}},
   ['ann']),
  ('two pair split',
   {'board': ['Kh', 'Kd', '7c', '7s', '2h'],
    'folded': [],
    'players': {'ann': ['Ac', '3d'], 'bob': ['As', '4d']}},
   ['ann', 'bob'])],
 [('board plays for both',
   {'board': ['Th', 'Jd', 'Qc', 'Ks', 'Ah'],
    'folded': [],
    'players': {'ann': ['2c', '3d'], 'bob': ['4h', '5s']}},
   ['ann', 'bob']),
  ('flush fifth card decides',
   {'board': ['Ah', 'Th', '9h', '3h', '4s'],
    'folded': [],
    'players': {'ann': ['2h', 'Kc'], 'bob': ['Kd', '2d']}},
   ['ann']),
  ('flush kickers deep',
   {'board': ['Ah', 'Kh', '9h', '3d', '4s'],
    'folded': [],
    'players': {'ann': ['7h', '2h'], 'bob': ['8h', '2c']}},
   ['ann']),
  ('same category different kicker',
   {'board': ['Ah', '8d', '7c', '4s', '2h'],
    'folded': [],
    'players': {'ann': ['8c', 'Kd'], 'bob': ['8s', 'Qd']}},
   ['ann']),
  ('two pair split',
   {'board': ['Kh', 'Kd', '7c', '7s', '2h'],
    'folded': [],
    'players': {'ann': ['Ac', '3d'], 'bob': ['As', '4d']}},
   ['ann', 'bob']),
  ('set beats two pair',
   {'board': ['Kh', '8d', '7c', '4s', '2h'],
    'folded': [],
    'players': {'ann': ['8c', '8s'], 'bob': ['Kc', '7d']}},
   ['ann']),
  ('three-way split',
   {'board': ['6h', '7d', '8c', '9s', 'Th'],
    'folded': [],
    'players': {'ann': ['2c', '3d'], 'bob': ['2h', '3c'], 'cat': ['2d', '4c']}},
   ['ann', 'bob', 'cat']),
  ('single hole flush',
   {'board': ['2s', '7s', '9s', 'Js', '4d'],
    'folded': [],
    'players': {'ann': ['As', 'Kd'], 'bob': ['Qc', 'Qd']}},
   ['ann'])],
 [('board plays for both',
   {'board': ['Th', 'Jd', 'Qc', 'Ks', 'Ah'],
    'folded': [],
    'players': {'ann': ['2c', '3d'], 'bob': ['4h', '5s']}},
   ['ann', 'bob']),
  ('one hole card plays',
   {'board': ['Ah', 'Kd', '7c', '7s', '2h'],
    'folded': [],
    'players': {'ann': ['Ac', '3d'], 'bob': ['Kc', 'Qs']}},
   ['ann']),
  ('kicker on paired board',
   {'board': ['9h', '9d', '5c', '4s', '2h'],
    'folded': [],
    'players': {'ann': ['Ac', 'Jd'], 'bob': ['Kc', 'Qs']}},
   ['ann']),
  ('folded best hand ignored',
   {'board': ['9h', '9d', '5c', '4s', '2h'],
    'folded': ['ann', 'dee'],
    'players': {'ann': ['9c', '9s'], 'bob': ['Kc', 'Qs'], 'cat': ['Ac', '3s']}},
   ['cat']),
  ('flush fifth card decides',
   {'board': ['Ah', 'Th', '9h', '3h', '4s'],
    'folded': [],
    'players': {'ann': ['2h', 'Kc'], 'bob': ['Kd', '2d']}},
   ['ann']),
  ('two pair split',
   {'board': ['Kh', 'Kd', '7c', '7s', '2h'],
    'folded': [],
    'players': {'ann': ['Ac', '3d'], 'bob': ['As', '4d']}},
   ['ann', 'bob']),
  ('three-way split',
   {'board': ['6h', '7d', '8c', '9s', 'Th'],
    'folded': [],
    'players': {'ann': ['2c', '3d'], 'bob': ['2h', '3c'], 'cat': ['2d', '4c']}},
   ['ann', 'bob', 'cat']),
  ('single hole flush',
   {'board': ['2s', '7s', '9s', 'Js', '4d'],
    'folded': [],
    'players': {'ann': ['As', 'Kd'], 'bob': ['Qc', 'Qd']}},
   ['ann'])],
 [('board plays for both',
   {'board': ['Th', 'Jd', 'Qc', 'Ks', 'Ah'],
    'folded': [],
    'players': {'ann': ['2c', '3d'], 'bob': ['4h', '5s']}},
   ['ann', 'bob']),
  ('one hole card plays',
   {'board': ['Ah', 'Kd', '7c', '7s', '2h'],
    'folded': [],
    'players': {'ann': ['Ac', '3d'], 'bob': ['Kc', 'Qs']}},
   ['ann']),
  ('kicker on paired board',
   {'board': ['9h', '9d', '5c', '4s', '2h'],
    'folded': [],
    'players': {'ann': ['Ac', 'Jd'], 'bob': ['Kc', 'Qs']}},
   ['ann']),
  ('folded best hand ignored',
   {'board': ['9h', '9d', '5c', '4s', '2h'],
    'folded': ['ann', 'dee'],
    'players': {'ann': ['9c', '9s'], 'bob': ['Kc', 'Qs'], 'cat': ['Ac', '3s']}},
   ['cat']),
  ('folded first then other',
   {'board': ['2h', '7d', '9c', 'Js', '4h'],
    'folded': ['cat', 'ann'],
    'players': {'ann': ['Jc', 'Jh'], 'bob': ['Kc', 'Qs'], 'cat': ['Ac', '3s']}},
   ['bob']),
  ('flush second card decides',
   {'board': ['2h', '7h', '9h', 'Jd', '4s'],
    'folded': [],
    'players': {'ann': ['Ah', '3h'], 'bob': ['Kh', 'Qh']}},
   ['ann']),
  ('three-way split',
   {'board': ['6h', '7d', '8c', '9s', 'Th'],
    'folded': [],
    'players': {'ann': ['2c', '3d'], 'bob': ['2h', '3c'], 'cat': ['2d', '4c']}},
   ['ann', 'bob', 'cat']),
  ('single hole flush',
   {'board': ['2s', '7s', '9s', 'Js', '4d'],
    'folded': [],
    'players': {'ann': ['As', 'Kd'], 'bob': ['Qc', 'Qd']}},
   ['ann'])]]
for label, args, expected in fixtures[N-1]:
    try:
        actual = solve(args)
    except Exception as exc:
        actual = 'error:' + type(exc).__name__
    check(label, actual, expected)
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

Boundary fixture	Actual	Expected	Outcome
board plays for both	`['bob']`	`['ann', 'bob']`	Failed
one hole card plays	`['ann']`	`['ann']`	Passed
kicker on paired board	`['ann']`	`['ann']`	Passed
folded best hand ignored	`['cat']`	`['cat']`	Passed
folded first then other	`['bob']`	`['bob']`	Passed
flush second card decides	`['ann']`	`['ann']`	Passed
flush fourth card decides	`['bob']`	`['bob']`	Passed
flush fifth card decides	`['ann', 'bob']`	`['ann']`	Failed

SHA-256 / b8dfcf5e92b45ed7461da3ccd13fe0cd48ac1c0c122a89dd20d0269ac7e25290

2 / The unsuccessful fix

Exit 1

"""Failure Map reference implementation. Python standard library only."""
import json
import collections
import itertools
N = 1
observations = []
def solve(x):
    R='23456789TJQKA'
    def key5(h):
        vals=sorted((R.index(c[0])+2 for c in h), reverse=True)
        cnt=collections.Counter(vals)
        order=sorted(cnt, key=lambda v:(cnt[v],v), reverse=True)
        shape=sorted(cnt.values(), reverse=True)
        flush=len({c[1] for c in h})==1
        straight=len(cnt)==5 and (vals[0]-vals[4]==4 or vals==[14,5,4,3,2])
        top=5 if vals==[14,5,4,3,2] else vals[0]
        if straight and flush: return (8,[top])
        if shape==[4,1]: return (7,order)
        if shape==[3,2]: return (6,order)
        if flush: return (5,vals)
        if straight: return (4,[top])
        if shape==[3,1,1]: return (3,order)
        if shape==[2,2,1]: return (2,order)
        if shape==[2,1,1,1]: return (1,order)
        return (0,vals)
    
    board=x['board']; folded=x.get('folded',[])
    scores={}
    for name,hole in x['players'].items():
        if name in folded: continue
        scores[name]=max(key5(c) for c in [tuple(hole[:1])+c for c in itertools.combinations(board,4)]+[tuple(hole)+c for c in itertools.combinations(board,3)])
    best=max(scores.values())
    return sorted(n for n,k in scores.items() if k==best)
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
fixtures = [[('board plays for both',
   {'board': ['Th', 'Jd', 'Qc', 'Ks', 'Ah'],
    'folded': [],
    'players': {'ann': ['2c', '3d'], 'bob': ['4h', '5s']}},
   ['ann', 'bob']),
  ('one hole card plays',
   {'board': ['Ah', 'Kd', '7c', '7s', '2h'],
    'folded': [],
    'players': {'ann': ['Ac', '3d'], 'bob': ['Kc', 'Qs']}},
   ['ann']),
  ('kicker on paired board',
   {'board': ['9h', '9d', '5c', '4s', '2h'],
    'folded': [],
    'players': {'ann': ['Ac', 'Jd'], 'bob': ['Kc', 'Qs']}},
   ['ann']),
  ('folded best hand ignored',
   {'board': ['9h', '9d', '5c', '4s', '2h'],
    'folded': ['ann', 'dee'],
    'players': {'ann': ['9c', '9s'], 'bob': ['Kc', 'Qs'], 'cat': ['Ac', '3s']}},
   ['cat']),
  ('folded first then other',
   {'board': ['2h', '7d', '9c', 'Js', '4h'],
    'folded': ['cat', 'ann'],
    'players': {'ann': ['Jc', 'Jh'], 'bob': ['Kc', 'Qs'], 'cat': ['Ac', '3s']}},
   ['bob']),
  ('flush second card decides',
   {'board': ['2h', '7h', '9h', 'Jd', '4s'],
    'folded': [],
    'players': {'ann': ['Ah', '3h'], 'bob': ['Kh', 'Qh']}},
   ['ann']),
  ('flush fourth card decides',
   {'board': ['Ah', 'Th', '9h', '3h', '4s'],
    'folded': [],
    'players': {'ann': ['7h', '2c'], 'bob': ['8h', '2d']}},
   ['bob']),
  ('flush fifth card decides',
   {'board': ['Ah', 'Th', '9h', '3h', '4s'],
    'folded': [],
    'players': {'ann': ['2h', 'Kc'], 'bob': ['Kd', '2d']}},
   ['ann'])],
 [('board plays for both',
   {'board': ['Th', 'Jd', 'Qc', 'Ks', 'Ah'],
    'folded': [],
    'players': {'ann': ['2c', '3d'], 'bob': ['4h', '5s']}},
   ['ann', 'bob']),
  ('folded first then other',
   {'board': ['2h', '7d', '9c', 'Js', '4h'],
    'folded': ['cat', 'ann'],
    'players': {'ann': ['Jc', 'Jh'], 'bob': ['Kc', 'Qs'], 'cat': ['Ac', '3s']}},
   ['bob']),
  ('flush second card decides',
   {'board': ['2h', '7h', '9h', 'Jd', '4s'],
    'folded': [],
    'players': {'ann': ['Ah', '3h'], 'bob': ['Kh', 'Qh']}},
   ['ann']),
  ('flush fourth card decides',
   {'board': ['Ah', 'Th', '9h', '3h', '4s'],
    'folded': [],
    'players': {'ann': ['7h', '2c'], 'bob': ['8h', '2d']}},
   ['bob']),
  ('flush fifth card decides',
   {'board': ['Ah', 'Th', '9h', '3h', '4s'],
    'folded': [],
    'players': {'ann': ['2h', 'Kc'], 'bob': ['Kd', '2d']}},
   ['ann']),
  ('flush kickers deep',
   {'board': ['Ah', 'Kh', '9h', '3d', '4s'],
    'folded': [],
    'players': {'ann': ['7h', '2h'], 'bob': ['8h', '2c']}},
   ['ann']),
  ('same category different kicker',
   {'board': ['Ah', '8d', '7c', '4s', '2h'],
    'folded': [],
    'players': {'ann': ['8c', 'Kd'], 'bob': ['8s', 'Qd']}},
   ['ann']),
  ('two pair split',
   {'board': ['Kh', 'Kd', '7c', '7s', '2h'],
    'folded': [],
    'players': {'ann': ['Ac', '3d'], 'bob': ['As', '4d']}},
   ['ann', 'bob'])],
 [('board plays for both',
   {'board': ['Th', 'Jd', 'Qc', 'Ks', 'Ah'],
    'folded': [],
    'players': {'ann': ['2c', '3d'], 'bob': ['4h', '5s']}},
   ['ann', 'bob']),
  ('flush fifth card decides',
   {'board': ['Ah', 'Th', '9h', '3h', '4s'],
    'folded': [],
    'players': {'ann': ['2h', 'Kc'], 'bob': ['Kd', '2d']}},
   ['ann']),
  ('flush kickers deep',
   {'board': ['Ah', 'Kh', '9h', '3d', '4s'],
    'folded': [],
    'players': {'ann': ['7h', '2h'], 'bob': ['8h', '2c']}},
   ['ann']),
  ('same category different kicker',
   {'board': ['Ah', '8d', '7c', '4s', '2h'],
    'folded': [],
    'players': {'ann': ['8c', 'Kd'], 'bob': ['8s', 'Qd']}},
   ['ann']),
  ('two pair split',
   {'board': ['Kh', 'Kd', '7c', '7s', '2h'],
    'folded': [],
    'players': {'ann': ['Ac', '3d'], 'bob': ['As', '4d']}},
   ['ann', 'bob']),
  ('set beats two pair',
   {'board': ['Kh', '8d', '7c', '4s', '2h'],
    'folded': [],
    'players': {'ann': ['8c', '8s'], 'bob': ['Kc', '7d']}},
   ['ann']),
  ('three-way split',
   {'board': ['6h', '7d', '8c', '9s', 'Th'],
    'folded': [],
    'players': {'ann': ['2c', '3d'], 'bob': ['2h', '3c'], 'cat': ['2d', '4c']}},
   ['ann', 'bob', 'cat']),
  ('single hole flush',
   {'board': ['2s', '7s', '9s', 'Js', '4d'],
    'folded': [],
    'players': {'ann': ['As', 'Kd'], 'bob': ['Qc', 'Qd']}},
   ['ann'])],
 [('board plays for both',
   {'board': ['Th', 'Jd', 'Qc', 'Ks', 'Ah'],
    'folded': [],
    'players': {'ann': ['2c', '3d'], 'bob': ['4h', '5s']}},
   ['ann', 'bob']),
  ('one hole card plays',
   {'board': ['Ah', 'Kd', '7c', '7s', '2h'],
    'folded': [],
    'players': {'ann': ['Ac', '3d'], 'bob': ['Kc', 'Qs']}},
   ['ann']),
  ('kicker on paired board',
   {'board': ['9h', '9d', '5c', '4s', '2h'],
    'folded': [],
    'players': {'ann': ['Ac', 'Jd'], 'bob': ['Kc', 'Qs']}},
   ['ann']),
  ('folded best hand ignored',
   {'board': ['9h', '9d', '5c', '4s', '2h'],
    'folded': ['ann', 'dee'],
    'players': {'ann': ['9c', '9s'], 'bob': ['Kc', 'Qs'], 'cat': ['Ac', '3s']}},
   ['cat']),
  ('flush fifth card decides',
   {'board': ['Ah', 'Th', '9h', '3h', '4s'],
    'folded': [],
    'players': {'ann': ['2h', 'Kc'], 'bob': ['Kd', '2d']}},
   ['ann']),
  ('two pair split',
   {'board': ['Kh', 'Kd', '7c', '7s', '2h'],
    'folded': [],
    'players': {'ann': ['Ac', '3d'], 'bob': ['As', '4d']}},
   ['ann', 'bob']),
  ('three-way split',
   {'board': ['6h', '7d', '8c', '9s', 'Th'],
    'folded': [],
    'players': {'ann': ['2c', '3d'], 'bob': ['2h', '3c'], 'cat': ['2d', '4c']}},
   ['ann', 'bob', 'cat']),
  ('single hole flush',
   {'board': ['2s', '7s', '9s', 'Js', '4d'],
    'folded': [],
    'players': {'ann': ['As', 'Kd'], 'bob': ['Qc', 'Qd']}},
   ['ann'])],
 [('board plays for both',
   {'board': ['Th', 'Jd', 'Qc', 'Ks', 'Ah'],
    'folded': [],
    'players': {'ann': ['2c', '3d'], 'bob': ['4h', '5s']}},
   ['ann', 'bob']),
  ('one hole card plays',
   {'board': ['Ah', 'Kd', '7c', '7s', '2h'],
    'folded': [],
    'players': {'ann': ['Ac', '3d'], 'bob': ['Kc', 'Qs']}},
   ['ann']),
  ('kicker on paired board',
   {'board': ['9h', '9d', '5c', '4s', '2h'],
    'folded': [],
    'players': {'ann': ['Ac', 'Jd'], 'bob': ['Kc', 'Qs']}},
   ['ann']),
  ('folded best hand ignored',
   {'board': ['9h', '9d', '5c', '4s', '2h'],
    'folded': ['ann', 'dee'],
    'players': {'ann': ['9c', '9s'], 'bob': ['Kc', 'Qs'], 'cat': ['Ac', '3s']}},
   ['cat']),
  ('folded first then other',
   {'board': ['2h', '7d', '9c', 'Js', '4h'],
    'folded': ['cat', 'ann'],
    'players': {'ann': ['Jc', 'Jh'], 'bob': ['Kc', 'Qs'], 'cat': ['Ac', '3s']}},
   ['bob']),
  ('flush second card decides',
   {'board': ['2h', '7h', '9h', 'Jd', '4s'],
    'folded': [],
    'players': {'ann': ['Ah', '3h'], 'bob': ['Kh', 'Qh']}},
   ['ann']),
  ('three-way split',
   {'board': ['6h', '7d', '8c', '9s', 'Th'],
    'folded': [],
    'players': {'ann': ['2c', '3d'], 'bob': ['2h', '3c'], 'cat': ['2d', '4c']}},
   ['ann', 'bob', 'cat']),
  ('single hole flush',
   {'board': ['2s', '7s', '9s', 'Js', '4d'],
    'folded': [],
    'players': {'ann': ['As', 'Kd'], 'bob': ['Qc', 'Qd']}},
   ['ann'])]]
for label, args, expected in fixtures[N-1]:
    try:
        actual = solve(args)
    except Exception as exc:
        actual = 'error:' + type(exc).__name__
    check(label, actual, expected)
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

Boundary fixture	Actual	Expected	Outcome
board plays for both	`['bob']`	`['ann', 'bob']`	Failed
one hole card plays	`['ann']`	`['ann']`	Passed
kicker on paired board	`['ann']`	`['ann']`	Passed
folded best hand ignored	`['cat']`	`['cat']`	Passed
folded first then other	`['bob']`	`['bob']`	Passed
flush second card decides	`['ann']`	`['ann']`	Passed
flush fourth card decides	`['bob']`	`['bob']`	Passed
flush fifth card decides	`['ann']`	`['ann']`	Passed

SHA-256 / 60dfbba502315c0989a89a3e6413e0be638fdb53a2479844ec081ea47ff4697a

3 / The verified repair

Exit 0

"""Failure Map reference implementation. Python standard library only."""
import json
import collections
import itertools
N = 1
observations = []
def solve(x):
    R='23456789TJQKA'
    def key5(h):
        vals=sorted((R.index(c[0])+2 for c in h), reverse=True)
        cnt=collections.Counter(vals)
        order=sorted(cnt, key=lambda v:(cnt[v],v), reverse=True)
        shape=sorted(cnt.values(), reverse=True)
        flush=len({c[1] for c in h})==1
        straight=len(cnt)==5 and (vals[0]-vals[4]==4 or vals==[14,5,4,3,2])
        top=5 if vals==[14,5,4,3,2] else vals[0]
        if straight and flush: return (8,[top])
        if shape==[4,1]: return (7,order)
        if shape==[3,2]: return (6,order)
        if flush: return (5,vals)
        if straight: return (4,[top])
        if shape==[3,1,1]: return (3,order)
        if shape==[2,2,1]: return (2,order)
        if shape==[2,1,1,1]: return (1,order)
        return (0,vals)
    
    board=x['board']; folded=x.get('folded',[])
    scores={}
    for name,hole in x['players'].items():
        if name in folded: continue
        scores[name]=max(key5(c) for c in itertools.combinations(hole+board,5))
    best=max(scores.values())
    return sorted(n for n,k in scores.items() if k==best)
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
fixtures = [[('board plays for both',
   {'board': ['Th', 'Jd', 'Qc', 'Ks', 'Ah'],
    'folded': [],
    'players': {'ann': ['2c', '3d'], 'bob': ['4h', '5s']}},
   ['ann', 'bob']),
  ('one hole card plays',
   {'board': ['Ah', 'Kd', '7c', '7s', '2h'],
    'folded': [],
    'players': {'ann': ['Ac', '3d'], 'bob': ['Kc', 'Qs']}},
   ['ann']),
  ('kicker on paired board',
   {'board': ['9h', '9d', '5c', '4s', '2h'],
    'folded': [],
    'players': {'ann': ['Ac', 'Jd'], 'bob': ['Kc', 'Qs']}},
   ['ann']),
  ('folded best hand ignored',
   {'board': ['9h', '9d', '5c', '4s', '2h'],
    'folded': ['ann', 'dee'],
    'players': {'ann': ['9c', '9s'], 'bob': ['Kc', 'Qs'], 'cat': ['Ac', '3s']}},
   ['cat']),
  ('folded first then other',
   {'board': ['2h', '7d', '9c', 'Js', '4h'],
    'folded': ['cat', 'ann'],
    'players': {'ann': ['Jc', 'Jh'], 'bob': ['Kc', 'Qs'], 'cat': ['Ac', '3s']}},
   ['bob']),
  ('flush second card decides',
   {'board': ['2h', '7h', '9h', 'Jd', '4s'],
    'folded': [],
    'players': {'ann': ['Ah', '3h'], 'bob': ['Kh', 'Qh']}},
   ['ann']),
  ('flush fourth card decides',
   {'board': ['Ah', 'Th', '9h', '3h', '4s'],
    'folded': [],
    'players': {'ann': ['7h', '2c'], 'bob': ['8h', '2d']}},
   ['bob']),
  ('flush fifth card decides',
   {'board': ['Ah', 'Th', '9h', '3h', '4s'],
    'folded': [],
    'players': {'ann': ['2h', 'Kc'], 'bob': ['Kd', '2d']}},
   ['ann'])],
 [('board plays for both',
   {'board': ['Th', 'Jd', 'Qc', 'Ks', 'Ah'],
    'folded': [],
    'players': {'ann': ['2c', '3d'], 'bob': ['4h', '5s']}},
   ['ann', 'bob']),
  ('folded first then other',
   {'board': ['2h', '7d', '9c', 'Js', '4h'],
    'folded': ['cat', 'ann'],
    'players': {'ann': ['Jc', 'Jh'], 'bob': ['Kc', 'Qs'], 'cat': ['Ac', '3s']}},
   ['bob']),
  ('flush second card decides',
   {'board': ['2h', '7h', '9h', 'Jd', '4s'],
    'folded': [],
    'players': {'ann': ['Ah', '3h'], 'bob': ['Kh', 'Qh']}},
   ['ann']),
  ('flush fourth card decides',
   {'board': ['Ah', 'Th', '9h', '3h', '4s'],
    'folded': [],
    'players': {'ann': ['7h', '2c'], 'bob': ['8h', '2d']}},
   ['bob']),
  ('flush fifth card decides',
   {'board': ['Ah', 'Th', '9h', '3h', '4s'],
    'folded': [],
    'players': {'ann': ['2h', 'Kc'], 'bob': ['Kd', '2d']}},
   ['ann']),
  ('flush kickers deep',
   {'board': ['Ah', 'Kh', '9h', '3d', '4s'],
    'folded': [],
    'players': {'ann': ['7h', '2h'], 'bob': ['8h', '2c']}},
   ['ann']),
  ('same category different kicker',
   {'board': ['Ah', '8d', '7c', '4s', '2h'],
    'folded': [],
    'players': {'ann': ['8c', 'Kd'], 'bob': ['8s', 'Qd']}},
   ['ann']),
  ('two pair split',
   {'board': ['Kh', 'Kd', '7c', '7s', '2h'],
    'folded': [],
    'players': {'ann': ['Ac', '3d'], 'bob': ['As', '4d']}},
   ['ann', 'bob'])],
 [('board plays for both',
   {'board': ['Th', 'Jd', 'Qc', 'Ks', 'Ah'],
    'folded': [],
    'players': {'ann': ['2c', '3d'], 'bob': ['4h', '5s']}},
   ['ann', 'bob']),
  ('flush fifth card decides',
   {'board': ['Ah', 'Th', '9h', '3h', '4s'],
    'folded': [],
    'players': {'ann': ['2h', 'Kc'], 'bob': ['Kd', '2d']}},
   ['ann']),
  ('flush kickers deep',
   {'board': ['Ah', 'Kh', '9h', '3d', '4s'],
    'folded': [],
    'players': {'ann': ['7h', '2h'], 'bob': ['8h', '2c']}},
   ['ann']),
  ('same category different kicker',
   {'board': ['Ah', '8d', '7c', '4s', '2h'],
    'folded': [],
    'players': {'ann': ['8c', 'Kd'], 'bob': ['8s', 'Qd']}},
   ['ann']),
  ('two pair split',
   {'board': ['Kh', 'Kd', '7c', '7s', '2h'],
    'folded': [],
    'players': {'ann': ['Ac', '3d'], 'bob': ['As', '4d']}},
   ['ann', 'bob']),
  ('set beats two pair',
   {'board': ['Kh', '8d', '7c', '4s', '2h'],
    'folded': [],
    'players': {'ann': ['8c', '8s'], 'bob': ['Kc', '7d']}},
   ['ann']),
  ('three-way split',
   {'board': ['6h', '7d', '8c', '9s', 'Th'],
    'folded': [],
    'players': {'ann': ['2c', '3d'], 'bob': ['2h', '3c'], 'cat': ['2d', '4c']}},
   ['ann', 'bob', 'cat']),
  ('single hole flush',
   {'board': ['2s', '7s', '9s', 'Js', '4d'],
    'folded': [],
    'players': {'ann': ['As', 'Kd'], 'bob': ['Qc', 'Qd']}},
   ['ann'])],
 [('board plays for both',
   {'board': ['Th', 'Jd', 'Qc', 'Ks', 'Ah'],
    'folded': [],
    'players': {'ann': ['2c', '3d'], 'bob': ['4h', '5s']}},
   ['ann', 'bob']),
  ('one hole card plays',
   {'board': ['Ah', 'Kd', '7c', '7s', '2h'],
    'folded': [],
    'players': {'ann': ['Ac', '3d'], 'bob': ['Kc', 'Qs']}},
   ['ann']),
  ('kicker on paired board',
   {'board': ['9h', '9d', '5c', '4s', '2h'],
    'folded': [],
    'players': {'ann': ['Ac', 'Jd'], 'bob': ['Kc', 'Qs']}},
   ['ann']),
  ('folded best hand ignored',
   {'board': ['9h', '9d', '5c', '4s', '2h'],
    'folded': ['ann', 'dee'],
    'players': {'ann': ['9c', '9s'], 'bob': ['Kc', 'Qs'], 'cat': ['Ac', '3s']}},
   ['cat']),
  ('flush fifth card decides',
   {'board': ['Ah', 'Th', '9h', '3h', '4s'],
    'folded': [],
    'players': {'ann': ['2h', 'Kc'], 'bob': ['Kd', '2d']}},
   ['ann']),
  ('two pair split',
   {'board': ['Kh', 'Kd', '7c', '7s', '2h'],
    'folded': [],
    'players': {'ann': ['Ac', '3d'], 'bob': ['As', '4d']}},
   ['ann', 'bob']),
  ('three-way split',
   {'board': ['6h', '7d', '8c', '9s', 'Th'],
    'folded': [],
    'players': {'ann': ['2c', '3d'], 'bob': ['2h', '3c'], 'cat': ['2d', '4c']}},
   ['ann', 'bob', 'cat']),
  ('single hole flush',
   {'board': ['2s', '7s', '9s', 'Js', '4d'],
    'folded': [],
    'players': {'ann': ['As', 'Kd'], 'bob': ['Qc', 'Qd']}},
   ['ann'])],
 [('board plays for both',
   {'board': ['Th', 'Jd', 'Qc', 'Ks', 'Ah'],
    'folded': [],
    'players': {'ann': ['2c', '3d'], 'bob': ['4h', '5s']}},
   ['ann', 'bob']),
  ('one hole card plays',
   {'board': ['Ah', 'Kd', '7c', '7s', '2h'],
    'folded': [],
    'players': {'ann': ['Ac', '3d'], 'bob': ['Kc', 'Qs']}},
   ['ann']),
  ('kicker on paired board',
   {'board': ['9h', '9d', '5c', '4s', '2h'],
    'folded': [],
    'players': {'ann': ['Ac', 'Jd'], 'bob': ['Kc', 'Qs']}},
   ['ann']),
  ('folded best hand ignored',
   {'board': ['9h', '9d', '5c', '4s', '2h'],
    'folded': ['ann', 'dee'],
    'players': {'ann': ['9c', '9s'], 'bob': ['Kc', 'Qs'], 'cat': ['Ac', '3s']}},
   ['cat']),
  ('folded first then other',
   {'board': ['2h', '7d', '9c', 'Js', '4h'],
    'folded': ['cat', 'ann'],
    'players': {'ann': ['Jc', 'Jh'], 'bob': ['Kc', 'Qs'], 'cat': ['Ac', '3s']}},
   ['bob']),
  ('flush second card decides',
   {'board': ['2h', '7h', '9h', 'Jd', '4s'],
    'folded': [],
    'players': {'ann': ['Ah', '3h'], 'bob': ['Kh', 'Qh']}},
   ['ann']),
  ('three-way split',
   {'board': ['6h', '7d', '8c', '9s', 'Th'],
    'folded': [],
    'players': {'ann': ['2c', '3d'], 'bob': ['2h', '3c'], 'cat': ['2d', '4c']}},
   ['ann', 'bob', 'cat']),
  ('single hole flush',
   {'board': ['2s', '7s', '9s', 'Js', '4d'],
    'folded': [],
    'players': {'ann': ['As', 'Kd'], 'bob': ['Qc', 'Qd']}},
   ['ann'])]]
for label, args, expected in fixtures[N-1]:
    try:
        actual = solve(args)
    except Exception as exc:
        actual = 'error:' + type(exc).__name__
    check(label, actual, expected)
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

Boundary fixture	Actual	Expected	Outcome
board plays for both	`['ann', 'bob']`	`['ann', 'bob']`	Passed
one hole card plays	`['ann']`	`['ann']`	Passed
kicker on paired board	`['ann']`	`['ann']`	Passed
folded best hand ignored	`['cat']`	`['cat']`	Passed
folded first then other	`['bob']`	`['bob']`	Passed
flush second card decides	`['ann']`	`['ann']`	Passed
flush fourth card decides	`['bob']`	`['bob']`	Passed
flush fifth card decides	`['ann']`	`['ann']`	Passed

SHA-256 / 96f4fff588ad662fa1b7ea02096c4f627462b90ee66214d44dbc1a7a19e27974

Verification & scope

A deterministic toy model with an explicitly stated contract; card strings are rank+suit (for example "As", "Td"); no claim of conformance to any casino or tournament rulebook. This reproducer isolates one failure mechanism. Results cover the supplied fixtures. Variants within a family share a test contract and should remain grouped when constructing evaluation splits. Related mechanisms with a shared evaluation_group must also remain together; these controlled models are not independent production incidents.

Observations recorded using Python 3.12.14 at 2026-09-29T14:50:07.911613+00:00.

Case digest / 8c255644a13f6150962cefa45446008babe509f52beb667c44cbe3b03db102e1