FAILURE MAP
← Case archive

FA-82091 / Poker hand evaluation / Open access

Ace played low in deuce-to-seven · case 01

Ace-high hands are scored as strong lows and beat seven-lows or king-lows.

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

ROOT CAUSE

The ace is valued 1 as in ace-to-five, but deuce-to-seven treats it as the highest card.

VERIFIED REPAIR

Value the ace at 14 and sort ranks descending.

Unsuccessful approach: Sorting ascending keeps the ace high but compares hands from their lowest card and disables straights.

Case contract

Input: [hand_a, hand_b] five distinct cards each. Deuce-to-seven lowball: aces are always high, A-2-3-4-5 is not a straight, straights and flushes count against the hand, and the standard high-hand ordering is inverted so the weaker high hand wins. Return 1 if hand_a wins, -1 if hand_b wins, 0 for a tie.

Why this case matters

Lowball variants reuse high-hand evaluators with inverted outcomes, a common source of subtle bugs.

1 / The failure

Exit 1
"""Failure Map reference implementation. Python standard library only."""
import json
import collections
N = 1
observations = []
def solve(x):
    R='23456789TJQKA'
    def key(h):
        vals=sorted((1 if c[0]=='A' else 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)
        straight=len(cnt)==5 and vals[0]-vals[4]==4
        flush=len({c[1] for c in h})==1
        if straight and flush: return (8,vals)
        if shape==[4,1]: return (7,order)
        if shape==[3,2]: return (6,order)
        if flush: return (5,vals)
        if straight: return (4,vals)
        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)
    ka,kb=key(x[0]),key(x[1])
    if ka==kb: return 0
    return 1 if ka<kb else -1
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
fixtures = [[('number one vs wheel', [['7h', '5d', '4c', '3s', '2h'], ['Ah', '2d', '3c', '4s', '5h']], 1),
  ('wheel is ace high', [['Ah', '2d', '3c', '4s', '5h'], ['Kh', 'Qd', 'Jc', '9s', '8h']], -1),
  ('seven low vs eight low', [['8h', '6d', '4c', '3s', '2h'], ['7c', '6h', '4d', '3c', '2d']], -1),
  ('flush counts against', [['2h', '4h', '5h', '6h', '8h'], ['9c', '6d', '4d', '3c', '2d']], -1),
  ('straight counts against', [['3h', '4d', '5c', '6s', '7h'], ['Kh', 'Qd', 'Jc', '9s', '7c']], -1),
  ('pair loses to king high', [['2h', '2d', '4c', '5s', '7h'], ['Kh', '8d', '6c', '4s', '3h']], -1),
  ('wheel vs pair', [['Ah', '2d', '3c', '4s', '5h'], ['3h', '3d', '6c', '8s', '9h']], 1),
  ('ace high vs king high', [['Ah', '9d', '7c', '4s', '2h'], ['Kh', 'Qd', 'Jc', '9s', '8c']], -1)],
 [('straight counts against', [['3h', '4d', '5c', '6s', '7h'], ['Kh', 'Qd', 'Jc', '9s', '7c']], -1),
  ('pair loses to king high', [['2h', '2d', '4c', '5s', '7h'], ['Kh', '8d', '6c', '4s', '3h']], -1),
  ('ace-king gap hand', [['Ah', 'Kd', '7c', '4s', '2h'], ['Qh', 'Jd', 'Tc', '8s', '6h']], -1),
  ('tie', [['7h', '5d', '4c', '3s', '2h'], ['7c', '5h', '4d', '3c', '2d']], 0),
  ('ace high vs pair', [['Ah', 'Qd', '9c', '7s', '5h'], ['3h', '3d', '6c', '5s', '4h']], 1),
  ('both pairs lower pair wins', [['4h', '4d', 'Kc', 'Qs', 'Jh'], ['5h', '5d', '2c', '3s', '7h']],
   1),
  ('wheel vs pair', [['Ah', '2d', '3c', '4s', '5h'], ['3h', '3d', '6c', '8s', '9h']], 1),
  ('ace high vs king high', [['Ah', '9d', '7c', '4s', '2h'], ['Kh', 'Qd', 'Jc', '9s', '8c']], -1)],
 [('wheel is ace high', [['Ah', '2d', '3c', '4s', '5h'], ['Kh', 'Qd', 'Jc', '9s', '8h']], -1),
  ('ace-king gap hand', [['Ah', 'Kd', '7c', '4s', '2h'], ['Qh', 'Jd', 'Tc', '8s', '6h']], -1),
  ('straight flush vs flush', [['2c', '3c', '4c', '5c', '6c'], ['9d', '7d', '5d', '3d', '2d']], -1),
  ('both pairs lower pair wins', [['4h', '4d', 'Kc', 'Qs', 'Jh'], ['5h', '5d', '2c', '3s', '7h']],
   1),
  ('wheel vs pair', [['Ah', '2d', '3c', '4s', '5h'], ['3h', '3d', '6c', '8s', '9h']], 1),
  ('ace-deuce span vs pair', [['Ah', 'Jd', '8c', '6s', '2h'], ['4h', '4d', '6d', '8d', '9s']], 1),
  ('ace high vs king high', [['Ah', '9d', '7c', '4s', '2h'], ['Kh', 'Qd', 'Jc', '9s', '8c']], -1),
  ('second tie', [['Kh', 'Jd', '9c', '6s', '3h'], ['Kc', 'Jh', '9d', '6c', '3d']], 0)],
 [('number one vs wheel', [['7h', '5d', '4c', '3s', '2h'], ['Ah', '2d', '3c', '4s', '5h']], 1),
  ('wheel is ace high', [['Ah', '2d', '3c', '4s', '5h'], ['Kh', 'Qd', 'Jc', '9s', '8h']], -1),
  ('straight counts against', [['3h', '4d', '5c', '6s', '7h'], ['Kh', 'Qd', 'Jc', '9s', '7c']], -1),
  ('ace-king gap hand', [['Ah', 'Kd', '7c', '4s', '2h'], ['Qh', 'Jd', 'Tc', '8s', '6h']], -1),
  ('straight flush vs flush', [['2c', '3c', '4c', '5c', '6c'], ['9d', '7d', '5d', '3d', '2d']], -1),
  ('wheel vs pair', [['Ah', '2d', '3c', '4s', '5h'], ['3h', '3d', '6c', '8s', '9h']], 1),
  ('ace high vs king high', [['Ah', '9d', '7c', '4s', '2h'], ['Kh', 'Qd', 'Jc', '9s', '8c']], -1),
  ('nine vs ten', [['9h', '7d', '5c', '3s', '2h'], ['Th', '4d', '3c', '6s', '2c']], 1)],
 [('number one vs wheel', [['7h', '5d', '4c', '3s', '2h'], ['Ah', '2d', '3c', '4s', '5h']], 1),
  ('seven low vs eight low', [['8h', '6d', '4c', '3s', '2h'], ['7c', '6h', '4d', '3c', '2d']], -1),
  ('flush counts against', [['2h', '4h', '5h', '6h', '8h'], ['9c', '6d', '4d', '3c', '2d']], -1),
  ('pair loses to king high', [['2h', '2d', '4c', '5s', '7h'], ['Kh', '8d', '6c', '4s', '3h']], -1),
  ('straight flush vs flush', [['2c', '3c', '4c', '5c', '6c'], ['9d', '7d', '5d', '3d', '2d']], -1),
  ('wheel vs pair', [['Ah', '2d', '3c', '4s', '5h'], ['3h', '3d', '6c', '8s', '9h']], 1),
  ('ace high vs king high', [['Ah', '9d', '7c', '4s', '2h'], ['Kh', 'Qd', 'Jc', '9s', '8c']], -1),
  ('nine vs ten', [['9h', '7d', '5c', '3s', '2h'], ['Th', '4d', '3c', '6s', '2c']], 1)]]
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
number one vs wheel11Passed
wheel is ace high-1-1Passed
seven low vs eight low-1-1Passed
flush counts against-1-1Passed
straight counts against-1-1Passed
pair loses to king high-1-1Passed
wheel vs pair-11Failed
ace high vs king high1-1Failed

SHA-256 / 3e48f128b8a9af16dde6c54e2fc5d66e3374ecbe232faa2d9d7f9300bff5c20a

2 / The unsuccessful fix

Exit 1
"""Failure Map reference implementation. Python standard library only."""
import json
import collections
N = 1
observations = []
def solve(x):
    R='23456789TJQKA'
    def key(h):
        vals=sorted((R.index(c[0])+2 for c in h))
        cnt=collections.Counter(vals)
        order=sorted(cnt, key=lambda v:(cnt[v],v), reverse=True)
        shape=sorted(cnt.values(), reverse=True)
        straight=len(cnt)==5 and vals[0]-vals[4]==4
        flush=len({c[1] for c in h})==1
        if straight and flush: return (8,vals)
        if shape==[4,1]: return (7,order)
        if shape==[3,2]: return (6,order)
        if flush: return (5,vals)
        if straight: return (4,vals)
        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)
    ka,kb=key(x[0]),key(x[1])
    if ka==kb: return 0
    return 1 if ka<kb else -1
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
fixtures = [[('number one vs wheel', [['7h', '5d', '4c', '3s', '2h'], ['Ah', '2d', '3c', '4s', '5h']], 1),
  ('wheel is ace high', [['Ah', '2d', '3c', '4s', '5h'], ['Kh', 'Qd', 'Jc', '9s', '8h']], -1),
  ('seven low vs eight low', [['8h', '6d', '4c', '3s', '2h'], ['7c', '6h', '4d', '3c', '2d']], -1),
  ('flush counts against', [['2h', '4h', '5h', '6h', '8h'], ['9c', '6d', '4d', '3c', '2d']], -1),
  ('straight counts against', [['3h', '4d', '5c', '6s', '7h'], ['Kh', 'Qd', 'Jc', '9s', '7c']], -1),
  ('pair loses to king high', [['2h', '2d', '4c', '5s', '7h'], ['Kh', '8d', '6c', '4s', '3h']], -1),
  ('wheel vs pair', [['Ah', '2d', '3c', '4s', '5h'], ['3h', '3d', '6c', '8s', '9h']], 1),
  ('ace high vs king high', [['Ah', '9d', '7c', '4s', '2h'], ['Kh', 'Qd', 'Jc', '9s', '8c']], -1)],
 [('straight counts against', [['3h', '4d', '5c', '6s', '7h'], ['Kh', 'Qd', 'Jc', '9s', '7c']], -1),
  ('pair loses to king high', [['2h', '2d', '4c', '5s', '7h'], ['Kh', '8d', '6c', '4s', '3h']], -1),
  ('ace-king gap hand', [['Ah', 'Kd', '7c', '4s', '2h'], ['Qh', 'Jd', 'Tc', '8s', '6h']], -1),
  ('tie', [['7h', '5d', '4c', '3s', '2h'], ['7c', '5h', '4d', '3c', '2d']], 0),
  ('ace high vs pair', [['Ah', 'Qd', '9c', '7s', '5h'], ['3h', '3d', '6c', '5s', '4h']], 1),
  ('both pairs lower pair wins', [['4h', '4d', 'Kc', 'Qs', 'Jh'], ['5h', '5d', '2c', '3s', '7h']],
   1),
  ('wheel vs pair', [['Ah', '2d', '3c', '4s', '5h'], ['3h', '3d', '6c', '8s', '9h']], 1),
  ('ace high vs king high', [['Ah', '9d', '7c', '4s', '2h'], ['Kh', 'Qd', 'Jc', '9s', '8c']], -1)],
 [('wheel is ace high', [['Ah', '2d', '3c', '4s', '5h'], ['Kh', 'Qd', 'Jc', '9s', '8h']], -1),
  ('ace-king gap hand', [['Ah', 'Kd', '7c', '4s', '2h'], ['Qh', 'Jd', 'Tc', '8s', '6h']], -1),
  ('straight flush vs flush', [['2c', '3c', '4c', '5c', '6c'], ['9d', '7d', '5d', '3d', '2d']], -1),
  ('both pairs lower pair wins', [['4h', '4d', 'Kc', 'Qs', 'Jh'], ['5h', '5d', '2c', '3s', '7h']],
   1),
  ('wheel vs pair', [['Ah', '2d', '3c', '4s', '5h'], ['3h', '3d', '6c', '8s', '9h']], 1),
  ('ace-deuce span vs pair', [['Ah', 'Jd', '8c', '6s', '2h'], ['4h', '4d', '6d', '8d', '9s']], 1),
  ('ace high vs king high', [['Ah', '9d', '7c', '4s', '2h'], ['Kh', 'Qd', 'Jc', '9s', '8c']], -1),
  ('second tie', [['Kh', 'Jd', '9c', '6s', '3h'], ['Kc', 'Jh', '9d', '6c', '3d']], 0)],
 [('number one vs wheel', [['7h', '5d', '4c', '3s', '2h'], ['Ah', '2d', '3c', '4s', '5h']], 1),
  ('wheel is ace high', [['Ah', '2d', '3c', '4s', '5h'], ['Kh', 'Qd', 'Jc', '9s', '8h']], -1),
  ('straight counts against', [['3h', '4d', '5c', '6s', '7h'], ['Kh', 'Qd', 'Jc', '9s', '7c']], -1),
  ('ace-king gap hand', [['Ah', 'Kd', '7c', '4s', '2h'], ['Qh', 'Jd', 'Tc', '8s', '6h']], -1),
  ('straight flush vs flush', [['2c', '3c', '4c', '5c', '6c'], ['9d', '7d', '5d', '3d', '2d']], -1),
  ('wheel vs pair', [['Ah', '2d', '3c', '4s', '5h'], ['3h', '3d', '6c', '8s', '9h']], 1),
  ('ace high vs king high', [['Ah', '9d', '7c', '4s', '2h'], ['Kh', 'Qd', 'Jc', '9s', '8c']], -1),
  ('nine vs ten', [['9h', '7d', '5c', '3s', '2h'], ['Th', '4d', '3c', '6s', '2c']], 1)],
 [('number one vs wheel', [['7h', '5d', '4c', '3s', '2h'], ['Ah', '2d', '3c', '4s', '5h']], 1),
  ('seven low vs eight low', [['8h', '6d', '4c', '3s', '2h'], ['7c', '6h', '4d', '3c', '2d']], -1),
  ('flush counts against', [['2h', '4h', '5h', '6h', '8h'], ['9c', '6d', '4d', '3c', '2d']], -1),
  ('pair loses to king high', [['2h', '2d', '4c', '5s', '7h'], ['Kh', '8d', '6c', '4s', '3h']], -1),
  ('straight flush vs flush', [['2c', '3c', '4c', '5c', '6c'], ['9d', '7d', '5d', '3d', '2d']], -1),
  ('wheel vs pair', [['Ah', '2d', '3c', '4s', '5h'], ['3h', '3d', '6c', '8s', '9h']], 1),
  ('ace high vs king high', [['Ah', '9d', '7c', '4s', '2h'], ['Kh', 'Qd', 'Jc', '9s', '8c']], -1),
  ('nine vs ten', [['9h', '7d', '5c', '3s', '2h'], ['Th', '4d', '3c', '6s', '2c']], 1)]]
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
number one vs wheel11Passed
wheel is ace high1-1Failed
seven low vs eight low-1-1Passed
flush counts against-1-1Passed
straight counts against1-1Failed
pair loses to king high-1-1Passed
wheel vs pair11Passed
ace high vs king high1-1Failed

SHA-256 / ab0780e54d52c74ccd17eec39be01368a3d26368c223603df374ba7254055bf4

3 / The verified repair

Exit 0
"""Failure Map reference implementation. Python standard library only."""
import json
import collections
N = 1
observations = []
def solve(x):
    R='23456789TJQKA'
    def key(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)
        straight=len(cnt)==5 and vals[0]-vals[4]==4
        flush=len({c[1] for c in h})==1
        if straight and flush: return (8,vals)
        if shape==[4,1]: return (7,order)
        if shape==[3,2]: return (6,order)
        if flush: return (5,vals)
        if straight: return (4,vals)
        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)
    ka,kb=key(x[0]),key(x[1])
    if ka==kb: return 0
    return 1 if ka<kb else -1
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
fixtures = [[('number one vs wheel', [['7h', '5d', '4c', '3s', '2h'], ['Ah', '2d', '3c', '4s', '5h']], 1),
  ('wheel is ace high', [['Ah', '2d', '3c', '4s', '5h'], ['Kh', 'Qd', 'Jc', '9s', '8h']], -1),
  ('seven low vs eight low', [['8h', '6d', '4c', '3s', '2h'], ['7c', '6h', '4d', '3c', '2d']], -1),
  ('flush counts against', [['2h', '4h', '5h', '6h', '8h'], ['9c', '6d', '4d', '3c', '2d']], -1),
  ('straight counts against', [['3h', '4d', '5c', '6s', '7h'], ['Kh', 'Qd', 'Jc', '9s', '7c']], -1),
  ('pair loses to king high', [['2h', '2d', '4c', '5s', '7h'], ['Kh', '8d', '6c', '4s', '3h']], -1),
  ('wheel vs pair', [['Ah', '2d', '3c', '4s', '5h'], ['3h', '3d', '6c', '8s', '9h']], 1),
  ('ace high vs king high', [['Ah', '9d', '7c', '4s', '2h'], ['Kh', 'Qd', 'Jc', '9s', '8c']], -1)],
 [('straight counts against', [['3h', '4d', '5c', '6s', '7h'], ['Kh', 'Qd', 'Jc', '9s', '7c']], -1),
  ('pair loses to king high', [['2h', '2d', '4c', '5s', '7h'], ['Kh', '8d', '6c', '4s', '3h']], -1),
  ('ace-king gap hand', [['Ah', 'Kd', '7c', '4s', '2h'], ['Qh', 'Jd', 'Tc', '8s', '6h']], -1),
  ('tie', [['7h', '5d', '4c', '3s', '2h'], ['7c', '5h', '4d', '3c', '2d']], 0),
  ('ace high vs pair', [['Ah', 'Qd', '9c', '7s', '5h'], ['3h', '3d', '6c', '5s', '4h']], 1),
  ('both pairs lower pair wins', [['4h', '4d', 'Kc', 'Qs', 'Jh'], ['5h', '5d', '2c', '3s', '7h']],
   1),
  ('wheel vs pair', [['Ah', '2d', '3c', '4s', '5h'], ['3h', '3d', '6c', '8s', '9h']], 1),
  ('ace high vs king high', [['Ah', '9d', '7c', '4s', '2h'], ['Kh', 'Qd', 'Jc', '9s', '8c']], -1)],
 [('wheel is ace high', [['Ah', '2d', '3c', '4s', '5h'], ['Kh', 'Qd', 'Jc', '9s', '8h']], -1),
  ('ace-king gap hand', [['Ah', 'Kd', '7c', '4s', '2h'], ['Qh', 'Jd', 'Tc', '8s', '6h']], -1),
  ('straight flush vs flush', [['2c', '3c', '4c', '5c', '6c'], ['9d', '7d', '5d', '3d', '2d']], -1),
  ('both pairs lower pair wins', [['4h', '4d', 'Kc', 'Qs', 'Jh'], ['5h', '5d', '2c', '3s', '7h']],
   1),
  ('wheel vs pair', [['Ah', '2d', '3c', '4s', '5h'], ['3h', '3d', '6c', '8s', '9h']], 1),
  ('ace-deuce span vs pair', [['Ah', 'Jd', '8c', '6s', '2h'], ['4h', '4d', '6d', '8d', '9s']], 1),
  ('ace high vs king high', [['Ah', '9d', '7c', '4s', '2h'], ['Kh', 'Qd', 'Jc', '9s', '8c']], -1),
  ('second tie', [['Kh', 'Jd', '9c', '6s', '3h'], ['Kc', 'Jh', '9d', '6c', '3d']], 0)],
 [('number one vs wheel', [['7h', '5d', '4c', '3s', '2h'], ['Ah', '2d', '3c', '4s', '5h']], 1),
  ('wheel is ace high', [['Ah', '2d', '3c', '4s', '5h'], ['Kh', 'Qd', 'Jc', '9s', '8h']], -1),
  ('straight counts against', [['3h', '4d', '5c', '6s', '7h'], ['Kh', 'Qd', 'Jc', '9s', '7c']], -1),
  ('ace-king gap hand', [['Ah', 'Kd', '7c', '4s', '2h'], ['Qh', 'Jd', 'Tc', '8s', '6h']], -1),
  ('straight flush vs flush', [['2c', '3c', '4c', '5c', '6c'], ['9d', '7d', '5d', '3d', '2d']], -1),
  ('wheel vs pair', [['Ah', '2d', '3c', '4s', '5h'], ['3h', '3d', '6c', '8s', '9h']], 1),
  ('ace high vs king high', [['Ah', '9d', '7c', '4s', '2h'], ['Kh', 'Qd', 'Jc', '9s', '8c']], -1),
  ('nine vs ten', [['9h', '7d', '5c', '3s', '2h'], ['Th', '4d', '3c', '6s', '2c']], 1)],
 [('number one vs wheel', [['7h', '5d', '4c', '3s', '2h'], ['Ah', '2d', '3c', '4s', '5h']], 1),
  ('seven low vs eight low', [['8h', '6d', '4c', '3s', '2h'], ['7c', '6h', '4d', '3c', '2d']], -1),
  ('flush counts against', [['2h', '4h', '5h', '6h', '8h'], ['9c', '6d', '4d', '3c', '2d']], -1),
  ('pair loses to king high', [['2h', '2d', '4c', '5s', '7h'], ['Kh', '8d', '6c', '4s', '3h']], -1),
  ('straight flush vs flush', [['2c', '3c', '4c', '5c', '6c'], ['9d', '7d', '5d', '3d', '2d']], -1),
  ('wheel vs pair', [['Ah', '2d', '3c', '4s', '5h'], ['3h', '3d', '6c', '8s', '9h']], 1),
  ('ace high vs king high', [['Ah', '9d', '7c', '4s', '2h'], ['Kh', 'Qd', 'Jc', '9s', '8c']], -1),
  ('nine vs ten', [['9h', '7d', '5c', '3s', '2h'], ['Th', '4d', '3c', '6s', '2c']], 1)]]
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
number one vs wheel11Passed
wheel is ace high-1-1Passed
seven low vs eight low-1-1Passed
flush counts against-1-1Passed
straight counts against-1-1Passed
pair loses to king high-1-1Passed
wheel vs pair11Passed
ace high vs king high-1-1Passed

SHA-256 / 65320d5553373dc0ce49affaa6df452aad9161b66555ce619e192f4d4d89c726

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

Case digest / feff116b9f1f876b65599930e58215c435cb9424bcfbc5e27dbcc70335f63a88