FAILURE MAP
← Case archive

FA-83926 / Sports scoring and tiebreakers / Open access

Volleyball set capped like badminton · case 01

A set is closed at 25-24 or at a 27-26 cap instead of continuing until a two-point lead.

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

ROOT CAUSE

The set completion test only requires a one-point lead.

VERIFIED REPAIR

Require a two-point lead with no cap.

Unsuccessful approach: Adding a two-points-over-target cap closes 27-26 sets that must continue.

Case contract

Best-of-five volleyball with rally scoring. rallies is a string of rally winners (A/B). Sets 1-4 are played to 25 and set 5 to 15, always win by two with no cap. The rally winner serves next; when the receiving team wins a rally (side-out) that team rotates once (rotation counter modulo 6). At the start of each set both rotation counters reset to 0 and the first server is first_serve in odd-numbered sets and the other team in even-numbered sets. Return [completed and current set scores as [a, b], match winner or None, rotation counters].

Why this case matters

Scoresheet apps track rotations to flag out-of-rotation faults and must reset them each set.

1 / The failure

Exit 1
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(rallies, first_serve):
    won = {'A': 0, 'B': 0}
    sets = []
    a = b = 0
    set_index = 0
    server = first_serve
    rot = {'A': 0, 'B': 0}
    for r in rallies:
        if r == 'A':
            a += 1
        else:
            b += 1
        if r != server:
            rot[r] = (rot[r] + 1) % 6
            server = r
        target = 15 if set_index == 4 else 25
        if max(a, b) >= target and abs(a - b) >= 1:
            w = 'A' if a > b else 'B'
            won[w] += 1
            sets.append([a, b])
            if won[w] == 3:
                return [sets, w, rot]
            a = b = 0
            set_index += 1
            rot = {'A': 0, 'B': 0}
            server = first_serve if set_index % 2 == 0 else ('B' if first_serve == 'A' else 'A')
    return [sets + ([[a, b]] if a or b else []), None, rot]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
def run(args):
    try:
        return solve(*args)
    except Exception as exc:
        return 'raised ' + type(exc).__name__
cases = [[('control first rally held by server', ('A', 'A'), [[[1, 0]], None, {'A': 0, 'B': 0}]),
  ('boundary side-out rotates receiver', ('B', 'A'), [[[0, 1]], None, {'A': 0, 'B': 1}]),
  ('control clean set', ('AAAAAAAAAAAAAAAAAAAAAAAAA', 'A'), [[[25, 0]], None, {'A': 0, 'B': 0}]),
  ('boundary second set served by other team',
   ('AAAAAAAAAAAAAAAAAAAAAAAAAA', 'A'),
   [[[25, 0], [1, 0]], None, {'A': 1, 'B': 0}]),
  ('boundary deuce in set',
   ('ABABABABABABABABABABABABABABABABABABABABABABABABAA', 'A'),
   [[[26, 24]], None, {'A': 0, 'B': 0}]),
  ('control straight-sets match',
   ('AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA', 'B'),
   [[[25, 0], [25, 0], [25, 0]], 'A', {'A': 1, 'B': 0}]),
  ('regression: win by two without cap',
   ('ABBBAABAAABAAABAABABBABAABBABBBBAAAABBBABBBAABABBAABAAAAAABBABBABAAAABBAAAABBBBAAABAABBBAB',
    'A'),
   [[[28, 26], [20, 16]], None, {'A': 2, 'B': 2}]),
  ('variant scenario 1',
   ('AABBBAABAABAAAAABAABBABBBBBBAABBBBAAAAAAABABABBBBBABBBBBABAAABABABAAABBABAABABBAAABAABABBAA',
    'B'),
   [[[25, 20], [22, 24]], None, {'A': 1, 'B': 1}]),
  ('variant scenario 2',
   ('AAAABBBBBBABABABABAAAABAABAABBBAAAAABAAABAABBAAABAAABBAAABBABBAAAAA', 'A'),
   [[[25, 17], [16, 9]], None, {'A': 0, 'B': 5}])],
 [('control first rally held by server', ('A', 'A'), [[[1, 0]], None, {'A': 0, 'B': 0}]),
  ('boundary side-out rotates receiver', ('B', 'A'), [[[0, 1]], None, {'A': 0, 'B': 1}]),
  ('control clean set', ('AAAAAAAAAAAAAAAAAAAAAAAAA', 'A'), [[[25, 0]], None, {'A': 0, 'B': 0}]),
  ('boundary second set served by other team',
   ('AAAAAAAAAAAAAAAAAAAAAAAAAA', 'A'),
   [[[25, 0], [1, 0]], None, {'A': 1, 'B': 0}]),
  ('boundary deuce in set',
   ('ABABABABABABABABABABABABABABABABABABABABABABABABAA', 'A'),
   [[[26, 24]], None, {'A': 0, 'B': 0}]),
  ('control straight-sets match',
   ('AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA', 'B'),
   [[[25, 0], [25, 0], [25, 0]], 'A', {'A': 1, 'B': 0}]),
  ('regression: win by two without cap',
   ('BAAABBBAAABABABBAABABAAAAABBBBABABBBAAABABBABBBAABAAAAAAAAAAAABBAABAAAA', 'A'),
   [[[27, 25], [16, 3]], None, {'A': 3, 'B': 2}]),
  ('regression: win by two without cap',
   ('BAAAAABAABBABABAABBAAAABAAAABAAAABBAABBABBABAAAAABBBBBBAABBAABAABBAAABBBAAABBBAAAABBAABABAAABABABBAAAAAABABABA',
    'B'),
   [[[25, 12], [28, 26], [12, 7]], None, {'A': 1, 'B': 0}]),
  ('variant scenario 1',
   ('ABAABBBAAAAABAABBAAAABBBAAAABABAABAAAAAAABBAABBAAAAAAABA', 'B'),
   [[[25, 13], [13, 5]], None, {'A': 3, 'B': 3}]),
  ('variant scenario 2',
   ('ABBAABBABBAAABAAAABBABABAAABABBAABBAAABBABAAABABAAABABABAAAAAABBBABBBABBABBAAAABBABAABAABBAAAAABBABBBABAABAAABBABBBBBBABBAABBAAAAABABAAABAAA',
    'A'),
   [[[25, 19], [25, 19], [25, 23]], 'A', {'A': 5, 'B': 5}])],
 [('control first rally held by server', ('A', 'A'), [[[1, 0]], None, {'A': 0, 'B': 0}]),
  ('boundary side-out rotates receiver', ('B', 'A'), [[[0, 1]], None, {'A': 0, 'B': 1}]),
  ('control clean set', ('AAAAAAAAAAAAAAAAAAAAAAAAA', 'A'), [[[25, 0]], None, {'A': 0, 'B': 0}]),
  ('boundary second set served by other team',
   ('AAAAAAAAAAAAAAAAAAAAAAAAAA', 'A'),
   [[[25, 0], [1, 0]], None, {'A': 1, 'B': 0}]),
  ('boundary deuce in set',
   ('ABABABABABABABABABABABABABABABABABABABABABABABABAA', 'A'),
   [[[26, 24]], None, {'A': 0, 'B': 0}]),
  ('control straight-sets match',
   ('AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA', 'B'),
   [[[25, 0], [25, 0], [25, 0]], 'A', {'A': 1, 'B': 0}]),
  ('regression: win by two without cap',
   ('ABABABABABABABABABABABABABABABABABABABABABABABABABABA', 'A'),
   [[[27, 26]], None, {'A': 2, 'B': 2}]),
  ('variant scenario 1',
   ('ABBAABAAAAAAAABBBBABBBBBBAAABBAAAAAAABAABBBBABAABBBAAAAAAAAAAABBABBBBABAAABABABAAAABABBBAAAAABAABABABAAAAAABABBAABBBBAAABABBBBBAAAAB',
    'A'),
   [[[25, 20], [25, 15], [25, 20]], 'A', {'A': 4, 'B': 4}]),
  ('variant scenario 2',
   ('AAAAABAAAAAAABAAAAAABABAABAAAAAAABAAABAAAAABBABABBAABAABABABABBBBABAABAAABAABAAAABABAAAAABBBBBBABAAAAAABABAAAABBAAAA',
    'A'),
   [[[25, 5], [25, 17], [25, 13]], 'A', {'A': 2, 'B': 2}])],
 [('control first rally held by server', ('A', 'A'), [[[1, 0]], None, {'A': 0, 'B': 0}]),
  ('boundary side-out rotates receiver', ('B', 'A'), [[[0, 1]], None, {'A': 0, 'B': 1}]),
  ('control clean set', ('AAAAAAAAAAAAAAAAAAAAAAAAA', 'A'), [[[25, 0]], None, {'A': 0, 'B': 0}]),
  ('boundary second set served by other team',
   ('AAAAAAAAAAAAAAAAAAAAAAAAAA', 'A'),
   [[[25, 0], [1, 0]], None, {'A': 1, 'B': 0}]),
  ('boundary deuce in set',
   ('ABABABABABABABABABABABABABABABABABABABABABABABABAA', 'A'),
   [[[26, 24]], None, {'A': 0, 'B': 0}]),
  ('control straight-sets match',
   ('AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA', 'B'),
   [[[25, 0], [25, 0], [25, 0]], 'A', {'A': 1, 'B': 0}]),
  ('regression: win by two without cap',
   ('ABAAAABBBBBBAAAAABABABABBABBAABAAAABBBAAAABAAAAABAAABAABBAAABAAAAABAAAAAABAABABBABBABAAAAABBBAAABBBAABABAAABBABBBABABABBAAABABBBABAABABA',
    'A'),
   [[[25, 19], [25, 7], [25, 27], [5, 3]], None, {'A': 4, 'B': 3}]),
  ('regression: win by two without cap',
   ('AAAAAABBAABBAAABABABAABAABAAAABBBBBBABBABABBAAAABBAABAAABAAABAAAABBBBAABABABABBAAAAAAABABABAAABBBBBBBAAAABBABBABABBBABAABAAABBAABABAABABAAAABAAAAAABABA',
    'A'),
   [[[25, 20], [25, 14], [28, 26]], 'A', {'A': 3, 'B': 3}]),
  ('variant scenario 1',
   ('ABBBAAABAABBAABAABAABABBABBAAABBBBAABAAABAABBAABBAAABBAABBAB', 'A'),
   [[[25, 21], [7, 7]], None, {'A': 4, 'B': 4}]),
  ('variant scenario 2',
   ('BAAAABBAAABBAAAAAAAAABABABABBBBAAABBABABBBAAABAAABAABABAABAABBBBBBABBBAAAABAAAAAAAABBABABABBBABAAAAABABABABAAABAABABAAAAAAABAABAABAAAAAABABBBABBBBAAAABAAAAAAAABBABABAAAAABABB',
    'A'),
   [[[25, 18], [25, 15], [25, 15]], 'A', {'A': 0, 'B': 0}])],
 [('control first rally held by server', ('A', 'A'), [[[1, 0]], None, {'A': 0, 'B': 0}]),
  ('boundary side-out rotates receiver', ('B', 'A'), [[[0, 1]], None, {'A': 0, 'B': 1}]),
  ('control clean set', ('AAAAAAAAAAAAAAAAAAAAAAAAA', 'A'), [[[25, 0]], None, {'A': 0, 'B': 0}]),
  ('boundary second set served by other team',
   ('AAAAAAAAAAAAAAAAAAAAAAAAAA', 'A'),
   [[[25, 0], [1, 0]], None, {'A': 1, 'B': 0}]),
  ('boundary deuce in set',
   ('ABABABABABABABABABABABABABABABABABABABABABABABABAA', 'A'),
   [[[26, 24]], None, {'A': 0, 'B': 0}]),
  ('control straight-sets match',
   ('AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA', 'B'),
   [[[25, 0], [25, 0], [25, 0]], 'A', {'A': 1, 'B': 0}]),
  ('regression: win by two without cap',
   ('ABABABABABABABABABABABABABABABABABABABABABABABABABABA', 'A'),
   [[[27, 26]], None, {'A': 2, 'B': 2}]),
  ('variant scenario 1',
   ('BAAAAAABABBABABABBABBBABABAAAABABABBBABABBABAABABAAAAAABBBBAAAAAABAAABAABABAAABBBBBABBBBABBBAABABABAAAAABABBBABBAAAABAAAAAABBBAAABABAABABAAAABAAAABBABAAAAAAAAAABBABBAAABBAAABBAAABAAAAABABAAAAAABBABAABAABBABAAAA',
    'A'),
   [[[25, 23], [25, 21], [25, 15]], 'A', {'A': 4, 'B': 4}]),
  ('variant scenario 2',
   ('ABAAAAAAABAABAAABABAAABAAAAABBAAABAABBBBAAABAABAAAABAABBABABABAAAAAAAAAABAAAABAAABBBAABBAABAAAAAABAAAAAABAAAABABBBAAAABBAAABAAABAAAABBBABAAAABABBBAAB',
    'B'),
   [[[25, 8], [25, 13], [25, 10]], 'A', {'A': 2, 'B': 1}])]]
for label, args, expected in cases[N - 1]:
    check(label, run(args), 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
control first rally held by server[[[1, 0]], None, {'A': 0, 'B': 0}][[[1, 0]], None, {'A': 0, 'B': 0}]Passed
boundary side-out rotates receiver[[[0, 1]], None, {'A': 0, 'B': 1}][[[0, 1]], None, {'A': 0, 'B': 1}]Passed
control clean set[[[25, 0]], None, {'A': 0, 'B': 0}][[[25, 0]], None, {'A': 0, 'B': 0}]Passed
boundary second set served by other team[[[25, 0], [1, 0]], None, {'A': 1, 'B': 0}][[[25, 0], [1, 0]], None, {'A': 1, 'B': 0}]Passed
boundary deuce in set[[[25, 24], [1, 0]], None, {'A': 1, 'B': 0}][[[26, 24]], None, {'A': 0, 'B': 0}]Failed
control straight-sets match[[[25, 0], [25, 0], [25, 0]], 'A', {'A': 1, 'B': 0}][[[25, 0], [25, 0], [25, 0]], 'A', {'A': 1, 'B': 0}]Passed
regression: win by two without cap[[[24, 25], [24, 17]], None, {'A': 3, 'B': 3}][[[28, 26], [20, 16]], None, {'A': 2, 'B': 2}]Failed
variant scenario 1[[[25, 20], [22, 24]], None, {'A': 1, 'B': 1}][[[25, 20], [22, 24]], None, {'A': 1, 'B': 1}]Passed
variant scenario 2[[[25, 17], [16, 9]], None, {'A': 0, 'B': 5}][[[25, 17], [16, 9]], None, {'A': 0, 'B': 5}]Passed

SHA-256 / 88e9d5ed93fcee908793db8b27d3cdc0abd39847ef104e18d5035349a327058a

2 / The unsuccessful fix

Exit 1
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(rallies, first_serve):
    won = {'A': 0, 'B': 0}
    sets = []
    a = b = 0
    set_index = 0
    server = first_serve
    rot = {'A': 0, 'B': 0}
    for r in rallies:
        if r == 'A':
            a += 1
        else:
            b += 1
        if r != server:
            rot[r] = (rot[r] + 1) % 6
            server = r
        target = 15 if set_index == 4 else 25
        if max(a, b) >= target and (abs(a - b) >= 2 or max(a, b) >= target + 2):
            w = 'A' if a > b else 'B'
            won[w] += 1
            sets.append([a, b])
            if won[w] == 3:
                return [sets, w, rot]
            a = b = 0
            set_index += 1
            rot = {'A': 0, 'B': 0}
            server = first_serve if set_index % 2 == 0 else ('B' if first_serve == 'A' else 'A')
    return [sets + ([[a, b]] if a or b else []), None, rot]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
def run(args):
    try:
        return solve(*args)
    except Exception as exc:
        return 'raised ' + type(exc).__name__
cases = [[('control first rally held by server', ('A', 'A'), [[[1, 0]], None, {'A': 0, 'B': 0}]),
  ('boundary side-out rotates receiver', ('B', 'A'), [[[0, 1]], None, {'A': 0, 'B': 1}]),
  ('control clean set', ('AAAAAAAAAAAAAAAAAAAAAAAAA', 'A'), [[[25, 0]], None, {'A': 0, 'B': 0}]),
  ('boundary second set served by other team',
   ('AAAAAAAAAAAAAAAAAAAAAAAAAA', 'A'),
   [[[25, 0], [1, 0]], None, {'A': 1, 'B': 0}]),
  ('boundary deuce in set',
   ('ABABABABABABABABABABABABABABABABABABABABABABABABAA', 'A'),
   [[[26, 24]], None, {'A': 0, 'B': 0}]),
  ('control straight-sets match',
   ('AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA', 'B'),
   [[[25, 0], [25, 0], [25, 0]], 'A', {'A': 1, 'B': 0}]),
  ('regression: win by two without cap',
   ('ABBBAABAAABAAABAABABBABAABBABBBBAAAABBBABBBAABABBAABAAAAAABBABBABAAAABBAAAABBBBAAABAABBBAB',
    'A'),
   [[[28, 26], [20, 16]], None, {'A': 2, 'B': 2}]),
  ('variant scenario 1',
   ('AABBBAABAABAAAAABAABBABBBBBBAABBBBAAAAAAABABABBBBBABBBBBABAAABABABAAABBABAABABBAAABAABABBAA',
    'B'),
   [[[25, 20], [22, 24]], None, {'A': 1, 'B': 1}]),
  ('variant scenario 2',
   ('AAAABBBBBBABABABABAAAABAABAABBBAAAAABAAABAABBAAABAAABBAAABBABBAAAAA', 'A'),
   [[[25, 17], [16, 9]], None, {'A': 0, 'B': 5}])],
 [('control first rally held by server', ('A', 'A'), [[[1, 0]], None, {'A': 0, 'B': 0}]),
  ('boundary side-out rotates receiver', ('B', 'A'), [[[0, 1]], None, {'A': 0, 'B': 1}]),
  ('control clean set', ('AAAAAAAAAAAAAAAAAAAAAAAAA', 'A'), [[[25, 0]], None, {'A': 0, 'B': 0}]),
  ('boundary second set served by other team',
   ('AAAAAAAAAAAAAAAAAAAAAAAAAA', 'A'),
   [[[25, 0], [1, 0]], None, {'A': 1, 'B': 0}]),
  ('boundary deuce in set',
   ('ABABABABABABABABABABABABABABABABABABABABABABABABAA', 'A'),
   [[[26, 24]], None, {'A': 0, 'B': 0}]),
  ('control straight-sets match',
   ('AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA', 'B'),
   [[[25, 0], [25, 0], [25, 0]], 'A', {'A': 1, 'B': 0}]),
  ('regression: win by two without cap',
   ('BAAABBBAAABABABBAABABAAAAABBBBABABBBAAABABBABBBAABAAAAAAAAAAAABBAABAAAA', 'A'),
   [[[27, 25], [16, 3]], None, {'A': 3, 'B': 2}]),
  ('regression: win by two without cap',
   ('BAAAAABAABBABABAABBAAAABAAAABAAAABBAABBABBABAAAAABBBBBBAABBAABAABBAAABBBAAABBBAAAABBAABABAAABABABBAAAAAABABABA',
    'B'),
   [[[25, 12], [28, 26], [12, 7]], None, {'A': 1, 'B': 0}]),
  ('variant scenario 1',
   ('ABAABBBAAAAABAABBAAAABBBAAAABABAABAAAAAAABBAABBAAAAAAABA', 'B'),
   [[[25, 13], [13, 5]], None, {'A': 3, 'B': 3}]),
  ('variant scenario 2',
   ('ABBAABBABBAAABAAAABBABABAAABABBAABBAAABBABAAABABAAABABABAAAAAABBBABBBABBABBAAAABBABAABAABBAAAAABBABBBABAABAAABBABBBBBBABBAABBAAAAABABAAABAAA',
    'A'),
   [[[25, 19], [25, 19], [25, 23]], 'A', {'A': 5, 'B': 5}])],
 [('control first rally held by server', ('A', 'A'), [[[1, 0]], None, {'A': 0, 'B': 0}]),
  ('boundary side-out rotates receiver', ('B', 'A'), [[[0, 1]], None, {'A': 0, 'B': 1}]),
  ('control clean set', ('AAAAAAAAAAAAAAAAAAAAAAAAA', 'A'), [[[25, 0]], None, {'A': 0, 'B': 0}]),
  ('boundary second set served by other team',
   ('AAAAAAAAAAAAAAAAAAAAAAAAAA', 'A'),
   [[[25, 0], [1, 0]], None, {'A': 1, 'B': 0}]),
  ('boundary deuce in set',
   ('ABABABABABABABABABABABABABABABABABABABABABABABABAA', 'A'),
   [[[26, 24]], None, {'A': 0, 'B': 0}]),
  ('control straight-sets match',
   ('AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA', 'B'),
   [[[25, 0], [25, 0], [25, 0]], 'A', {'A': 1, 'B': 0}]),
  ('regression: win by two without cap',
   ('ABABABABABABABABABABABABABABABABABABABABABABABABABABA', 'A'),
   [[[27, 26]], None, {'A': 2, 'B': 2}]),
  ('variant scenario 1',
   ('ABBAABAAAAAAAABBBBABBBBBBAAABBAAAAAAABAABBBBABAABBBAAAAAAAAAAABBABBBBABAAABABABAAAABABBBAAAAABAABABABAAAAAABABBAABBBBAAABABBBBBAAAAB',
    'A'),
   [[[25, 20], [25, 15], [25, 20]], 'A', {'A': 4, 'B': 4}]),
  ('variant scenario 2',
   ('AAAAABAAAAAAABAAAAAABABAABAAAAAAABAAABAAAAABBABABBAABAABABABABBBBABAABAAABAABAAAABABAAAAABBBBBBABAAAAAABABAAAABBAAAA',
    'A'),
   [[[25, 5], [25, 17], [25, 13]], 'A', {'A': 2, 'B': 2}])],
 [('control first rally held by server', ('A', 'A'), [[[1, 0]], None, {'A': 0, 'B': 0}]),
  ('boundary side-out rotates receiver', ('B', 'A'), [[[0, 1]], None, {'A': 0, 'B': 1}]),
  ('control clean set', ('AAAAAAAAAAAAAAAAAAAAAAAAA', 'A'), [[[25, 0]], None, {'A': 0, 'B': 0}]),
  ('boundary second set served by other team',
   ('AAAAAAAAAAAAAAAAAAAAAAAAAA', 'A'),
   [[[25, 0], [1, 0]], None, {'A': 1, 'B': 0}]),
  ('boundary deuce in set',
   ('ABABABABABABABABABABABABABABABABABABABABABABABABAA', 'A'),
   [[[26, 24]], None, {'A': 0, 'B': 0}]),
  ('control straight-sets match',
   ('AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA', 'B'),
   [[[25, 0], [25, 0], [25, 0]], 'A', {'A': 1, 'B': 0}]),
  ('regression: win by two without cap',
   ('ABAAAABBBBBBAAAAABABABABBABBAABAAAABBBAAAABAAAAABAAABAABBAAABAAAAABAAAAAABAABABBABBABAAAAABBBAAABBBAABABAAABBABBBABABABBAAABABBBABAABABA',
    'A'),
   [[[25, 19], [25, 7], [25, 27], [5, 3]], None, {'A': 4, 'B': 3}]),
  ('regression: win by two without cap',
   ('AAAAAABBAABBAAABABABAABAABAAAABBBBBBABBABABBAAAABBAABAAABAAABAAAABBBBAABABABABBAAAAAAABABABAAABBBBBBBAAAABBABBABABBBABAABAAABBAABABAABABAAAABAAAAAABABA',
    'A'),
   [[[25, 20], [25, 14], [28, 26]], 'A', {'A': 3, 'B': 3}]),
  ('variant scenario 1',
   ('ABBBAAABAABBAABAABAABABBABBAAABBBBAABAAABAABBAABBAAABBAABBAB', 'A'),
   [[[25, 21], [7, 7]], None, {'A': 4, 'B': 4}]),
  ('variant scenario 2',
   ('BAAAABBAAABBAAAAAAAAABABABABBBBAAABBABABBBAAABAAABAABABAABAABBBBBBABBBAAAABAAAAAAAABBABABABBBABAAAAABABABABAAABAABABAAAAAAABAABAABAAAAAABABBBABBBBAAAABAAAAAAAABBABABAAAAABABB',
    'A'),
   [[[25, 18], [25, 15], [25, 15]], 'A', {'A': 0, 'B': 0}])],
 [('control first rally held by server', ('A', 'A'), [[[1, 0]], None, {'A': 0, 'B': 0}]),
  ('boundary side-out rotates receiver', ('B', 'A'), [[[0, 1]], None, {'A': 0, 'B': 1}]),
  ('control clean set', ('AAAAAAAAAAAAAAAAAAAAAAAAA', 'A'), [[[25, 0]], None, {'A': 0, 'B': 0}]),
  ('boundary second set served by other team',
   ('AAAAAAAAAAAAAAAAAAAAAAAAAA', 'A'),
   [[[25, 0], [1, 0]], None, {'A': 1, 'B': 0}]),
  ('boundary deuce in set',
   ('ABABABABABABABABABABABABABABABABABABABABABABABABAA', 'A'),
   [[[26, 24]], None, {'A': 0, 'B': 0}]),
  ('control straight-sets match',
   ('AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA', 'B'),
   [[[25, 0], [25, 0], [25, 0]], 'A', {'A': 1, 'B': 0}]),
  ('regression: win by two without cap',
   ('ABABABABABABABABABABABABABABABABABABABABABABABABABABA', 'A'),
   [[[27, 26]], None, {'A': 2, 'B': 2}]),
  ('variant scenario 1',
   ('BAAAAAABABBABABABBABBBABABAAAABABABBBABABBABAABABAAAAAABBBBAAAAAABAAABAABABAAABBBBBABBBBABBBAABABABAAAAABABBBABBAAAABAAAAAABBBAAABABAABABAAAABAAAABBABAAAAAAAAAABBABBAAABBAAABBAAABAAAAABABAAAAAABBABAABAABBABAAAA',
    'A'),
   [[[25, 23], [25, 21], [25, 15]], 'A', {'A': 4, 'B': 4}]),
  ('variant scenario 2',
   ('ABAAAAAAABAABAAABABAAABAAAAABBAAABAABBBBAAABAABAAAABAABBABABABAAAAAAAAAABAAAABAAABBBAABBAABAAAAAABAAAAAABAAAABABBBAAAABBAAABAAABAAAABBBABAAAABABBBAAB',
    'B'),
   [[[25, 8], [25, 13], [25, 10]], 'A', {'A': 2, 'B': 1}])]]
for label, args, expected in cases[N - 1]:
    check(label, run(args), 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
control first rally held by server[[[1, 0]], None, {'A': 0, 'B': 0}][[[1, 0]], None, {'A': 0, 'B': 0}]Passed
boundary side-out rotates receiver[[[0, 1]], None, {'A': 0, 'B': 1}][[[0, 1]], None, {'A': 0, 'B': 1}]Passed
control clean set[[[25, 0]], None, {'A': 0, 'B': 0}][[[25, 0]], None, {'A': 0, 'B': 0}]Passed
boundary second set served by other team[[[25, 0], [1, 0]], None, {'A': 1, 'B': 0}][[[25, 0], [1, 0]], None, {'A': 1, 'B': 0}]Passed
boundary deuce in set[[[26, 24]], None, {'A': 0, 'B': 0}][[[26, 24]], None, {'A': 0, 'B': 0}]Passed
control straight-sets match[[[25, 0], [25, 0], [25, 0]], 'A', {'A': 1, 'B': 0}][[[25, 0], [25, 0], [25, 0]], 'A', {'A': 1, 'B': 0}]Passed
regression: win by two without cap[[[27, 26], [21, 16]], None, {'A': 2, 'B': 2}][[[28, 26], [20, 16]], None, {'A': 2, 'B': 2}]Failed
variant scenario 1[[[25, 20], [22, 24]], None, {'A': 1, 'B': 1}][[[25, 20], [22, 24]], None, {'A': 1, 'B': 1}]Passed
variant scenario 2[[[25, 17], [16, 9]], None, {'A': 0, 'B': 5}][[[25, 17], [16, 9]], None, {'A': 0, 'B': 5}]Passed

SHA-256 / 42111831ed3afd122af8456abc3a80acbe3be41718d5fd61e98386e5e1091249

3 / The verified repair

Exit 0
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(rallies, first_serve):
    won = {'A': 0, 'B': 0}
    sets = []
    a = b = 0
    set_index = 0
    server = first_serve
    rot = {'A': 0, 'B': 0}
    for r in rallies:
        if r == 'A':
            a += 1
        else:
            b += 1
        if r != server:
            rot[r] = (rot[r] + 1) % 6
            server = r
        target = 15 if set_index == 4 else 25
        if max(a, b) >= target and abs(a - b) >= 2:
            w = 'A' if a > b else 'B'
            won[w] += 1
            sets.append([a, b])
            if won[w] == 3:
                return [sets, w, rot]
            a = b = 0
            set_index += 1
            rot = {'A': 0, 'B': 0}
            server = first_serve if set_index % 2 == 0 else ('B' if first_serve == 'A' else 'A')
    return [sets + ([[a, b]] if a or b else []), None, rot]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
def run(args):
    try:
        return solve(*args)
    except Exception as exc:
        return 'raised ' + type(exc).__name__
cases = [[('control first rally held by server', ('A', 'A'), [[[1, 0]], None, {'A': 0, 'B': 0}]),
  ('boundary side-out rotates receiver', ('B', 'A'), [[[0, 1]], None, {'A': 0, 'B': 1}]),
  ('control clean set', ('AAAAAAAAAAAAAAAAAAAAAAAAA', 'A'), [[[25, 0]], None, {'A': 0, 'B': 0}]),
  ('boundary second set served by other team',
   ('AAAAAAAAAAAAAAAAAAAAAAAAAA', 'A'),
   [[[25, 0], [1, 0]], None, {'A': 1, 'B': 0}]),
  ('boundary deuce in set',
   ('ABABABABABABABABABABABABABABABABABABABABABABABABAA', 'A'),
   [[[26, 24]], None, {'A': 0, 'B': 0}]),
  ('control straight-sets match',
   ('AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA', 'B'),
   [[[25, 0], [25, 0], [25, 0]], 'A', {'A': 1, 'B': 0}]),
  ('regression: win by two without cap',
   ('ABBBAABAAABAAABAABABBABAABBABBBBAAAABBBABBBAABABBAABAAAAAABBABBABAAAABBAAAABBBBAAABAABBBAB',
    'A'),
   [[[28, 26], [20, 16]], None, {'A': 2, 'B': 2}]),
  ('variant scenario 1',
   ('AABBBAABAABAAAAABAABBABBBBBBAABBBBAAAAAAABABABBBBBABBBBBABAAABABABAAABBABAABABBAAABAABABBAA',
    'B'),
   [[[25, 20], [22, 24]], None, {'A': 1, 'B': 1}]),
  ('variant scenario 2',
   ('AAAABBBBBBABABABABAAAABAABAABBBAAAAABAAABAABBAAABAAABBAAABBABBAAAAA', 'A'),
   [[[25, 17], [16, 9]], None, {'A': 0, 'B': 5}])],
 [('control first rally held by server', ('A', 'A'), [[[1, 0]], None, {'A': 0, 'B': 0}]),
  ('boundary side-out rotates receiver', ('B', 'A'), [[[0, 1]], None, {'A': 0, 'B': 1}]),
  ('control clean set', ('AAAAAAAAAAAAAAAAAAAAAAAAA', 'A'), [[[25, 0]], None, {'A': 0, 'B': 0}]),
  ('boundary second set served by other team',
   ('AAAAAAAAAAAAAAAAAAAAAAAAAA', 'A'),
   [[[25, 0], [1, 0]], None, {'A': 1, 'B': 0}]),
  ('boundary deuce in set',
   ('ABABABABABABABABABABABABABABABABABABABABABABABABAA', 'A'),
   [[[26, 24]], None, {'A': 0, 'B': 0}]),
  ('control straight-sets match',
   ('AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA', 'B'),
   [[[25, 0], [25, 0], [25, 0]], 'A', {'A': 1, 'B': 0}]),
  ('regression: win by two without cap',
   ('BAAABBBAAABABABBAABABAAAAABBBBABABBBAAABABBABBBAABAAAAAAAAAAAABBAABAAAA', 'A'),
   [[[27, 25], [16, 3]], None, {'A': 3, 'B': 2}]),
  ('regression: win by two without cap',
   ('BAAAAABAABBABABAABBAAAABAAAABAAAABBAABBABBABAAAAABBBBBBAABBAABAABBAAABBBAAABBBAAAABBAABABAAABABABBAAAAAABABABA',
    'B'),
   [[[25, 12], [28, 26], [12, 7]], None, {'A': 1, 'B': 0}]),
  ('variant scenario 1',
   ('ABAABBBAAAAABAABBAAAABBBAAAABABAABAAAAAAABBAABBAAAAAAABA', 'B'),
   [[[25, 13], [13, 5]], None, {'A': 3, 'B': 3}]),
  ('variant scenario 2',
   ('ABBAABBABBAAABAAAABBABABAAABABBAABBAAABBABAAABABAAABABABAAAAAABBBABBBABBABBAAAABBABAABAABBAAAAABBABBBABAABAAABBABBBBBBABBAABBAAAAABABAAABAAA',
    'A'),
   [[[25, 19], [25, 19], [25, 23]], 'A', {'A': 5, 'B': 5}])],
 [('control first rally held by server', ('A', 'A'), [[[1, 0]], None, {'A': 0, 'B': 0}]),
  ('boundary side-out rotates receiver', ('B', 'A'), [[[0, 1]], None, {'A': 0, 'B': 1}]),
  ('control clean set', ('AAAAAAAAAAAAAAAAAAAAAAAAA', 'A'), [[[25, 0]], None, {'A': 0, 'B': 0}]),
  ('boundary second set served by other team',
   ('AAAAAAAAAAAAAAAAAAAAAAAAAA', 'A'),
   [[[25, 0], [1, 0]], None, {'A': 1, 'B': 0}]),
  ('boundary deuce in set',
   ('ABABABABABABABABABABABABABABABABABABABABABABABABAA', 'A'),
   [[[26, 24]], None, {'A': 0, 'B': 0}]),
  ('control straight-sets match',
   ('AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA', 'B'),
   [[[25, 0], [25, 0], [25, 0]], 'A', {'A': 1, 'B': 0}]),
  ('regression: win by two without cap',
   ('ABABABABABABABABABABABABABABABABABABABABABABABABABABA', 'A'),
   [[[27, 26]], None, {'A': 2, 'B': 2}]),
  ('variant scenario 1',
   ('ABBAABAAAAAAAABBBBABBBBBBAAABBAAAAAAABAABBBBABAABBBAAAAAAAAAAABBABBBBABAAABABABAAAABABBBAAAAABAABABABAAAAAABABBAABBBBAAABABBBBBAAAAB',
    'A'),
   [[[25, 20], [25, 15], [25, 20]], 'A', {'A': 4, 'B': 4}]),
  ('variant scenario 2',
   ('AAAAABAAAAAAABAAAAAABABAABAAAAAAABAAABAAAAABBABABBAABAABABABABBBBABAABAAABAABAAAABABAAAAABBBBBBABAAAAAABABAAAABBAAAA',
    'A'),
   [[[25, 5], [25, 17], [25, 13]], 'A', {'A': 2, 'B': 2}])],
 [('control first rally held by server', ('A', 'A'), [[[1, 0]], None, {'A': 0, 'B': 0}]),
  ('boundary side-out rotates receiver', ('B', 'A'), [[[0, 1]], None, {'A': 0, 'B': 1}]),
  ('control clean set', ('AAAAAAAAAAAAAAAAAAAAAAAAA', 'A'), [[[25, 0]], None, {'A': 0, 'B': 0}]),
  ('boundary second set served by other team',
   ('AAAAAAAAAAAAAAAAAAAAAAAAAA', 'A'),
   [[[25, 0], [1, 0]], None, {'A': 1, 'B': 0}]),
  ('boundary deuce in set',
   ('ABABABABABABABABABABABABABABABABABABABABABABABABAA', 'A'),
   [[[26, 24]], None, {'A': 0, 'B': 0}]),
  ('control straight-sets match',
   ('AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA', 'B'),
   [[[25, 0], [25, 0], [25, 0]], 'A', {'A': 1, 'B': 0}]),
  ('regression: win by two without cap',
   ('ABAAAABBBBBBAAAAABABABABBABBAABAAAABBBAAAABAAAAABAAABAABBAAABAAAAABAAAAAABAABABBABBABAAAAABBBAAABBBAABABAAABBABBBABABABBAAABABBBABAABABA',
    'A'),
   [[[25, 19], [25, 7], [25, 27], [5, 3]], None, {'A': 4, 'B': 3}]),
  ('regression: win by two without cap',
   ('AAAAAABBAABBAAABABABAABAABAAAABBBBBBABBABABBAAAABBAABAAABAAABAAAABBBBAABABABABBAAAAAAABABABAAABBBBBBBAAAABBABBABABBBABAABAAABBAABABAABABAAAABAAAAAABABA',
    'A'),
   [[[25, 20], [25, 14], [28, 26]], 'A', {'A': 3, 'B': 3}]),
  ('variant scenario 1',
   ('ABBBAAABAABBAABAABAABABBABBAAABBBBAABAAABAABBAABBAAABBAABBAB', 'A'),
   [[[25, 21], [7, 7]], None, {'A': 4, 'B': 4}]),
  ('variant scenario 2',
   ('BAAAABBAAABBAAAAAAAAABABABABBBBAAABBABABBBAAABAAABAABABAABAABBBBBBABBBAAAABAAAAAAAABBABABABBBABAAAAABABABABAAABAABABAAAAAAABAABAABAAAAAABABBBABBBBAAAABAAAAAAAABBABABAAAAABABB',
    'A'),
   [[[25, 18], [25, 15], [25, 15]], 'A', {'A': 0, 'B': 0}])],
 [('control first rally held by server', ('A', 'A'), [[[1, 0]], None, {'A': 0, 'B': 0}]),
  ('boundary side-out rotates receiver', ('B', 'A'), [[[0, 1]], None, {'A': 0, 'B': 1}]),
  ('control clean set', ('AAAAAAAAAAAAAAAAAAAAAAAAA', 'A'), [[[25, 0]], None, {'A': 0, 'B': 0}]),
  ('boundary second set served by other team',
   ('AAAAAAAAAAAAAAAAAAAAAAAAAA', 'A'),
   [[[25, 0], [1, 0]], None, {'A': 1, 'B': 0}]),
  ('boundary deuce in set',
   ('ABABABABABABABABABABABABABABABABABABABABABABABABAA', 'A'),
   [[[26, 24]], None, {'A': 0, 'B': 0}]),
  ('control straight-sets match',
   ('AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA', 'B'),
   [[[25, 0], [25, 0], [25, 0]], 'A', {'A': 1, 'B': 0}]),
  ('regression: win by two without cap',
   ('ABABABABABABABABABABABABABABABABABABABABABABABABABABA', 'A'),
   [[[27, 26]], None, {'A': 2, 'B': 2}]),
  ('variant scenario 1',
   ('BAAAAAABABBABABABBABBBABABAAAABABABBBABABBABAABABAAAAAABBBBAAAAAABAAABAABABAAABBBBBABBBBABBBAABABABAAAAABABBBABBAAAABAAAAAABBBAAABABAABABAAAABAAAABBABAAAAAAAAAABBABBAAABBAAABBAAABAAAAABABAAAAAABBABAABAABBABAAAA',
    'A'),
   [[[25, 23], [25, 21], [25, 15]], 'A', {'A': 4, 'B': 4}]),
  ('variant scenario 2',
   ('ABAAAAAAABAABAAABABAAABAAAAABBAAABAABBBBAAABAABAAAABAABBABABABAAAAAAAAAABAAAABAAABBBAABBAABAAAAAABAAAAAABAAAABABBBAAAABBAAABAAABAAAABBBABAAAABABBBAAB',
    'B'),
   [[[25, 8], [25, 13], [25, 10]], 'A', {'A': 2, 'B': 1}])]]
for label, args, expected in cases[N - 1]:
    check(label, run(args), 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
control first rally held by server[[[1, 0]], None, {'A': 0, 'B': 0}][[[1, 0]], None, {'A': 0, 'B': 0}]Passed
boundary side-out rotates receiver[[[0, 1]], None, {'A': 0, 'B': 1}][[[0, 1]], None, {'A': 0, 'B': 1}]Passed
control clean set[[[25, 0]], None, {'A': 0, 'B': 0}][[[25, 0]], None, {'A': 0, 'B': 0}]Passed
boundary second set served by other team[[[25, 0], [1, 0]], None, {'A': 1, 'B': 0}][[[25, 0], [1, 0]], None, {'A': 1, 'B': 0}]Passed
boundary deuce in set[[[26, 24]], None, {'A': 0, 'B': 0}][[[26, 24]], None, {'A': 0, 'B': 0}]Passed
control straight-sets match[[[25, 0], [25, 0], [25, 0]], 'A', {'A': 1, 'B': 0}][[[25, 0], [25, 0], [25, 0]], 'A', {'A': 1, 'B': 0}]Passed
regression: win by two without cap[[[28, 26], [20, 16]], None, {'A': 2, 'B': 2}][[[28, 26], [20, 16]], None, {'A': 2, 'B': 2}]Passed
variant scenario 1[[[25, 20], [22, 24]], None, {'A': 1, 'B': 1}][[[25, 20], [22, 24]], None, {'A': 1, 'B': 1}]Passed
variant scenario 2[[[25, 17], [16, 9]], None, {'A': 0, 'B': 5}][[[25, 17], [16, 9]], None, {'A': 0, 'B': 5}]Passed

SHA-256 / e3ea8a34b15748373dab0dcb7075d48cc177212a061c55155c6f58cbe5020f64

Verification & scope

Stipulated, bounded toy contract stated in the contract field; not a claim of conformance with any governing body rulebook or operator house rules. 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:26.031226+00:00.

Case digest / c4c86f48f0ca48e5b6fa5399a6c72986ef221312c804d00b3e95dafd85f0b6d3