broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(events):
    capacity=2; credit=2; q=[]; flying={}; sent=[]
    for e in events:
        if e[0]=='queue': q.append([e[1],e[2]])
        elif e[0]=='pump':
            while q and credit>0:
                ident,text=q.pop(0)
                flying[ident]=text
                sent.append(text)
                credit-=1
        elif e[0]=='ack' and e[1] in flying:
            pass
            credit=max(0,capacity-len(flying))
        elif e[0]=='window':
            capacity=max(0,e[1]); credit=max(0,capacity-len(flying))
        elif e[0]=='disconnect':
            q=[[k,v] for k,v in flying.items()]+q
            flying.clear(); credit=capacity
        elif e[0]=='cancel': q=[x for x in q if x[0]!=e[1]]
    return [sent,list(flying),[x[0] for x in q],credit]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
fixtures = ["[['queue','a','alpha'*N],['queue','b','beta'],['queue','c','gamma'],['pump'],['ack','a']]", "[['queue','a','alpha'*N],['queue','b','beta'],['queue','c','gamma'],['pump'],['disconnect'],['pump']]", "[['window',0],['queue','a','x'*N],['pump']]", "[['window',N+2],['queue','a','alpha'],['pump'],['ack','a'],['ack','a']]", "[['queue','a','x'*N],['queue','b','y'],['cancel','b']]", "[['ack','missing'],['pump']]", "[['queue','a','x'*N],['queue','b','y'],['pump'],['window',1],['ack','a'],['pump']]"]
expected = {1: [[['alpha', 'beta'], ['b'], ['c'], 1], [['alpha', 'beta', 'alpha', 'beta'], ['a', 'b'], ['c'], 0], [[], [], ['a'], 0], [['alpha'], [], [], 3], [[], [], ['a'], 2], [[], [], [], 2], [['x', 'y'], ['b'], [], 0]], 2: [[['alphaalpha', 'beta'], ['b'], ['c'], 1], [['alphaalpha', 'beta', 'alphaalpha', 'beta'], ['a', 'b'], ['c'], 0], [[], [], ['a'], 0], [['alpha'], [], [], 4], [[], [], ['a'], 2], [[], [], [], 2], [['xx', 'y'], ['b'], [], 0]], 3: [[['alphaalphaalpha', 'beta'], ['b'], ['c'], 1], [['alphaalphaalpha', 'beta', 'alphaalphaalpha', 'beta'], ['a', 'b'], ['c'], 0], [[], [], ['a'], 0], [['alpha'], [], [], 5], [[], [], ['a'], 2], [[], [], [], 2], [['xxx', 'y'], ['b'], [], 0]], 4: [[['alphaalphaalphaalpha', 'beta'], ['b'], ['c'], 1], [['alphaalphaalphaalpha', 'beta', 'alphaalphaalphaalpha', 'beta'], ['a', 'b'], ['c'], 0], [[], [], ['a'], 0], [['alpha'], [], [], 6], [[], [], ['a'], 2], [[], [], [], 2], [['xxxx', 'y'], ['b'], [], 0]], 5: [[['alphaalphaalphaalphaalpha', 'beta'], ['b'], ['c'], 1], [['alphaalphaalphaalphaalpha', 'beta', 'alphaalphaalphaalphaalpha', 'beta'], ['a', 'b'], ['c'], 0], [[], [], ['a'], 0], [['alpha'], [], [], 7], [[], [], ['a'], 2], [[], [], [], 2], [['xxxxx', 'y'], ['b'], [], 0]]}[N]
for i, expression in enumerate(fixtures):
    check("trace-"+str(i+1), solve(eval(expression)), expected[i])
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)

source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(events):
    capacity=2; credit=2; q=[]; flying={}; sent=[]
    for e in events:
        if e[0]=='queue': q.append([e[1],e[2]])
        elif e[0]=='pump':
            while q and credit>0:
                ident,text=q.pop(0)
                flying[ident]=text
                sent.append(text)
                credit-=1
        elif e[0]=='ack' and e[1] in flying:
            flying.clear()
            credit=max(0,capacity-len(flying))
        elif e[0]=='window':
            capacity=max(0,e[1]); credit=max(0,capacity-len(flying))
        elif e[0]=='disconnect':
            q=[[k,v] for k,v in flying.items()]+q
            flying.clear(); credit=capacity
        elif e[0]=='cancel': q=[x for x in q if x[0]!=e[1]]
    return [sent,list(flying),[x[0] for x in q],credit]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
fixtures = ["[['queue','a','alpha'*N],['queue','b','beta'],['queue','c','gamma'],['pump'],['ack','a']]", "[['queue','a','alpha'*N],['queue','b','beta'],['queue','c','gamma'],['pump'],['disconnect'],['pump']]", "[['window',0],['queue','a','x'*N],['pump']]", "[['window',N+2],['queue','a','alpha'],['pump'],['ack','a'],['ack','a']]", "[['queue','a','x'*N],['queue','b','y'],['cancel','b']]", "[['ack','missing'],['pump']]", "[['queue','a','x'*N],['queue','b','y'],['pump'],['window',1],['ack','a'],['pump']]"]
expected = {1: [[['alpha', 'beta'], ['b'], ['c'], 1], [['alpha', 'beta', 'alpha', 'beta'], ['a', 'b'], ['c'], 0], [[], [], ['a'], 0], [['alpha'], [], [], 3], [[], [], ['a'], 2], [[], [], [], 2], [['x', 'y'], ['b'], [], 0]], 2: [[['alphaalpha', 'beta'], ['b'], ['c'], 1], [['alphaalpha', 'beta', 'alphaalpha', 'beta'], ['a', 'b'], ['c'], 0], [[], [], ['a'], 0], [['alpha'], [], [], 4], [[], [], ['a'], 2], [[], [], [], 2], [['xx', 'y'], ['b'], [], 0]], 3: [[['alphaalphaalpha', 'beta'], ['b'], ['c'], 1], [['alphaalphaalpha', 'beta', 'alphaalphaalpha', 'beta'], ['a', 'b'], ['c'], 0], [[], [], ['a'], 0], [['alpha'], [], [], 5], [[], [], ['a'], 2], [[], [], [], 2], [['xxx', 'y'], ['b'], [], 0]], 4: [[['alphaalphaalphaalpha', 'beta'], ['b'], ['c'], 1], [['alphaalphaalphaalpha', 'beta', 'alphaalphaalphaalpha', 'beta'], ['a', 'b'], ['c'], 0], [[], [], ['a'], 0], [['alpha'], [], [], 6], [[], [], ['a'], 2], [[], [], [], 2], [['xxxx', 'y'], ['b'], [], 0]], 5: [[['alphaalphaalphaalphaalpha', 'beta'], ['b'], ['c'], 1], [['alphaalphaalphaalphaalpha', 'beta', 'alphaalphaalphaalphaalpha', 'beta'], ['a', 'b'], ['c'], 0], [[], [], ['a'], 0], [['alpha'], [], [], 7], [[], [], ['a'], 2], [[], [], [], 2], [['xxxxx', 'y'], ['b'], [], 0]]}[N]
for i, expression in enumerate(fixtures):
    check("trace-"+str(i+1), solve(eval(expression)), expected[i])
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)

prompt:
The announcement trace violates the stated speech-backpressure contract.

Transport starts with two credits. Queue appends speech. Pump sends up to available credits, records inflight IDs and consumes credit. Acknowledge known inflight ID releases exactly one credit; unknown ACK does nothing. Window sets nonnegative capacity and credit to max(0,capacity-inflight). Disconnect moves inflight messages before queued ones in original send order and restores credits; cancel removes only queued matching IDs. Return sent text trace, inflight IDs, queue IDs and credit.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(events):
    capacity=2; credit=2; q=[]; flying={}; sent=[]
    for e in events:
        if e[0]=='queue': q.append([e[1],e[2]])
        elif e[0]=='pump':
            while q and credit>0:
                ident,text=q.pop(0)
                flying[ident]=text
                sent.append(text)
                credit-=1
        elif e[0]=='ack' and e[1] in flying:
            del flying[e[1]]
            credit=capacity
        elif e[0]=='window':
            capacity=max(0,e[1]); credit=max(0,capacity-len(flying))
        elif e[0]=='disconnect':
            q=[[k,v] for k,v in flying.items()]+q
            flying.clear(); credit=capacity
        elif e[0]=='cancel': q=[x for x in q if x[0]!=e[1]]
    return [sent,list(flying),[x[0] for x in q],credit]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
fixtures = ["[['queue','a','alpha'*N],['queue','b','beta'],['queue','c','gamma'],['pump'],['ack','a']]", "[['queue','a','alpha'*N],['queue','b','beta'],['queue','c','gamma'],['pump'],['disconnect'],['pump']]", "[['window',0],['queue','a','x'*N],['pump']]", "[['window',N+2],['queue','a','alpha'],['pump'],['ack','a'],['ack','a']]", "[['queue','a','x'*N],['queue','b','y'],['cancel','b']]", "[['ack','missing'],['pump']]", "[['queue','a','x'*N],['queue','b','y'],['pump'],['window',1],['ack','a'],['pump']]"]
expected = {1: [[['alpha', 'beta'], ['b'], ['c'], 1], [['alpha', 'beta', 'alpha', 'beta'], ['a', 'b'], ['c'], 0], [[], [], ['a'], 0], [['alpha'], [], [], 3], [[], [], ['a'], 2], [[], [], [], 2], [['x', 'y'], ['b'], [], 0]], 2: [[['alphaalpha', 'beta'], ['b'], ['c'], 1], [['alphaalpha', 'beta', 'alphaalpha', 'beta'], ['a', 'b'], ['c'], 0], [[], [], ['a'], 0], [['alpha'], [], [], 4], [[], [], ['a'], 2], [[], [], [], 2], [['xx', 'y'], ['b'], [], 0]], 3: [[['alphaalphaalpha', 'beta'], ['b'], ['c'], 1], [['alphaalphaalpha', 'beta', 'alphaalphaalpha', 'beta'], ['a', 'b'], ['c'], 0], [[], [], ['a'], 0], [['alpha'], [], [], 5], [[], [], ['a'], 2], [[], [], [], 2], [['xxx', 'y'], ['b'], [], 0]], 4: [[['alphaalphaalphaalpha', 'beta'], ['b'], ['c'], 1], [['alphaalphaalphaalpha', 'beta', 'alphaalphaalphaalpha', 'beta'], ['a', 'b'], ['c'], 0], [[], [], ['a'], 0], [['alpha'], [], [], 6], [[], [], ['a'], 2], [[], [], [], 2], [['xxxx', 'y'], ['b'], [], 0]], 5: [[['alphaalphaalphaalphaalpha', 'beta'], ['b'], ['c'], 1], [['alphaalphaalphaalphaalpha', 'beta', 'alphaalphaalphaalphaalpha', 'beta'], ['a', 'b'], ['c'], 0], [[], [], ['a'], 0], [['alpha'], [], [], 7], [[], [], ['a'], 2], [[], [], [], 2], [['xxxxx', 'y'], ['b'], [], 0]]}[N]
for i, expression in enumerate(fixtures):
    check("trace-"+str(i+1), solve(eval(expression)), expected[i])
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)

meaning: Fixture-count band, not measured model difficulty

deps: stdlib

source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(events):
    capacity=2; credit=2; q=[]; flying={}; sent=[]
    for e in events:
        if e[0]=='queue': q.append([e[1],e[2]])
        elif e[0]=='pump':
            while q and credit>0:
                ident,text=q.pop(0)
                flying[ident]=text
                sent.append(text)
                credit-=1
        elif e[0]=='ack' and e[1] in flying:
            del flying[e[1]]
            credit=1
        elif e[0]=='window':
            capacity=max(0,e[1]); credit=max(0,capacity-len(flying))
        elif e[0]=='disconnect':
            q=[[k,v] for k,v in flying.items()]+q
            flying.clear(); credit=capacity
        elif e[0]=='cancel': q=[x for x in q if x[0]!=e[1]]
    return [sent,list(flying),[x[0] for x in q],credit]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
fixtures = ["[['queue','a','alpha'*N],['queue','b','beta'],['queue','c','gamma'],['pump'],['ack','a']]", "[['queue','a','alpha'*N],['queue','b','beta'],['queue','c','gamma'],['pump'],['disconnect'],['pump']]", "[['window',0],['queue','a','x'*N],['pump']]", "[['window',N+2],['queue','a','alpha'],['pump'],['ack','a'],['ack','a']]", "[['queue','a','x'*N],['queue','b','y'],['cancel','b']]", "[['ack','missing'],['pump']]", "[['queue','a','x'*N],['queue','b','y'],['pump'],['window',1],['ack','a'],['pump']]"]
expected = {1: [[['alpha', 'beta'], ['b'], ['c'], 1], [['alpha', 'beta', 'alpha', 'beta'], ['a', 'b'], ['c'], 0], [[], [], ['a'], 0], [['alpha'], [], [], 3], [[], [], ['a'], 2], [[], [], [], 2], [['x', 'y'], ['b'], [], 0]], 2: [[['alphaalpha', 'beta'], ['b'], ['c'], 1], [['alphaalpha', 'beta', 'alphaalpha', 'beta'], ['a', 'b'], ['c'], 0], [[], [], ['a'], 0], [['alpha'], [], [], 4], [[], [], ['a'], 2], [[], [], [], 2], [['xx', 'y'], ['b'], [], 0]], 3: [[['alphaalphaalpha', 'beta'], ['b'], ['c'], 1], [['alphaalphaalpha', 'beta', 'alphaalphaalpha', 'beta'], ['a', 'b'], ['c'], 0], [[], [], ['a'], 0], [['alpha'], [], [], 5], [[], [], ['a'], 2], [[], [], [], 2], [['xxx', 'y'], ['b'], [], 0]], 4: [[['alphaalphaalphaalpha', 'beta'], ['b'], ['c'], 1], [['alphaalphaalphaalpha', 'beta', 'alphaalphaalphaalpha', 'beta'], ['a', 'b'], ['c'], 0], [[], [], ['a'], 0], [['alpha'], [], [], 6], [[], [], ['a'], 2], [[], [], [], 2], [['xxxx', 'y'], ['b'], [], 0]], 5: [[['alphaalphaalphaalphaalpha', 'beta'], ['b'], ['c'], 1], [['alphaalphaalphaalphaalpha', 'beta', 'alphaalphaalphaalphaalpha', 'beta'], ['a', 'b'], ['c'], 0], [[], [], ['a'], 0], [['alpha'], [], [], 7], [[], [], ['a'], 2], [[], [], [], 2], [['xxxxx', 'y'], ['b'], [], 0]]}[N]
for i, expression in enumerate(fixtures):
    check("trace-"+str(i+1), solve(eval(expression)), expected[i])
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)

prompt:
The announcement trace violates the stated speech-backpressure contract.

Transport starts with two credits. Queue appends speech. Pump sends up to available credits, records inflight IDs and consumes credit. Acknowledge known inflight ID releases exactly one credit; unknown ACK does nothing. Window sets nonnegative capacity and credit to max(0,capacity-inflight). Disconnect moves inflight messages before queued ones in original send order and restores credits; cancel removes only queued matching IDs. Return sent text trace, inflight IDs, queue IDs and credit.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(events):
    capacity=2; credit=2; q=[]; flying={}; sent=[]
    for e in events:
        if e[0]=='queue': q.append([e[1],e[2]])
        elif e[0]=='pump':
            while q and credit>0:
                ident,text=q.pop(0)
                flying[ident]=text
                sent.append(text)
                credit-=1
        elif e[0]=='ack' and e[1] in flying:
            del flying[e[1]]
            credit=max(0,capacity-len(flying))
        elif e[0]=='window':
            capacity=max(0,e[1]); credit=max(0,capacity-len(flying))
        elif e[0]=='disconnect':
            q=q+[[k,v] for k,v in flying.items()]
            flying.clear(); credit=capacity
        elif e[0]=='cancel': q=[x for x in q if x[0]!=e[1]]
    return [sent,list(flying),[x[0] for x in q],credit]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
fixtures = ["[['queue','a','alpha'*N],['queue','b','beta'],['queue','c','gamma'],['pump'],['ack','a']]", "[['queue','a','alpha'*N],['queue','b','beta'],['queue','c','gamma'],['pump'],['disconnect'],['pump']]", "[['window',0],['queue','a','x'*N],['pump']]", "[['window',N+2],['queue','a','alpha'],['pump'],['ack','a'],['ack','a']]", "[['queue','a','x'*N],['queue','b','y'],['cancel','b']]", "[['ack','missing'],['pump']]", "[['queue','a','x'*N],['queue','b','y'],['pump'],['window',1],['ack','a'],['pump']]"]
expected = {1: [[['alpha', 'beta'], ['b'], ['c'], 1], [['alpha', 'beta', 'alpha', 'beta'], ['a', 'b'], ['c'], 0], [[], [], ['a'], 0], [['alpha'], [], [], 3], [[], [], ['a'], 2], [[], [], [], 2], [['x', 'y'], ['b'], [], 0]], 2: [[['alphaalpha', 'beta'], ['b'], ['c'], 1], [['alphaalpha', 'beta', 'alphaalpha', 'beta'], ['a', 'b'], ['c'], 0], [[], [], ['a'], 0], [['alpha'], [], [], 4], [[], [], ['a'], 2], [[], [], [], 2], [['xx', 'y'], ['b'], [], 0]], 3: [[['alphaalphaalpha', 'beta'], ['b'], ['c'], 1], [['alphaalphaalpha', 'beta', 'alphaalphaalpha', 'beta'], ['a', 'b'], ['c'], 0], [[], [], ['a'], 0], [['alpha'], [], [], 5], [[], [], ['a'], 2], [[], [], [], 2], [['xxx', 'y'], ['b'], [], 0]], 4: [[['alphaalphaalphaalpha', 'beta'], ['b'], ['c'], 1], [['alphaalphaalphaalpha', 'beta', 'alphaalphaalphaalpha', 'beta'], ['a', 'b'], ['c'], 0], [[], [], ['a'], 0], [['alpha'], [], [], 6], [[], [], ['a'], 2], [[], [], [], 2], [['xxxx', 'y'], ['b'], [], 0]], 5: [[['alphaalphaalphaalphaalpha', 'beta'], ['b'], ['c'], 1], [['alphaalphaalphaalphaalpha', 'beta', 'alphaalphaalphaalphaalpha', 'beta'], ['a', 'b'], ['c'], 0], [[], [], ['a'], 0], [['alpha'], [], [], 7], [[], [], ['a'], 2], [[], [], [], 2], [['xxxxx', 'y'], ['b'], [], 0]]}[N]
for i, expression in enumerate(fixtures):
    check("trace-"+str(i+1), solve(eval(expression)), expected[i])
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)

source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(events):
    capacity=2; credit=2; q=[]; flying={}; sent=[]
    for e in events:
        if e[0]=='queue': q.append([e[1],e[2]])
        elif e[0]=='pump':
            while q and credit>0:
                ident,text=q.pop(0)
                flying[ident]=text
                sent.append(text)
                credit-=1
        elif e[0]=='ack' and e[1] in flying:
            del flying[e[1]]
            credit=max(0,capacity-len(flying))
        elif e[0]=='window':
            capacity=max(0,e[1]); credit=max(0,capacity-len(flying))
        elif e[0]=='disconnect':
            q=[[k,v] for k,v in reversed(list(flying.items()))]+q
            flying.clear(); credit=capacity
        elif e[0]=='cancel': q=[x for x in q if x[0]!=e[1]]
    return [sent,list(flying),[x[0] for x in q],credit]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
fixtures = ["[['queue','a','alpha'*N],['queue','b','beta'],['queue','c','gamma'],['pump'],['ack','a']]", "[['queue','a','alpha'*N],['queue','b','beta'],['queue','c','gamma'],['pump'],['disconnect'],['pump']]", "[['window',0],['queue','a','x'*N],['pump']]", "[['window',N+2],['queue','a','alpha'],['pump'],['ack','a'],['ack','a']]", "[['queue','a','x'*N],['queue','b','y'],['cancel','b']]", "[['ack','missing'],['pump']]", "[['queue','a','x'*N],['queue','b','y'],['pump'],['window',1],['ack','a'],['pump']]"]
expected = {1: [[['alpha', 'beta'], ['b'], ['c'], 1], [['alpha', 'beta', 'alpha', 'beta'], ['a', 'b'], ['c'], 0], [[], [], ['a'], 0], [['alpha'], [], [], 3], [[], [], ['a'], 2], [[], [], [], 2], [['x', 'y'], ['b'], [], 0]], 2: [[['alphaalpha', 'beta'], ['b'], ['c'], 1], [['alphaalpha', 'beta', 'alphaalpha', 'beta'], ['a', 'b'], ['c'], 0], [[], [], ['a'], 0], [['alpha'], [], [], 4], [[], [], ['a'], 2], [[], [], [], 2], [['xx', 'y'], ['b'], [], 0]], 3: [[['alphaalphaalpha', 'beta'], ['b'], ['c'], 1], [['alphaalphaalpha', 'beta', 'alphaalphaalpha', 'beta'], ['a', 'b'], ['c'], 0], [[], [], ['a'], 0], [['alpha'], [], [], 5], [[], [], ['a'], 2], [[], [], [], 2], [['xxx', 'y'], ['b'], [], 0]], 4: [[['alphaalphaalphaalpha', 'beta'], ['b'], ['c'], 1], [['alphaalphaalphaalpha', 'beta', 'alphaalphaalphaalpha', 'beta'], ['a', 'b'], ['c'], 0], [[], [], ['a'], 0], [['alpha'], [], [], 6], [[], [], ['a'], 2], [[], [], [], 2], [['xxxx', 'y'], ['b'], [], 0]], 5: [[['alphaalphaalphaalphaalpha', 'beta'], ['b'], ['c'], 1], [['alphaalphaalphaalphaalpha', 'beta', 'alphaalphaalphaalphaalpha', 'beta'], ['a', 'b'], ['c'], 0], [[], [], ['a'], 0], [['alpha'], [], [], 7], [[], [], ['a'], 2], [[], [], [], 2], [['xxxxx', 'y'], ['b'], [], 0]]}[N]
for i, expression in enumerate(fixtures):
    check("trace-"+str(i+1), solve(eval(expression)), expected[i])
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)

prompt:
The announcement trace violates the stated speech-backpressure contract.

Transport starts with two credits. Queue appends speech. Pump sends up to available credits, records inflight IDs and consumes credit. Acknowledge known inflight ID releases exactly one credit; unknown ACK does nothing. Window sets nonnegative capacity and credit to max(0,capacity-inflight). Disconnect moves inflight messages before queued ones in original send order and restores credits; cancel removes only queued matching IDs. Return sent text trace, inflight IDs, queue IDs and credit.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(events):
    capacity=2; credit=2; q=[]; flying={}; sent=[]
    for e in events:
        if e[0]=='queue': q.append([e[1],e[2]])
        elif e[0]=='pump':
            while q and credit>0:
                ident,text=q.pop(0)
                flying[ident]=text
                sent.append(text)
                credit-=1
        elif e[0]=='ack' and e[1] in flying:
            del flying[e[1]]
            credit=max(0,capacity-len(flying))
        elif e[0]=='window':
            capacity=max(0,e[1]); credit=max(0,capacity-len(flying))
        elif e[0]=='disconnect':
            q=[[k,v] for k,v in flying.items()]+q
            flying.clear(); credit=capacity
        elif e[0]=='cancel': q=[]
    return [sent,list(flying),[x[0] for x in q],credit]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
fixtures = ["[['queue','a','alpha'*N],['queue','b','beta'],['queue','c','gamma'],['pump'],['ack','a']]", "[['queue','a','alpha'*N],['queue','b','beta'],['queue','c','gamma'],['pump'],['disconnect'],['pump']]", "[['window',0],['queue','a','x'*N],['pump']]", "[['window',N+2],['queue','a','alpha'],['pump'],['ack','a'],['ack','a']]", "[['queue','a','x'*N],['queue','b','y'],['cancel','b']]", "[['ack','missing'],['pump']]", "[['queue','a','x'*N],['queue','b','y'],['pump'],['window',1],['ack','a'],['pump']]"]
expected = {1: [[['alpha', 'beta'], ['b'], ['c'], 1], [['alpha', 'beta', 'alpha', 'beta'], ['a', 'b'], ['c'], 0], [[], [], ['a'], 0], [['alpha'], [], [], 3], [[], [], ['a'], 2], [[], [], [], 2], [['x', 'y'], ['b'], [], 0]], 2: [[['alphaalpha', 'beta'], ['b'], ['c'], 1], [['alphaalpha', 'beta', 'alphaalpha', 'beta'], ['a', 'b'], ['c'], 0], [[], [], ['a'], 0], [['alpha'], [], [], 4], [[], [], ['a'], 2], [[], [], [], 2], [['xx', 'y'], ['b'], [], 0]], 3: [[['alphaalphaalpha', 'beta'], ['b'], ['c'], 1], [['alphaalphaalpha', 'beta', 'alphaalphaalpha', 'beta'], ['a', 'b'], ['c'], 0], [[], [], ['a'], 0], [['alpha'], [], [], 5], [[], [], ['a'], 2], [[], [], [], 2], [['xxx', 'y'], ['b'], [], 0]], 4: [[['alphaalphaalphaalpha', 'beta'], ['b'], ['c'], 1], [['alphaalphaalphaalpha', 'beta', 'alphaalphaalphaalpha', 'beta'], ['a', 'b'], ['c'], 0], [[], [], ['a'], 0], [['alpha'], [], [], 6], [[], [], ['a'], 2], [[], [], [], 2], [['xxxx', 'y'], ['b'], [], 0]], 5: [[['alphaalphaalphaalphaalpha', 'beta'], ['b'], ['c'], 1], [['alphaalphaalphaalphaalpha', 'beta', 'alphaalphaalphaalphaalpha', 'beta'], ['a', 'b'], ['c'], 0], [[], [], ['a'], 0], [['alpha'], [], [], 7], [[], [], ['a'], 2], [[], [], [], 2], [['xxxxx', 'y'], ['b'], [], 0]]}[N]
for i, expression in enumerate(fixtures):
    check("trace-"+str(i+1), solve(eval(expression)), expected[i])
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)

source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(events):
    capacity=2; credit=2; q=[]; flying={}; sent=[]
    for e in events:
        if e[0]=='queue': q.append([e[1],e[2]])
        elif e[0]=='pump':
            while q and credit>0:
                ident,text=q.pop(0)
                flying[ident]=text
                sent.append(text)
                credit-=1
        elif e[0]=='ack' and e[1] in flying:
            del flying[e[1]]
            credit=max(0,capacity-len(flying))
        elif e[0]=='window':
            capacity=max(0,e[1]); credit=max(0,capacity-len(flying))
        elif e[0]=='disconnect':
            q=[[k,v] for k,v in flying.items()]+q
            flying.clear(); credit=capacity
        elif e[0]=='cancel': q=q[1:]
    return [sent,list(flying),[x[0] for x in q],credit]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
fixtures = ["[['queue','a','alpha'*N],['queue','b','beta'],['queue','c','gamma'],['pump'],['ack','a']]", "[['queue','a','alpha'*N],['queue','b','beta'],['queue','c','gamma'],['pump'],['disconnect'],['pump']]", "[['window',0],['queue','a','x'*N],['pump']]", "[['window',N+2],['queue','a','alpha'],['pump'],['ack','a'],['ack','a']]", "[['queue','a','x'*N],['queue','b','y'],['cancel','b']]", "[['ack','missing'],['pump']]", "[['queue','a','x'*N],['queue','b','y'],['pump'],['window',1],['ack','a'],['pump']]"]
expected = {1: [[['alpha', 'beta'], ['b'], ['c'], 1], [['alpha', 'beta', 'alpha', 'beta'], ['a', 'b'], ['c'], 0], [[], [], ['a'], 0], [['alpha'], [], [], 3], [[], [], ['a'], 2], [[], [], [], 2], [['x', 'y'], ['b'], [], 0]], 2: [[['alphaalpha', 'beta'], ['b'], ['c'], 1], [['alphaalpha', 'beta', 'alphaalpha', 'beta'], ['a', 'b'], ['c'], 0], [[], [], ['a'], 0], [['alpha'], [], [], 4], [[], [], ['a'], 2], [[], [], [], 2], [['xx', 'y'], ['b'], [], 0]], 3: [[['alphaalphaalpha', 'beta'], ['b'], ['c'], 1], [['alphaalphaalpha', 'beta', 'alphaalphaalpha', 'beta'], ['a', 'b'], ['c'], 0], [[], [], ['a'], 0], [['alpha'], [], [], 5], [[], [], ['a'], 2], [[], [], [], 2], [['xxx', 'y'], ['b'], [], 0]], 4: [[['alphaalphaalphaalpha', 'beta'], ['b'], ['c'], 1], [['alphaalphaalphaalpha', 'beta', 'alphaalphaalphaalpha', 'beta'], ['a', 'b'], ['c'], 0], [[], [], ['a'], 0], [['alpha'], [], [], 6], [[], [], ['a'], 2], [[], [], [], 2], [['xxxx', 'y'], ['b'], [], 0]], 5: [[['alphaalphaalphaalphaalpha', 'beta'], ['b'], ['c'], 1], [['alphaalphaalphaalphaalpha', 'beta', 'alphaalphaalphaalphaalpha', 'beta'], ['a', 'b'], ['c'], 0], [[], [], ['a'], 0], [['alpha'], [], [], 7], [[], [], ['a'], 2], [[], [], [], 2], [['xxxxx', 'y'], ['b'], [], 0]]}[N]
for i, expression in enumerate(fixtures):
    check("trace-"+str(i+1), solve(eval(expression)), expected[i])
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)

prompt:
The announcement trace violates the stated speech-backpressure contract.

Transport starts with two credits. Queue appends speech. Pump sends up to available credits, records inflight IDs and consumes credit. Acknowledge known inflight ID releases exactly one credit; unknown ACK does nothing. Window sets nonnegative capacity and credit to max(0,capacity-inflight). Disconnect moves inflight messages before queued ones in original send order and restores credits; cancel removes only queued matching IDs. Return sent text trace, inflight IDs, queue IDs and credit.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(events):
    current=None; suspended=[]; waiting=[]; spoken=[]
    for e in events:
        if e[0] in ('start','urgent'):
            job=[e[1],list(e[2]),0]
            if e[0]=='urgent':
                if current is not None: suspended.append([current[0],current[1],0])
                current=job
            elif current is None: current=job
            else: waiting.append(job)
        elif e[0]=='cancel':
            if current is not None and current[0]==e[1]: current=None
            suspended=[x for x in suspended if x[0]!=e[1]]
            waiting=[x for x in waiting if x[0]!=e[1]]
        elif e[0]=='clear': current=None; suspended=[]; waiting=[]
        elif e[0]=='step' and current is not None:
            if current[2]<len(current[1]):
                spoken.append([current[0],current[1][current[2]]])
                current[2]+=1
            if current[2]>=len(current[1]): current=None
        if current is None:
            if suspended: current=suspended.pop()
            elif waiting: current=waiting.pop(0)
    return [spoken,None if current is None else [current[0],current[2]],[[x[0],x[2]] for x in suspended],[[x[0],x[2]] for x in waiting]]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
fixtures = ["[['start','a',['a']*(N+2)],['step'],['urgent','b',['b']],['urgent','c',['c']],['step'],['step'],['step']]", "[['start','a',['a']*N],['start','b',['b']],['start','c',['c']]]+[['step']]*(N+2)", "[['start','a',['a']*N],['urgent','b',['b']],['start','c',['c']],['cancel','a'],['step'],['step']]", "[['start','a',['a']*N],['start','b',['beta']],['start','c',['gamma']],['cancel','b']]", "[['start','a',['a']*N],['urgent','b',['b']],['start','c',['c']],['clear']]", "[['start','a',['a']*N],['urgent','b',['b']],['urgent','c',['c']],['cancel','a']]", "[['start','a',[]],['step']]", "[['start','a',['a']*N],['cancel','a']]"]
expected = {1: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]], 2: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]], 3: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['a', 'a'], ['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]], 4: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['a', 'a'], ['a', 'a'], ['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]], 5: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['a', 'a'], ['a', 'a'], ['a', 'a'], ['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]]}[N]
for i, expression in enumerate(fixtures):
    check("trace-"+str(i+1), solve(eval(expression)), expected[i])
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)

source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(events):
    current=None; suspended=[]; waiting=[]; spoken=[]
    for e in events:
        if e[0] in ('start','urgent'):
            job=[e[1],list(e[2]),0]
            if e[0]=='urgent':
                if current is not None: suspended.insert(0,current)
                current=job
            elif current is None: current=job
            else: waiting.append(job)
        elif e[0]=='cancel':
            if current is not None and current[0]==e[1]: current=None
            suspended=[x for x in suspended if x[0]!=e[1]]
            waiting=[x for x in waiting if x[0]!=e[1]]
        elif e[0]=='clear': current=None; suspended=[]; waiting=[]
        elif e[0]=='step' and current is not None:
            if current[2]<len(current[1]):
                spoken.append([current[0],current[1][current[2]]])
                current[2]+=1
            if current[2]>=len(current[1]): current=None
        if current is None:
            if suspended: current=suspended.pop()
            elif waiting: current=waiting.pop(0)
    return [spoken,None if current is None else [current[0],current[2]],[[x[0],x[2]] for x in suspended],[[x[0],x[2]] for x in waiting]]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
fixtures = ["[['start','a',['a']*(N+2)],['step'],['urgent','b',['b']],['urgent','c',['c']],['step'],['step'],['step']]", "[['start','a',['a']*N],['start','b',['b']],['start','c',['c']]]+[['step']]*(N+2)", "[['start','a',['a']*N],['urgent','b',['b']],['start','c',['c']],['cancel','a'],['step'],['step']]", "[['start','a',['a']*N],['start','b',['beta']],['start','c',['gamma']],['cancel','b']]", "[['start','a',['a']*N],['urgent','b',['b']],['start','c',['c']],['clear']]", "[['start','a',['a']*N],['urgent','b',['b']],['urgent','c',['c']],['cancel','a']]", "[['start','a',[]],['step']]", "[['start','a',['a']*N],['cancel','a']]"]
expected = {1: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]], 2: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]], 3: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['a', 'a'], ['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]], 4: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['a', 'a'], ['a', 'a'], ['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]], 5: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['a', 'a'], ['a', 'a'], ['a', 'a'], ['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]]}[N]
for i, expression in enumerate(fixtures):
    check("trace-"+str(i+1), solve(eval(expression)), expected[i])
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)

prompt:
The announcement trace violates the stated interrupt-resumption contract.

Speech jobs are [id,words,cursor]. Start queues a new job when one is active. Urgent pushes the current job on a LIFO suspended stack and begins fresh. Step speaks one word and finishes only after its last word; suspended jobs resume before queued normal work. Cancel ID removes it from every location and promotes next available job. Clear discards all jobs without speech. Report emitted [id,word] and current/suspended/waiting IDs with cursors.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(events):
    current=None; suspended=[]; waiting=[]; spoken=[]
    for e in events:
        if e[0] in ('start','urgent'):
            job=[e[1],list(e[2]),0]
            if e[0]=='urgent':
                if current is not None: suspended.append(current)
                waiting.append(job)
            elif current is None: current=job
            else: waiting.append(job)
        elif e[0]=='cancel':
            if current is not None and current[0]==e[1]: current=None
            suspended=[x for x in suspended if x[0]!=e[1]]
            waiting=[x for x in waiting if x[0]!=e[1]]
        elif e[0]=='clear': current=None; suspended=[]; waiting=[]
        elif e[0]=='step' and current is not None:
            if current[2]<len(current[1]):
                spoken.append([current[0],current[1][current[2]]])
                current[2]+=1
            if current[2]>=len(current[1]): current=None
        if current is None:
            if suspended: current=suspended.pop()
            elif waiting: current=waiting.pop(0)
    return [spoken,None if current is None else [current[0],current[2]],[[x[0],x[2]] for x in suspended],[[x[0],x[2]] for x in waiting]]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
fixtures = ["[['start','a',['a']*(N+2)],['step'],['urgent','b',['b']],['urgent','c',['c']],['step'],['step'],['step']]", "[['start','a',['a']*N],['start','b',['b']],['start','c',['c']]]+[['step']]*(N+2)", "[['start','a',['a']*N],['urgent','b',['b']],['start','c',['c']],['cancel','a'],['step'],['step']]", "[['start','a',['a']*N],['start','b',['beta']],['start','c',['gamma']],['cancel','b']]", "[['start','a',['a']*N],['urgent','b',['b']],['start','c',['c']],['clear']]", "[['start','a',['a']*N],['urgent','b',['b']],['urgent','c',['c']],['cancel','a']]", "[['start','a',[]],['step']]", "[['start','a',['a']*N],['cancel','a']]"]
expected = {1: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]], 2: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]], 3: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['a', 'a'], ['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]], 4: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['a', 'a'], ['a', 'a'], ['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]], 5: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['a', 'a'], ['a', 'a'], ['a', 'a'], ['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]]}[N]
for i, expression in enumerate(fixtures):
    check("trace-"+str(i+1), solve(eval(expression)), expected[i])
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)

source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(events):
    current=None; suspended=[]; waiting=[]; spoken=[]
    for e in events:
        if e[0] in ('start','urgent'):
            job=[e[1],list(e[2]),0]
            if e[0]=='urgent':
                if current is not None: suspended.append(current)
                suspended.append(job)
            elif current is None: current=job
            else: waiting.append(job)
        elif e[0]=='cancel':
            if current is not None and current[0]==e[1]: current=None
            suspended=[x for x in suspended if x[0]!=e[1]]
            waiting=[x for x in waiting if x[0]!=e[1]]
        elif e[0]=='clear': current=None; suspended=[]; waiting=[]
        elif e[0]=='step' and current is not None:
            if current[2]<len(current[1]):
                spoken.append([current[0],current[1][current[2]]])
                current[2]+=1
            if current[2]>=len(current[1]): current=None
        if current is None:
            if suspended: current=suspended.pop()
            elif waiting: current=waiting.pop(0)
    return [spoken,None if current is None else [current[0],current[2]],[[x[0],x[2]] for x in suspended],[[x[0],x[2]] for x in waiting]]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
fixtures = ["[['start','a',['a']*(N+2)],['step'],['urgent','b',['b']],['urgent','c',['c']],['step'],['step'],['step']]", "[['start','a',['a']*N],['start','b',['b']],['start','c',['c']]]+[['step']]*(N+2)", "[['start','a',['a']*N],['urgent','b',['b']],['start','c',['c']],['cancel','a'],['step'],['step']]", "[['start','a',['a']*N],['start','b',['beta']],['start','c',['gamma']],['cancel','b']]", "[['start','a',['a']*N],['urgent','b',['b']],['start','c',['c']],['clear']]", "[['start','a',['a']*N],['urgent','b',['b']],['urgent','c',['c']],['cancel','a']]", "[['start','a',[]],['step']]", "[['start','a',['a']*N],['cancel','a']]"]
expected = {1: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]], 2: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]], 3: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['a', 'a'], ['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]], 4: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['a', 'a'], ['a', 'a'], ['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]], 5: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['a', 'a'], ['a', 'a'], ['a', 'a'], ['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]]}[N]
for i, expression in enumerate(fixtures):
    check("trace-"+str(i+1), solve(eval(expression)), expected[i])
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)

prompt:
The announcement trace violates the stated interrupt-resumption contract.

Speech jobs are [id,words,cursor]. Start queues a new job when one is active. Urgent pushes the current job on a LIFO suspended stack and begins fresh. Step speaks one word and finishes only after its last word; suspended jobs resume before queued normal work. Cancel ID removes it from every location and promotes next available job. Clear discards all jobs without speech. Report emitted [id,word] and current/suspended/waiting IDs with cursors.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(events):
    current=None; suspended=[]; waiting=[]; spoken=[]
    for e in events:
        if e[0] in ('start','urgent'):
            job=[e[1],list(e[2]),0]
            if e[0]=='urgent':
                if current is not None: suspended.append(current)
                current=job
            elif current is None: current=job
            else: current=job
        elif e[0]=='cancel':
            if current is not None and current[0]==e[1]: current=None
            suspended=[x for x in suspended if x[0]!=e[1]]
            waiting=[x for x in waiting if x[0]!=e[1]]
        elif e[0]=='clear': current=None; suspended=[]; waiting=[]
        elif e[0]=='step' and current is not None:
            if current[2]<len(current[1]):
                spoken.append([current[0],current[1][current[2]]])
                current[2]+=1
            if current[2]>=len(current[1]): current=None
        if current is None:
            if suspended: current=suspended.pop()
            elif waiting: current=waiting.pop(0)
    return [spoken,None if current is None else [current[0],current[2]],[[x[0],x[2]] for x in suspended],[[x[0],x[2]] for x in waiting]]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
fixtures = ["[['start','a',['a']*(N+2)],['step'],['urgent','b',['b']],['urgent','c',['c']],['step'],['step'],['step']]", "[['start','a',['a']*N],['start','b',['b']],['start','c',['c']]]+[['step']]*(N+2)", "[['start','a',['a']*N],['urgent','b',['b']],['start','c',['c']],['cancel','a'],['step'],['step']]", "[['start','a',['a']*N],['start','b',['beta']],['start','c',['gamma']],['cancel','b']]", "[['start','a',['a']*N],['urgent','b',['b']],['start','c',['c']],['clear']]", "[['start','a',['a']*N],['urgent','b',['b']],['urgent','c',['c']],['cancel','a']]", "[['start','a',[]],['step']]", "[['start','a',['a']*N],['cancel','a']]"]
expected = {1: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]], 2: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]], 3: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['a', 'a'], ['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]], 4: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['a', 'a'], ['a', 'a'], ['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]], 5: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['a', 'a'], ['a', 'a'], ['a', 'a'], ['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]]}[N]
for i, expression in enumerate(fixtures):
    check("trace-"+str(i+1), solve(eval(expression)), expected[i])
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)

source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(events):
    current=None; suspended=[]; waiting=[]; spoken=[]
    for e in events:
        if e[0] in ('start','urgent'):
            job=[e[1],list(e[2]),0]
            if e[0]=='urgent':
                if current is not None: suspended.append(current)
                current=job
            elif current is None: current=job
            else: waiting.insert(0,job)
        elif e[0]=='cancel':
            if current is not None and current[0]==e[1]: current=None
            suspended=[x for x in suspended if x[0]!=e[1]]
            waiting=[x for x in waiting if x[0]!=e[1]]
        elif e[0]=='clear': current=None; suspended=[]; waiting=[]
        elif e[0]=='step' and current is not None:
            if current[2]<len(current[1]):
                spoken.append([current[0],current[1][current[2]]])
                current[2]+=1
            if current[2]>=len(current[1]): current=None
        if current is None:
            if suspended: current=suspended.pop()
            elif waiting: current=waiting.pop(0)
    return [spoken,None if current is None else [current[0],current[2]],[[x[0],x[2]] for x in suspended],[[x[0],x[2]] for x in waiting]]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
fixtures = ["[['start','a',['a']*(N+2)],['step'],['urgent','b',['b']],['urgent','c',['c']],['step'],['step'],['step']]", "[['start','a',['a']*N],['start','b',['b']],['start','c',['c']]]+[['step']]*(N+2)", "[['start','a',['a']*N],['urgent','b',['b']],['start','c',['c']],['cancel','a'],['step'],['step']]", "[['start','a',['a']*N],['start','b',['beta']],['start','c',['gamma']],['cancel','b']]", "[['start','a',['a']*N],['urgent','b',['b']],['start','c',['c']],['clear']]", "[['start','a',['a']*N],['urgent','b',['b']],['urgent','c',['c']],['cancel','a']]", "[['start','a',[]],['step']]", "[['start','a',['a']*N],['cancel','a']]"]
expected = {1: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]], 2: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]], 3: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['a', 'a'], ['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]], 4: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['a', 'a'], ['a', 'a'], ['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]], 5: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['a', 'a'], ['a', 'a'], ['a', 'a'], ['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]]}[N]
for i, expression in enumerate(fixtures):
    check("trace-"+str(i+1), solve(eval(expression)), expected[i])
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)

prompt:
The announcement trace violates the stated interrupt-resumption contract.

Speech jobs are [id,words,cursor]. Start queues a new job when one is active. Urgent pushes the current job on a LIFO suspended stack and begins fresh. Step speaks one word and finishes only after its last word; suspended jobs resume before queued normal work. Cancel ID removes it from every location and promotes next available job. Clear discards all jobs without speech. Report emitted [id,word] and current/suspended/waiting IDs with cursors.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(events):
    current=None; suspended=[]; waiting=[]; spoken=[]
    for e in events:
        if e[0] in ('start','urgent'):
            job=[e[1],list(e[2]),0]
            if e[0]=='urgent':
                if current is not None: suspended.append(current)
                current=job
            elif current is None: current=job
            else: waiting.append(job)
        elif e[0]=='cancel':
            if current is not None: current=None
            suspended=[x for x in suspended if x[0]!=e[1]]
            waiting=[x for x in waiting if x[0]!=e[1]]
        elif e[0]=='clear': current=None; suspended=[]; waiting=[]
        elif e[0]=='step' and current is not None:
            if current[2]<len(current[1]):
                spoken.append([current[0],current[1][current[2]]])
                current[2]+=1
            if current[2]>=len(current[1]): current=None
        if current is None:
            if suspended: current=suspended.pop()
            elif waiting: current=waiting.pop(0)
    return [spoken,None if current is None else [current[0],current[2]],[[x[0],x[2]] for x in suspended],[[x[0],x[2]] for x in waiting]]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
fixtures = ["[['start','a',['a']*(N+2)],['step'],['urgent','b',['b']],['urgent','c',['c']],['step'],['step'],['step']]", "[['start','a',['a']*N],['start','b',['b']],['start','c',['c']]]+[['step']]*(N+2)", "[['start','a',['a']*N],['urgent','b',['b']],['start','c',['c']],['cancel','a'],['step'],['step']]", "[['start','a',['a']*N],['start','b',['beta']],['start','c',['gamma']],['cancel','b']]", "[['start','a',['a']*N],['urgent','b',['b']],['start','c',['c']],['clear']]", "[['start','a',['a']*N],['urgent','b',['b']],['urgent','c',['c']],['cancel','a']]", "[['start','a',[]],['step']]", "[['start','a',['a']*N],['cancel','a']]"]
expected = {1: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]], 2: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]], 3: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['a', 'a'], ['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]], 4: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['a', 'a'], ['a', 'a'], ['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]], 5: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['a', 'a'], ['a', 'a'], ['a', 'a'], ['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]]}[N]
for i, expression in enumerate(fixtures):
    check("trace-"+str(i+1), solve(eval(expression)), expected[i])
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)

source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(events):
    current=None; suspended=[]; waiting=[]; spoken=[]
    for e in events:
        if e[0] in ('start','urgent'):
            job=[e[1],list(e[2]),0]
            if e[0]=='urgent':
                if current is not None: suspended.append(current)
                current=job
            elif current is None: current=job
            else: waiting.append(job)
        elif e[0]=='cancel':
            if current is not None and current[0]==e[1]: current[2]=0
            suspended=[x for x in suspended if x[0]!=e[1]]
            waiting=[x for x in waiting if x[0]!=e[1]]
        elif e[0]=='clear': current=None; suspended=[]; waiting=[]
        elif e[0]=='step' and current is not None:
            if current[2]<len(current[1]):
                spoken.append([current[0],current[1][current[2]]])
                current[2]+=1
            if current[2]>=len(current[1]): current=None
        if current is None:
            if suspended: current=suspended.pop()
            elif waiting: current=waiting.pop(0)
    return [spoken,None if current is None else [current[0],current[2]],[[x[0],x[2]] for x in suspended],[[x[0],x[2]] for x in waiting]]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
fixtures = ["[['start','a',['a']*(N+2)],['step'],['urgent','b',['b']],['urgent','c',['c']],['step'],['step'],['step']]", "[['start','a',['a']*N],['start','b',['b']],['start','c',['c']]]+[['step']]*(N+2)", "[['start','a',['a']*N],['urgent','b',['b']],['start','c',['c']],['cancel','a'],['step'],['step']]", "[['start','a',['a']*N],['start','b',['beta']],['start','c',['gamma']],['cancel','b']]", "[['start','a',['a']*N],['urgent','b',['b']],['start','c',['c']],['clear']]", "[['start','a',['a']*N],['urgent','b',['b']],['urgent','c',['c']],['cancel','a']]", "[['start','a',[]],['step']]", "[['start','a',['a']*N],['cancel','a']]"]
expected = {1: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]], 2: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]], 3: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['a', 'a'], ['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]], 4: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['a', 'a'], ['a', 'a'], ['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]], 5: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['a', 'a'], ['a', 'a'], ['a', 'a'], ['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]]}[N]
for i, expression in enumerate(fixtures):
    check("trace-"+str(i+1), solve(eval(expression)), expected[i])
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)

prompt:
The announcement trace violates the stated interrupt-resumption contract.

Speech jobs are [id,words,cursor]. Start queues a new job when one is active. Urgent pushes the current job on a LIFO suspended stack and begins fresh. Step speaks one word and finishes only after its last word; suspended jobs resume before queued normal work. Cancel ID removes it from every location and promotes next available job. Clear discards all jobs without speech. Report emitted [id,word] and current/suspended/waiting IDs with cursors.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(events):
    current=None; suspended=[]; waiting=[]; spoken=[]
    for e in events:
        if e[0] in ('start','urgent'):
            job=[e[1],list(e[2]),0]
            if e[0]=='urgent':
                if current is not None: suspended.append(current)
                current=job
            elif current is None: current=job
            else: waiting.append(job)
        elif e[0]=='cancel':
            if current is not None and current[0]==e[1]: current=None
            suspended=list(suspended)
            waiting=[x for x in waiting if x[0]!=e[1]]
        elif e[0]=='clear': current=None; suspended=[]; waiting=[]
        elif e[0]=='step' and current is not None:
            if current[2]<len(current[1]):
                spoken.append([current[0],current[1][current[2]]])
                current[2]+=1
            if current[2]>=len(current[1]): current=None
        if current is None:
            if suspended: current=suspended.pop()
            elif waiting: current=waiting.pop(0)
    return [spoken,None if current is None else [current[0],current[2]],[[x[0],x[2]] for x in suspended],[[x[0],x[2]] for x in waiting]]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
fixtures = ["[['start','a',['a']*(N+2)],['step'],['urgent','b',['b']],['urgent','c',['c']],['step'],['step'],['step']]", "[['start','a',['a']*N],['start','b',['b']],['start','c',['c']]]+[['step']]*(N+2)", "[['start','a',['a']*N],['urgent','b',['b']],['start','c',['c']],['cancel','a'],['step'],['step']]", "[['start','a',['a']*N],['start','b',['beta']],['start','c',['gamma']],['cancel','b']]", "[['start','a',['a']*N],['urgent','b',['b']],['start','c',['c']],['clear']]", "[['start','a',['a']*N],['urgent','b',['b']],['urgent','c',['c']],['cancel','a']]", "[['start','a',[]],['step']]", "[['start','a',['a']*N],['cancel','a']]"]
expected = {1: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]], 2: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]], 3: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['a', 'a'], ['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]], 4: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['a', 'a'], ['a', 'a'], ['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]], 5: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['a', 'a'], ['a', 'a'], ['a', 'a'], ['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]]}[N]
for i, expression in enumerate(fixtures):
    check("trace-"+str(i+1), solve(eval(expression)), expected[i])
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)

source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(events):
    current=None; suspended=[]; waiting=[]; spoken=[]
    for e in events:
        if e[0] in ('start','urgent'):
            job=[e[1],list(e[2]),0]
            if e[0]=='urgent':
                if current is not None: suspended.append(current)
                current=job
            elif current is None: current=job
            else: waiting.append(job)
        elif e[0]=='cancel':
            if current is not None and current[0]==e[1]: current=None
            suspended=[]
            waiting=[x for x in waiting if x[0]!=e[1]]
        elif e[0]=='clear': current=None; suspended=[]; waiting=[]
        elif e[0]=='step' and current is not None:
            if current[2]<len(current[1]):
                spoken.append([current[0],current[1][current[2]]])
                current[2]+=1
            if current[2]>=len(current[1]): current=None
        if current is None:
            if suspended: current=suspended.pop()
            elif waiting: current=waiting.pop(0)
    return [spoken,None if current is None else [current[0],current[2]],[[x[0],x[2]] for x in suspended],[[x[0],x[2]] for x in waiting]]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
fixtures = ["[['start','a',['a']*(N+2)],['step'],['urgent','b',['b']],['urgent','c',['c']],['step'],['step'],['step']]", "[['start','a',['a']*N],['start','b',['b']],['start','c',['c']]]+[['step']]*(N+2)", "[['start','a',['a']*N],['urgent','b',['b']],['start','c',['c']],['cancel','a'],['step'],['step']]", "[['start','a',['a']*N],['start','b',['beta']],['start','c',['gamma']],['cancel','b']]", "[['start','a',['a']*N],['urgent','b',['b']],['start','c',['c']],['clear']]", "[['start','a',['a']*N],['urgent','b',['b']],['urgent','c',['c']],['cancel','a']]", "[['start','a',[]],['step']]", "[['start','a',['a']*N],['cancel','a']]"]
expected = {1: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]], 2: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]], 3: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['a', 'a'], ['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]], 4: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['a', 'a'], ['a', 'a'], ['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]], 5: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['a', 'a'], ['a', 'a'], ['a', 'a'], ['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]]}[N]
for i, expression in enumerate(fixtures):
    check("trace-"+str(i+1), solve(eval(expression)), expected[i])
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)

prompt:
The announcement trace violates the stated interrupt-resumption contract.

Speech jobs are [id,words,cursor]. Start queues a new job when one is active. Urgent pushes the current job on a LIFO suspended stack and begins fresh. Step speaks one word and finishes only after its last word; suspended jobs resume before queued normal work. Cancel ID removes it from every location and promotes next available job. Clear discards all jobs without speech. Report emitted [id,word] and current/suspended/waiting IDs with cursors.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(events):
    current=None; suspended=[]; waiting=[]; spoken=[]
    for e in events:
        if e[0] in ('start','urgent'):
            job=[e[1],list(e[2]),0]
            if e[0]=='urgent':
                if current is not None: suspended.append(current)
                current=job
            elif current is None: current=job
            else: waiting.append(job)
        elif e[0]=='cancel':
            if current is not None and current[0]==e[1]: current=None
            suspended=[x for x in suspended if x[0]!=e[1]]
            waiting=[x for x in waiting if e[1] not in x[1]]
        elif e[0]=='clear': current=None; suspended=[]; waiting=[]
        elif e[0]=='step' and current is not None:
            if current[2]<len(current[1]):
                spoken.append([current[0],current[1][current[2]]])
                current[2]+=1
            if current[2]>=len(current[1]): current=None
        if current is None:
            if suspended: current=suspended.pop()
            elif waiting: current=waiting.pop(0)
    return [spoken,None if current is None else [current[0],current[2]],[[x[0],x[2]] for x in suspended],[[x[0],x[2]] for x in waiting]]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
fixtures = ["[['start','a',['a']*(N+2)],['step'],['urgent','b',['b']],['urgent','c',['c']],['step'],['step'],['step']]", "[['start','a',['a']*N],['start','b',['b']],['start','c',['c']]]+[['step']]*(N+2)", "[['start','a',['a']*N],['urgent','b',['b']],['start','c',['c']],['cancel','a'],['step'],['step']]", "[['start','a',['a']*N],['start','b',['beta']],['start','c',['gamma']],['cancel','b']]", "[['start','a',['a']*N],['urgent','b',['b']],['start','c',['c']],['clear']]", "[['start','a',['a']*N],['urgent','b',['b']],['urgent','c',['c']],['cancel','a']]", "[['start','a',[]],['step']]", "[['start','a',['a']*N],['cancel','a']]"]
expected = {1: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]], 2: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]], 3: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['a', 'a'], ['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]], 4: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['a', 'a'], ['a', 'a'], ['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]], 5: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['a', 'a'], ['a', 'a'], ['a', 'a'], ['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]]}[N]
for i, expression in enumerate(fixtures):
    check("trace-"+str(i+1), solve(eval(expression)), expected[i])
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)

source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(events):
    current=None; suspended=[]; waiting=[]; spoken=[]
    for e in events:
        if e[0] in ('start','urgent'):
            job=[e[1],list(e[2]),0]
            if e[0]=='urgent':
                if current is not None: suspended.append(current)
                current=job
            elif current is None: current=job
            else: waiting.append(job)
        elif e[0]=='cancel':
            if current is not None and current[0]==e[1]: current=None
            suspended=[x for x in suspended if x[0]!=e[1]]
            waiting=[]
        elif e[0]=='clear': current=None; suspended=[]; waiting=[]
        elif e[0]=='step' and current is not None:
            if current[2]<len(current[1]):
                spoken.append([current[0],current[1][current[2]]])
                current[2]+=1
            if current[2]>=len(current[1]): current=None
        if current is None:
            if suspended: current=suspended.pop()
            elif waiting: current=waiting.pop(0)
    return [spoken,None if current is None else [current[0],current[2]],[[x[0],x[2]] for x in suspended],[[x[0],x[2]] for x in waiting]]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
fixtures = ["[['start','a',['a']*(N+2)],['step'],['urgent','b',['b']],['urgent','c',['c']],['step'],['step'],['step']]", "[['start','a',['a']*N],['start','b',['b']],['start','c',['c']]]+[['step']]*(N+2)", "[['start','a',['a']*N],['urgent','b',['b']],['start','c',['c']],['cancel','a'],['step'],['step']]", "[['start','a',['a']*N],['start','b',['beta']],['start','c',['gamma']],['cancel','b']]", "[['start','a',['a']*N],['urgent','b',['b']],['start','c',['c']],['clear']]", "[['start','a',['a']*N],['urgent','b',['b']],['urgent','c',['c']],['cancel','a']]", "[['start','a',[]],['step']]", "[['start','a',['a']*N],['cancel','a']]"]
expected = {1: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]], 2: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]], 3: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['a', 'a'], ['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]], 4: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['a', 'a'], ['a', 'a'], ['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]], 5: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['a', 'a'], ['a', 'a'], ['a', 'a'], ['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]]}[N]
for i, expression in enumerate(fixtures):
    check("trace-"+str(i+1), solve(eval(expression)), expected[i])
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)

prompt:
The announcement trace violates the stated interrupt-resumption contract.

Speech jobs are [id,words,cursor]. Start queues a new job when one is active. Urgent pushes the current job on a LIFO suspended stack and begins fresh. Step speaks one word and finishes only after its last word; suspended jobs resume before queued normal work. Cancel ID removes it from every location and promotes next available job. Clear discards all jobs without speech. Report emitted [id,word] and current/suspended/waiting IDs with cursors.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(events):
    current=None; suspended=[]; waiting=[]; spoken=[]
    for e in events:
        if e[0] in ('start','urgent'):
            job=[e[1],list(e[2]),0]
            if e[0]=='urgent':
                if current is not None: suspended.append(current)
                current=job
            elif current is None: current=job
            else: waiting.append(job)
        elif e[0]=='cancel':
            if current is not None and current[0]==e[1]: current=None
            suspended=[x for x in suspended if x[0]!=e[1]]
            waiting=[x for x in waiting if x[0]!=e[1]]
        elif e[0]=='clear': current=None; waiting=[]
        elif e[0]=='step' and current is not None:
            if current[2]<len(current[1]):
                spoken.append([current[0],current[1][current[2]]])
                current[2]+=1
            if current[2]>=len(current[1]): current=None
        if current is None:
            if suspended: current=suspended.pop()
            elif waiting: current=waiting.pop(0)
    return [spoken,None if current is None else [current[0],current[2]],[[x[0],x[2]] for x in suspended],[[x[0],x[2]] for x in waiting]]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
fixtures = ["[['start','a',['a']*(N+2)],['step'],['urgent','b',['b']],['urgent','c',['c']],['step'],['step'],['step']]", "[['start','a',['a']*N],['start','b',['b']],['start','c',['c']]]+[['step']]*(N+2)", "[['start','a',['a']*N],['urgent','b',['b']],['start','c',['c']],['cancel','a'],['step'],['step']]", "[['start','a',['a']*N],['start','b',['beta']],['start','c',['gamma']],['cancel','b']]", "[['start','a',['a']*N],['urgent','b',['b']],['start','c',['c']],['clear']]", "[['start','a',['a']*N],['urgent','b',['b']],['urgent','c',['c']],['cancel','a']]", "[['start','a',[]],['step']]", "[['start','a',['a']*N],['cancel','a']]"]
expected = {1: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]], 2: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]], 3: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['a', 'a'], ['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]], 4: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['a', 'a'], ['a', 'a'], ['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]], 5: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['a', 'a'], ['a', 'a'], ['a', 'a'], ['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]]}[N]
for i, expression in enumerate(fixtures):
    check("trace-"+str(i+1), solve(eval(expression)), expected[i])
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)

source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(events):
    current=None; suspended=[]; waiting=[]; spoken=[]
    for e in events:
        if e[0] in ('start','urgent'):
            job=[e[1],list(e[2]),0]
            if e[0]=='urgent':
                if current is not None: suspended.append(current)
                current=job
            elif current is None: current=job
            else: waiting.append(job)
        elif e[0]=='cancel':
            if current is not None and current[0]==e[1]: current=None
            suspended=[x for x in suspended if x[0]!=e[1]]
            waiting=[x for x in waiting if x[0]!=e[1]]
        elif e[0]=='clear': current=None; suspended=[]
        elif e[0]=='step' and current is not None:
            if current[2]<len(current[1]):
                spoken.append([current[0],current[1][current[2]]])
                current[2]+=1
            if current[2]>=len(current[1]): current=None
        if current is None:
            if suspended: current=suspended.pop()
            elif waiting: current=waiting.pop(0)
    return [spoken,None if current is None else [current[0],current[2]],[[x[0],x[2]] for x in suspended],[[x[0],x[2]] for x in waiting]]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
fixtures = ["[['start','a',['a']*(N+2)],['step'],['urgent','b',['b']],['urgent','c',['c']],['step'],['step'],['step']]", "[['start','a',['a']*N],['start','b',['b']],['start','c',['c']]]+[['step']]*(N+2)", "[['start','a',['a']*N],['urgent','b',['b']],['start','c',['c']],['cancel','a'],['step'],['step']]", "[['start','a',['a']*N],['start','b',['beta']],['start','c',['gamma']],['cancel','b']]", "[['start','a',['a']*N],['urgent','b',['b']],['start','c',['c']],['clear']]", "[['start','a',['a']*N],['urgent','b',['b']],['urgent','c',['c']],['cancel','a']]", "[['start','a',[]],['step']]", "[['start','a',['a']*N],['cancel','a']]"]
expected = {1: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]], 2: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]], 3: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['a', 'a'], ['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]], 4: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['a', 'a'], ['a', 'a'], ['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]], 5: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['a', 'a'], ['a', 'a'], ['a', 'a'], ['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]]}[N]
for i, expression in enumerate(fixtures):
    check("trace-"+str(i+1), solve(eval(expression)), expected[i])
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)

prompt:
The announcement trace violates the stated interrupt-resumption contract.

Speech jobs are [id,words,cursor]. Start queues a new job when one is active. Urgent pushes the current job on a LIFO suspended stack and begins fresh. Step speaks one word and finishes only after its last word; suspended jobs resume before queued normal work. Cancel ID removes it from every location and promotes next available job. Clear discards all jobs without speech. Report emitted [id,word] and current/suspended/waiting IDs with cursors.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(events):
    current=None; suspended=[]; waiting=[]; spoken=[]
    for e in events:
        if e[0] in ('start','urgent'):
            job=[e[1],list(e[2]),0]
            if e[0]=='urgent':
                if current is not None: suspended.append(current)
                current=job
            elif current is None: current=job
            else: waiting.append(job)
        elif e[0]=='cancel':
            if current is not None and current[0]==e[1]: current=None
            suspended=[x for x in suspended if x[0]!=e[1]]
            waiting=[x for x in waiting if x[0]!=e[1]]
        elif e[0]=='clear': current=None; suspended=[]; waiting=[]
        elif e[0]=='step' and current is not None:
            if current[2]<len(current[1]):
                spoken.append([current[0],current[1][current[2]]])
                current[2]+=0
            if current[2]>=len(current[1]): current=None
        if current is None:
            if suspended: current=suspended.pop()
            elif waiting: current=waiting.pop(0)
    return [spoken,None if current is None else [current[0],current[2]],[[x[0],x[2]] for x in suspended],[[x[0],x[2]] for x in waiting]]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
fixtures = ["[['start','a',['a']*(N+2)],['step'],['urgent','b',['b']],['urgent','c',['c']],['step'],['step'],['step']]", "[['start','a',['a']*N],['start','b',['b']],['start','c',['c']]]+[['step']]*(N+2)", "[['start','a',['a']*N],['urgent','b',['b']],['start','c',['c']],['cancel','a'],['step'],['step']]", "[['start','a',['a']*N],['start','b',['beta']],['start','c',['gamma']],['cancel','b']]", "[['start','a',['a']*N],['urgent','b',['b']],['start','c',['c']],['clear']]", "[['start','a',['a']*N],['urgent','b',['b']],['urgent','c',['c']],['cancel','a']]", "[['start','a',[]],['step']]", "[['start','a',['a']*N],['cancel','a']]"]
expected = {1: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]], 2: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]], 3: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['a', 'a'], ['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]], 4: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['a', 'a'], ['a', 'a'], ['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]], 5: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['a', 'a'], ['a', 'a'], ['a', 'a'], ['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]]}[N]
for i, expression in enumerate(fixtures):
    check("trace-"+str(i+1), solve(eval(expression)), expected[i])
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)

source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(events):
    current=None; suspended=[]; waiting=[]; spoken=[]
    for e in events:
        if e[0] in ('start','urgent'):
            job=[e[1],list(e[2]),0]
            if e[0]=='urgent':
                if current is not None: suspended.append(current)
                current=job
            elif current is None: current=job
            else: waiting.append(job)
        elif e[0]=='cancel':
            if current is not None and current[0]==e[1]: current=None
            suspended=[x for x in suspended if x[0]!=e[1]]
            waiting=[x for x in waiting if x[0]!=e[1]]
        elif e[0]=='clear': current=None; suspended=[]; waiting=[]
        elif e[0]=='step' and current is not None:
            if current[2]<len(current[1]):
                spoken.append([current[0],current[1][current[2]]])
                current[2]=len(current[1])
            if current[2]>=len(current[1]): current=None
        if current is None:
            if suspended: current=suspended.pop()
            elif waiting: current=waiting.pop(0)
    return [spoken,None if current is None else [current[0],current[2]],[[x[0],x[2]] for x in suspended],[[x[0],x[2]] for x in waiting]]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
fixtures = ["[['start','a',['a']*(N+2)],['step'],['urgent','b',['b']],['urgent','c',['c']],['step'],['step'],['step']]", "[['start','a',['a']*N],['start','b',['b']],['start','c',['c']]]+[['step']]*(N+2)", "[['start','a',['a']*N],['urgent','b',['b']],['start','c',['c']],['cancel','a'],['step'],['step']]", "[['start','a',['a']*N],['start','b',['beta']],['start','c',['gamma']],['cancel','b']]", "[['start','a',['a']*N],['urgent','b',['b']],['start','c',['c']],['clear']]", "[['start','a',['a']*N],['urgent','b',['b']],['urgent','c',['c']],['cancel','a']]", "[['start','a',[]],['step']]", "[['start','a',['a']*N],['cancel','a']]"]
expected = {1: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]], 2: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]], 3: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['a', 'a'], ['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]], 4: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['a', 'a'], ['a', 'a'], ['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]], 5: [[[['a', 'a'], ['c', 'c'], ['b', 'b'], ['a', 'a']], ['a', 2], [], []], [[['a', 'a'], ['a', 'a'], ['a', 'a'], ['a', 'a'], ['a', 'a'], ['b', 'b'], ['c', 'c']], None, [], []], [[['b', 'b'], ['c', 'c']], None, [], []], [[], ['a', 0], [], [['c', 0]]], [[], None, [], []], [[], ['c', 0], [['b', 0]], []], [[], None, [], []], [[], None, [], []]]}[N]
for i, expression in enumerate(fixtures):
    check("trace-"+str(i+1), solve(eval(expression)), expected[i])
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)

prompt:
The announcement trace violates the stated interrupt-resumption contract.

Speech jobs are [id,words,cursor]. Start queues a new job when one is active. Urgent pushes the current job on a LIFO suspended stack and begins fresh. Step speaks one word and finishes only after its last word; suspended jobs resume before queued normal work. Cancel ID removes it from every location and promotes next available job. Clear discards all jobs without speech. Report emitted [id,word] and current/suspended/waiting IDs with cursors.

split: open-access