FAILURE MAP
← Case archive

FA-83911 / Sports scoring and tiebreakers / Open access

Rotation advanced on every point instead of on side-outs · case 01

A serving team that keeps winning rallies is shown rotating through positions.

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

ROOT CAUSE

The rotation counter is advanced for every rally winner regardless of who served.

VERIFIED REPAIR

Rotate only the team that wins a rally it did not serve.

Unsuccessful approach: Rotating the losing server instead of the side-out winner moves the wrong team.

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
        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: side out rotation',
   ('ABBABABAAAABAABABAAAAAABABBBAABBAAAAABBABABABBAAABABAABBABAABBAABABBAAABBBABBBAABABA', 'B'),
   [[[25, 15], [22, 22]], None, {'A': 2, 'B': 2}]),
  ('regression: side out rotation',
   ('AAABBBABAAAAABBAABBBAAAAABAABBAABBAA', 'B'),
   [[[22, 14]], None, {'A': 2, 'B': 1}]),
  ('variant scenario 1',
   ('BBABBBABBBBBBABAABAABAABBBAAABAAAAABBABAAABABAAABABAA', 'B'),
   [[[25, 23], [3, 2]], None, {'A': 2, 'B': 2}]),
  ('variant scenario 2',
   ('BABBBBABBAABBABBBAABBAAABBABAAABAAABAAAABABBBBBABAAABABAAAAABAAAABBAAABABAAABBBBBAABABBAABBBBBBAA',
    'A'),
   [[[22, 25], [25, 16], [3, 6]], None, {'A': 1, 'B': 1}])],
 [('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: side out rotation',
   ('BABBAABAAAABAABABBAAAA', 'A'),
   [[[14, 8]], None, {'A': 0, 'B': 0}]),
  ('regression: side out rotation',
   ('BAABABAABBAAAABABBBBAA', 'B'),
   [[[12, 10]], None, {'A': 0, 'B': 5}]),
  ('variant scenario 1',
   ('ABABBBAABABAABABBABBBAABAAABAAABABBBBBBBBAAABABABAAABAABAAAABBAAAAABBAABAAAAAABBBAA', 'B'),
   [[[22, 25], [25, 11]], None, {'A': 0, 'B': 0}]),
  ('variant scenario 2',
   ('ABAABABAAABAABAAABBABBBAABAAABABBAAAAABBAABABABBBAAABABABBAAAABBAAAABAABBAABAABAABABABBABAAAABAA',
    'A'),
   [[[25, 16], [25, 17], [8, 5]], None, {'A': 4, 'B': 4}])],
 [('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: side out rotation',
   ('BAAAABABABAABAABAAAAABAABBBAABBAAAAABBAAABAAAABAABAABABBABAAAABAABABAAABABBBAAABBBBBABBBAABAAABBAAAAABBBAAAAAAAAAABABBAAAAA',
    'A'),
   [[[25, 14], [25, 14], [25, 17]], 'A', {'A': 1, 'B': 1}]),
  ('regression: side out rotation',
   ('BBAAAAAABABAAABAABAAABABBBBBBAB', 'A'),
   [[[17, 14]], None, {'A': 1, 'B': 2}]),
  ('variant scenario 1',
   ('BBBAAAABBAABBABBABBBAABAAABABAAAAAAABBBABAAABAAAABABAABAAAAAAABBABBBBABABAAAAABBAABABAAAABBBAABAABABBAABAABAAAABAAAAAAAABBAAAAAAAAABABAAAABBABABAAAABBA',
    'A'),
   [[[25, 19], [25, 15], [25, 11]], 'A', {'A': 2, 'B': 2}]),
  ('variant scenario 2',
   ('AAABBABBBAAABABAAAABAAAAAABBBAAABABBABAAAABBBBAABABAABAABAABBAAAABBABBABBBABAABBAABABAAAAAAAAABBABABAA',
    'A'),
   [[[25, 15], [25, 22], [11, 4]], None, {'A': 3, 'B': 3}])],
 [('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: side out rotation',
   ('AAAAAAAABAAABAAABAABAAAAAABABBABAABABBBBAAAAAAAAABABBBABBBBBABAABBBBBBBBBAAABAABAABAAAAAAAAABBAABAAAABABBBAAABABABAAAAAAABABABAAAABAAAAAABAAB',
    'B'),
   [[[25, 8], [19, 25], [25, 11], [21, 7]], None, {'A': 0, 'B': 1}]),
  ('variant scenario 1',
   ('AAABBABAABAABABBAAAAAAABBBAABAAAAB', 'B'),
   [[[22, 12]], None, {'A': 2, 'B': 2}]),
  ('variant scenario 2',
   ('BABABABAAABAAAAABAAABAAAAABABBBAABBBAAB', 'B'),
   [[[24, 15]], None, {'A': 4, 'B': 4}])],
 [('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: side out rotation',
   ('AAAABAABABAAABAABAAABAABAAABAAABAAAABAAAABAAABAABAAAAAAAABABAAABBAAAAAAAABABAAAABABAABBAA',
    'B'),
   [[[25, 9], [25, 8], [16, 6]], None, {'A': 0, 'B': 5}]),
  ('variant scenario 1',
   ('ABBBABAAAAABABAAAABBABAAABABBAAAAABBBAABBAABAAAABBBABBAABABABAAAAABABABBABBABAABAAABAABAAABAAABABAAAAAAABAAAAABAAAABABABABAAABABAAAAAABABAA',
    'A'),
   [[[25, 17], [25, 18], [25, 7]], 'A', {'A': 1, 'B': 1}]),
  ('variant scenario 2',
   ('AABAAAAABBABABAABAAAABAAABABAAAAABBBBAAABAABBAAABBAAABABAABBABAAAAAAAABAAAAABBBAAABBAAAAAABAAAAAABABAABBAAABBAAAAAAAABAABBBAABABBAABABBAAABBABABAABBAABAAABAAABAABAABBAAABBAABAAABAAAAABBAAAAAABAABAAAAABAABBBAAAAABAABAABA',
    'B'),
   [[[25, 13], [25, 11], [25, 12]], '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': 1, 'B': 0}][[[1, 0]], None, {'A': 0, 'B': 0}]Failed
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: side out rotation[[[25, 15], [22, 22]], None, {'A': 4, 'B': 4}][[[25, 15], [22, 22]], None, {'A': 2, 'B': 2}]Failed
regression: side out rotation[[[22, 14]], None, {'A': 4, 'B': 2}][[[22, 14]], None, {'A': 2, 'B': 1}]Failed
variant scenario 1[[[25, 23], [3, 2]], None, {'A': 3, 'B': 2}][[[25, 23], [3, 2]], None, {'A': 2, 'B': 2}]Failed
variant scenario 2[[[22, 25], [25, 16], [3, 6]], None, {'A': 3, 'B': 0}][[[22, 25], [25, 16], [3, 6]], None, {'A': 1, 'B': 1}]Failed

SHA-256 / be3991104566b06016e35fdbdc8c1688540b901f6d0bc6d5a348e8efa4b82138

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[server] = (rot[server] + 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: side out rotation',
   ('ABBABABAAAABAABABAAAAAABABBBAABBAAAAABBABABABBAAABABAABBABAABBAABABBAAABBBABBBAABABA', 'B'),
   [[[25, 15], [22, 22]], None, {'A': 2, 'B': 2}]),
  ('regression: side out rotation',
   ('AAABBBABAAAAABBAABBBAAAAABAABBAABBAA', 'B'),
   [[[22, 14]], None, {'A': 2, 'B': 1}]),
  ('variant scenario 1',
   ('BBABBBABBBBBBABAABAABAABBBAAABAAAAABBABAAABABAAABABAA', 'B'),
   [[[25, 23], [3, 2]], None, {'A': 2, 'B': 2}]),
  ('variant scenario 2',
   ('BABBBBABBAABBABBBAABBAAABBABAAABAAABAAAABABBBBBABAAABABAAAAABAAAABBAAABABAAABBBBBAABABBAABBBBBBAA',
    'A'),
   [[[22, 25], [25, 16], [3, 6]], None, {'A': 1, 'B': 1}])],
 [('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: side out rotation',
   ('BABBAABAAAABAABABBAAAA', 'A'),
   [[[14, 8]], None, {'A': 0, 'B': 0}]),
  ('regression: side out rotation',
   ('BAABABAABBAAAABABBBBAA', 'B'),
   [[[12, 10]], None, {'A': 0, 'B': 5}]),
  ('variant scenario 1',
   ('ABABBBAABABAABABBABBBAABAAABAAABABBBBBBBBAAABABABAAABAABAAAABBAAAAABBAABAAAAAABBBAA', 'B'),
   [[[22, 25], [25, 11]], None, {'A': 0, 'B': 0}]),
  ('variant scenario 2',
   ('ABAABABAAABAABAAABBABBBAABAAABABBAAAAABBAABABABBBAAABABABBAAAABBAAAABAABBAABAABAABABABBABAAAABAA',
    'A'),
   [[[25, 16], [25, 17], [8, 5]], None, {'A': 4, 'B': 4}])],
 [('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: side out rotation',
   ('BAAAABABABAABAABAAAAABAABBBAABBAAAAABBAAABAAAABAABAABABBABAAAABAABABAAABABBBAAABBBBBABBBAABAAABBAAAAABBBAAAAAAAAAABABBAAAAA',
    'A'),
   [[[25, 14], [25, 14], [25, 17]], 'A', {'A': 1, 'B': 1}]),
  ('regression: side out rotation',
   ('BBAAAAAABABAAABAABAAABABBBBBBAB', 'A'),
   [[[17, 14]], None, {'A': 1, 'B': 2}]),
  ('variant scenario 1',
   ('BBBAAAABBAABBABBABBBAABAAABABAAAAAAABBBABAAABAAAABABAABAAAAAAABBABBBBABABAAAAABBAABABAAAABBBAABAABABBAABAABAAAABAAAAAAAABBAAAAAAAAABABAAAABBABABAAAABBA',
    'A'),
   [[[25, 19], [25, 15], [25, 11]], 'A', {'A': 2, 'B': 2}]),
  ('variant scenario 2',
   ('AAABBABBBAAABABAAAABAAAAAABBBAAABABBABAAAABBBBAABABAABAABAABBAAAABBABBABBBABAABBAABABAAAAAAAAABBABABAA',
    'A'),
   [[[25, 15], [25, 22], [11, 4]], None, {'A': 3, 'B': 3}])],
 [('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: side out rotation',
   ('AAAAAAAABAAABAAABAABAAAAAABABBABAABABBBBAAAAAAAAABABBBABBBBBABAABBBBBBBBBAAABAABAABAAAAAAAAABBAABAAAABABBBAAABABABAAAAAAABABABAAAABAAAAAABAAB',
    'B'),
   [[[25, 8], [19, 25], [25, 11], [21, 7]], None, {'A': 0, 'B': 1}]),
  ('variant scenario 1',
   ('AAABBABAABAABABBAAAAAAABBBAABAAAAB', 'B'),
   [[[22, 12]], None, {'A': 2, 'B': 2}]),
  ('variant scenario 2',
   ('BABABABAAABAAAAABAAABAAAAABABBBAABBBAAB', 'B'),
   [[[24, 15]], None, {'A': 4, 'B': 4}])],
 [('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: side out rotation',
   ('AAAABAABABAAABAABAAABAABAAABAAABAAAABAAAABAAABAABAAAAAAAABABAAABBAAAAAAAABABAAAABABAABBAA',
    'B'),
   [[[25, 9], [25, 8], [16, 6]], None, {'A': 0, 'B': 5}]),
  ('variant scenario 1',
   ('ABBBABAAAAABABAAAABBABAAABABBAAAAABBBAABBAABAAAABBBABBAABABABAAAAABABABBABBABAABAAABAABAAABAAABABAAAAAAABAAAAABAAAABABABABAAABABAAAAAABABAA',
    'A'),
   [[[25, 17], [25, 18], [25, 7]], 'A', {'A': 1, 'B': 1}]),
  ('variant scenario 2',
   ('AABAAAAABBABABAABAAAABAAABABAAAAABBBBAAABAABBAAABBAAABABAABBABAAAAAAAABAAAAABBBAAABBAAAAAABAAAAAABABAABBAAABBAAAAAAAABAABBBAABABBAABABBAAABBABABAABBAABAAABAAABAABAABBAAABBAABAAABAAAAABBAAAAAABAABAAAAABAABBBAAAAABAABAABA',
    'B'),
   [[[25, 13], [25, 11], [25, 12]], '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': 1, 'B': 0}][[[0, 1]], None, {'A': 0, 'B': 1}]Failed
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': 0, 'B': 1}][[[25, 0], [1, 0]], None, {'A': 1, 'B': 0}]Failed
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': 0, 'B': 1}][[[25, 0], [25, 0], [25, 0]], 'A', {'A': 1, 'B': 0}]Failed
regression: side out rotation[[[25, 15], [22, 22]], None, {'A': 2, 'B': 2}][[[25, 15], [22, 22]], None, {'A': 2, 'B': 2}]Passed
regression: side out rotation[[[22, 14]], None, {'A': 1, 'B': 2}][[[22, 14]], None, {'A': 2, 'B': 1}]Failed
variant scenario 1[[[25, 23], [3, 2]], None, {'A': 2, 'B': 2}][[[25, 23], [3, 2]], None, {'A': 2, 'B': 2}]Passed
variant scenario 2[[[22, 25], [25, 16], [3, 6]], None, {'A': 1, 'B': 1}][[[22, 25], [25, 16], [3, 6]], None, {'A': 1, 'B': 1}]Passed

SHA-256 / 0af140a39f99cc469ca51df973de64db331af6fe669f1d56861c42a508f8ce8d

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: side out rotation',
   ('ABBABABAAAABAABABAAAAAABABBBAABBAAAAABBABABABBAAABABAABBABAABBAABABBAAABBBABBBAABABA', 'B'),
   [[[25, 15], [22, 22]], None, {'A': 2, 'B': 2}]),
  ('regression: side out rotation',
   ('AAABBBABAAAAABBAABBBAAAAABAABBAABBAA', 'B'),
   [[[22, 14]], None, {'A': 2, 'B': 1}]),
  ('variant scenario 1',
   ('BBABBBABBBBBBABAABAABAABBBAAABAAAAABBABAAABABAAABABAA', 'B'),
   [[[25, 23], [3, 2]], None, {'A': 2, 'B': 2}]),
  ('variant scenario 2',
   ('BABBBBABBAABBABBBAABBAAABBABAAABAAABAAAABABBBBBABAAABABAAAAABAAAABBAAABABAAABBBBBAABABBAABBBBBBAA',
    'A'),
   [[[22, 25], [25, 16], [3, 6]], None, {'A': 1, 'B': 1}])],
 [('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: side out rotation',
   ('BABBAABAAAABAABABBAAAA', 'A'),
   [[[14, 8]], None, {'A': 0, 'B': 0}]),
  ('regression: side out rotation',
   ('BAABABAABBAAAABABBBBAA', 'B'),
   [[[12, 10]], None, {'A': 0, 'B': 5}]),
  ('variant scenario 1',
   ('ABABBBAABABAABABBABBBAABAAABAAABABBBBBBBBAAABABABAAABAABAAAABBAAAAABBAABAAAAAABBBAA', 'B'),
   [[[22, 25], [25, 11]], None, {'A': 0, 'B': 0}]),
  ('variant scenario 2',
   ('ABAABABAAABAABAAABBABBBAABAAABABBAAAAABBAABABABBBAAABABABBAAAABBAAAABAABBAABAABAABABABBABAAAABAA',
    'A'),
   [[[25, 16], [25, 17], [8, 5]], None, {'A': 4, 'B': 4}])],
 [('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: side out rotation',
   ('BAAAABABABAABAABAAAAABAABBBAABBAAAAABBAAABAAAABAABAABABBABAAAABAABABAAABABBBAAABBBBBABBBAABAAABBAAAAABBBAAAAAAAAAABABBAAAAA',
    'A'),
   [[[25, 14], [25, 14], [25, 17]], 'A', {'A': 1, 'B': 1}]),
  ('regression: side out rotation',
   ('BBAAAAAABABAAABAABAAABABBBBBBAB', 'A'),
   [[[17, 14]], None, {'A': 1, 'B': 2}]),
  ('variant scenario 1',
   ('BBBAAAABBAABBABBABBBAABAAABABAAAAAAABBBABAAABAAAABABAABAAAAAAABBABBBBABABAAAAABBAABABAAAABBBAABAABABBAABAABAAAABAAAAAAAABBAAAAAAAAABABAAAABBABABAAAABBA',
    'A'),
   [[[25, 19], [25, 15], [25, 11]], 'A', {'A': 2, 'B': 2}]),
  ('variant scenario 2',
   ('AAABBABBBAAABABAAAABAAAAAABBBAAABABBABAAAABBBBAABABAABAABAABBAAAABBABBABBBABAABBAABABAAAAAAAAABBABABAA',
    'A'),
   [[[25, 15], [25, 22], [11, 4]], None, {'A': 3, 'B': 3}])],
 [('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: side out rotation',
   ('AAAAAAAABAAABAAABAABAAAAAABABBABAABABBBBAAAAAAAAABABBBABBBBBABAABBBBBBBBBAAABAABAABAAAAAAAAABBAABAAAABABBBAAABABABAAAAAAABABABAAAABAAAAAABAAB',
    'B'),
   [[[25, 8], [19, 25], [25, 11], [21, 7]], None, {'A': 0, 'B': 1}]),
  ('variant scenario 1',
   ('AAABBABAABAABABBAAAAAAABBBAABAAAAB', 'B'),
   [[[22, 12]], None, {'A': 2, 'B': 2}]),
  ('variant scenario 2',
   ('BABABABAAABAAAAABAAABAAAAABABBBAABBBAAB', 'B'),
   [[[24, 15]], None, {'A': 4, 'B': 4}])],
 [('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: side out rotation',
   ('AAAABAABABAAABAABAAABAABAAABAAABAAAABAAAABAAABAABAAAAAAAABABAAABBAAAAAAAABABAAAABABAABBAA',
    'B'),
   [[[25, 9], [25, 8], [16, 6]], None, {'A': 0, 'B': 5}]),
  ('variant scenario 1',
   ('ABBBABAAAAABABAAAABBABAAABABBAAAAABBBAABBAABAAAABBBABBAABABABAAAAABABABBABBABAABAAABAABAAABAAABABAAAAAAABAAAAABAAAABABABABAAABABAAAAAABABAA',
    'A'),
   [[[25, 17], [25, 18], [25, 7]], 'A', {'A': 1, 'B': 1}]),
  ('variant scenario 2',
   ('AABAAAAABBABABAABAAAABAAABABAAAAABBBBAAABAABBAAABBAAABABAABBABAAAAAAAABAAAAABBBAAABBAAAAAABAAAAAABABAABBAAABBAAAAAAAABAABBBAABABBAABABBAAABBABABAABBAABAAABAAABAABAABBAAABBAABAAABAAAAABBAAAAAABAABAAAAABAABBBAAAAABAABAABA',
    'B'),
   [[[25, 13], [25, 11], [25, 12]], '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: side out rotation[[[25, 15], [22, 22]], None, {'A': 2, 'B': 2}][[[25, 15], [22, 22]], None, {'A': 2, 'B': 2}]Passed
regression: side out rotation[[[22, 14]], None, {'A': 2, 'B': 1}][[[22, 14]], None, {'A': 2, 'B': 1}]Passed
variant scenario 1[[[25, 23], [3, 2]], None, {'A': 2, 'B': 2}][[[25, 23], [3, 2]], None, {'A': 2, 'B': 2}]Passed
variant scenario 2[[[22, 25], [25, 16], [3, 6]], None, {'A': 1, 'B': 1}][[[22, 25], [25, 16], [3, 6]], None, {'A': 1, 'B': 1}]Passed

SHA-256 / dc8c1c3db99dad30b8872c31f338477882d56ddadb6e2cb0070b6a7a9603edf6

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

Case digest / 3738f903efaf8747e7d306a39dc9b2790abca372069fc39bedda9120c63e3c97