FAILURE MAP
← Case archive

FA-94326 / Shift rostering labor rules / Open access

Offer reaching exactly twelve hours treated as ineligible · case 01

Workers who would finish at exactly 12 hours are skipped.

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

ROOT CAUSE

The daily maximum comparison is inclusive.

VERIFIED REPAIR

Skip only offers that would push the day above 720 minutes.

Unsuccessful approach: Testing current minutes without the offer lets offers exceed 12 hours.

Case contract

ledger: worker -> [overtime minutes charged, seniority rank (1 most senior), minutes already worked today]; offers: [minutes, workers who will refuse]. For each offer, candidates are ordered by charged overtime then seniority rank. Workers who would exceed 720 minutes today are skipped without charge; refusers are charged the offered minutes; the first remaining worker takes it and is charged and credited today. Return [taker per offer (or None), charged minutes by worker].

Why this case matters

Overtime equalization clauses require fair rotation of offers, including charging refusals.

1 / The failure

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

N = 1
observations = []
def solve(ledger, offers):
    led = {w: list(v) for w, v in ledger.items()}
    result = []
    for minutes, refusers in offers:
        cands = sorted(led, key=lambda w: (led[w][0], led[w][1]))
        taker = None
        for w in cands:
            if led[w][2] + minutes >= 720:
                continue
            if w in refusers:
                led[w][0] += minutes
                continue
            taker = w
            break
        if taker is not None:
            led[taker][0] += minutes
            led[taker][2] += minutes
        result.append(taker)
    return [result, {w: led[w][0] for w in sorted(led)}]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
fixtures = [[('regression: daily maximum boundary 1',
   [{'p': [120, 1, 240], 'r': [0, 2, 480], 'q': [60, 3, 240], 's': [60, 4, 480]},
    [[60, []], [240, ['q', 'r']]]],
   [['r', 's'], {'p': 120, 'q': 300, 'r': 60, 's': 300}]),
  ('regression variant: daily maximum boundary 2',
   [{'r': [0, 1, 480], 'q': [240, 2, 660], 'p': [120, 3, 660]},
    [[60, ['q', 'r']], [120, ['r', 'p']], [240, []]]],
   [['p', None, 'r'], {'p': 180, 'q': 240, 'r': 420}]),
  ('partial repair guard 3', [{'q': [120, 1, 0], 'p': [120, 2, 660]}, [[240, ['q']], [240, []], [120, []]]],
   [[None, 'q', 'q'], {'p': 120, 'q': 720}]),
  ('normal control 4',
   [{'p': [240, 1, 0], 'q': [60, 2, 660]}, [[60, ['q', 'p']], [120, ['p', 'q']], [120, ['p']]]],
   [[None, None, None], {'p': 540, 'q': 120}]),
  ('normal control 5', [{'r': [0, 1, 480], 'p': [120, 2, 240], 'q': [120, 3, 660]}, [[120, ['r']]]],
   [['p'], {'p': 240, 'q': 120, 'r': 120}]),
  ('normal control 6', [{'p': [120, 1, 480], 'q': [240, 2, 0]}, [[120, ['p', 'q']], [240, []]]],
   [[None, 'p'], {'p': 480, 'q': 360}]),
  ('normal control 7',
   [{'r': [60, 1, 480], 'q': [120, 2, 660], 's': [0, 3, 660], 'p': [60, 4, 0]}, [[240, []]]],
   [['r'], {'p': 60, 'q': 120, 'r': 300, 's': 0}]),
  ('normal control 8',
   [{'s': [60, 1, 0], 'p': [240, 2, 600], 'r': [120, 3, 600], 'q': [120, 4, 0]},
    [[240, ['p']], [120, ['s', 'r']], [240, []]]],
   [['s', 'q', 'q'], {'p': 240, 'q': 480, 'r': 240, 's': 300}])],
 [('regression: daily maximum boundary 1',
   [{'p': [0, 1, 0], 'q': [120, 2, 600]}, [[60, ['q', 'p']], [120, []], [120, ['q']], [120, []]]],
   [[None, 'p', 'p', 'q'], {'p': 300, 'q': 300}]),
  ('regression variant: daily maximum boundary 2',
   [{'q': [240, 1, 240], 'p': [120, 2, 660], 'r': [60, 3, 660], 's': [0, 4, 480]}, [[240, ['q']]]],
   [['s'], {'p': 120, 'q': 240, 'r': 60, 's': 240}]),
  ('partial repair guard 3',
   [{'p': [240, 1, 660], 'r': [60, 2, 240], 's': [120, 3, 0], 'q': [0, 4, 600]},
    [[240, []], [60, ['q', 'p']]]],
   [['r', 's'], {'p': 240, 'q': 60, 'r': 300, 's': 180}]),
  ('normal control 4', [{'q': [120, 1, 660], 'p': [240, 2, 600]}, [[120, []], [240, []], [240, []]]],
   [['p', None, None], {'p': 360, 'q': 120}]),
  ('normal control 5', [{'p': [240, 1, 0], 'r': [240, 2, 600], 'q': [120, 3, 600]}, [[120, []], [60, ['p']]]],
   [['q', 'r'], {'p': 300, 'q': 240, 'r': 300}]),
  ('normal control 6',
   [{'p': [60, 1, 600], 'q': [120, 2, 660]}, [[60, []], [60, ['q']], [240, []], [240, ['p']]]],
   [['p', 'p', None, None], {'p': 180, 'q': 120}]),
  ('normal control 7',
   [{'q': [120, 1, 0], 'p': [0, 2, 0]}, [[120, ['p']], [120, ['q']], [240, ['p']], [120, []]]],
   [['q', 'p', 'q', 'p'], {'p': 360, 'q': 480}]),
  ('normal control 8',
   [{'r': [60, 1, 480], 'q': [60, 2, 660], 'p': [240, 3, 600]}, [[240, ['r']], [120, []]]],
   [[None, 'p'], {'p': 360, 'q': 60, 'r': 300}])],
 [('regression: daily maximum boundary 1',
   [{'q': [240, 1, 480], 's': [120, 2, 480], 'r': [0, 3, 660], 'p': [120, 4, 480]}, [[240, ['r', 'q']]]],
   [['s'], {'p': 120, 'q': 240, 'r': 0, 's': 360}]),
  ('regression variant: daily maximum boundary 2',
   [{'s': [60, 1, 660], 'p': [0, 2, 660], 'r': [240, 3, 480], 'q': [120, 4, 0]},
    [[60, ['s', 'p']], [120, ['p']], [240, ['r']], [120, ['r']]]],
   [['q', 'q', 'q', 'q'], {'p': 60, 'q': 660, 'r': 600, 's': 120}]),
  ('normal control 3',
   [{'q': [0, 1, 0], 'r': [120, 2, 660], 'p': [120, 3, 240]}, [[120, ['r']], [240, ['r']]]],
   [['q', 'q'], {'p': 120, 'q': 360, 'r': 120}]),
  ('normal control 4',
   [{'s': [60, 1, 0], 'p': [240, 2, 600], 'r': [120, 3, 600], 'q': [120, 4, 0]},
    [[240, ['p']], [120, ['s', 'r']], [240, []]]],
   [['s', 'q', 'q'], {'p': 240, 'q': 480, 'r': 240, 's': 300}]),
  ('normal control 5', [{'q': [120, 1, 240], 'r': [240, 2, 0], 'p': [0, 3, 0]}, [[60, []]]],
   [['p'], {'p': 60, 'q': 120, 'r': 240}]),
  ('normal control 6', [{'q': [0, 1, 660], 'p': [240, 2, 480]}, [[240, []]]], [['p'], {'p': 480, 'q': 0}]),
  ('normal control 7',
   [{'q': [60, 1, 660], 'p': [60, 2, 0]}, [[60, []], [240, []], [120, ['p']], [240, ['q', 'p']]]],
   [['q', 'p', None, None], {'p': 660, 'q': 120}]),
  ('normal control 8',
   [{'p': [240, 1, 600], 'r': [60, 2, 480], 'q': [120, 3, 0], 's': [0, 4, 240]},
    [[240, ['r', 's']], [60, ['s']], [60, []]]],
   [['q', 'p', 's'], {'p': 300, 'q': 360, 'r': 300, 's': 300}])],
 [('regression: daily maximum boundary 1',
   [{'r': [240, 1, 0], 'p': [60, 2, 0], 'q': [120, 3, 0], 's': [120, 4, 600]}, [[120, ['p', 'q']]]],
   [['s'], {'p': 180, 'q': 240, 'r': 240, 's': 240}]),
  ('regression variant: daily maximum boundary 2', [{'p': [0, 1, 0], 'q': [240, 2, 660]}, [[60, ['q', 'p']]]],
   [[None], {'p': 60, 'q': 300}]),
  ('partial repair guard 3',
   [{'r': [120, 1, 480], 'p': [120, 2, 660], 'q': [60, 3, 480]},
    [[240, ['p', 'q']], [120, ['r', 'q']], [120, ['p', 'r']], [120, ['r', 'p']]]],
   [['r', None, 'q', 'q'], {'p': 120, 'q': 660, 'r': 360}]),
  ('normal control 4',
   [{'p': [120, 1, 0], 'r': [120, 2, 240], 's': [60, 3, 660], 'q': [120, 4, 0]},
    [[120, ['p', 's']], [60, []], [60, ['r']]]],
   [['r', 's', 'q'], {'p': 240, 'q': 180, 'r': 240, 's': 120}]),
  ('normal control 5',
   [{'p': [240, 1, 600], 'q': [120, 2, 480], 'r': [240, 3, 0]},
    [[60, ['r', 'q']], [60, ['q', 'r']], [60, ['r']]]],
   [['p', 'p', 'q'], {'p': 360, 'q': 300, 'r': 300}]),
  ('normal control 6', [{'q': [120, 1, 600], 'p': [240, 2, 600]}, [[120, ['q', 'p']]]],
   [[None], {'p': 360, 'q': 240}]),
  ('normal control 7',
   [{'q': [60, 1, 660], 'p': [120, 2, 480], 'r': [0, 3, 240]},
    [[60, []], [120, ['p', 'q']], [60, ['q']], [60, ['r']]]],
   [['r', 'r', 'p', 'q'], {'p': 180, 'q': 180, 'r': 180}]),
  ('normal control 8', [{'p': [120, 1, 660], 'r': [120, 2, 600], 'q': [120, 3, 240]}, [[120, ['p', 'q']]]],
   [['r'], {'p': 120, 'q': 120, 'r': 240}])],
 [('regression: daily maximum boundary 1',
   [{'q': [120, 1, 600], 'p': [240, 2, 660]}, [[120, ['q']], [60, []], [120, []], [240, []]]],
   [[None, 'q', None, None], {'p': 240, 'q': 300}]),
  ('regression variant: daily maximum boundary 2',
   [{'q': [120, 1, 600], 'p': [0, 2, 600]}, [[120, []], [240, ['p', 'q']], [60, ['q', 'p']], [120, ['q']]]],
   [['p', None, None, None], {'p': 120, 'q': 300}]),
  ('partial repair guard 3', [{'q': [120, 1, 600], 'p': [60, 2, 660]}, [[240, ['q', 'p']]]],
   [[None], {'p': 60, 'q': 120}]),
  ('normal control 4',
   [{'r': [120, 1, 240], 'p': [240, 2, 600], 'q': [120, 3, 480]},
    [[120, ['p', 'q']], [60, ['r']], [240, ['q']], [120, ['p']]]],
   [['r', 'q', 'r', 'q'], {'p': 240, 'q': 300, 'r': 480}]),
  ('normal control 5', [{'p': [60, 1, 0], 'r': [240, 2, 600], 'q': [0, 3, 480]}, [[240, ['r']]]],
   [['q'], {'p': 60, 'q': 240, 'r': 240}]),
  ('normal control 6',
   [{'r': [120, 1, 0], 'p': [120, 2, 240], 'q': [120, 3, 600]}, [[240, []], [60, ['q', 'p']]]],
   [['r', 'r'], {'p': 180, 'q': 180, 'r': 420}]),
  ('normal control 7',
   [{'p': [120, 1, 480], 'q': [60, 2, 660], 's': [120, 3, 600], 'r': [120, 4, 0]},
    [[240, ['r']], [120, ['r', 's']]]],
   [['p', None], {'p': 360, 'q': 60, 'r': 240, 's': 240}]),
  ('normal control 8',
   [{'q': [120, 1, 480], 'p': [120, 2, 600], 'r': [240, 3, 600], 's': [240, 4, 480]},
    [[120, ['r']], [120, ['s']], [60, ['q']], [240, ['q']]]],
   [['q', 'p', 'r', 's'], {'p': 240, 'q': 300, 'r': 300, 's': 480}])]]
for label, args, expected in fixtures[N-1]:
    check(label, solve(*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
regression: daily maximum boundary 1[['r', 'p'], {'p': 360, 'q': 300, 'r': 60, 's': 60}][['r', 's'], {'p': 120, 'q': 300, 'r': 60, 's': 300}]Failed
regression variant: daily maximum boundary 2[[None, None, None], {'p': 120, 'q': 240, 'r': 180}][['p', None, 'r'], {'p': 180, 'q': 240, 'r': 420}]Failed
partial repair guard 3[[None, 'q', 'q'], {'p': 120, 'q': 720}][[None, 'q', 'q'], {'p': 120, 'q': 720}]Passed
normal control 4[[None, None, None], {'p': 540, 'q': 60}][[None, None, None], {'p': 540, 'q': 120}]Failed
normal control 5[['p'], {'p': 240, 'q': 120, 'r': 120}][['p'], {'p': 240, 'q': 120, 'r': 120}]Passed
normal control 6[[None, 'q'], {'p': 240, 'q': 600}][[None, 'p'], {'p': 480, 'q': 360}]Failed
normal control 7[['p'], {'p': 300, 'q': 120, 'r': 60, 's': 0}][['r'], {'p': 60, 'q': 120, 'r': 300, 's': 0}]Failed
normal control 8[['s', 'q', 'q'], {'p': 240, 'q': 480, 'r': 120, 's': 300}][['s', 'q', 'q'], {'p': 240, 'q': 480, 'r': 240, 's': 300}]Failed

SHA-256 / 73a6ccf672f9bc450b0c4ef30ed7328d00e1b553006f6a5e1d5a866f2ecb8d36

2 / The unsuccessful fix

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

N = 1
observations = []
def solve(ledger, offers):
    led = {w: list(v) for w, v in ledger.items()}
    result = []
    for minutes, refusers in offers:
        cands = sorted(led, key=lambda w: (led[w][0], led[w][1]))
        taker = None
        for w in cands:
            if led[w][2] > 720:
                continue
            if w in refusers:
                led[w][0] += minutes
                continue
            taker = w
            break
        if taker is not None:
            led[taker][0] += minutes
            led[taker][2] += minutes
        result.append(taker)
    return [result, {w: led[w][0] for w in sorted(led)}]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
fixtures = [[('regression: daily maximum boundary 1',
   [{'p': [120, 1, 240], 'r': [0, 2, 480], 'q': [60, 3, 240], 's': [60, 4, 480]},
    [[60, []], [240, ['q', 'r']]]],
   [['r', 's'], {'p': 120, 'q': 300, 'r': 60, 's': 300}]),
  ('regression variant: daily maximum boundary 2',
   [{'r': [0, 1, 480], 'q': [240, 2, 660], 'p': [120, 3, 660]},
    [[60, ['q', 'r']], [120, ['r', 'p']], [240, []]]],
   [['p', None, 'r'], {'p': 180, 'q': 240, 'r': 420}]),
  ('partial repair guard 3', [{'q': [120, 1, 0], 'p': [120, 2, 660]}, [[240, ['q']], [240, []], [120, []]]],
   [[None, 'q', 'q'], {'p': 120, 'q': 720}]),
  ('normal control 4',
   [{'p': [240, 1, 0], 'q': [60, 2, 660]}, [[60, ['q', 'p']], [120, ['p', 'q']], [120, ['p']]]],
   [[None, None, None], {'p': 540, 'q': 120}]),
  ('normal control 5', [{'r': [0, 1, 480], 'p': [120, 2, 240], 'q': [120, 3, 660]}, [[120, ['r']]]],
   [['p'], {'p': 240, 'q': 120, 'r': 120}]),
  ('normal control 6', [{'p': [120, 1, 480], 'q': [240, 2, 0]}, [[120, ['p', 'q']], [240, []]]],
   [[None, 'p'], {'p': 480, 'q': 360}]),
  ('normal control 7',
   [{'r': [60, 1, 480], 'q': [120, 2, 660], 's': [0, 3, 660], 'p': [60, 4, 0]}, [[240, []]]],
   [['r'], {'p': 60, 'q': 120, 'r': 300, 's': 0}]),
  ('normal control 8',
   [{'s': [60, 1, 0], 'p': [240, 2, 600], 'r': [120, 3, 600], 'q': [120, 4, 0]},
    [[240, ['p']], [120, ['s', 'r']], [240, []]]],
   [['s', 'q', 'q'], {'p': 240, 'q': 480, 'r': 240, 's': 300}])],
 [('regression: daily maximum boundary 1',
   [{'p': [0, 1, 0], 'q': [120, 2, 600]}, [[60, ['q', 'p']], [120, []], [120, ['q']], [120, []]]],
   [[None, 'p', 'p', 'q'], {'p': 300, 'q': 300}]),
  ('regression variant: daily maximum boundary 2',
   [{'q': [240, 1, 240], 'p': [120, 2, 660], 'r': [60, 3, 660], 's': [0, 4, 480]}, [[240, ['q']]]],
   [['s'], {'p': 120, 'q': 240, 'r': 60, 's': 240}]),
  ('partial repair guard 3',
   [{'p': [240, 1, 660], 'r': [60, 2, 240], 's': [120, 3, 0], 'q': [0, 4, 600]},
    [[240, []], [60, ['q', 'p']]]],
   [['r', 's'], {'p': 240, 'q': 60, 'r': 300, 's': 180}]),
  ('normal control 4', [{'q': [120, 1, 660], 'p': [240, 2, 600]}, [[120, []], [240, []], [240, []]]],
   [['p', None, None], {'p': 360, 'q': 120}]),
  ('normal control 5', [{'p': [240, 1, 0], 'r': [240, 2, 600], 'q': [120, 3, 600]}, [[120, []], [60, ['p']]]],
   [['q', 'r'], {'p': 300, 'q': 240, 'r': 300}]),
  ('normal control 6',
   [{'p': [60, 1, 600], 'q': [120, 2, 660]}, [[60, []], [60, ['q']], [240, []], [240, ['p']]]],
   [['p', 'p', None, None], {'p': 180, 'q': 120}]),
  ('normal control 7',
   [{'q': [120, 1, 0], 'p': [0, 2, 0]}, [[120, ['p']], [120, ['q']], [240, ['p']], [120, []]]],
   [['q', 'p', 'q', 'p'], {'p': 360, 'q': 480}]),
  ('normal control 8',
   [{'r': [60, 1, 480], 'q': [60, 2, 660], 'p': [240, 3, 600]}, [[240, ['r']], [120, []]]],
   [[None, 'p'], {'p': 360, 'q': 60, 'r': 300}])],
 [('regression: daily maximum boundary 1',
   [{'q': [240, 1, 480], 's': [120, 2, 480], 'r': [0, 3, 660], 'p': [120, 4, 480]}, [[240, ['r', 'q']]]],
   [['s'], {'p': 120, 'q': 240, 'r': 0, 's': 360}]),
  ('regression variant: daily maximum boundary 2',
   [{'s': [60, 1, 660], 'p': [0, 2, 660], 'r': [240, 3, 480], 'q': [120, 4, 0]},
    [[60, ['s', 'p']], [120, ['p']], [240, ['r']], [120, ['r']]]],
   [['q', 'q', 'q', 'q'], {'p': 60, 'q': 660, 'r': 600, 's': 120}]),
  ('normal control 3',
   [{'q': [0, 1, 0], 'r': [120, 2, 660], 'p': [120, 3, 240]}, [[120, ['r']], [240, ['r']]]],
   [['q', 'q'], {'p': 120, 'q': 360, 'r': 120}]),
  ('normal control 4',
   [{'s': [60, 1, 0], 'p': [240, 2, 600], 'r': [120, 3, 600], 'q': [120, 4, 0]},
    [[240, ['p']], [120, ['s', 'r']], [240, []]]],
   [['s', 'q', 'q'], {'p': 240, 'q': 480, 'r': 240, 's': 300}]),
  ('normal control 5', [{'q': [120, 1, 240], 'r': [240, 2, 0], 'p': [0, 3, 0]}, [[60, []]]],
   [['p'], {'p': 60, 'q': 120, 'r': 240}]),
  ('normal control 6', [{'q': [0, 1, 660], 'p': [240, 2, 480]}, [[240, []]]], [['p'], {'p': 480, 'q': 0}]),
  ('normal control 7',
   [{'q': [60, 1, 660], 'p': [60, 2, 0]}, [[60, []], [240, []], [120, ['p']], [240, ['q', 'p']]]],
   [['q', 'p', None, None], {'p': 660, 'q': 120}]),
  ('normal control 8',
   [{'p': [240, 1, 600], 'r': [60, 2, 480], 'q': [120, 3, 0], 's': [0, 4, 240]},
    [[240, ['r', 's']], [60, ['s']], [60, []]]],
   [['q', 'p', 's'], {'p': 300, 'q': 360, 'r': 300, 's': 300}])],
 [('regression: daily maximum boundary 1',
   [{'r': [240, 1, 0], 'p': [60, 2, 0], 'q': [120, 3, 0], 's': [120, 4, 600]}, [[120, ['p', 'q']]]],
   [['s'], {'p': 180, 'q': 240, 'r': 240, 's': 240}]),
  ('regression variant: daily maximum boundary 2', [{'p': [0, 1, 0], 'q': [240, 2, 660]}, [[60, ['q', 'p']]]],
   [[None], {'p': 60, 'q': 300}]),
  ('partial repair guard 3',
   [{'r': [120, 1, 480], 'p': [120, 2, 660], 'q': [60, 3, 480]},
    [[240, ['p', 'q']], [120, ['r', 'q']], [120, ['p', 'r']], [120, ['r', 'p']]]],
   [['r', None, 'q', 'q'], {'p': 120, 'q': 660, 'r': 360}]),
  ('normal control 4',
   [{'p': [120, 1, 0], 'r': [120, 2, 240], 's': [60, 3, 660], 'q': [120, 4, 0]},
    [[120, ['p', 's']], [60, []], [60, ['r']]]],
   [['r', 's', 'q'], {'p': 240, 'q': 180, 'r': 240, 's': 120}]),
  ('normal control 5',
   [{'p': [240, 1, 600], 'q': [120, 2, 480], 'r': [240, 3, 0]},
    [[60, ['r', 'q']], [60, ['q', 'r']], [60, ['r']]]],
   [['p', 'p', 'q'], {'p': 360, 'q': 300, 'r': 300}]),
  ('normal control 6', [{'q': [120, 1, 600], 'p': [240, 2, 600]}, [[120, ['q', 'p']]]],
   [[None], {'p': 360, 'q': 240}]),
  ('normal control 7',
   [{'q': [60, 1, 660], 'p': [120, 2, 480], 'r': [0, 3, 240]},
    [[60, []], [120, ['p', 'q']], [60, ['q']], [60, ['r']]]],
   [['r', 'r', 'p', 'q'], {'p': 180, 'q': 180, 'r': 180}]),
  ('normal control 8', [{'p': [120, 1, 660], 'r': [120, 2, 600], 'q': [120, 3, 240]}, [[120, ['p', 'q']]]],
   [['r'], {'p': 120, 'q': 120, 'r': 240}])],
 [('regression: daily maximum boundary 1',
   [{'q': [120, 1, 600], 'p': [240, 2, 660]}, [[120, ['q']], [60, []], [120, []], [240, []]]],
   [[None, 'q', None, None], {'p': 240, 'q': 300}]),
  ('regression variant: daily maximum boundary 2',
   [{'q': [120, 1, 600], 'p': [0, 2, 600]}, [[120, []], [240, ['p', 'q']], [60, ['q', 'p']], [120, ['q']]]],
   [['p', None, None, None], {'p': 120, 'q': 300}]),
  ('partial repair guard 3', [{'q': [120, 1, 600], 'p': [60, 2, 660]}, [[240, ['q', 'p']]]],
   [[None], {'p': 60, 'q': 120}]),
  ('normal control 4',
   [{'r': [120, 1, 240], 'p': [240, 2, 600], 'q': [120, 3, 480]},
    [[120, ['p', 'q']], [60, ['r']], [240, ['q']], [120, ['p']]]],
   [['r', 'q', 'r', 'q'], {'p': 240, 'q': 300, 'r': 480}]),
  ('normal control 5', [{'p': [60, 1, 0], 'r': [240, 2, 600], 'q': [0, 3, 480]}, [[240, ['r']]]],
   [['q'], {'p': 60, 'q': 240, 'r': 240}]),
  ('normal control 6',
   [{'r': [120, 1, 0], 'p': [120, 2, 240], 'q': [120, 3, 600]}, [[240, []], [60, ['q', 'p']]]],
   [['r', 'r'], {'p': 180, 'q': 180, 'r': 420}]),
  ('normal control 7',
   [{'p': [120, 1, 480], 'q': [60, 2, 660], 's': [120, 3, 600], 'r': [120, 4, 0]},
    [[240, ['r']], [120, ['r', 's']]]],
   [['p', None], {'p': 360, 'q': 60, 'r': 240, 's': 240}]),
  ('normal control 8',
   [{'q': [120, 1, 480], 'p': [120, 2, 600], 'r': [240, 3, 600], 's': [240, 4, 480]},
    [[120, ['r']], [120, ['s']], [60, ['q']], [240, ['q']]]],
   [['q', 'p', 'r', 's'], {'p': 240, 'q': 300, 'r': 300, 's': 480}])]]
for label, args, expected in fixtures[N-1]:
    check(label, solve(*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
regression: daily maximum boundary 1[['r', 's'], {'p': 120, 'q': 300, 'r': 300, 's': 300}][['r', 's'], {'p': 120, 'q': 300, 'r': 60, 's': 300}]Failed
regression variant: daily maximum boundary 2[['p', 'q', 'r'], {'p': 300, 'q': 360, 'r': 420}][['p', None, 'r'], {'p': 180, 'q': 240, 'r': 420}]Failed
partial repair guard 3[['p', 'q', 'q'], {'p': 360, 'q': 720}][[None, 'q', 'q'], {'p': 120, 'q': 720}]Failed
normal control 4[[None, None, 'q'], {'p': 420, 'q': 360}][[None, None, None], {'p': 540, 'q': 120}]Failed
normal control 5[['p'], {'p': 240, 'q': 120, 'r': 120}][['p'], {'p': 240, 'q': 120, 'r': 120}]Passed
normal control 6[[None, 'p'], {'p': 480, 'q': 360}][[None, 'p'], {'p': 480, 'q': 360}]Passed
normal control 7[['s'], {'p': 60, 'q': 120, 'r': 60, 's': 240}][['r'], {'p': 60, 'q': 120, 'r': 300, 's': 0}]Failed
normal control 8[['s', 'q', 'p'], {'p': 480, 'q': 240, 'r': 240, 's': 300}][['s', 'q', 'q'], {'p': 240, 'q': 480, 'r': 240, 's': 300}]Failed

SHA-256 / d9d61f3a0e10f6c7b25fa25f449d148378ec7a4ba9422cf8ef20acb4e9fa67ad

3 / The verified repair

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

N = 1
observations = []
def solve(ledger, offers):
    led = {w: list(v) for w, v in ledger.items()}
    result = []
    for minutes, refusers in offers:
        cands = sorted(led, key=lambda w: (led[w][0], led[w][1]))
        taker = None
        for w in cands:
            if led[w][2] + minutes > 720:
                continue
            if w in refusers:
                led[w][0] += minutes
                continue
            taker = w
            break
        if taker is not None:
            led[taker][0] += minutes
            led[taker][2] += minutes
        result.append(taker)
    return [result, {w: led[w][0] for w in sorted(led)}]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
fixtures = [[('regression: daily maximum boundary 1',
   [{'p': [120, 1, 240], 'r': [0, 2, 480], 'q': [60, 3, 240], 's': [60, 4, 480]},
    [[60, []], [240, ['q', 'r']]]],
   [['r', 's'], {'p': 120, 'q': 300, 'r': 60, 's': 300}]),
  ('regression variant: daily maximum boundary 2',
   [{'r': [0, 1, 480], 'q': [240, 2, 660], 'p': [120, 3, 660]},
    [[60, ['q', 'r']], [120, ['r', 'p']], [240, []]]],
   [['p', None, 'r'], {'p': 180, 'q': 240, 'r': 420}]),
  ('partial repair guard 3', [{'q': [120, 1, 0], 'p': [120, 2, 660]}, [[240, ['q']], [240, []], [120, []]]],
   [[None, 'q', 'q'], {'p': 120, 'q': 720}]),
  ('normal control 4',
   [{'p': [240, 1, 0], 'q': [60, 2, 660]}, [[60, ['q', 'p']], [120, ['p', 'q']], [120, ['p']]]],
   [[None, None, None], {'p': 540, 'q': 120}]),
  ('normal control 5', [{'r': [0, 1, 480], 'p': [120, 2, 240], 'q': [120, 3, 660]}, [[120, ['r']]]],
   [['p'], {'p': 240, 'q': 120, 'r': 120}]),
  ('normal control 6', [{'p': [120, 1, 480], 'q': [240, 2, 0]}, [[120, ['p', 'q']], [240, []]]],
   [[None, 'p'], {'p': 480, 'q': 360}]),
  ('normal control 7',
   [{'r': [60, 1, 480], 'q': [120, 2, 660], 's': [0, 3, 660], 'p': [60, 4, 0]}, [[240, []]]],
   [['r'], {'p': 60, 'q': 120, 'r': 300, 's': 0}]),
  ('normal control 8',
   [{'s': [60, 1, 0], 'p': [240, 2, 600], 'r': [120, 3, 600], 'q': [120, 4, 0]},
    [[240, ['p']], [120, ['s', 'r']], [240, []]]],
   [['s', 'q', 'q'], {'p': 240, 'q': 480, 'r': 240, 's': 300}])],
 [('regression: daily maximum boundary 1',
   [{'p': [0, 1, 0], 'q': [120, 2, 600]}, [[60, ['q', 'p']], [120, []], [120, ['q']], [120, []]]],
   [[None, 'p', 'p', 'q'], {'p': 300, 'q': 300}]),
  ('regression variant: daily maximum boundary 2',
   [{'q': [240, 1, 240], 'p': [120, 2, 660], 'r': [60, 3, 660], 's': [0, 4, 480]}, [[240, ['q']]]],
   [['s'], {'p': 120, 'q': 240, 'r': 60, 's': 240}]),
  ('partial repair guard 3',
   [{'p': [240, 1, 660], 'r': [60, 2, 240], 's': [120, 3, 0], 'q': [0, 4, 600]},
    [[240, []], [60, ['q', 'p']]]],
   [['r', 's'], {'p': 240, 'q': 60, 'r': 300, 's': 180}]),
  ('normal control 4', [{'q': [120, 1, 660], 'p': [240, 2, 600]}, [[120, []], [240, []], [240, []]]],
   [['p', None, None], {'p': 360, 'q': 120}]),
  ('normal control 5', [{'p': [240, 1, 0], 'r': [240, 2, 600], 'q': [120, 3, 600]}, [[120, []], [60, ['p']]]],
   [['q', 'r'], {'p': 300, 'q': 240, 'r': 300}]),
  ('normal control 6',
   [{'p': [60, 1, 600], 'q': [120, 2, 660]}, [[60, []], [60, ['q']], [240, []], [240, ['p']]]],
   [['p', 'p', None, None], {'p': 180, 'q': 120}]),
  ('normal control 7',
   [{'q': [120, 1, 0], 'p': [0, 2, 0]}, [[120, ['p']], [120, ['q']], [240, ['p']], [120, []]]],
   [['q', 'p', 'q', 'p'], {'p': 360, 'q': 480}]),
  ('normal control 8',
   [{'r': [60, 1, 480], 'q': [60, 2, 660], 'p': [240, 3, 600]}, [[240, ['r']], [120, []]]],
   [[None, 'p'], {'p': 360, 'q': 60, 'r': 300}])],
 [('regression: daily maximum boundary 1',
   [{'q': [240, 1, 480], 's': [120, 2, 480], 'r': [0, 3, 660], 'p': [120, 4, 480]}, [[240, ['r', 'q']]]],
   [['s'], {'p': 120, 'q': 240, 'r': 0, 's': 360}]),
  ('regression variant: daily maximum boundary 2',
   [{'s': [60, 1, 660], 'p': [0, 2, 660], 'r': [240, 3, 480], 'q': [120, 4, 0]},
    [[60, ['s', 'p']], [120, ['p']], [240, ['r']], [120, ['r']]]],
   [['q', 'q', 'q', 'q'], {'p': 60, 'q': 660, 'r': 600, 's': 120}]),
  ('normal control 3',
   [{'q': [0, 1, 0], 'r': [120, 2, 660], 'p': [120, 3, 240]}, [[120, ['r']], [240, ['r']]]],
   [['q', 'q'], {'p': 120, 'q': 360, 'r': 120}]),
  ('normal control 4',
   [{'s': [60, 1, 0], 'p': [240, 2, 600], 'r': [120, 3, 600], 'q': [120, 4, 0]},
    [[240, ['p']], [120, ['s', 'r']], [240, []]]],
   [['s', 'q', 'q'], {'p': 240, 'q': 480, 'r': 240, 's': 300}]),
  ('normal control 5', [{'q': [120, 1, 240], 'r': [240, 2, 0], 'p': [0, 3, 0]}, [[60, []]]],
   [['p'], {'p': 60, 'q': 120, 'r': 240}]),
  ('normal control 6', [{'q': [0, 1, 660], 'p': [240, 2, 480]}, [[240, []]]], [['p'], {'p': 480, 'q': 0}]),
  ('normal control 7',
   [{'q': [60, 1, 660], 'p': [60, 2, 0]}, [[60, []], [240, []], [120, ['p']], [240, ['q', 'p']]]],
   [['q', 'p', None, None], {'p': 660, 'q': 120}]),
  ('normal control 8',
   [{'p': [240, 1, 600], 'r': [60, 2, 480], 'q': [120, 3, 0], 's': [0, 4, 240]},
    [[240, ['r', 's']], [60, ['s']], [60, []]]],
   [['q', 'p', 's'], {'p': 300, 'q': 360, 'r': 300, 's': 300}])],
 [('regression: daily maximum boundary 1',
   [{'r': [240, 1, 0], 'p': [60, 2, 0], 'q': [120, 3, 0], 's': [120, 4, 600]}, [[120, ['p', 'q']]]],
   [['s'], {'p': 180, 'q': 240, 'r': 240, 's': 240}]),
  ('regression variant: daily maximum boundary 2', [{'p': [0, 1, 0], 'q': [240, 2, 660]}, [[60, ['q', 'p']]]],
   [[None], {'p': 60, 'q': 300}]),
  ('partial repair guard 3',
   [{'r': [120, 1, 480], 'p': [120, 2, 660], 'q': [60, 3, 480]},
    [[240, ['p', 'q']], [120, ['r', 'q']], [120, ['p', 'r']], [120, ['r', 'p']]]],
   [['r', None, 'q', 'q'], {'p': 120, 'q': 660, 'r': 360}]),
  ('normal control 4',
   [{'p': [120, 1, 0], 'r': [120, 2, 240], 's': [60, 3, 660], 'q': [120, 4, 0]},
    [[120, ['p', 's']], [60, []], [60, ['r']]]],
   [['r', 's', 'q'], {'p': 240, 'q': 180, 'r': 240, 's': 120}]),
  ('normal control 5',
   [{'p': [240, 1, 600], 'q': [120, 2, 480], 'r': [240, 3, 0]},
    [[60, ['r', 'q']], [60, ['q', 'r']], [60, ['r']]]],
   [['p', 'p', 'q'], {'p': 360, 'q': 300, 'r': 300}]),
  ('normal control 6', [{'q': [120, 1, 600], 'p': [240, 2, 600]}, [[120, ['q', 'p']]]],
   [[None], {'p': 360, 'q': 240}]),
  ('normal control 7',
   [{'q': [60, 1, 660], 'p': [120, 2, 480], 'r': [0, 3, 240]},
    [[60, []], [120, ['p', 'q']], [60, ['q']], [60, ['r']]]],
   [['r', 'r', 'p', 'q'], {'p': 180, 'q': 180, 'r': 180}]),
  ('normal control 8', [{'p': [120, 1, 660], 'r': [120, 2, 600], 'q': [120, 3, 240]}, [[120, ['p', 'q']]]],
   [['r'], {'p': 120, 'q': 120, 'r': 240}])],
 [('regression: daily maximum boundary 1',
   [{'q': [120, 1, 600], 'p': [240, 2, 660]}, [[120, ['q']], [60, []], [120, []], [240, []]]],
   [[None, 'q', None, None], {'p': 240, 'q': 300}]),
  ('regression variant: daily maximum boundary 2',
   [{'q': [120, 1, 600], 'p': [0, 2, 600]}, [[120, []], [240, ['p', 'q']], [60, ['q', 'p']], [120, ['q']]]],
   [['p', None, None, None], {'p': 120, 'q': 300}]),
  ('partial repair guard 3', [{'q': [120, 1, 600], 'p': [60, 2, 660]}, [[240, ['q', 'p']]]],
   [[None], {'p': 60, 'q': 120}]),
  ('normal control 4',
   [{'r': [120, 1, 240], 'p': [240, 2, 600], 'q': [120, 3, 480]},
    [[120, ['p', 'q']], [60, ['r']], [240, ['q']], [120, ['p']]]],
   [['r', 'q', 'r', 'q'], {'p': 240, 'q': 300, 'r': 480}]),
  ('normal control 5', [{'p': [60, 1, 0], 'r': [240, 2, 600], 'q': [0, 3, 480]}, [[240, ['r']]]],
   [['q'], {'p': 60, 'q': 240, 'r': 240}]),
  ('normal control 6',
   [{'r': [120, 1, 0], 'p': [120, 2, 240], 'q': [120, 3, 600]}, [[240, []], [60, ['q', 'p']]]],
   [['r', 'r'], {'p': 180, 'q': 180, 'r': 420}]),
  ('normal control 7',
   [{'p': [120, 1, 480], 'q': [60, 2, 660], 's': [120, 3, 600], 'r': [120, 4, 0]},
    [[240, ['r']], [120, ['r', 's']]]],
   [['p', None], {'p': 360, 'q': 60, 'r': 240, 's': 240}]),
  ('normal control 8',
   [{'q': [120, 1, 480], 'p': [120, 2, 600], 'r': [240, 3, 600], 's': [240, 4, 480]},
    [[120, ['r']], [120, ['s']], [60, ['q']], [240, ['q']]]],
   [['q', 'p', 'r', 's'], {'p': 240, 'q': 300, 'r': 300, 's': 480}])]]
for label, args, expected in fixtures[N-1]:
    check(label, solve(*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
regression: daily maximum boundary 1[['r', 's'], {'p': 120, 'q': 300, 'r': 60, 's': 300}][['r', 's'], {'p': 120, 'q': 300, 'r': 60, 's': 300}]Passed
regression variant: daily maximum boundary 2[['p', None, 'r'], {'p': 180, 'q': 240, 'r': 420}][['p', None, 'r'], {'p': 180, 'q': 240, 'r': 420}]Passed
partial repair guard 3[[None, 'q', 'q'], {'p': 120, 'q': 720}][[None, 'q', 'q'], {'p': 120, 'q': 720}]Passed
normal control 4[[None, None, None], {'p': 540, 'q': 120}][[None, None, None], {'p': 540, 'q': 120}]Passed
normal control 5[['p'], {'p': 240, 'q': 120, 'r': 120}][['p'], {'p': 240, 'q': 120, 'r': 120}]Passed
normal control 6[[None, 'p'], {'p': 480, 'q': 360}][[None, 'p'], {'p': 480, 'q': 360}]Passed
normal control 7[['r'], {'p': 60, 'q': 120, 'r': 300, 's': 0}][['r'], {'p': 60, 'q': 120, 'r': 300, 's': 0}]Passed
normal control 8[['s', 'q', 'q'], {'p': 240, 'q': 480, 'r': 240, 's': 300}][['s', 'q', 'q'], {'p': 240, 'q': 480, 'r': 240, 's': 300}]Passed

SHA-256 / 6fcdb1a8a5ea13dc8a0457ea9a2619d9688dbe371166d8f36da03cef43dab509

Verification & scope

Stipulated toy labor rule for a bounded roster model; it is not legal advice and does not claim conformance with any jurisdiction, award, or collective agreement. 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:52:03.278770+00:00.

Case digest / b1b3a07521ae829d8cb34fbdf09a13628723c1baf24d91825e31f5adbaaad16d