FAILURE MAP
← Case archive

FA-82331 / Poker hand evaluation / Open access

Reports the most hole cards that can play · case 01

When the board plays, the hand is annotated as using both hole cards.

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

ROOT CAUSE

The search tries two hole cards first and returns the first matching count.

VERIFIED REPAIR

Search from zero hole cards upward so the first match is the minimum.

Unsuccessful approach: Starting from one hole card never reports that the board plays.

Case contract

Input: {"hole": two cards, "board": five cards}. Return the minimum number of hole cards (0, 1 or 2) needed to make the player's best possible five-card hand; 0 means the board plays.

Why this case matters

"Board plays" detection drives split-pot explanations and hand-history annotations.

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: return (8 if flush else 4, [top])
        if flush: return (5, vals)
        return ({(4,1):7,(3,2):6,(3,1,1):3,(2,2,1):2,(2,1,1,1):1}.get(tuple(shape),0), order)
    hole=x['hole']; board=x['board']
    best=max(key5(c) for c in itertools.combinations(hole+board,5))
    for n in range(2,-1,-1):
        for hc in itertools.combinations(hole,n):
            for bc in itertools.combinations(board,5-n):
                if key5(hc+bc)==best: return n
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
fixtures = [[('board straight plays', {'board': ['9h', 'Td', 'Jc', 'Qs', 'Kh'], 'hole': ['2c', '3d']}, 0),
  ('one card kicker', {'board': ['9h', '9d', '7c', '6s', '2h'], 'hole': ['Ac', '3d']}, 1),
  ('hole ranks duplicate board straight',
   {'board': ['9h', 'Td', 'Jc', 'Qs', 'Kh'], 'hole': ['9c', 'Ts']}, 0),
  ('second hole card redundant', {'board': ['Kh', 'Kd', '9c', '7s', '5h'], 'hole': ['9d', '7d']},
   1),
  ('wheel with both', {'board': ['9h', '9d', '5c', '4s', '2h'], 'hole': ['Ac', '3d']}, 2),
  ('both cards pair', {'board': ['Kh', 'Qs', '5c', '4s', '2h'], 'hole': ['Kc', 'Qd']}, 2),
  ('pocket pair', {'board': ['Kh', 'Qs', '5c', '4s', '2h'], 'hole': ['8c', '8d']}, 2),
  ('same category better kicker', {'board': ['Ah', 'Ad', '9c', '7s', '5h'], 'hole': ['Jc', '2d']},
   1)],
 [('hole ranks duplicate board straight',
   {'board': ['9h', 'Td', 'Jc', 'Qs', 'Kh'], 'hole': ['9c', 'Ts']}, 0),
  ('second hole card redundant', {'board': ['Kh', 'Kd', '9c', '7s', '5h'], 'hole': ['9d', '7d']},
   1),
  ('pocket pair', {'board': ['Kh', 'Qs', '5c', '4s', '2h'], 'hole': ['8c', '8d']}, 2),
  ('low kicker does not play', {'board': ['Ah', 'Kd', '9c', '7s', '5h'], 'hole': ['2c', '3d']}, 0),
  ('same category better kicker', {'board': ['Ah', 'Ad', '9c', '7s', '5h'], 'hole': ['Jc', '2d']},
   1),
  ('flush with one card', {'board': ['3h', '7h', '9h', 'Jh', 'Kd'], 'hole': ['Ah', '2c']}, 1),
  ('improved board flush', {'board': ['4h', '7h', '9h', 'Jh', 'Kh'], 'hole': ['Ah', '3d']}, 1),
  ('quads on board kicker', {'board': ['9h', '9d', '9c', '9s', 'Kh'], 'hole': ['Ac', '2d']}, 1)],
 [('board straight plays', {'board': ['9h', 'Td', 'Jc', 'Qs', 'Kh'], 'hole': ['2c', '3d']}, 0),
  ('one card kicker', {'board': ['9h', '9d', '7c', '6s', '2h'], 'hole': ['Ac', '3d']}, 1),
  ('hole ranks duplicate board straight',
   {'board': ['9h', 'Td', 'Jc', 'Qs', 'Kh'], 'hole': ['9c', 'Ts']}, 0),
  ('second hole card redundant', {'board': ['Kh', 'Kd', '9c', '7s', '5h'], 'hole': ['9d', '7d']},
   1),
  ('low kicker does not play', {'board': ['Ah', 'Kd', '9c', '7s', '5h'], 'hole': ['2c', '3d']}, 0),
  ('board flush plays', {'board': ['4h', '7h', '9h', 'Jh', 'Kh'], 'hole': ['2c', '3d']}, 0),
  ('improved board flush', {'board': ['4h', '7h', '9h', 'Jh', 'Kh'], 'hole': ['Ah', '3d']}, 1),
  ('quads on board kicker', {'board': ['9h', '9d', '9c', '9s', 'Kh'], 'hole': ['Ac', '2d']}, 1)],
 [('board straight plays', {'board': ['9h', 'Td', 'Jc', 'Qs', 'Kh'], 'hole': ['2c', '3d']}, 0),
  ('one card kicker', {'board': ['9h', '9d', '7c', '6s', '2h'], 'hole': ['Ac', '3d']}, 1),
  ('hole ranks duplicate board straight',
   {'board': ['9h', 'Td', 'Jc', 'Qs', 'Kh'], 'hole': ['9c', 'Ts']}, 0),
  ('second hole card redundant', {'board': ['Kh', 'Kd', '9c', '7s', '5h'], 'hole': ['9d', '7d']},
   1),
  ('wheel with both', {'board': ['9h', '9d', '5c', '4s', '2h'], 'hole': ['Ac', '3d']}, 2),
  ('both cards pair', {'board': ['Kh', 'Qs', '5c', '4s', '2h'], 'hole': ['Kc', 'Qd']}, 2),
  ('low kicker does not play', {'board': ['Ah', 'Kd', '9c', '7s', '5h'], 'hole': ['2c', '3d']}, 0),
  ('board flush plays', {'board': ['4h', '7h', '9h', 'Jh', 'Kh'], 'hole': ['2c', '3d']}, 0)],
 [('board straight plays', {'board': ['9h', 'Td', 'Jc', 'Qs', 'Kh'], 'hole': ['2c', '3d']}, 0),
  ('one card kicker', {'board': ['9h', '9d', '7c', '6s', '2h'], 'hole': ['Ac', '3d']}, 1),
  ('hole ranks duplicate board straight',
   {'board': ['9h', 'Td', 'Jc', 'Qs', 'Kh'], 'hole': ['9c', 'Ts']}, 0),
  ('second hole card redundant', {'board': ['Kh', 'Kd', '9c', '7s', '5h'], 'hole': ['9d', '7d']},
   1),
  ('wheel with both', {'board': ['9h', '9d', '5c', '4s', '2h'], 'hole': ['Ac', '3d']}, 2),
  ('both cards pair', {'board': ['Kh', 'Qs', '5c', '4s', '2h'], 'hole': ['Kc', 'Qd']}, 2),
  ('pocket pair', {'board': ['Kh', 'Qs', '5c', '4s', '2h'], 'hole': ['8c', '8d']}, 2),
  ('board flush plays', {'board': ['4h', '7h', '9h', 'Jh', 'Kh'], 'hole': ['2c', '3d']}, 0)]]
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 fixtureActualExpectedOutcome
board straight plays00Passed
one card kicker11Passed
hole ranks duplicate board straight20Failed
second hole card redundant21Failed
wheel with both22Passed
both cards pair22Passed
pocket pair22Passed
same category better kicker11Passed

SHA-256 / 75c4384f73a6c8b1c3cdc23be7fe098c091dc55e91f47b1e88462282f032dd82

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: return (8 if flush else 4, [top])
        if flush: return (5, vals)
        return ({(4,1):7,(3,2):6,(3,1,1):3,(2,2,1):2,(2,1,1,1):1}.get(tuple(shape),0), order)
    hole=x['hole']; board=x['board']
    best=max(key5(c) for c in itertools.combinations(hole+board,5))
    for n in range(1,3):
        for hc in itertools.combinations(hole,n):
            for bc in itertools.combinations(board,5-n):
                if key5(hc+bc)==best: return n
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
fixtures = [[('board straight plays', {'board': ['9h', 'Td', 'Jc', 'Qs', 'Kh'], 'hole': ['2c', '3d']}, 0),
  ('one card kicker', {'board': ['9h', '9d', '7c', '6s', '2h'], 'hole': ['Ac', '3d']}, 1),
  ('hole ranks duplicate board straight',
   {'board': ['9h', 'Td', 'Jc', 'Qs', 'Kh'], 'hole': ['9c', 'Ts']}, 0),
  ('second hole card redundant', {'board': ['Kh', 'Kd', '9c', '7s', '5h'], 'hole': ['9d', '7d']},
   1),
  ('wheel with both', {'board': ['9h', '9d', '5c', '4s', '2h'], 'hole': ['Ac', '3d']}, 2),
  ('both cards pair', {'board': ['Kh', 'Qs', '5c', '4s', '2h'], 'hole': ['Kc', 'Qd']}, 2),
  ('pocket pair', {'board': ['Kh', 'Qs', '5c', '4s', '2h'], 'hole': ['8c', '8d']}, 2),
  ('same category better kicker', {'board': ['Ah', 'Ad', '9c', '7s', '5h'], 'hole': ['Jc', '2d']},
   1)],
 [('hole ranks duplicate board straight',
   {'board': ['9h', 'Td', 'Jc', 'Qs', 'Kh'], 'hole': ['9c', 'Ts']}, 0),
  ('second hole card redundant', {'board': ['Kh', 'Kd', '9c', '7s', '5h'], 'hole': ['9d', '7d']},
   1),
  ('pocket pair', {'board': ['Kh', 'Qs', '5c', '4s', '2h'], 'hole': ['8c', '8d']}, 2),
  ('low kicker does not play', {'board': ['Ah', 'Kd', '9c', '7s', '5h'], 'hole': ['2c', '3d']}, 0),
  ('same category better kicker', {'board': ['Ah', 'Ad', '9c', '7s', '5h'], 'hole': ['Jc', '2d']},
   1),
  ('flush with one card', {'board': ['3h', '7h', '9h', 'Jh', 'Kd'], 'hole': ['Ah', '2c']}, 1),
  ('improved board flush', {'board': ['4h', '7h', '9h', 'Jh', 'Kh'], 'hole': ['Ah', '3d']}, 1),
  ('quads on board kicker', {'board': ['9h', '9d', '9c', '9s', 'Kh'], 'hole': ['Ac', '2d']}, 1)],
 [('board straight plays', {'board': ['9h', 'Td', 'Jc', 'Qs', 'Kh'], 'hole': ['2c', '3d']}, 0),
  ('one card kicker', {'board': ['9h', '9d', '7c', '6s', '2h'], 'hole': ['Ac', '3d']}, 1),
  ('hole ranks duplicate board straight',
   {'board': ['9h', 'Td', 'Jc', 'Qs', 'Kh'], 'hole': ['9c', 'Ts']}, 0),
  ('second hole card redundant', {'board': ['Kh', 'Kd', '9c', '7s', '5h'], 'hole': ['9d', '7d']},
   1),
  ('low kicker does not play', {'board': ['Ah', 'Kd', '9c', '7s', '5h'], 'hole': ['2c', '3d']}, 0),
  ('board flush plays', {'board': ['4h', '7h', '9h', 'Jh', 'Kh'], 'hole': ['2c', '3d']}, 0),
  ('improved board flush', {'board': ['4h', '7h', '9h', 'Jh', 'Kh'], 'hole': ['Ah', '3d']}, 1),
  ('quads on board kicker', {'board': ['9h', '9d', '9c', '9s', 'Kh'], 'hole': ['Ac', '2d']}, 1)],
 [('board straight plays', {'board': ['9h', 'Td', 'Jc', 'Qs', 'Kh'], 'hole': ['2c', '3d']}, 0),
  ('one card kicker', {'board': ['9h', '9d', '7c', '6s', '2h'], 'hole': ['Ac', '3d']}, 1),
  ('hole ranks duplicate board straight',
   {'board': ['9h', 'Td', 'Jc', 'Qs', 'Kh'], 'hole': ['9c', 'Ts']}, 0),
  ('second hole card redundant', {'board': ['Kh', 'Kd', '9c', '7s', '5h'], 'hole': ['9d', '7d']},
   1),
  ('wheel with both', {'board': ['9h', '9d', '5c', '4s', '2h'], 'hole': ['Ac', '3d']}, 2),
  ('both cards pair', {'board': ['Kh', 'Qs', '5c', '4s', '2h'], 'hole': ['Kc', 'Qd']}, 2),
  ('low kicker does not play', {'board': ['Ah', 'Kd', '9c', '7s', '5h'], 'hole': ['2c', '3d']}, 0),
  ('board flush plays', {'board': ['4h', '7h', '9h', 'Jh', 'Kh'], 'hole': ['2c', '3d']}, 0)],
 [('board straight plays', {'board': ['9h', 'Td', 'Jc', 'Qs', 'Kh'], 'hole': ['2c', '3d']}, 0),
  ('one card kicker', {'board': ['9h', '9d', '7c', '6s', '2h'], 'hole': ['Ac', '3d']}, 1),
  ('hole ranks duplicate board straight',
   {'board': ['9h', 'Td', 'Jc', 'Qs', 'Kh'], 'hole': ['9c', 'Ts']}, 0),
  ('second hole card redundant', {'board': ['Kh', 'Kd', '9c', '7s', '5h'], 'hole': ['9d', '7d']},
   1),
  ('wheel with both', {'board': ['9h', '9d', '5c', '4s', '2h'], 'hole': ['Ac', '3d']}, 2),
  ('both cards pair', {'board': ['Kh', 'Qs', '5c', '4s', '2h'], 'hole': ['Kc', 'Qd']}, 2),
  ('pocket pair', {'board': ['Kh', 'Qs', '5c', '4s', '2h'], 'hole': ['8c', '8d']}, 2),
  ('board flush plays', {'board': ['4h', '7h', '9h', 'Jh', 'Kh'], 'hole': ['2c', '3d']}, 0)]]
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 fixtureActualExpectedOutcome
board straight playsNone0Failed
one card kicker11Passed
hole ranks duplicate board straight10Failed
second hole card redundant11Passed
wheel with both22Passed
both cards pair22Passed
pocket pair22Passed
same category better kicker11Passed

SHA-256 / b81a5c9f84e31b54d9929f0d5280d80c776a067efbfedc96d8e49ac072a27c85

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: return (8 if flush else 4, [top])
        if flush: return (5, vals)
        return ({(4,1):7,(3,2):6,(3,1,1):3,(2,2,1):2,(2,1,1,1):1}.get(tuple(shape),0), order)
    hole=x['hole']; board=x['board']
    best=max(key5(c) for c in itertools.combinations(hole+board,5))
    for n in range(3):
        for hc in itertools.combinations(hole,n):
            for bc in itertools.combinations(board,5-n):
                if key5(hc+bc)==best: return n
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
fixtures = [[('board straight plays', {'board': ['9h', 'Td', 'Jc', 'Qs', 'Kh'], 'hole': ['2c', '3d']}, 0),
  ('one card kicker', {'board': ['9h', '9d', '7c', '6s', '2h'], 'hole': ['Ac', '3d']}, 1),
  ('hole ranks duplicate board straight',
   {'board': ['9h', 'Td', 'Jc', 'Qs', 'Kh'], 'hole': ['9c', 'Ts']}, 0),
  ('second hole card redundant', {'board': ['Kh', 'Kd', '9c', '7s', '5h'], 'hole': ['9d', '7d']},
   1),
  ('wheel with both', {'board': ['9h', '9d', '5c', '4s', '2h'], 'hole': ['Ac', '3d']}, 2),
  ('both cards pair', {'board': ['Kh', 'Qs', '5c', '4s', '2h'], 'hole': ['Kc', 'Qd']}, 2),
  ('pocket pair', {'board': ['Kh', 'Qs', '5c', '4s', '2h'], 'hole': ['8c', '8d']}, 2),
  ('same category better kicker', {'board': ['Ah', 'Ad', '9c', '7s', '5h'], 'hole': ['Jc', '2d']},
   1)],
 [('hole ranks duplicate board straight',
   {'board': ['9h', 'Td', 'Jc', 'Qs', 'Kh'], 'hole': ['9c', 'Ts']}, 0),
  ('second hole card redundant', {'board': ['Kh', 'Kd', '9c', '7s', '5h'], 'hole': ['9d', '7d']},
   1),
  ('pocket pair', {'board': ['Kh', 'Qs', '5c', '4s', '2h'], 'hole': ['8c', '8d']}, 2),
  ('low kicker does not play', {'board': ['Ah', 'Kd', '9c', '7s', '5h'], 'hole': ['2c', '3d']}, 0),
  ('same category better kicker', {'board': ['Ah', 'Ad', '9c', '7s', '5h'], 'hole': ['Jc', '2d']},
   1),
  ('flush with one card', {'board': ['3h', '7h', '9h', 'Jh', 'Kd'], 'hole': ['Ah', '2c']}, 1),
  ('improved board flush', {'board': ['4h', '7h', '9h', 'Jh', 'Kh'], 'hole': ['Ah', '3d']}, 1),
  ('quads on board kicker', {'board': ['9h', '9d', '9c', '9s', 'Kh'], 'hole': ['Ac', '2d']}, 1)],
 [('board straight plays', {'board': ['9h', 'Td', 'Jc', 'Qs', 'Kh'], 'hole': ['2c', '3d']}, 0),
  ('one card kicker', {'board': ['9h', '9d', '7c', '6s', '2h'], 'hole': ['Ac', '3d']}, 1),
  ('hole ranks duplicate board straight',
   {'board': ['9h', 'Td', 'Jc', 'Qs', 'Kh'], 'hole': ['9c', 'Ts']}, 0),
  ('second hole card redundant', {'board': ['Kh', 'Kd', '9c', '7s', '5h'], 'hole': ['9d', '7d']},
   1),
  ('low kicker does not play', {'board': ['Ah', 'Kd', '9c', '7s', '5h'], 'hole': ['2c', '3d']}, 0),
  ('board flush plays', {'board': ['4h', '7h', '9h', 'Jh', 'Kh'], 'hole': ['2c', '3d']}, 0),
  ('improved board flush', {'board': ['4h', '7h', '9h', 'Jh', 'Kh'], 'hole': ['Ah', '3d']}, 1),
  ('quads on board kicker', {'board': ['9h', '9d', '9c', '9s', 'Kh'], 'hole': ['Ac', '2d']}, 1)],
 [('board straight plays', {'board': ['9h', 'Td', 'Jc', 'Qs', 'Kh'], 'hole': ['2c', '3d']}, 0),
  ('one card kicker', {'board': ['9h', '9d', '7c', '6s', '2h'], 'hole': ['Ac', '3d']}, 1),
  ('hole ranks duplicate board straight',
   {'board': ['9h', 'Td', 'Jc', 'Qs', 'Kh'], 'hole': ['9c', 'Ts']}, 0),
  ('second hole card redundant', {'board': ['Kh', 'Kd', '9c', '7s', '5h'], 'hole': ['9d', '7d']},
   1),
  ('wheel with both', {'board': ['9h', '9d', '5c', '4s', '2h'], 'hole': ['Ac', '3d']}, 2),
  ('both cards pair', {'board': ['Kh', 'Qs', '5c', '4s', '2h'], 'hole': ['Kc', 'Qd']}, 2),
  ('low kicker does not play', {'board': ['Ah', 'Kd', '9c', '7s', '5h'], 'hole': ['2c', '3d']}, 0),
  ('board flush plays', {'board': ['4h', '7h', '9h', 'Jh', 'Kh'], 'hole': ['2c', '3d']}, 0)],
 [('board straight plays', {'board': ['9h', 'Td', 'Jc', 'Qs', 'Kh'], 'hole': ['2c', '3d']}, 0),
  ('one card kicker', {'board': ['9h', '9d', '7c', '6s', '2h'], 'hole': ['Ac', '3d']}, 1),
  ('hole ranks duplicate board straight',
   {'board': ['9h', 'Td', 'Jc', 'Qs', 'Kh'], 'hole': ['9c', 'Ts']}, 0),
  ('second hole card redundant', {'board': ['Kh', 'Kd', '9c', '7s', '5h'], 'hole': ['9d', '7d']},
   1),
  ('wheel with both', {'board': ['9h', '9d', '5c', '4s', '2h'], 'hole': ['Ac', '3d']}, 2),
  ('both cards pair', {'board': ['Kh', 'Qs', '5c', '4s', '2h'], 'hole': ['Kc', 'Qd']}, 2),
  ('pocket pair', {'board': ['Kh', 'Qs', '5c', '4s', '2h'], 'hole': ['8c', '8d']}, 2),
  ('board flush plays', {'board': ['4h', '7h', '9h', 'Jh', 'Kh'], 'hole': ['2c', '3d']}, 0)]]
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 fixtureActualExpectedOutcome
board straight plays00Passed
one card kicker11Passed
hole ranks duplicate board straight00Passed
second hole card redundant11Passed
wheel with both22Passed
both cards pair22Passed
pocket pair22Passed
same category better kicker11Passed

SHA-256 / bd12036bea5e069e9389f02318b06c0120b7d40ecfd8b52c9089315ea90fe068

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:11.204130+00:00.

Case digest / 1cef28fcc9678f739318e587796bdd73139391aa75bff11eb73f41caeb351896