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

N = 1
observations = []
def solve(cases):
    def run(c):
        bindings,timeout,events=c
        buffer=[]; pending=None; deadline=None; out=[]
        for kind,key,now in events:
            if kind=='cancel':
                buffer=[]; pending=None; deadline=None
                continue
            if deadline is not None and now>=deadline:
                if pending is not None: out.append([pending,now])
                buffer=[]; pending=None; deadline=None
            if kind!='down': continue
            candidate=buffer+[key]
            candidates=[b for b in bindings if b[0][:len(candidate)]==candidate]
            if not candidates:
                if pending is not None: out.append([pending,now])
                candidate=[key]
                candidates=[b for b in bindings if b[0][:1]==candidate]
                pending=None
            buffer=candidate if candidates else []
            exact=[b for b in candidates if len(b[0])==len(buffer)]
            longer=[b for b in candidates if len(b[0])>len(buffer)]
            if exact and not longer:
                out.append([exact[0][1],now])
                buffer=[]; pending=None; deadline=None
            else:
                pending=exact[0][1] if exact else None
                deadline=now+timeout if candidates else None
        return [out,buffer,pending,deadline]
    return [run(c) for c in cases]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('ambiguous-shortcut-prefix scenario 0', solve([[[[['A'], 'short'], [['A', 'B'], 'long'], [['C'], 'other']], 5, []]] * N), [[[], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 1', solve([[[[['A'], 'short'], [['A', 'B'], 'long'], [['C'], 'other']], 5, [['down', 'A', 10], ['tick', '', 15]]]] * N), [[[['short', 15]], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 2', solve([[[[['A'], 'short'], [['A', 'B'], 'long']], 5, [['down', 'A', 10], ['tick', '', 20]]]] * N), [[[['short', 15]], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 3', solve([[[[['A'], 'short'], [['A', 'B'], 'long']], 5, [['down', 'A', 10], ['down', 'B', 12]]]] * N), [[[['long', 12]], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 4', solve([[[[['A'], 'short'], [['A', 'B'], 'long'], [['C'], 'other']], 5, [['down', 'A', 10], ['down', 'C', 12]]]] * N), [[[['short', 12], ['other', 12]], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 5', solve([[[[['A'], 'short'], [['A', 'B'], 'long']], 5, [['down', 'A', 10], ['cancel', '', 11]]]] * N), [[[], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 6', solve([[[[['A', 'B'], 'long']], 5, [['down', 'A', 10], ['up', 'B', 11]]]] * N), [[[], ['A'], None, 15]] * N)
check('ambiguous-shortcut-prefix scenario 7', solve([[[[['A', 'B'], 'long']], 5, [['down', 'A', 10], ['tick', 'B', 11]]]] * N), [[[], ['A'], None, 15]] * N)
check('ambiguous-shortcut-prefix scenario 8', solve([[[[['A', 'B'], 'long']], 5, [['down', 'Z', 10]]]] * N), [[[], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 9', solve([[[[['A'], 'short'], [['A', 'B'], 'long']], 5, [['down', 'A', 10], ['down', 'B', 15]]]] * N), [[[['short', 15]], [], None, None]] * N)
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(cases):
    def run(c):
        bindings,timeout,events=c
        buffer=[]; pending=None; deadline=None; out=[]
        for kind,key,now in events:
            if kind=='cancel':
                buffer=[]; pending=None; deadline=None
                continue
            if deadline is not None and now>=deadline:
                if pending is not None: out.append([pending,deadline+timeout])
                buffer=[]; pending=None; deadline=None
            if kind!='down': continue
            candidate=buffer+[key]
            candidates=[b for b in bindings if b[0][:len(candidate)]==candidate]
            if not candidates:
                if pending is not None: out.append([pending,now])
                candidate=[key]
                candidates=[b for b in bindings if b[0][:1]==candidate]
                pending=None
            buffer=candidate if candidates else []
            exact=[b for b in candidates if len(b[0])==len(buffer)]
            longer=[b for b in candidates if len(b[0])>len(buffer)]
            if exact and not longer:
                out.append([exact[0][1],now])
                buffer=[]; pending=None; deadline=None
            else:
                pending=exact[0][1] if exact else None
                deadline=now+timeout if candidates else None
        return [out,buffer,pending,deadline]
    return [run(c) for c in cases]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('ambiguous-shortcut-prefix scenario 0', solve([[[[['A'], 'short'], [['A', 'B'], 'long'], [['C'], 'other']], 5, []]] * N), [[[], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 1', solve([[[[['A'], 'short'], [['A', 'B'], 'long'], [['C'], 'other']], 5, [['down', 'A', 10], ['tick', '', 15]]]] * N), [[[['short', 15]], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 2', solve([[[[['A'], 'short'], [['A', 'B'], 'long']], 5, [['down', 'A', 10], ['tick', '', 20]]]] * N), [[[['short', 15]], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 3', solve([[[[['A'], 'short'], [['A', 'B'], 'long']], 5, [['down', 'A', 10], ['down', 'B', 12]]]] * N), [[[['long', 12]], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 4', solve([[[[['A'], 'short'], [['A', 'B'], 'long'], [['C'], 'other']], 5, [['down', 'A', 10], ['down', 'C', 12]]]] * N), [[[['short', 12], ['other', 12]], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 5', solve([[[[['A'], 'short'], [['A', 'B'], 'long']], 5, [['down', 'A', 10], ['cancel', '', 11]]]] * N), [[[], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 6', solve([[[[['A', 'B'], 'long']], 5, [['down', 'A', 10], ['up', 'B', 11]]]] * N), [[[], ['A'], None, 15]] * N)
check('ambiguous-shortcut-prefix scenario 7', solve([[[[['A', 'B'], 'long']], 5, [['down', 'A', 10], ['tick', 'B', 11]]]] * N), [[[], ['A'], None, 15]] * N)
check('ambiguous-shortcut-prefix scenario 8', solve([[[[['A', 'B'], 'long']], 5, [['down', 'Z', 10]]]] * N), [[[], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 9', solve([[[[['A'], 'short'], [['A', 'B'], 'long']], 5, [['down', 'A', 10], ['down', 'B', 15]]]] * N), [[[['short', 15]], [], None, None]] * N)
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 event trace violates the timeout timestamp rule and produces incorrect keyboard state or command output.

Case [bindings,timeout,events]. Binding [nonempty_key_sequence,action] has unique sequence. Events [kind,key,time]. Down extends prefix. Exact match with longer candidates is delayed until deadline; exact unambiguous match dispatches immediately. Tick or next event at deadline emits pending exact match and clears prefix. Mismatch dispatches pending match then retries only current key as fresh prefix. Cancel drops pending without dispatch. Return [action,time] dispatches,buffer,pending action,deadline. Inputs are finite ordered event traces; return the stated deterministic state. Batch entries are independent. N varies the number of independent input transactions.

split: open-access


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

N = 1
observations = []
def solve(cases):
    def run(c):
        bindings,timeout,events=c
        buffer=[]; pending=None; deadline=None; out=[]
        for kind,key,now in events:
            if kind=='cancel':
                buffer=[]; pending=None; deadline=None
                continue
            if deadline is not None and now>=deadline:
                if pending is not None: out.append([pending,deadline])
                buffer=[]; pending=None; deadline=None
            if kind=='cancel': continue
            candidate=buffer+[key]
            candidates=[b for b in bindings if b[0][:len(candidate)]==candidate]
            if not candidates:
                if pending is not None: out.append([pending,now])
                candidate=[key]
                candidates=[b for b in bindings if b[0][:1]==candidate]
                pending=None
            buffer=candidate if candidates else []
            exact=[b for b in candidates if len(b[0])==len(buffer)]
            longer=[b for b in candidates if len(b[0])>len(buffer)]
            if exact and not longer:
                out.append([exact[0][1],now])
                buffer=[]; pending=None; deadline=None
            else:
                pending=exact[0][1] if exact else None
                deadline=now+timeout if candidates else None
        return [out,buffer,pending,deadline]
    return [run(c) for c in cases]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('ambiguous-shortcut-prefix scenario 0', solve([[[[['A'], 'short'], [['A', 'B'], 'long'], [['C'], 'other']], 5, []]] * N), [[[], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 1', solve([[[[['A'], 'short'], [['A', 'B'], 'long'], [['C'], 'other']], 5, [['down', 'A', 10], ['tick', '', 15]]]] * N), [[[['short', 15]], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 2', solve([[[[['A'], 'short'], [['A', 'B'], 'long']], 5, [['down', 'A', 10], ['tick', '', 20]]]] * N), [[[['short', 15]], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 3', solve([[[[['A'], 'short'], [['A', 'B'], 'long']], 5, [['down', 'A', 10], ['down', 'B', 12]]]] * N), [[[['long', 12]], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 4', solve([[[[['A'], 'short'], [['A', 'B'], 'long'], [['C'], 'other']], 5, [['down', 'A', 10], ['down', 'C', 12]]]] * N), [[[['short', 12], ['other', 12]], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 5', solve([[[[['A'], 'short'], [['A', 'B'], 'long']], 5, [['down', 'A', 10], ['cancel', '', 11]]]] * N), [[[], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 6', solve([[[[['A', 'B'], 'long']], 5, [['down', 'A', 10], ['up', 'B', 11]]]] * N), [[[], ['A'], None, 15]] * N)
check('ambiguous-shortcut-prefix scenario 7', solve([[[[['A', 'B'], 'long']], 5, [['down', 'A', 10], ['tick', 'B', 11]]]] * N), [[[], ['A'], None, 15]] * N)
check('ambiguous-shortcut-prefix scenario 8', solve([[[[['A', 'B'], 'long']], 5, [['down', 'Z', 10]]]] * N), [[[], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 9', solve([[[[['A'], 'short'], [['A', 'B'], 'long']], 5, [['down', 'A', 10], ['down', 'B', 15]]]] * N), [[[['short', 15]], [], None, None]] * N)
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(cases):
    def run(c):
        bindings,timeout,events=c
        buffer=[]; pending=None; deadline=None; out=[]
        for kind,key,now in events:
            if kind=='cancel':
                buffer=[]; pending=None; deadline=None
                continue
            if deadline is not None and now>=deadline:
                if pending is not None: out.append([pending,deadline])
                buffer=[]; pending=None; deadline=None
            if kind=='up': continue
            candidate=buffer+[key]
            candidates=[b for b in bindings if b[0][:len(candidate)]==candidate]
            if not candidates:
                if pending is not None: out.append([pending,now])
                candidate=[key]
                candidates=[b for b in bindings if b[0][:1]==candidate]
                pending=None
            buffer=candidate if candidates else []
            exact=[b for b in candidates if len(b[0])==len(buffer)]
            longer=[b for b in candidates if len(b[0])>len(buffer)]
            if exact and not longer:
                out.append([exact[0][1],now])
                buffer=[]; pending=None; deadline=None
            else:
                pending=exact[0][1] if exact else None
                deadline=now+timeout if candidates else None
        return [out,buffer,pending,deadline]
    return [run(c) for c in cases]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('ambiguous-shortcut-prefix scenario 0', solve([[[[['A'], 'short'], [['A', 'B'], 'long'], [['C'], 'other']], 5, []]] * N), [[[], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 1', solve([[[[['A'], 'short'], [['A', 'B'], 'long'], [['C'], 'other']], 5, [['down', 'A', 10], ['tick', '', 15]]]] * N), [[[['short', 15]], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 2', solve([[[[['A'], 'short'], [['A', 'B'], 'long']], 5, [['down', 'A', 10], ['tick', '', 20]]]] * N), [[[['short', 15]], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 3', solve([[[[['A'], 'short'], [['A', 'B'], 'long']], 5, [['down', 'A', 10], ['down', 'B', 12]]]] * N), [[[['long', 12]], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 4', solve([[[[['A'], 'short'], [['A', 'B'], 'long'], [['C'], 'other']], 5, [['down', 'A', 10], ['down', 'C', 12]]]] * N), [[[['short', 12], ['other', 12]], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 5', solve([[[[['A'], 'short'], [['A', 'B'], 'long']], 5, [['down', 'A', 10], ['cancel', '', 11]]]] * N), [[[], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 6', solve([[[[['A', 'B'], 'long']], 5, [['down', 'A', 10], ['up', 'B', 11]]]] * N), [[[], ['A'], None, 15]] * N)
check('ambiguous-shortcut-prefix scenario 7', solve([[[[['A', 'B'], 'long']], 5, [['down', 'A', 10], ['tick', 'B', 11]]]] * N), [[[], ['A'], None, 15]] * N)
check('ambiguous-shortcut-prefix scenario 8', solve([[[[['A', 'B'], 'long']], 5, [['down', 'Z', 10]]]] * N), [[[], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 9', solve([[[[['A'], 'short'], [['A', 'B'], 'long']], 5, [['down', 'A', 10], ['down', 'B', 15]]]] * N), [[[['short', 15]], [], None, None]] * N)
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 event trace violates the phase filter rule and produces incorrect keyboard state or command output.

Case [bindings,timeout,events]. Binding [nonempty_key_sequence,action] has unique sequence. Events [kind,key,time]. Down extends prefix. Exact match with longer candidates is delayed until deadline; exact unambiguous match dispatches immediately. Tick or next event at deadline emits pending exact match and clears prefix. Mismatch dispatches pending match then retries only current key as fresh prefix. Cancel drops pending without dispatch. Return [action,time] dispatches,buffer,pending action,deadline. Inputs are finite ordered event traces; return the stated deterministic state. Batch entries are independent. N varies the number of independent input transactions.

split: open-access


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

N = 1
observations = []
def solve(cases):
    def run(c):
        bindings,timeout,events=c
        buffer=[]; pending=None; deadline=None; out=[]
        for kind,key,now in events:
            if kind=='cancel':
                buffer=[]; pending=None; deadline=None
                continue
            if deadline is not None and now>=deadline:
                if pending is not None: out.append([pending,deadline])
                buffer=[]; pending=None; deadline=None
            if kind!='down': continue
            candidate=[key]+buffer
            candidates=[b for b in bindings if b[0][:len(candidate)]==candidate]
            if not candidates:
                if pending is not None: out.append([pending,now])
                candidate=[key]
                candidates=[b for b in bindings if b[0][:1]==candidate]
                pending=None
            buffer=candidate if candidates else []
            exact=[b for b in candidates if len(b[0])==len(buffer)]
            longer=[b for b in candidates if len(b[0])>len(buffer)]
            if exact and not longer:
                out.append([exact[0][1],now])
                buffer=[]; pending=None; deadline=None
            else:
                pending=exact[0][1] if exact else None
                deadline=now+timeout if candidates else None
        return [out,buffer,pending,deadline]
    return [run(c) for c in cases]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('ambiguous-shortcut-prefix scenario 0', solve([[[[['A'], 'short'], [['A', 'B'], 'long'], [['C'], 'other']], 5, []]] * N), [[[], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 1', solve([[[[['A'], 'short'], [['A', 'B'], 'long'], [['C'], 'other']], 5, [['down', 'A', 10], ['tick', '', 15]]]] * N), [[[['short', 15]], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 2', solve([[[[['A'], 'short'], [['A', 'B'], 'long']], 5, [['down', 'A', 10], ['tick', '', 20]]]] * N), [[[['short', 15]], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 3', solve([[[[['A'], 'short'], [['A', 'B'], 'long']], 5, [['down', 'A', 10], ['down', 'B', 12]]]] * N), [[[['long', 12]], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 4', solve([[[[['A'], 'short'], [['A', 'B'], 'long'], [['C'], 'other']], 5, [['down', 'A', 10], ['down', 'C', 12]]]] * N), [[[['short', 12], ['other', 12]], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 5', solve([[[[['A'], 'short'], [['A', 'B'], 'long']], 5, [['down', 'A', 10], ['cancel', '', 11]]]] * N), [[[], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 6', solve([[[[['A', 'B'], 'long']], 5, [['down', 'A', 10], ['up', 'B', 11]]]] * N), [[[], ['A'], None, 15]] * N)
check('ambiguous-shortcut-prefix scenario 7', solve([[[[['A', 'B'], 'long']], 5, [['down', 'A', 10], ['tick', 'B', 11]]]] * N), [[[], ['A'], None, 15]] * N)
check('ambiguous-shortcut-prefix scenario 8', solve([[[[['A', 'B'], 'long']], 5, [['down', 'Z', 10]]]] * N), [[[], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 9', solve([[[[['A'], 'short'], [['A', 'B'], 'long']], 5, [['down', 'A', 10], ['down', 'B', 15]]]] * N), [[[['short', 15]], [], None, None]] * N)
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(cases):
    def run(c):
        bindings,timeout,events=c
        buffer=[]; pending=None; deadline=None; out=[]
        for kind,key,now in events:
            if kind=='cancel':
                buffer=[]; pending=None; deadline=None
                continue
            if deadline is not None and now>=deadline:
                if pending is not None: out.append([pending,deadline])
                buffer=[]; pending=None; deadline=None
            if kind!='down': continue
            candidate=[key]
            candidates=[b for b in bindings if b[0][:len(candidate)]==candidate]
            if not candidates:
                if pending is not None: out.append([pending,now])
                candidate=[key]
                candidates=[b for b in bindings if b[0][:1]==candidate]
                pending=None
            buffer=candidate if candidates else []
            exact=[b for b in candidates if len(b[0])==len(buffer)]
            longer=[b for b in candidates if len(b[0])>len(buffer)]
            if exact and not longer:
                out.append([exact[0][1],now])
                buffer=[]; pending=None; deadline=None
            else:
                pending=exact[0][1] if exact else None
                deadline=now+timeout if candidates else None
        return [out,buffer,pending,deadline]
    return [run(c) for c in cases]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('ambiguous-shortcut-prefix scenario 0', solve([[[[['A'], 'short'], [['A', 'B'], 'long'], [['C'], 'other']], 5, []]] * N), [[[], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 1', solve([[[[['A'], 'short'], [['A', 'B'], 'long'], [['C'], 'other']], 5, [['down', 'A', 10], ['tick', '', 15]]]] * N), [[[['short', 15]], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 2', solve([[[[['A'], 'short'], [['A', 'B'], 'long']], 5, [['down', 'A', 10], ['tick', '', 20]]]] * N), [[[['short', 15]], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 3', solve([[[[['A'], 'short'], [['A', 'B'], 'long']], 5, [['down', 'A', 10], ['down', 'B', 12]]]] * N), [[[['long', 12]], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 4', solve([[[[['A'], 'short'], [['A', 'B'], 'long'], [['C'], 'other']], 5, [['down', 'A', 10], ['down', 'C', 12]]]] * N), [[[['short', 12], ['other', 12]], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 5', solve([[[[['A'], 'short'], [['A', 'B'], 'long']], 5, [['down', 'A', 10], ['cancel', '', 11]]]] * N), [[[], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 6', solve([[[[['A', 'B'], 'long']], 5, [['down', 'A', 10], ['up', 'B', 11]]]] * N), [[[], ['A'], None, 15]] * N)
check('ambiguous-shortcut-prefix scenario 7', solve([[[[['A', 'B'], 'long']], 5, [['down', 'A', 10], ['tick', 'B', 11]]]] * N), [[[], ['A'], None, 15]] * N)
check('ambiguous-shortcut-prefix scenario 8', solve([[[[['A', 'B'], 'long']], 5, [['down', 'Z', 10]]]] * N), [[[], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 9', solve([[[[['A'], 'short'], [['A', 'B'], 'long']], 5, [['down', 'A', 10], ['down', 'B', 15]]]] * N), [[[['short', 15]], [], None, None]] * N)
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 event trace violates the prefix extension rule and produces incorrect keyboard state or command output.

Case [bindings,timeout,events]. Binding [nonempty_key_sequence,action] has unique sequence. Events [kind,key,time]. Down extends prefix. Exact match with longer candidates is delayed until deadline; exact unambiguous match dispatches immediately. Tick or next event at deadline emits pending exact match and clears prefix. Mismatch dispatches pending match then retries only current key as fresh prefix. Cancel drops pending without dispatch. Return [action,time] dispatches,buffer,pending action,deadline. Inputs are finite ordered event traces; return the stated deterministic state. Batch entries are independent. N varies the number of independent input transactions.

split: open-access


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

N = 1
observations = []
def solve(cases):
    def run(c):
        bindings,timeout,events=c
        buffer=[]; pending=None; deadline=None; out=[]
        for kind,key,now in events:
            if kind=='cancel':
                buffer=[]; pending=None; deadline=None
                continue
            if deadline is not None and now>=deadline:
                if pending is not None: out.append([pending,deadline])
                buffer=[]; pending=None; deadline=None
            if kind!='down': continue
            candidate=buffer+[key]
            candidates=[b for b in bindings if b[0][-len(candidate):]==candidate]
            if not candidates:
                if pending is not None: out.append([pending,now])
                candidate=[key]
                candidates=[b for b in bindings if b[0][:1]==candidate]
                pending=None
            buffer=candidate if candidates else []
            exact=[b for b in candidates if len(b[0])==len(buffer)]
            longer=[b for b in candidates if len(b[0])>len(buffer)]
            if exact and not longer:
                out.append([exact[0][1],now])
                buffer=[]; pending=None; deadline=None
            else:
                pending=exact[0][1] if exact else None
                deadline=now+timeout if candidates else None
        return [out,buffer,pending,deadline]
    return [run(c) for c in cases]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('ambiguous-shortcut-prefix scenario 0', solve([[[[['A'], 'short'], [['A', 'B'], 'long'], [['C'], 'other']], 5, []]] * N), [[[], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 1', solve([[[[['A'], 'short'], [['A', 'B'], 'long'], [['C'], 'other']], 5, [['down', 'A', 10], ['tick', '', 15]]]] * N), [[[['short', 15]], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 2', solve([[[[['A'], 'short'], [['A', 'B'], 'long']], 5, [['down', 'A', 10], ['tick', '', 20]]]] * N), [[[['short', 15]], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 3', solve([[[[['A'], 'short'], [['A', 'B'], 'long']], 5, [['down', 'A', 10], ['down', 'B', 12]]]] * N), [[[['long', 12]], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 4', solve([[[[['A'], 'short'], [['A', 'B'], 'long'], [['C'], 'other']], 5, [['down', 'A', 10], ['down', 'C', 12]]]] * N), [[[['short', 12], ['other', 12]], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 5', solve([[[[['A'], 'short'], [['A', 'B'], 'long']], 5, [['down', 'A', 10], ['cancel', '', 11]]]] * N), [[[], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 6', solve([[[[['A', 'B'], 'long']], 5, [['down', 'A', 10], ['up', 'B', 11]]]] * N), [[[], ['A'], None, 15]] * N)
check('ambiguous-shortcut-prefix scenario 7', solve([[[[['A', 'B'], 'long']], 5, [['down', 'A', 10], ['tick', 'B', 11]]]] * N), [[[], ['A'], None, 15]] * N)
check('ambiguous-shortcut-prefix scenario 8', solve([[[[['A', 'B'], 'long']], 5, [['down', 'Z', 10]]]] * N), [[[], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 9', solve([[[[['A'], 'short'], [['A', 'B'], 'long']], 5, [['down', 'A', 10], ['down', 'B', 15]]]] * N), [[[['short', 15]], [], None, None]] * N)
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(cases):
    def run(c):
        bindings,timeout,events=c
        buffer=[]; pending=None; deadline=None; out=[]
        for kind,key,now in events:
            if kind=='cancel':
                buffer=[]; pending=None; deadline=None
                continue
            if deadline is not None and now>=deadline:
                if pending is not None: out.append([pending,deadline])
                buffer=[]; pending=None; deadline=None
            if kind!='down': continue
            candidate=buffer+[key]
            candidates=[b for b in bindings if b[0]==candidate]
            if not candidates:
                if pending is not None: out.append([pending,now])
                candidate=[key]
                candidates=[b for b in bindings if b[0][:1]==candidate]
                pending=None
            buffer=candidate if candidates else []
            exact=[b for b in candidates if len(b[0])==len(buffer)]
            longer=[b for b in candidates if len(b[0])>len(buffer)]
            if exact and not longer:
                out.append([exact[0][1],now])
                buffer=[]; pending=None; deadline=None
            else:
                pending=exact[0][1] if exact else None
                deadline=now+timeout if candidates else None
        return [out,buffer,pending,deadline]
    return [run(c) for c in cases]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('ambiguous-shortcut-prefix scenario 0', solve([[[[['A'], 'short'], [['A', 'B'], 'long'], [['C'], 'other']], 5, []]] * N), [[[], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 1', solve([[[[['A'], 'short'], [['A', 'B'], 'long'], [['C'], 'other']], 5, [['down', 'A', 10], ['tick', '', 15]]]] * N), [[[['short', 15]], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 2', solve([[[[['A'], 'short'], [['A', 'B'], 'long']], 5, [['down', 'A', 10], ['tick', '', 20]]]] * N), [[[['short', 15]], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 3', solve([[[[['A'], 'short'], [['A', 'B'], 'long']], 5, [['down', 'A', 10], ['down', 'B', 12]]]] * N), [[[['long', 12]], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 4', solve([[[[['A'], 'short'], [['A', 'B'], 'long'], [['C'], 'other']], 5, [['down', 'A', 10], ['down', 'C', 12]]]] * N), [[[['short', 12], ['other', 12]], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 5', solve([[[[['A'], 'short'], [['A', 'B'], 'long']], 5, [['down', 'A', 10], ['cancel', '', 11]]]] * N), [[[], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 6', solve([[[[['A', 'B'], 'long']], 5, [['down', 'A', 10], ['up', 'B', 11]]]] * N), [[[], ['A'], None, 15]] * N)
check('ambiguous-shortcut-prefix scenario 7', solve([[[[['A', 'B'], 'long']], 5, [['down', 'A', 10], ['tick', 'B', 11]]]] * N), [[[], ['A'], None, 15]] * N)
check('ambiguous-shortcut-prefix scenario 8', solve([[[[['A', 'B'], 'long']], 5, [['down', 'Z', 10]]]] * N), [[[], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 9', solve([[[[['A'], 'short'], [['A', 'B'], 'long']], 5, [['down', 'A', 10], ['down', 'B', 15]]]] * N), [[[['short', 15]], [], None, None]] * N)
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 event trace violates the prefix candidate rule and produces incorrect keyboard state or command output.

Case [bindings,timeout,events]. Binding [nonempty_key_sequence,action] has unique sequence. Events [kind,key,time]. Down extends prefix. Exact match with longer candidates is delayed until deadline; exact unambiguous match dispatches immediately. Tick or next event at deadline emits pending exact match and clears prefix. Mismatch dispatches pending match then retries only current key as fresh prefix. Cancel drops pending without dispatch. Return [action,time] dispatches,buffer,pending action,deadline. Inputs are finite ordered event traces; return the stated deterministic state. Batch entries are independent. N varies the number of independent input transactions.

split: open-access


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

N = 1
observations = []
def solve(cases):
    def run(c):
        bindings,timeout,events=c
        buffer=[]; pending=None; deadline=None; out=[]
        for kind,key,now in events:
            if kind=='cancel':
                buffer=[]; pending=None; deadline=None
                continue
            if deadline is not None and now>=deadline:
                if pending is not None: out.append([pending,deadline])
                buffer=[]; pending=None; deadline=None
            if kind!='down': continue
            candidate=buffer+[key]
            candidates=[b for b in bindings if b[0][:len(candidate)]==candidate]
            if not candidates:
                if pending is not None: out.append([pending,deadline])
                candidate=[key]
                candidates=[b for b in bindings if b[0][:1]==candidate]
                pending=None
            buffer=candidate if candidates else []
            exact=[b for b in candidates if len(b[0])==len(buffer)]
            longer=[b for b in candidates if len(b[0])>len(buffer)]
            if exact and not longer:
                out.append([exact[0][1],now])
                buffer=[]; pending=None; deadline=None
            else:
                pending=exact[0][1] if exact else None
                deadline=now+timeout if candidates else None
        return [out,buffer,pending,deadline]
    return [run(c) for c in cases]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('ambiguous-shortcut-prefix scenario 0', solve([[[[['A'], 'short'], [['A', 'B'], 'long'], [['C'], 'other']], 5, []]] * N), [[[], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 1', solve([[[[['A'], 'short'], [['A', 'B'], 'long'], [['C'], 'other']], 5, [['down', 'A', 10], ['tick', '', 15]]]] * N), [[[['short', 15]], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 2', solve([[[[['A'], 'short'], [['A', 'B'], 'long']], 5, [['down', 'A', 10], ['tick', '', 20]]]] * N), [[[['short', 15]], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 3', solve([[[[['A'], 'short'], [['A', 'B'], 'long']], 5, [['down', 'A', 10], ['down', 'B', 12]]]] * N), [[[['long', 12]], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 4', solve([[[[['A'], 'short'], [['A', 'B'], 'long'], [['C'], 'other']], 5, [['down', 'A', 10], ['down', 'C', 12]]]] * N), [[[['short', 12], ['other', 12]], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 5', solve([[[[['A'], 'short'], [['A', 'B'], 'long']], 5, [['down', 'A', 10], ['cancel', '', 11]]]] * N), [[[], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 6', solve([[[[['A', 'B'], 'long']], 5, [['down', 'A', 10], ['up', 'B', 11]]]] * N), [[[], ['A'], None, 15]] * N)
check('ambiguous-shortcut-prefix scenario 7', solve([[[[['A', 'B'], 'long']], 5, [['down', 'A', 10], ['tick', 'B', 11]]]] * N), [[[], ['A'], None, 15]] * N)
check('ambiguous-shortcut-prefix scenario 8', solve([[[[['A', 'B'], 'long']], 5, [['down', 'Z', 10]]]] * N), [[[], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 9', solve([[[[['A'], 'short'], [['A', 'B'], 'long']], 5, [['down', 'A', 10], ['down', 'B', 15]]]] * N), [[[['short', 15]], [], None, None]] * N)
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(cases):
    def run(c):
        bindings,timeout,events=c
        buffer=[]; pending=None; deadline=None; out=[]
        for kind,key,now in events:
            if kind=='cancel':
                buffer=[]; pending=None; deadline=None
                continue
            if deadline is not None and now>=deadline:
                if pending is not None: out.append([pending,deadline])
                buffer=[]; pending=None; deadline=None
            if kind!='down': continue
            candidate=buffer+[key]
            candidates=[b for b in bindings if b[0][:len(candidate)]==candidate]
            if not candidates:
                if pending is not None: out.append([key,now])
                candidate=[key]
                candidates=[b for b in bindings if b[0][:1]==candidate]
                pending=None
            buffer=candidate if candidates else []
            exact=[b for b in candidates if len(b[0])==len(buffer)]
            longer=[b for b in candidates if len(b[0])>len(buffer)]
            if exact and not longer:
                out.append([exact[0][1],now])
                buffer=[]; pending=None; deadline=None
            else:
                pending=exact[0][1] if exact else None
                deadline=now+timeout if candidates else None
        return [out,buffer,pending,deadline]
    return [run(c) for c in cases]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('ambiguous-shortcut-prefix scenario 0', solve([[[[['A'], 'short'], [['A', 'B'], 'long'], [['C'], 'other']], 5, []]] * N), [[[], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 1', solve([[[[['A'], 'short'], [['A', 'B'], 'long'], [['C'], 'other']], 5, [['down', 'A', 10], ['tick', '', 15]]]] * N), [[[['short', 15]], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 2', solve([[[[['A'], 'short'], [['A', 'B'], 'long']], 5, [['down', 'A', 10], ['tick', '', 20]]]] * N), [[[['short', 15]], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 3', solve([[[[['A'], 'short'], [['A', 'B'], 'long']], 5, [['down', 'A', 10], ['down', 'B', 12]]]] * N), [[[['long', 12]], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 4', solve([[[[['A'], 'short'], [['A', 'B'], 'long'], [['C'], 'other']], 5, [['down', 'A', 10], ['down', 'C', 12]]]] * N), [[[['short', 12], ['other', 12]], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 5', solve([[[[['A'], 'short'], [['A', 'B'], 'long']], 5, [['down', 'A', 10], ['cancel', '', 11]]]] * N), [[[], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 6', solve([[[[['A', 'B'], 'long']], 5, [['down', 'A', 10], ['up', 'B', 11]]]] * N), [[[], ['A'], None, 15]] * N)
check('ambiguous-shortcut-prefix scenario 7', solve([[[[['A', 'B'], 'long']], 5, [['down', 'A', 10], ['tick', 'B', 11]]]] * N), [[[], ['A'], None, 15]] * N)
check('ambiguous-shortcut-prefix scenario 8', solve([[[[['A', 'B'], 'long']], 5, [['down', 'Z', 10]]]] * N), [[[], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 9', solve([[[[['A'], 'short'], [['A', 'B'], 'long']], 5, [['down', 'A', 10], ['down', 'B', 15]]]] * N), [[[['short', 15]], [], None, None]] * N)
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 event trace violates the mismatch pending rule and produces incorrect keyboard state or command output.

Case [bindings,timeout,events]. Binding [nonempty_key_sequence,action] has unique sequence. Events [kind,key,time]. Down extends prefix. Exact match with longer candidates is delayed until deadline; exact unambiguous match dispatches immediately. Tick or next event at deadline emits pending exact match and clears prefix. Mismatch dispatches pending match then retries only current key as fresh prefix. Cancel drops pending without dispatch. Return [action,time] dispatches,buffer,pending action,deadline. Inputs are finite ordered event traces; return the stated deterministic state. Batch entries are independent. N varies the number of independent input transactions.

split: open-access


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

N = 1
observations = []
def solve(cases):
    def run(c):
        bindings,timeout,events=c
        buffer=[]; pending=None; deadline=None; out=[]
        for kind,key,now in events:
            if kind=='cancel':
                buffer=[]; pending=None; deadline=None
                continue
            if deadline is not None and now>=deadline:
                if pending is not None: out.append([pending,deadline])
                buffer=[]; pending=None; deadline=None
            if kind!='down': continue
            candidate=buffer+[key]
            candidates=[b for b in bindings if b[0][:len(candidate)]==candidate]
            if not candidates:
                if pending is not None: out.append([pending,now])
                candidate=[]
                candidates=[b for b in bindings if b[0][:1]==candidate]
                pending=None
            buffer=candidate if candidates else []
            exact=[b for b in candidates if len(b[0])==len(buffer)]
            longer=[b for b in candidates if len(b[0])>len(buffer)]
            if exact and not longer:
                out.append([exact[0][1],now])
                buffer=[]; pending=None; deadline=None
            else:
                pending=exact[0][1] if exact else None
                deadline=now+timeout if candidates else None
        return [out,buffer,pending,deadline]
    return [run(c) for c in cases]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('ambiguous-shortcut-prefix scenario 0', solve([[[[['A'], 'short'], [['A', 'B'], 'long'], [['C'], 'other']], 5, []]] * N), [[[], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 1', solve([[[[['A'], 'short'], [['A', 'B'], 'long'], [['C'], 'other']], 5, [['down', 'A', 10], ['tick', '', 15]]]] * N), [[[['short', 15]], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 2', solve([[[[['A'], 'short'], [['A', 'B'], 'long']], 5, [['down', 'A', 10], ['tick', '', 20]]]] * N), [[[['short', 15]], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 3', solve([[[[['A'], 'short'], [['A', 'B'], 'long']], 5, [['down', 'A', 10], ['down', 'B', 12]]]] * N), [[[['long', 12]], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 4', solve([[[[['A'], 'short'], [['A', 'B'], 'long'], [['C'], 'other']], 5, [['down', 'A', 10], ['down', 'C', 12]]]] * N), [[[['short', 12], ['other', 12]], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 5', solve([[[[['A'], 'short'], [['A', 'B'], 'long']], 5, [['down', 'A', 10], ['cancel', '', 11]]]] * N), [[[], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 6', solve([[[[['A', 'B'], 'long']], 5, [['down', 'A', 10], ['up', 'B', 11]]]] * N), [[[], ['A'], None, 15]] * N)
check('ambiguous-shortcut-prefix scenario 7', solve([[[[['A', 'B'], 'long']], 5, [['down', 'A', 10], ['tick', 'B', 11]]]] * N), [[[], ['A'], None, 15]] * N)
check('ambiguous-shortcut-prefix scenario 8', solve([[[[['A', 'B'], 'long']], 5, [['down', 'Z', 10]]]] * N), [[[], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 9', solve([[[[['A'], 'short'], [['A', 'B'], 'long']], 5, [['down', 'A', 10], ['down', 'B', 15]]]] * N), [[[['short', 15]], [], None, None]] * N)
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(cases):
    def run(c):
        bindings,timeout,events=c
        buffer=[]; pending=None; deadline=None; out=[]
        for kind,key,now in events:
            if kind=='cancel':
                buffer=[]; pending=None; deadline=None
                continue
            if deadline is not None and now>=deadline:
                if pending is not None: out.append([pending,deadline])
                buffer=[]; pending=None; deadline=None
            if kind!='down': continue
            candidate=buffer+[key]
            candidates=[b for b in bindings if b[0][:len(candidate)]==candidate]
            if not candidates:
                if pending is not None: out.append([pending,now])
                candidate=buffer+[key]
                candidates=[b for b in bindings if b[0][:1]==candidate]
                pending=None
            buffer=candidate if candidates else []
            exact=[b for b in candidates if len(b[0])==len(buffer)]
            longer=[b for b in candidates if len(b[0])>len(buffer)]
            if exact and not longer:
                out.append([exact[0][1],now])
                buffer=[]; pending=None; deadline=None
            else:
                pending=exact[0][1] if exact else None
                deadline=now+timeout if candidates else None
        return [out,buffer,pending,deadline]
    return [run(c) for c in cases]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('ambiguous-shortcut-prefix scenario 0', solve([[[[['A'], 'short'], [['A', 'B'], 'long'], [['C'], 'other']], 5, []]] * N), [[[], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 1', solve([[[[['A'], 'short'], [['A', 'B'], 'long'], [['C'], 'other']], 5, [['down', 'A', 10], ['tick', '', 15]]]] * N), [[[['short', 15]], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 2', solve([[[[['A'], 'short'], [['A', 'B'], 'long']], 5, [['down', 'A', 10], ['tick', '', 20]]]] * N), [[[['short', 15]], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 3', solve([[[[['A'], 'short'], [['A', 'B'], 'long']], 5, [['down', 'A', 10], ['down', 'B', 12]]]] * N), [[[['long', 12]], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 4', solve([[[[['A'], 'short'], [['A', 'B'], 'long'], [['C'], 'other']], 5, [['down', 'A', 10], ['down', 'C', 12]]]] * N), [[[['short', 12], ['other', 12]], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 5', solve([[[[['A'], 'short'], [['A', 'B'], 'long']], 5, [['down', 'A', 10], ['cancel', '', 11]]]] * N), [[[], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 6', solve([[[[['A', 'B'], 'long']], 5, [['down', 'A', 10], ['up', 'B', 11]]]] * N), [[[], ['A'], None, 15]] * N)
check('ambiguous-shortcut-prefix scenario 7', solve([[[[['A', 'B'], 'long']], 5, [['down', 'A', 10], ['tick', 'B', 11]]]] * N), [[[], ['A'], None, 15]] * N)
check('ambiguous-shortcut-prefix scenario 8', solve([[[[['A', 'B'], 'long']], 5, [['down', 'Z', 10]]]] * N), [[[], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 9', solve([[[[['A'], 'short'], [['A', 'B'], 'long']], 5, [['down', 'A', 10], ['down', 'B', 15]]]] * N), [[[['short', 15]], [], None, None]] * N)
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 event trace violates the retry current rule and produces incorrect keyboard state or command output.

Case [bindings,timeout,events]. Binding [nonempty_key_sequence,action] has unique sequence. Events [kind,key,time]. Down extends prefix. Exact match with longer candidates is delayed until deadline; exact unambiguous match dispatches immediately. Tick or next event at deadline emits pending exact match and clears prefix. Mismatch dispatches pending match then retries only current key as fresh prefix. Cancel drops pending without dispatch. Return [action,time] dispatches,buffer,pending action,deadline. Inputs are finite ordered event traces; return the stated deterministic state. Batch entries are independent. N varies the number of independent input transactions.

split: open-access


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

N = 1
observations = []
def solve(cases):
    def run(c):
        bindings,timeout,events=c
        buffer=[]; pending=None; deadline=None; out=[]
        for kind,key,now in events:
            if kind=='cancel':
                buffer=[]; pending=None; deadline=None
                continue
            if deadline is not None and now>=deadline:
                if pending is not None: out.append([pending,deadline])
                buffer=[]; pending=None; deadline=None
            if kind!='down': continue
            candidate=buffer+[key]
            candidates=[b for b in bindings if b[0][:len(candidate)]==candidate]
            if not candidates:
                if pending is not None: out.append([pending,now])
                candidate=[key]
                candidates=[b for b in bindings if b[0][:1]==candidate]
                pending=None
            buffer=candidate if candidates else []
            exact=[b for b in candidates if len(b[0])==len(buffer)]
            longer=[b for b in candidates if len(b[0])>=len(buffer)]
            if exact and not longer:
                out.append([exact[0][1],now])
                buffer=[]; pending=None; deadline=None
            else:
                pending=exact[0][1] if exact else None
                deadline=now+timeout if candidates else None
        return [out,buffer,pending,deadline]
    return [run(c) for c in cases]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('ambiguous-shortcut-prefix scenario 0', solve([[[[['A'], 'short'], [['A', 'B'], 'long'], [['C'], 'other']], 5, []]] * N), [[[], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 1', solve([[[[['A'], 'short'], [['A', 'B'], 'long'], [['C'], 'other']], 5, [['down', 'A', 10], ['tick', '', 15]]]] * N), [[[['short', 15]], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 2', solve([[[[['A'], 'short'], [['A', 'B'], 'long']], 5, [['down', 'A', 10], ['tick', '', 20]]]] * N), [[[['short', 15]], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 3', solve([[[[['A'], 'short'], [['A', 'B'], 'long']], 5, [['down', 'A', 10], ['down', 'B', 12]]]] * N), [[[['long', 12]], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 4', solve([[[[['A'], 'short'], [['A', 'B'], 'long'], [['C'], 'other']], 5, [['down', 'A', 10], ['down', 'C', 12]]]] * N), [[[['short', 12], ['other', 12]], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 5', solve([[[[['A'], 'short'], [['A', 'B'], 'long']], 5, [['down', 'A', 10], ['cancel', '', 11]]]] * N), [[[], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 6', solve([[[[['A', 'B'], 'long']], 5, [['down', 'A', 10], ['up', 'B', 11]]]] * N), [[[], ['A'], None, 15]] * N)
check('ambiguous-shortcut-prefix scenario 7', solve([[[[['A', 'B'], 'long']], 5, [['down', 'A', 10], ['tick', 'B', 11]]]] * N), [[[], ['A'], None, 15]] * N)
check('ambiguous-shortcut-prefix scenario 8', solve([[[[['A', 'B'], 'long']], 5, [['down', 'Z', 10]]]] * N), [[[], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 9', solve([[[[['A'], 'short'], [['A', 'B'], 'long']], 5, [['down', 'A', 10], ['down', 'B', 15]]]] * N), [[[['short', 15]], [], None, None]] * N)
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(cases):
    def run(c):
        bindings,timeout,events=c
        buffer=[]; pending=None; deadline=None; out=[]
        for kind,key,now in events:
            if kind=='cancel':
                buffer=[]; pending=None; deadline=None
                continue
            if deadline is not None and now>=deadline:
                if pending is not None: out.append([pending,deadline])
                buffer=[]; pending=None; deadline=None
            if kind!='down': continue
            candidate=buffer+[key]
            candidates=[b for b in bindings if b[0][:len(candidate)]==candidate]
            if not candidates:
                if pending is not None: out.append([pending,now])
                candidate=[key]
                candidates=[b for b in bindings if b[0][:1]==candidate]
                pending=None
            buffer=candidate if candidates else []
            exact=[b for b in candidates if len(b[0])==len(buffer)]
            longer=[b for b in candidates if len(b[0])>len(buffer)+1]
            if exact and not longer:
                out.append([exact[0][1],now])
                buffer=[]; pending=None; deadline=None
            else:
                pending=exact[0][1] if exact else None
                deadline=now+timeout if candidates else None
        return [out,buffer,pending,deadline]
    return [run(c) for c in cases]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('ambiguous-shortcut-prefix scenario 0', solve([[[[['A'], 'short'], [['A', 'B'], 'long'], [['C'], 'other']], 5, []]] * N), [[[], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 1', solve([[[[['A'], 'short'], [['A', 'B'], 'long'], [['C'], 'other']], 5, [['down', 'A', 10], ['tick', '', 15]]]] * N), [[[['short', 15]], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 2', solve([[[[['A'], 'short'], [['A', 'B'], 'long']], 5, [['down', 'A', 10], ['tick', '', 20]]]] * N), [[[['short', 15]], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 3', solve([[[[['A'], 'short'], [['A', 'B'], 'long']], 5, [['down', 'A', 10], ['down', 'B', 12]]]] * N), [[[['long', 12]], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 4', solve([[[[['A'], 'short'], [['A', 'B'], 'long'], [['C'], 'other']], 5, [['down', 'A', 10], ['down', 'C', 12]]]] * N), [[[['short', 12], ['other', 12]], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 5', solve([[[[['A'], 'short'], [['A', 'B'], 'long']], 5, [['down', 'A', 10], ['cancel', '', 11]]]] * N), [[[], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 6', solve([[[[['A', 'B'], 'long']], 5, [['down', 'A', 10], ['up', 'B', 11]]]] * N), [[[], ['A'], None, 15]] * N)
check('ambiguous-shortcut-prefix scenario 7', solve([[[[['A', 'B'], 'long']], 5, [['down', 'A', 10], ['tick', 'B', 11]]]] * N), [[[], ['A'], None, 15]] * N)
check('ambiguous-shortcut-prefix scenario 8', solve([[[[['A', 'B'], 'long']], 5, [['down', 'Z', 10]]]] * N), [[[], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 9', solve([[[[['A'], 'short'], [['A', 'B'], 'long']], 5, [['down', 'A', 10], ['down', 'B', 15]]]] * N), [[[['short', 15]], [], None, None]] * N)
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 event trace violates the longer candidate rule and produces incorrect keyboard state or command output.

Case [bindings,timeout,events]. Binding [nonempty_key_sequence,action] has unique sequence. Events [kind,key,time]. Down extends prefix. Exact match with longer candidates is delayed until deadline; exact unambiguous match dispatches immediately. Tick or next event at deadline emits pending exact match and clears prefix. Mismatch dispatches pending match then retries only current key as fresh prefix. Cancel drops pending without dispatch. Return [action,time] dispatches,buffer,pending action,deadline. Inputs are finite ordered event traces; return the stated deterministic state. Batch entries are independent. N varies the number of independent input transactions.

split: open-access


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

N = 1
observations = []
def solve(cases):
    def run(c):
        bindings,timeout,events=c
        buffer=[]; pending=None; deadline=None; out=[]
        for kind,key,now in events:
            if kind=='cancel':
                buffer=[]; pending=None; deadline=None
                continue
            if deadline is not None and now>=deadline:
                if pending is not None: out.append([pending,deadline])
                buffer=[]; pending=None; deadline=None
            if kind!='down': continue
            candidate=buffer+[key]
            candidates=[b for b in bindings if b[0][:len(candidate)]==candidate]
            if not candidates:
                if pending is not None: out.append([pending,now])
                candidate=[key]
                candidates=[b for b in bindings if b[0][:1]==candidate]
                pending=None
            buffer=candidate if candidates else []
            exact=[b for b in candidates if len(b[0])==len(buffer)]
            longer=[b for b in candidates if len(b[0])>len(buffer)]
            if exact and not longer:
                out.append([exact[0][1],now])
                buffer=[]; pending=None; deadline=None
            else:
                pending=exact[0][1] if exact else None
                deadline=timeout if candidates else None
        return [out,buffer,pending,deadline]
    return [run(c) for c in cases]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('ambiguous-shortcut-prefix scenario 0', solve([[[[['A'], 'short'], [['A', 'B'], 'long'], [['C'], 'other']], 5, []]] * N), [[[], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 1', solve([[[[['A'], 'short'], [['A', 'B'], 'long'], [['C'], 'other']], 5, [['down', 'A', 10], ['tick', '', 15]]]] * N), [[[['short', 15]], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 2', solve([[[[['A'], 'short'], [['A', 'B'], 'long']], 5, [['down', 'A', 10], ['tick', '', 20]]]] * N), [[[['short', 15]], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 3', solve([[[[['A'], 'short'], [['A', 'B'], 'long']], 5, [['down', 'A', 10], ['down', 'B', 12]]]] * N), [[[['long', 12]], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 4', solve([[[[['A'], 'short'], [['A', 'B'], 'long'], [['C'], 'other']], 5, [['down', 'A', 10], ['down', 'C', 12]]]] * N), [[[['short', 12], ['other', 12]], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 5', solve([[[[['A'], 'short'], [['A', 'B'], 'long']], 5, [['down', 'A', 10], ['cancel', '', 11]]]] * N), [[[], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 6', solve([[[[['A', 'B'], 'long']], 5, [['down', 'A', 10], ['up', 'B', 11]]]] * N), [[[], ['A'], None, 15]] * N)
check('ambiguous-shortcut-prefix scenario 7', solve([[[[['A', 'B'], 'long']], 5, [['down', 'A', 10], ['tick', 'B', 11]]]] * N), [[[], ['A'], None, 15]] * N)
check('ambiguous-shortcut-prefix scenario 8', solve([[[[['A', 'B'], 'long']], 5, [['down', 'Z', 10]]]] * N), [[[], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 9', solve([[[[['A'], 'short'], [['A', 'B'], 'long']], 5, [['down', 'A', 10], ['down', 'B', 15]]]] * N), [[[['short', 15]], [], None, None]] * N)
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(cases):
    def run(c):
        bindings,timeout,events=c
        buffer=[]; pending=None; deadline=None; out=[]
        for kind,key,now in events:
            if kind=='cancel':
                buffer=[]; pending=None; deadline=None
                continue
            if deadline is not None and now>=deadline:
                if pending is not None: out.append([pending,deadline])
                buffer=[]; pending=None; deadline=None
            if kind!='down': continue
            candidate=buffer+[key]
            candidates=[b for b in bindings if b[0][:len(candidate)]==candidate]
            if not candidates:
                if pending is not None: out.append([pending,now])
                candidate=[key]
                candidates=[b for b in bindings if b[0][:1]==candidate]
                pending=None
            buffer=candidate if candidates else []
            exact=[b for b in candidates if len(b[0])==len(buffer)]
            longer=[b for b in candidates if len(b[0])>len(buffer)]
            if exact and not longer:
                out.append([exact[0][1],now])
                buffer=[]; pending=None; deadline=None
            else:
                pending=exact[0][1] if exact else None
                deadline=now+timeout
        return [out,buffer,pending,deadline]
    return [run(c) for c in cases]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('ambiguous-shortcut-prefix scenario 0', solve([[[[['A'], 'short'], [['A', 'B'], 'long'], [['C'], 'other']], 5, []]] * N), [[[], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 1', solve([[[[['A'], 'short'], [['A', 'B'], 'long'], [['C'], 'other']], 5, [['down', 'A', 10], ['tick', '', 15]]]] * N), [[[['short', 15]], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 2', solve([[[[['A'], 'short'], [['A', 'B'], 'long']], 5, [['down', 'A', 10], ['tick', '', 20]]]] * N), [[[['short', 15]], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 3', solve([[[[['A'], 'short'], [['A', 'B'], 'long']], 5, [['down', 'A', 10], ['down', 'B', 12]]]] * N), [[[['long', 12]], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 4', solve([[[[['A'], 'short'], [['A', 'B'], 'long'], [['C'], 'other']], 5, [['down', 'A', 10], ['down', 'C', 12]]]] * N), [[[['short', 12], ['other', 12]], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 5', solve([[[[['A'], 'short'], [['A', 'B'], 'long']], 5, [['down', 'A', 10], ['cancel', '', 11]]]] * N), [[[], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 6', solve([[[[['A', 'B'], 'long']], 5, [['down', 'A', 10], ['up', 'B', 11]]]] * N), [[[], ['A'], None, 15]] * N)
check('ambiguous-shortcut-prefix scenario 7', solve([[[[['A', 'B'], 'long']], 5, [['down', 'A', 10], ['tick', 'B', 11]]]] * N), [[[], ['A'], None, 15]] * N)
check('ambiguous-shortcut-prefix scenario 8', solve([[[[['A', 'B'], 'long']], 5, [['down', 'Z', 10]]]] * N), [[[], [], None, None]] * N)
check('ambiguous-shortcut-prefix scenario 9', solve([[[[['A'], 'short'], [['A', 'B'], 'long']], 5, [['down', 'A', 10], ['down', 'B', 15]]]] * N), [[[['short', 15]], [], None, None]] * N)
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 event trace violates the pending deadline rule and produces incorrect keyboard state or command output.

Case [bindings,timeout,events]. Binding [nonempty_key_sequence,action] has unique sequence. Events [kind,key,time]. Down extends prefix. Exact match with longer candidates is delayed until deadline; exact unambiguous match dispatches immediately. Tick or next event at deadline emits pending exact match and clears prefix. Mismatch dispatches pending match then retries only current key as fresh prefix. Cancel drops pending without dispatch. Return [action,time] dispatches,buffer,pending action,deadline. Inputs are finite ordered event traces; return the stated deterministic state. Batch entries are independent. N varies the number of independent input transactions.

split: open-access


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

N = 1
observations = []
def solve(cases):
    def run(c):
        capacity,events=c
        queue=[]; admitted=set(); held=set(); out=[]; dropped=0
        def dispatch(event):
            phase,key=event
            out.append([phase,key])
            if phase=='down': held.add(key)
            else: held.discard(key)
        for kind,key in events:
            if kind=='down' and key not in admitted:
                if len(queue)>capacity: dropped+=1
                else:
                    admitted.add(key)
                    queue.append(['down',key])
            elif kind=='up' and key in admitted:
                admitted.discard(key)
                while len(queue)>=capacity: dispatch(queue.pop(0))
                queue.append(['up',key])
            elif kind=='tick' and queue: dispatch(queue.pop(0))
            elif kind=='flush':
                while queue: dispatch(queue.pop(0))
            elif kind=='reset':
                queue.clear(); admitted.clear()
                for k in sorted(held): out.append(['up',k])
                held.clear()
        return [out,queue,sorted(admitted),sorted(held),dropped]
    return [run(c) for c in cases]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('bounded-keyboard-pump scenario 0', solve([[2, []]] * N), [[[], [], [], [], 0]] * N)
check('bounded-keyboard-pump scenario 1', solve([[2, [['down', 'A'], ['down', 'B'], ['down', 'C']]]] * N), [[[], [['down', 'A'], ['down', 'B']], ['A', 'B'], [], 1]] * N)
check('bounded-keyboard-pump scenario 2', solve([[2, [['down', 'A'], ['down', 'B'], ['up', 'A']]]] * N), [[[['down', 'A']], [['down', 'B'], ['up', 'A']], ['B'], ['A'], 0]] * N)
check('bounded-keyboard-pump scenario 3', solve([[2, [['down', 'A'], ['down', 'B'], ['tick', '']]]] * N), [[[['down', 'A']], [['down', 'B']], ['A', 'B'], ['A'], 0]] * N)
check('bounded-keyboard-pump scenario 4', solve([[2, [['down', 'A'], ['down', 'B'], ['flush', '']]]] * N), [[[['down', 'A'], ['down', 'B']], [], ['A', 'B'], ['A', 'B'], 0]] * N)
check('bounded-keyboard-pump scenario 5', solve([[2, [['down', 'A'], ['down', 'B'], ['reset', '']]]] * N), [[[], [], [], [], 0]] * N)
check('bounded-keyboard-pump scenario 6', solve([[2, [['down', 'A'], ['tick', ''], ['down', 'B'], ['reset', '']]]] * N), [[[['down', 'A'], ['up', 'A']], [], [], [], 0]] * N)
check('bounded-keyboard-pump scenario 7', solve([[1, [['down', 'A'], ['up', 'A'], ['flush', '']]]] * N), [[[['down', 'A'], ['up', 'A']], [], [], [], 0]] * N)
check('bounded-keyboard-pump scenario 8', solve([[2, [['down', 'A'], ['down', 'A'], ['up', 'A'], ['flush', '']]]] * N), [[[['down', 'A'], ['up', 'A']], [], [], [], 0]] * N)
check('bounded-keyboard-pump scenario 9', solve([[2, [['up', 'A']]]] * N), [[[], [], [], [], 0]] * N)
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(cases):
    def run(c):
        capacity,events=c
        queue=[]; admitted=set(); held=set(); out=[]; dropped=0
        def dispatch(event):
            phase,key=event
            out.append([phase,key])
            if phase=='down': held.add(key)
            else: held.discard(key)
        for kind,key in events:
            if kind=='down' and key not in admitted:
                if len(queue)>=capacity-1: dropped+=1
                else:
                    admitted.add(key)
                    queue.append(['down',key])
            elif kind=='up' and key in admitted:
                admitted.discard(key)
                while len(queue)>=capacity: dispatch(queue.pop(0))
                queue.append(['up',key])
            elif kind=='tick' and queue: dispatch(queue.pop(0))
            elif kind=='flush':
                while queue: dispatch(queue.pop(0))
            elif kind=='reset':
                queue.clear(); admitted.clear()
                for k in sorted(held): out.append(['up',k])
                held.clear()
        return [out,queue,sorted(admitted),sorted(held),dropped]
    return [run(c) for c in cases]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('bounded-keyboard-pump scenario 0', solve([[2, []]] * N), [[[], [], [], [], 0]] * N)
check('bounded-keyboard-pump scenario 1', solve([[2, [['down', 'A'], ['down', 'B'], ['down', 'C']]]] * N), [[[], [['down', 'A'], ['down', 'B']], ['A', 'B'], [], 1]] * N)
check('bounded-keyboard-pump scenario 2', solve([[2, [['down', 'A'], ['down', 'B'], ['up', 'A']]]] * N), [[[['down', 'A']], [['down', 'B'], ['up', 'A']], ['B'], ['A'], 0]] * N)
check('bounded-keyboard-pump scenario 3', solve([[2, [['down', 'A'], ['down', 'B'], ['tick', '']]]] * N), [[[['down', 'A']], [['down', 'B']], ['A', 'B'], ['A'], 0]] * N)
check('bounded-keyboard-pump scenario 4', solve([[2, [['down', 'A'], ['down', 'B'], ['flush', '']]]] * N), [[[['down', 'A'], ['down', 'B']], [], ['A', 'B'], ['A', 'B'], 0]] * N)
check('bounded-keyboard-pump scenario 5', solve([[2, [['down', 'A'], ['down', 'B'], ['reset', '']]]] * N), [[[], [], [], [], 0]] * N)
check('bounded-keyboard-pump scenario 6', solve([[2, [['down', 'A'], ['tick', ''], ['down', 'B'], ['reset', '']]]] * N), [[[['down', 'A'], ['up', 'A']], [], [], [], 0]] * N)
check('bounded-keyboard-pump scenario 7', solve([[1, [['down', 'A'], ['up', 'A'], ['flush', '']]]] * N), [[[['down', 'A'], ['up', 'A']], [], [], [], 0]] * N)
check('bounded-keyboard-pump scenario 8', solve([[2, [['down', 'A'], ['down', 'A'], ['up', 'A'], ['flush', '']]]] * N), [[[['down', 'A'], ['up', 'A']], [], [], [], 0]] * N)
check('bounded-keyboard-pump scenario 9', solve([[2, [['up', 'A']]]] * N), [[[], [], [], [], 0]] * N)
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 event trace violates the capacity boundary rule and produces incorrect keyboard state or command output.

Case [capacity,events], positive capacity; events [kind,key]. Down admitted only once per physical key and only when queue has capacity; overflow drops down. Up for an admitted key must be retained: dispatch oldest queued events until a slot exists, then queue the up. Tick dispatches one queued event; flush dispatches all. Reset discards pending queue and emits sorted synthetic ups for actually dispatched held keys. Return emitted edges,queue,admitted keys,delivered-held keys,dropped downs. Inputs are finite ordered event traces; return the stated deterministic state. Batch entries are independent. N varies the number of independent input transactions.

split: open-access


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

N = 1
observations = []
def solve(cases):
    def run(c):
        capacity,events=c
        queue=[]; admitted=set(); held=set(); out=[]; dropped=0
        def dispatch(event):
            phase,key=event
            out.append([phase,key])
            if phase=='down': held.add(key)
            else: held.discard(key)
        for kind,key in events:
            if kind=='down' and key not in admitted:
                if len(queue)>=capacity: dropped+=1
                else:
                    pass
                    queue.append(['down',key])
            elif kind=='up' and key in admitted:
                admitted.discard(key)
                while len(queue)>=capacity: dispatch(queue.pop(0))
                queue.append(['up',key])
            elif kind=='tick' and queue: dispatch(queue.pop(0))
            elif kind=='flush':
                while queue: dispatch(queue.pop(0))
            elif kind=='reset':
                queue.clear(); admitted.clear()
                for k in sorted(held): out.append(['up',k])
                held.clear()
        return [out,queue,sorted(admitted),sorted(held),dropped]
    return [run(c) for c in cases]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('bounded-keyboard-pump scenario 0', solve([[2, []]] * N), [[[], [], [], [], 0]] * N)
check('bounded-keyboard-pump scenario 1', solve([[2, [['down', 'A'], ['down', 'B'], ['down', 'C']]]] * N), [[[], [['down', 'A'], ['down', 'B']], ['A', 'B'], [], 1]] * N)
check('bounded-keyboard-pump scenario 2', solve([[2, [['down', 'A'], ['down', 'B'], ['up', 'A']]]] * N), [[[['down', 'A']], [['down', 'B'], ['up', 'A']], ['B'], ['A'], 0]] * N)
check('bounded-keyboard-pump scenario 3', solve([[2, [['down', 'A'], ['down', 'B'], ['tick', '']]]] * N), [[[['down', 'A']], [['down', 'B']], ['A', 'B'], ['A'], 0]] * N)
check('bounded-keyboard-pump scenario 4', solve([[2, [['down', 'A'], ['down', 'B'], ['flush', '']]]] * N), [[[['down', 'A'], ['down', 'B']], [], ['A', 'B'], ['A', 'B'], 0]] * N)
check('bounded-keyboard-pump scenario 5', solve([[2, [['down', 'A'], ['down', 'B'], ['reset', '']]]] * N), [[[], [], [], [], 0]] * N)
check('bounded-keyboard-pump scenario 6', solve([[2, [['down', 'A'], ['tick', ''], ['down', 'B'], ['reset', '']]]] * N), [[[['down', 'A'], ['up', 'A']], [], [], [], 0]] * N)
check('bounded-keyboard-pump scenario 7', solve([[1, [['down', 'A'], ['up', 'A'], ['flush', '']]]] * N), [[[['down', 'A'], ['up', 'A']], [], [], [], 0]] * N)
check('bounded-keyboard-pump scenario 8', solve([[2, [['down', 'A'], ['down', 'A'], ['up', 'A'], ['flush', '']]]] * N), [[[['down', 'A'], ['up', 'A']], [], [], [], 0]] * N)
check('bounded-keyboard-pump scenario 9', solve([[2, [['up', 'A']]]] * N), [[[], [], [], [], 0]] * N)
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(cases):
    def run(c):
        capacity,events=c
        queue=[]; admitted=set(); held=set(); out=[]; dropped=0
        def dispatch(event):
            phase,key=event
            out.append([phase,key])
            if phase=='down': held.add(key)
            else: held.discard(key)
        for kind,key in events:
            if kind=='down' and key not in admitted:
                if len(queue)>=capacity: dropped+=1
                else:
                    admitted={key}
                    queue.append(['down',key])
            elif kind=='up' and key in admitted:
                admitted.discard(key)
                while len(queue)>=capacity: dispatch(queue.pop(0))
                queue.append(['up',key])
            elif kind=='tick' and queue: dispatch(queue.pop(0))
            elif kind=='flush':
                while queue: dispatch(queue.pop(0))
            elif kind=='reset':
                queue.clear(); admitted.clear()
                for k in sorted(held): out.append(['up',k])
                held.clear()
        return [out,queue,sorted(admitted),sorted(held),dropped]
    return [run(c) for c in cases]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('bounded-keyboard-pump scenario 0', solve([[2, []]] * N), [[[], [], [], [], 0]] * N)
check('bounded-keyboard-pump scenario 1', solve([[2, [['down', 'A'], ['down', 'B'], ['down', 'C']]]] * N), [[[], [['down', 'A'], ['down', 'B']], ['A', 'B'], [], 1]] * N)
check('bounded-keyboard-pump scenario 2', solve([[2, [['down', 'A'], ['down', 'B'], ['up', 'A']]]] * N), [[[['down', 'A']], [['down', 'B'], ['up', 'A']], ['B'], ['A'], 0]] * N)
check('bounded-keyboard-pump scenario 3', solve([[2, [['down', 'A'], ['down', 'B'], ['tick', '']]]] * N), [[[['down', 'A']], [['down', 'B']], ['A', 'B'], ['A'], 0]] * N)
check('bounded-keyboard-pump scenario 4', solve([[2, [['down', 'A'], ['down', 'B'], ['flush', '']]]] * N), [[[['down', 'A'], ['down', 'B']], [], ['A', 'B'], ['A', 'B'], 0]] * N)
check('bounded-keyboard-pump scenario 5', solve([[2, [['down', 'A'], ['down', 'B'], ['reset', '']]]] * N), [[[], [], [], [], 0]] * N)
check('bounded-keyboard-pump scenario 6', solve([[2, [['down', 'A'], ['tick', ''], ['down', 'B'], ['reset', '']]]] * N), [[[['down', 'A'], ['up', 'A']], [], [], [], 0]] * N)
check('bounded-keyboard-pump scenario 7', solve([[1, [['down', 'A'], ['up', 'A'], ['flush', '']]]] * N), [[[['down', 'A'], ['up', 'A']], [], [], [], 0]] * N)
check('bounded-keyboard-pump scenario 8', solve([[2, [['down', 'A'], ['down', 'A'], ['up', 'A'], ['flush', '']]]] * N), [[[['down', 'A'], ['up', 'A']], [], [], [], 0]] * N)
check('bounded-keyboard-pump scenario 9', solve([[2, [['up', 'A']]]] * N), [[[], [], [], [], 0]] * N)
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 event trace violates the admitted down rule and produces incorrect keyboard state or command output.

Case [capacity,events], positive capacity; events [kind,key]. Down admitted only once per physical key and only when queue has capacity; overflow drops down. Up for an admitted key must be retained: dispatch oldest queued events until a slot exists, then queue the up. Tick dispatches one queued event; flush dispatches all. Reset discards pending queue and emits sorted synthetic ups for actually dispatched held keys. Return emitted edges,queue,admitted keys,delivered-held keys,dropped downs. Inputs are finite ordered event traces; return the stated deterministic state. Batch entries are independent. N varies the number of independent input transactions.

split: open-access


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

N = 1
observations = []
def solve(cases):
    def run(c):
        capacity,events=c
        queue=[]; admitted=set(); held=set(); out=[]; dropped=0
        def dispatch(event):
            phase,key=event
            out.append([phase,key])
            if phase=='down': held.add(key)
            else: held.discard(key)
        for kind,key in events:
            if kind=='down' and key not in admitted:
                if len(queue)>=capacity: dropped+=1
                else:
                    admitted.add(key)
                    queue.insert(0,['down',key])
            elif kind=='up' and key in admitted:
                admitted.discard(key)
                while len(queue)>=capacity: dispatch(queue.pop(0))
                queue.append(['up',key])
            elif kind=='tick' and queue: dispatch(queue.pop(0))
            elif kind=='flush':
                while queue: dispatch(queue.pop(0))
            elif kind=='reset':
                queue.clear(); admitted.clear()
                for k in sorted(held): out.append(['up',k])
                held.clear()
        return [out,queue,sorted(admitted),sorted(held),dropped]
    return [run(c) for c in cases]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('bounded-keyboard-pump scenario 0', solve([[2, []]] * N), [[[], [], [], [], 0]] * N)
check('bounded-keyboard-pump scenario 1', solve([[2, [['down', 'A'], ['down', 'B'], ['down', 'C']]]] * N), [[[], [['down', 'A'], ['down', 'B']], ['A', 'B'], [], 1]] * N)
check('bounded-keyboard-pump scenario 2', solve([[2, [['down', 'A'], ['down', 'B'], ['up', 'A']]]] * N), [[[['down', 'A']], [['down', 'B'], ['up', 'A']], ['B'], ['A'], 0]] * N)
check('bounded-keyboard-pump scenario 3', solve([[2, [['down', 'A'], ['down', 'B'], ['tick', '']]]] * N), [[[['down', 'A']], [['down', 'B']], ['A', 'B'], ['A'], 0]] * N)
check('bounded-keyboard-pump scenario 4', solve([[2, [['down', 'A'], ['down', 'B'], ['flush', '']]]] * N), [[[['down', 'A'], ['down', 'B']], [], ['A', 'B'], ['A', 'B'], 0]] * N)
check('bounded-keyboard-pump scenario 5', solve([[2, [['down', 'A'], ['down', 'B'], ['reset', '']]]] * N), [[[], [], [], [], 0]] * N)
check('bounded-keyboard-pump scenario 6', solve([[2, [['down', 'A'], ['tick', ''], ['down', 'B'], ['reset', '']]]] * N), [[[['down', 'A'], ['up', 'A']], [], [], [], 0]] * N)
check('bounded-keyboard-pump scenario 7', solve([[1, [['down', 'A'], ['up', 'A'], ['flush', '']]]] * N), [[[['down', 'A'], ['up', 'A']], [], [], [], 0]] * N)
check('bounded-keyboard-pump scenario 8', solve([[2, [['down', 'A'], ['down', 'A'], ['up', 'A'], ['flush', '']]]] * N), [[[['down', 'A'], ['up', 'A']], [], [], [], 0]] * N)
check('bounded-keyboard-pump scenario 9', solve([[2, [['up', 'A']]]] * N), [[[], [], [], [], 0]] * N)
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(cases):
    def run(c):
        capacity,events=c
        queue=[]; admitted=set(); held=set(); out=[]; dropped=0
        def dispatch(event):
            phase,key=event
            out.append([phase,key])
            if phase=='down': held.add(key)
            else: held.discard(key)
        for kind,key in events:
            if kind=='down' and key not in admitted:
                if len(queue)>=capacity: dropped+=1
                else:
                    admitted.add(key)
                    queue.append(['up',key])
            elif kind=='up' and key in admitted:
                admitted.discard(key)
                while len(queue)>=capacity: dispatch(queue.pop(0))
                queue.append(['up',key])
            elif kind=='tick' and queue: dispatch(queue.pop(0))
            elif kind=='flush':
                while queue: dispatch(queue.pop(0))
            elif kind=='reset':
                queue.clear(); admitted.clear()
                for k in sorted(held): out.append(['up',k])
                held.clear()
        return [out,queue,sorted(admitted),sorted(held),dropped]
    return [run(c) for c in cases]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('bounded-keyboard-pump scenario 0', solve([[2, []]] * N), [[[], [], [], [], 0]] * N)
check('bounded-keyboard-pump scenario 1', solve([[2, [['down', 'A'], ['down', 'B'], ['down', 'C']]]] * N), [[[], [['down', 'A'], ['down', 'B']], ['A', 'B'], [], 1]] * N)
check('bounded-keyboard-pump scenario 2', solve([[2, [['down', 'A'], ['down', 'B'], ['up', 'A']]]] * N), [[[['down', 'A']], [['down', 'B'], ['up', 'A']], ['B'], ['A'], 0]] * N)
check('bounded-keyboard-pump scenario 3', solve([[2, [['down', 'A'], ['down', 'B'], ['tick', '']]]] * N), [[[['down', 'A']], [['down', 'B']], ['A', 'B'], ['A'], 0]] * N)
check('bounded-keyboard-pump scenario 4', solve([[2, [['down', 'A'], ['down', 'B'], ['flush', '']]]] * N), [[[['down', 'A'], ['down', 'B']], [], ['A', 'B'], ['A', 'B'], 0]] * N)
check('bounded-keyboard-pump scenario 5', solve([[2, [['down', 'A'], ['down', 'B'], ['reset', '']]]] * N), [[[], [], [], [], 0]] * N)
check('bounded-keyboard-pump scenario 6', solve([[2, [['down', 'A'], ['tick', ''], ['down', 'B'], ['reset', '']]]] * N), [[[['down', 'A'], ['up', 'A']], [], [], [], 0]] * N)
check('bounded-keyboard-pump scenario 7', solve([[1, [['down', 'A'], ['up', 'A'], ['flush', '']]]] * N), [[[['down', 'A'], ['up', 'A']], [], [], [], 0]] * N)
check('bounded-keyboard-pump scenario 8', solve([[2, [['down', 'A'], ['down', 'A'], ['up', 'A'], ['flush', '']]]] * N), [[[['down', 'A'], ['up', 'A']], [], [], [], 0]] * N)
check('bounded-keyboard-pump scenario 9', solve([[2, [['up', 'A']]]] * N), [[[], [], [], [], 0]] * N)
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 event trace violates the queue press rule and produces incorrect keyboard state or command output.

Case [capacity,events], positive capacity; events [kind,key]. Down admitted only once per physical key and only when queue has capacity; overflow drops down. Up for an admitted key must be retained: dispatch oldest queued events until a slot exists, then queue the up. Tick dispatches one queued event; flush dispatches all. Reset discards pending queue and emits sorted synthetic ups for actually dispatched held keys. Return emitted edges,queue,admitted keys,delivered-held keys,dropped downs. Inputs are finite ordered event traces; return the stated deterministic state. Batch entries are independent. N varies the number of independent input transactions.

split: open-access


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

N = 1
observations = []
def solve(cases):
    def run(c):
        capacity,events=c
        queue=[]; admitted=set(); held=set(); out=[]; dropped=0
        def dispatch(event):
            phase,key=event
            out.append([phase,key])
            if phase=='down': held.add(key)
            else: held.discard(key)
        for kind,key in events:
            if kind=='down' and key not in admitted:
                if len(queue)>=capacity: dropped+=1
                else:
                    admitted.add(key)
                    queue.append(['down',key])
            elif kind=='up' and key in held:
                admitted.discard(key)
                while len(queue)>=capacity: dispatch(queue.pop(0))
                queue.append(['up',key])
            elif kind=='tick' and queue: dispatch(queue.pop(0))
            elif kind=='flush':
                while queue: dispatch(queue.pop(0))
            elif kind=='reset':
                queue.clear(); admitted.clear()
                for k in sorted(held): out.append(['up',k])
                held.clear()
        return [out,queue,sorted(admitted),sorted(held),dropped]
    return [run(c) for c in cases]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('bounded-keyboard-pump scenario 0', solve([[2, []]] * N), [[[], [], [], [], 0]] * N)
check('bounded-keyboard-pump scenario 1', solve([[2, [['down', 'A'], ['down', 'B'], ['down', 'C']]]] * N), [[[], [['down', 'A'], ['down', 'B']], ['A', 'B'], [], 1]] * N)
check('bounded-keyboard-pump scenario 2', solve([[2, [['down', 'A'], ['down', 'B'], ['up', 'A']]]] * N), [[[['down', 'A']], [['down', 'B'], ['up', 'A']], ['B'], ['A'], 0]] * N)
check('bounded-keyboard-pump scenario 3', solve([[2, [['down', 'A'], ['down', 'B'], ['tick', '']]]] * N), [[[['down', 'A']], [['down', 'B']], ['A', 'B'], ['A'], 0]] * N)
check('bounded-keyboard-pump scenario 4', solve([[2, [['down', 'A'], ['down', 'B'], ['flush', '']]]] * N), [[[['down', 'A'], ['down', 'B']], [], ['A', 'B'], ['A', 'B'], 0]] * N)
check('bounded-keyboard-pump scenario 5', solve([[2, [['down', 'A'], ['down', 'B'], ['reset', '']]]] * N), [[[], [], [], [], 0]] * N)
check('bounded-keyboard-pump scenario 6', solve([[2, [['down', 'A'], ['tick', ''], ['down', 'B'], ['reset', '']]]] * N), [[[['down', 'A'], ['up', 'A']], [], [], [], 0]] * N)
check('bounded-keyboard-pump scenario 7', solve([[1, [['down', 'A'], ['up', 'A'], ['flush', '']]]] * N), [[[['down', 'A'], ['up', 'A']], [], [], [], 0]] * N)
check('bounded-keyboard-pump scenario 8', solve([[2, [['down', 'A'], ['down', 'A'], ['up', 'A'], ['flush', '']]]] * N), [[[['down', 'A'], ['up', 'A']], [], [], [], 0]] * N)
check('bounded-keyboard-pump scenario 9', solve([[2, [['up', 'A']]]] * N), [[[], [], [], [], 0]] * N)
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(cases):
    def run(c):
        capacity,events=c
        queue=[]; admitted=set(); held=set(); out=[]; dropped=0
        def dispatch(event):
            phase,key=event
            out.append([phase,key])
            if phase=='down': held.add(key)
            else: held.discard(key)
        for kind,key in events:
            if kind=='down' and key not in admitted:
                if len(queue)>=capacity: dropped+=1
                else:
                    admitted.add(key)
                    queue.append(['down',key])
            elif kind=='up' and key not in admitted:
                admitted.discard(key)
                while len(queue)>=capacity: dispatch(queue.pop(0))
                queue.append(['up',key])
            elif kind=='tick' and queue: dispatch(queue.pop(0))
            elif kind=='flush':
                while queue: dispatch(queue.pop(0))
            elif kind=='reset':
                queue.clear(); admitted.clear()
                for k in sorted(held): out.append(['up',k])
                held.clear()
        return [out,queue,sorted(admitted),sorted(held),dropped]
    return [run(c) for c in cases]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('bounded-keyboard-pump scenario 0', solve([[2, []]] * N), [[[], [], [], [], 0]] * N)
check('bounded-keyboard-pump scenario 1', solve([[2, [['down', 'A'], ['down', 'B'], ['down', 'C']]]] * N), [[[], [['down', 'A'], ['down', 'B']], ['A', 'B'], [], 1]] * N)
check('bounded-keyboard-pump scenario 2', solve([[2, [['down', 'A'], ['down', 'B'], ['up', 'A']]]] * N), [[[['down', 'A']], [['down', 'B'], ['up', 'A']], ['B'], ['A'], 0]] * N)
check('bounded-keyboard-pump scenario 3', solve([[2, [['down', 'A'], ['down', 'B'], ['tick', '']]]] * N), [[[['down', 'A']], [['down', 'B']], ['A', 'B'], ['A'], 0]] * N)
check('bounded-keyboard-pump scenario 4', solve([[2, [['down', 'A'], ['down', 'B'], ['flush', '']]]] * N), [[[['down', 'A'], ['down', 'B']], [], ['A', 'B'], ['A', 'B'], 0]] * N)
check('bounded-keyboard-pump scenario 5', solve([[2, [['down', 'A'], ['down', 'B'], ['reset', '']]]] * N), [[[], [], [], [], 0]] * N)
check('bounded-keyboard-pump scenario 6', solve([[2, [['down', 'A'], ['tick', ''], ['down', 'B'], ['reset', '']]]] * N), [[[['down', 'A'], ['up', 'A']], [], [], [], 0]] * N)
check('bounded-keyboard-pump scenario 7', solve([[1, [['down', 'A'], ['up', 'A'], ['flush', '']]]] * N), [[[['down', 'A'], ['up', 'A']], [], [], [], 0]] * N)
check('bounded-keyboard-pump scenario 8', solve([[2, [['down', 'A'], ['down', 'A'], ['up', 'A'], ['flush', '']]]] * N), [[[['down', 'A'], ['up', 'A']], [], [], [], 0]] * N)
check('bounded-keyboard-pump scenario 9', solve([[2, [['up', 'A']]]] * N), [[[], [], [], [], 0]] * N)
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 event trace violates the release admission rule and produces incorrect keyboard state or command output.

Case [capacity,events], positive capacity; events [kind,key]. Down admitted only once per physical key and only when queue has capacity; overflow drops down. Up for an admitted key must be retained: dispatch oldest queued events until a slot exists, then queue the up. Tick dispatches one queued event; flush dispatches all. Reset discards pending queue and emits sorted synthetic ups for actually dispatched held keys. Return emitted edges,queue,admitted keys,delivered-held keys,dropped downs. Inputs are finite ordered event traces; return the stated deterministic state. Batch entries are independent. N varies the number of independent input transactions.

split: open-access


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

N = 1
observations = []
def solve(cases):
    def run(c):
        capacity,events=c
        queue=[]; admitted=set(); held=set(); out=[]; dropped=0
        def dispatch(event):
            phase,key=event
            out.append([phase,key])
            if phase=='down': held.add(key)
            else: held.discard(key)
        for kind,key in events:
            if kind=='down' and key not in admitted:
                if len(queue)>=capacity: dropped+=1
                else:
                    admitted.add(key)
                    queue.append(['down',key])
            elif kind=='up' and key in admitted:
                admitted.discard(key)
                while len(queue)>capacity: dispatch(queue.pop(0))
                queue.append(['up',key])
            elif kind=='tick' and queue: dispatch(queue.pop(0))
            elif kind=='flush':
                while queue: dispatch(queue.pop(0))
            elif kind=='reset':
                queue.clear(); admitted.clear()
                for k in sorted(held): out.append(['up',k])
                held.clear()
        return [out,queue,sorted(admitted),sorted(held),dropped]
    return [run(c) for c in cases]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('bounded-keyboard-pump scenario 0', solve([[2, []]] * N), [[[], [], [], [], 0]] * N)
check('bounded-keyboard-pump scenario 1', solve([[2, [['down', 'A'], ['down', 'B'], ['down', 'C']]]] * N), [[[], [['down', 'A'], ['down', 'B']], ['A', 'B'], [], 1]] * N)
check('bounded-keyboard-pump scenario 2', solve([[2, [['down', 'A'], ['down', 'B'], ['up', 'A']]]] * N), [[[['down', 'A']], [['down', 'B'], ['up', 'A']], ['B'], ['A'], 0]] * N)
check('bounded-keyboard-pump scenario 3', solve([[2, [['down', 'A'], ['down', 'B'], ['tick', '']]]] * N), [[[['down', 'A']], [['down', 'B']], ['A', 'B'], ['A'], 0]] * N)
check('bounded-keyboard-pump scenario 4', solve([[2, [['down', 'A'], ['down', 'B'], ['flush', '']]]] * N), [[[['down', 'A'], ['down', 'B']], [], ['A', 'B'], ['A', 'B'], 0]] * N)
check('bounded-keyboard-pump scenario 5', solve([[2, [['down', 'A'], ['down', 'B'], ['reset', '']]]] * N), [[[], [], [], [], 0]] * N)
check('bounded-keyboard-pump scenario 6', solve([[2, [['down', 'A'], ['tick', ''], ['down', 'B'], ['reset', '']]]] * N), [[[['down', 'A'], ['up', 'A']], [], [], [], 0]] * N)
check('bounded-keyboard-pump scenario 7', solve([[1, [['down', 'A'], ['up', 'A'], ['flush', '']]]] * N), [[[['down', 'A'], ['up', 'A']], [], [], [], 0]] * N)
check('bounded-keyboard-pump scenario 8', solve([[2, [['down', 'A'], ['down', 'A'], ['up', 'A'], ['flush', '']]]] * N), [[[['down', 'A'], ['up', 'A']], [], [], [], 0]] * N)
check('bounded-keyboard-pump scenario 9', solve([[2, [['up', 'A']]]] * N), [[[], [], [], [], 0]] * N)
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(cases):
    def run(c):
        capacity,events=c
        queue=[]; admitted=set(); held=set(); out=[]; dropped=0
        def dispatch(event):
            phase,key=event
            out.append([phase,key])
            if phase=='down': held.add(key)
            else: held.discard(key)
        for kind,key in events:
            if kind=='down' and key not in admitted:
                if len(queue)>=capacity: dropped+=1
                else:
                    admitted.add(key)
                    queue.append(['down',key])
            elif kind=='up' and key in admitted:
                admitted.discard(key)
                while len(queue)>=capacity: dispatch(queue.pop())
                queue.append(['up',key])
            elif kind=='tick' and queue: dispatch(queue.pop(0))
            elif kind=='flush':
                while queue: dispatch(queue.pop(0))
            elif kind=='reset':
                queue.clear(); admitted.clear()
                for k in sorted(held): out.append(['up',k])
                held.clear()
        return [out,queue,sorted(admitted),sorted(held),dropped]
    return [run(c) for c in cases]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('bounded-keyboard-pump scenario 0', solve([[2, []]] * N), [[[], [], [], [], 0]] * N)
check('bounded-keyboard-pump scenario 1', solve([[2, [['down', 'A'], ['down', 'B'], ['down', 'C']]]] * N), [[[], [['down', 'A'], ['down', 'B']], ['A', 'B'], [], 1]] * N)
check('bounded-keyboard-pump scenario 2', solve([[2, [['down', 'A'], ['down', 'B'], ['up', 'A']]]] * N), [[[['down', 'A']], [['down', 'B'], ['up', 'A']], ['B'], ['A'], 0]] * N)
check('bounded-keyboard-pump scenario 3', solve([[2, [['down', 'A'], ['down', 'B'], ['tick', '']]]] * N), [[[['down', 'A']], [['down', 'B']], ['A', 'B'], ['A'], 0]] * N)
check('bounded-keyboard-pump scenario 4', solve([[2, [['down', 'A'], ['down', 'B'], ['flush', '']]]] * N), [[[['down', 'A'], ['down', 'B']], [], ['A', 'B'], ['A', 'B'], 0]] * N)
check('bounded-keyboard-pump scenario 5', solve([[2, [['down', 'A'], ['down', 'B'], ['reset', '']]]] * N), [[[], [], [], [], 0]] * N)
check('bounded-keyboard-pump scenario 6', solve([[2, [['down', 'A'], ['tick', ''], ['down', 'B'], ['reset', '']]]] * N), [[[['down', 'A'], ['up', 'A']], [], [], [], 0]] * N)
check('bounded-keyboard-pump scenario 7', solve([[1, [['down', 'A'], ['up', 'A'], ['flush', '']]]] * N), [[[['down', 'A'], ['up', 'A']], [], [], [], 0]] * N)
check('bounded-keyboard-pump scenario 8', solve([[2, [['down', 'A'], ['down', 'A'], ['up', 'A'], ['flush', '']]]] * N), [[[['down', 'A'], ['up', 'A']], [], [], [], 0]] * N)
check('bounded-keyboard-pump scenario 9', solve([[2, [['up', 'A']]]] * N), [[[], [], [], [], 0]] * N)
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 event trace violates the release room rule and produces incorrect keyboard state or command output.

Case [capacity,events], positive capacity; events [kind,key]. Down admitted only once per physical key and only when queue has capacity; overflow drops down. Up for an admitted key must be retained: dispatch oldest queued events until a slot exists, then queue the up. Tick dispatches one queued event; flush dispatches all. Reset discards pending queue and emits sorted synthetic ups for actually dispatched held keys. Return emitted edges,queue,admitted keys,delivered-held keys,dropped downs. Inputs are finite ordered event traces; return the stated deterministic state. Batch entries are independent. N varies the number of independent input transactions.

split: open-access