broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
from collections import Counter, defaultdict
import math
import itertools
N = 1
observations = []
def solve(rows, k):
    remaining=k
    out=0
    for x,w in sorted(rows):
        take=min(remaining,w)
        out+=x*take
        remaining-=w
    return out
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('regression 1', solve(*([(2, 1), (2, 1), (9, 3)], 3)), 13)
check('regression 2', solve(*([(8, 2), (1, 3), (4, 2)], 4)), 7)
check('regression 3', solve(*([(2, 3)], 0)), 0)
check('regression 4', solve(*([], 3)), 0)
check('regression 5', solve(*([(9, 0), (2, 1)], 8)), 2)
check('regression 6', solve(*([(-5, 2), (3, 4)], 3)), -7)
check('regression 7', solve(*([(2, 1), (2, 2), (9, 1)], 2)), 4)
check('regression 8', solve(*([(1, 8), (7, 2)], 9)), 15)
check("variable tail mass",solve([(N,3),(N+5,2)],4),4*N+5)
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
from fractions import Fraction
from collections import Counter, defaultdict
import math
import itertools
N = 1
observations = []
def solve(rows, k):
    remaining=k
    out=0
    for x,w in sorted(rows):
        take=min(remaining,w)
        out+=x*take
        remaining-=w+take
    return out
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('regression 1', solve(*([(2, 1), (2, 1), (9, 3)], 3)), 13)
check('regression 2', solve(*([(8, 2), (1, 3), (4, 2)], 4)), 7)
check('regression 3', solve(*([(2, 3)], 0)), 0)
check('regression 4', solve(*([], 3)), 0)
check('regression 5', solve(*([(9, 0), (2, 1)], 8)), 2)
check('regression 6', solve(*([(-5, 2), (3, 4)], 3)), -7)
check('regression 7', solve(*([(2, 1), (2, 2), (9, 1)], 2)), 4)
check('regression 8', solve(*([(1, 8), (7, 2)], 9)), 15)
check("variable tail mass",solve([(N,3),(N+5,2)],4),4*N+5)
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 reduction disagrees with its explicit aggregation oracle.

Rows [integer value, nonnegative frequency] expand to a multiset. Sum its smallest min(k,total frequency) observations for nonnegative integer k; zero/empty tail sums to zero.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
from collections import Counter, defaultdict
import math
import itertools
N = 1
observations = []
def solve(rows, k):
    remaining=k
    out=0
    for x,w in sorted(rows,reverse=True):
        take=min(remaining,w)
        out+=x*take
        remaining-=take
    return out
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('regression 1', solve(*([(2, 1), (2, 1), (9, 3)], 3)), 13)
check('regression 2', solve(*([(8, 2), (1, 3), (4, 2)], 4)), 7)
check('regression 3', solve(*([(2, 3)], 0)), 0)
check('regression 4', solve(*([], 3)), 0)
check('regression 5', solve(*([(9, 0), (2, 1)], 8)), 2)
check('regression 6', solve(*([(-5, 2), (3, 4)], 3)), -7)
check('regression 7', solve(*([(2, 1), (2, 2), (9, 1)], 2)), 4)
check('regression 8', solve(*([(1, 8), (7, 2)], 9)), 15)
check("variable tail mass",solve([(N,3),(N+5,2)],4),4*N+5)
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
from fractions import Fraction
from collections import Counter, defaultdict
import math
import itertools
N = 1
observations = []
def solve(rows, k):
    remaining=k
    out=0
    for x,w in sorted(rows,key=lambda r:abs(r[0])):
        take=min(remaining,w)
        out+=x*take
        remaining-=take
    return out
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('regression 1', solve(*([(2, 1), (2, 1), (9, 3)], 3)), 13)
check('regression 2', solve(*([(8, 2), (1, 3), (4, 2)], 4)), 7)
check('regression 3', solve(*([(2, 3)], 0)), 0)
check('regression 4', solve(*([], 3)), 0)
check('regression 5', solve(*([(9, 0), (2, 1)], 8)), 2)
check('regression 6', solve(*([(-5, 2), (3, 4)], 3)), -7)
check('regression 7', solve(*([(2, 1), (2, 2), (9, 1)], 2)), 4)
check('regression 8', solve(*([(1, 8), (7, 2)], 9)), 15)
check("variable tail mass",solve([(N,3),(N+5,2)],4),4*N+5)
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 reduction disagrees with its explicit aggregation oracle.

Rows [integer value, nonnegative frequency] expand to a multiset. Sum its smallest min(k,total frequency) observations for nonnegative integer k; zero/empty tail sums to zero.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
from collections import Counter, defaultdict
import math
import itertools
N = 1
observations = []
def solve(rows, k):
    rows=list(dict(rows).items())
    remaining=k
    out=0
    for x,w in sorted(rows):
        take=min(remaining,w)
        out+=x*take
        remaining-=take
    return out
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('regression 1', solve(*([(2, 1), (2, 1), (9, 3)], 3)), 13)
check('regression 2', solve(*([(8, 2), (1, 3), (4, 2)], 4)), 7)
check('regression 3', solve(*([(2, 3)], 0)), 0)
check('regression 4', solve(*([], 3)), 0)
check('regression 5', solve(*([(9, 0), (2, 1)], 8)), 2)
check('regression 6', solve(*([(-5, 2), (3, 4)], 3)), -7)
check('regression 7', solve(*([(2, 1), (2, 2), (9, 1)], 2)), 4)
check('regression 8', solve(*([(1, 8), (7, 2)], 9)), 15)
check("variable tail mass",solve([(N,3),(N+5,2)],4),4*N+5)
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
from fractions import Fraction
from collections import Counter, defaultdict
import math
import itertools
N = 1
observations = []
def solve(rows, k):
    rows=list(set(rows))
    remaining=k
    out=0
    for x,w in sorted(rows):
        take=min(remaining,w)
        out+=x*take
        remaining-=take
    return out
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('regression 1', solve(*([(2, 1), (2, 1), (9, 3)], 3)), 13)
check('regression 2', solve(*([(8, 2), (1, 3), (4, 2)], 4)), 7)
check('regression 3', solve(*([(2, 3)], 0)), 0)
check('regression 4', solve(*([], 3)), 0)
check('regression 5', solve(*([(9, 0), (2, 1)], 8)), 2)
check('regression 6', solve(*([(-5, 2), (3, 4)], 3)), -7)
check('regression 7', solve(*([(2, 1), (2, 2), (9, 1)], 2)), 4)
check('regression 8', solve(*([(1, 8), (7, 2)], 9)), 15)
check("variable tail mass",solve([(N,3),(N+5,2)],4),4*N+5)
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 reduction disagrees with its explicit aggregation oracle.

Rows [integer value, nonnegative frequency] expand to a multiset. Sum its smallest min(k,total frequency) observations for nonnegative integer k; zero/empty tail sums to zero.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
from collections import Counter, defaultdict
import math
import itertools
N = 1
observations = []
def solve(rows, k):
    remaining=k
    out=0
    for x,w in sorted(rows):
        take=min(remaining+1,w)
        out+=x*take
        remaining-=take
    return out
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('regression 1', solve(*([(2, 1), (2, 1), (9, 3)], 3)), 13)
check('regression 2', solve(*([(8, 2), (1, 3), (4, 2)], 4)), 7)
check('regression 3', solve(*([(2, 3)], 0)), 0)
check('regression 4', solve(*([], 3)), 0)
check('regression 5', solve(*([(9, 0), (2, 1)], 8)), 2)
check('regression 6', solve(*([(-5, 2), (3, 4)], 3)), -7)
check('regression 7', solve(*([(2, 1), (2, 2), (9, 1)], 2)), 4)
check('regression 8', solve(*([(1, 8), (7, 2)], 9)), 15)
check("variable tail mass",solve([(N,3),(N+5,2)],4),4*N+5)
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
from fractions import Fraction
from collections import Counter, defaultdict
import math
import itertools
N = 1
observations = []
def solve(rows, k):
    remaining=k
    out=0
    for x,w in sorted(rows):
        take=min(max(1,remaining),w)
        out+=x*take
        remaining-=take
    return out
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('regression 1', solve(*([(2, 1), (2, 1), (9, 3)], 3)), 13)
check('regression 2', solve(*([(8, 2), (1, 3), (4, 2)], 4)), 7)
check('regression 3', solve(*([(2, 3)], 0)), 0)
check('regression 4', solve(*([], 3)), 0)
check('regression 5', solve(*([(9, 0), (2, 1)], 8)), 2)
check('regression 6', solve(*([(-5, 2), (3, 4)], 3)), -7)
check('regression 7', solve(*([(2, 1), (2, 2), (9, 1)], 2)), 4)
check('regression 8', solve(*([(1, 8), (7, 2)], 9)), 15)
check("variable tail mass",solve([(N,3),(N+5,2)],4),4*N+5)
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 reduction disagrees with its explicit aggregation oracle.

Rows [integer value, nonnegative frequency] expand to a multiset. Sum its smallest min(k,total frequency) observations for nonnegative integer k; zero/empty tail sums to zero.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
from collections import Counter, defaultdict
import math
import itertools
N = 1
observations = []
def solve(rows, k):
    xs=sorted(x for x,w in rows if w>0)
    if not xs or 2*k>=len(xs): return None
    return str(Fraction(sum(xs[k:len(xs)-k]),len(xs)-2*k))
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('regression 1', solve(*([(9, 1), (1, 4), (5, 2)], 2)), '7/3')
check('regression 2', solve(*([(2, 4)], 1)), '2')
check('regression 3', solve(*([], 0)), None)
check('regression 4', solve(*([(1, 2), (4, 2)], 2)), None)
check('regression 5', solve(*([(0, 1), (10, 3), (-5, 2)], 1)), '15/4')
check('regression 6', solve(*([(3, 0), (8, 1)], 0)), '8')
check('regression 7', solve(*([(1, 1), (8, 4), (9, 1)], 1)), '8')
check("variable weighted trim",solve([(N,3),(N+6,2)],1),str(Fraction(3*N+6,3)))
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
from fractions import Fraction
from collections import Counter, defaultdict
import math
import itertools
N = 1
observations = []
def solve(rows, k):
    xs=sorted(set(x for x,w in rows if w>0))
    if not xs or 2*k>=len(xs): return None
    return str(Fraction(sum(xs[k:len(xs)-k]),len(xs)-2*k))
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('regression 1', solve(*([(9, 1), (1, 4), (5, 2)], 2)), '7/3')
check('regression 2', solve(*([(2, 4)], 1)), '2')
check('regression 3', solve(*([], 0)), None)
check('regression 4', solve(*([(1, 2), (4, 2)], 2)), None)
check('regression 5', solve(*([(0, 1), (10, 3), (-5, 2)], 1)), '15/4')
check('regression 6', solve(*([(3, 0), (8, 1)], 0)), '8')
check('regression 7', solve(*([(1, 1), (8, 4), (9, 1)], 1)), '8')
check("variable weighted trim",solve([(N,3),(N+6,2)],1),str(Fraction(3*N+6,3)))
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 reduction disagrees with its explicit aggregation oracle.

Expand nonnegative integer frequencies. Remove exactly k lowest and k highest observations by multiplicity. Return the exact mean as a Fraction string, or None when no observations survive.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
from collections import Counter, defaultdict
import math
import itertools
N = 1
observations = []
def solve(rows, k):
    xs=sorted(x for x,w in rows for _ in range(w))
    if not xs or 2*k>=len(xs): return None
    return str(Fraction(sum(xs[k:len(xs)-k]),len(xs)))
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('regression 1', solve(*([(9, 1), (1, 4), (5, 2)], 2)), '7/3')
check('regression 2', solve(*([(2, 4)], 1)), '2')
check('regression 3', solve(*([], 0)), None)
check('regression 4', solve(*([(1, 2), (4, 2)], 2)), None)
check('regression 5', solve(*([(0, 1), (10, 3), (-5, 2)], 1)), '15/4')
check('regression 6', solve(*([(3, 0), (8, 1)], 0)), '8')
check('regression 7', solve(*([(1, 1), (8, 4), (9, 1)], 1)), '8')
check("variable weighted trim",solve([(N,3),(N+6,2)],1),str(Fraction(3*N+6,3)))
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
from fractions import Fraction
from collections import Counter, defaultdict
import math
import itertools
N = 1
observations = []
def solve(rows, k):
    xs=sorted(x for x,w in rows for _ in range(w))
    if not xs or 2*k>=len(xs): return None
    return str(Fraction(sum(xs[k:len(xs)-k]),len(xs)-k))
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('regression 1', solve(*([(9, 1), (1, 4), (5, 2)], 2)), '7/3')
check('regression 2', solve(*([(2, 4)], 1)), '2')
check('regression 3', solve(*([], 0)), None)
check('regression 4', solve(*([(1, 2), (4, 2)], 2)), None)
check('regression 5', solve(*([(0, 1), (10, 3), (-5, 2)], 1)), '15/4')
check('regression 6', solve(*([(3, 0), (8, 1)], 0)), '8')
check('regression 7', solve(*([(1, 1), (8, 4), (9, 1)], 1)), '8')
check("variable weighted trim",solve([(N,3),(N+6,2)],1),str(Fraction(3*N+6,3)))
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 reduction disagrees with its explicit aggregation oracle.

Expand nonnegative integer frequencies. Remove exactly k lowest and k highest observations by multiplicity. Return the exact mean as a Fraction string, or None when no observations survive.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
from collections import Counter, defaultdict
import math
import itertools
N = 1
observations = []
def solve(rows, k):
    xs=sorted(x for x,w in rows for _ in range(w))
    if not xs or 2*k>=len(xs): return None
    return str(Fraction(sum(xs[2*k:]),len(xs)-2*k))
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('regression 1', solve(*([(9, 1), (1, 4), (5, 2)], 2)), '7/3')
check('regression 2', solve(*([(2, 4)], 1)), '2')
check('regression 3', solve(*([], 0)), None)
check('regression 4', solve(*([(1, 2), (4, 2)], 2)), None)
check('regression 5', solve(*([(0, 1), (10, 3), (-5, 2)], 1)), '15/4')
check('regression 6', solve(*([(3, 0), (8, 1)], 0)), '8')
check('regression 7', solve(*([(1, 1), (8, 4), (9, 1)], 1)), '8')
check("variable weighted trim",solve([(N,3),(N+6,2)],1),str(Fraction(3*N+6,3)))
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
from fractions import Fraction
from collections import Counter, defaultdict
import math
import itertools
N = 1
observations = []
def solve(rows, k):
    xs=sorted(x for x,w in rows for _ in range(w))
    if not xs or 2*k>=len(xs): return None
    return str(Fraction(sum(xs[:len(xs)-2*k]),len(xs)-2*k))
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('regression 1', solve(*([(9, 1), (1, 4), (5, 2)], 2)), '7/3')
check('regression 2', solve(*([(2, 4)], 1)), '2')
check('regression 3', solve(*([], 0)), None)
check('regression 4', solve(*([(1, 2), (4, 2)], 2)), None)
check('regression 5', solve(*([(0, 1), (10, 3), (-5, 2)], 1)), '15/4')
check('regression 6', solve(*([(3, 0), (8, 1)], 0)), '8')
check('regression 7', solve(*([(1, 1), (8, 4), (9, 1)], 1)), '8')
check("variable weighted trim",solve([(N,3),(N+6,2)],1),str(Fraction(3*N+6,3)))
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 reduction disagrees with its explicit aggregation oracle.

Expand nonnegative integer frequencies. Remove exactly k lowest and k highest observations by multiplicity. Return the exact mean as a Fraction string, or None when no observations survive.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
from collections import Counter, defaultdict
import math
import itertools
N = 1
observations = []
def solve(rows, k):
    xs=sorted(x for x,w in rows for _ in range(w))
    if not xs or 2*k>=len(xs): return None
    return str(Fraction(sum(xs[k:-k]),len(xs)-2*k))
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('regression 1', solve(*([(9, 1), (1, 4), (5, 2)], 2)), '7/3')
check('regression 2', solve(*([(2, 4)], 1)), '2')
check('regression 3', solve(*([], 0)), None)
check('regression 4', solve(*([(1, 2), (4, 2)], 2)), None)
check('regression 5', solve(*([(0, 1), (10, 3), (-5, 2)], 1)), '15/4')
check('regression 6', solve(*([(3, 0), (8, 1)], 0)), '8')
check('regression 7', solve(*([(1, 1), (8, 4), (9, 1)], 1)), '8')
check("variable weighted trim",solve([(N,3),(N+6,2)],1),str(Fraction(3*N+6,3)))
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
from fractions import Fraction
from collections import Counter, defaultdict
import math
import itertools
N = 1
observations = []
def solve(rows, k):
    xs=sorted(x for x,w in rows for _ in range(w))
    if not xs or 2*k>=len(xs): return None
    return str(Fraction(sum(xs[k:-max(1,k)]),len(xs)-2*k))
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('regression 1', solve(*([(9, 1), (1, 4), (5, 2)], 2)), '7/3')
check('regression 2', solve(*([(2, 4)], 1)), '2')
check('regression 3', solve(*([], 0)), None)
check('regression 4', solve(*([(1, 2), (4, 2)], 2)), None)
check('regression 5', solve(*([(0, 1), (10, 3), (-5, 2)], 1)), '15/4')
check('regression 6', solve(*([(3, 0), (8, 1)], 0)), '8')
check('regression 7', solve(*([(1, 1), (8, 4), (9, 1)], 1)), '8')
check("variable weighted trim",solve([(N,3),(N+6,2)],1),str(Fraction(3*N+6,3)))
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 reduction disagrees with its explicit aggregation oracle.

Expand nonnegative integer frequencies. Remove exactly k lowest and k highest observations by multiplicity. Return the exact mean as a Fraction string, or None when no observations survive.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
from collections import Counter, defaultdict
import math
import itertools
N = 1
observations = []
def solve(rows, k):
    xs=sorted(x for x,w in rows for _ in range(w))
    if not xs or 2*k>=len(xs): return None
    return str(Fraction(sum(x for x in xs if xs[k]<x<xs[-k-1]),len(xs)-2*k))
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('regression 1', solve(*([(9, 1), (1, 4), (5, 2)], 2)), '7/3')
check('regression 2', solve(*([(2, 4)], 1)), '2')
check('regression 3', solve(*([], 0)), None)
check('regression 4', solve(*([(1, 2), (4, 2)], 2)), None)
check('regression 5', solve(*([(0, 1), (10, 3), (-5, 2)], 1)), '15/4')
check('regression 6', solve(*([(3, 0), (8, 1)], 0)), '8')
check('regression 7', solve(*([(1, 1), (8, 4), (9, 1)], 1)), '8')
check("variable weighted trim",solve([(N,3),(N+6,2)],1),str(Fraction(3*N+6,3)))
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
from fractions import Fraction
from collections import Counter, defaultdict
import math
import itertools
N = 1
observations = []
def solve(rows, k):
    xs=sorted(x for x,w in rows for _ in range(w))
    if not xs or 2*k>=len(xs): return None
    return str(Fraction(sum(x for x in xs if xs[k]<=x<=xs[-k-1]),len(xs)-2*k))
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('regression 1', solve(*([(9, 1), (1, 4), (5, 2)], 2)), '7/3')
check('regression 2', solve(*([(2, 4)], 1)), '2')
check('regression 3', solve(*([], 0)), None)
check('regression 4', solve(*([(1, 2), (4, 2)], 2)), None)
check('regression 5', solve(*([(0, 1), (10, 3), (-5, 2)], 1)), '15/4')
check('regression 6', solve(*([(3, 0), (8, 1)], 0)), '8')
check('regression 7', solve(*([(1, 1), (8, 4), (9, 1)], 1)), '8')
check("variable weighted trim",solve([(N,3),(N+6,2)],1),str(Fraction(3*N+6,3)))
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 reduction disagrees with its explicit aggregation oracle.

Expand nonnegative integer frequencies. Remove exactly k lowest and k highest observations by multiplicity. Return the exact mean as a Fraction string, or None when no observations survive.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
from collections import Counter, defaultdict
import math
import itertools
N = 1
observations = []
def solve(rows, k):
    xs=sorted(x for x,w in rows for _ in range(w+1))
    if not xs or 2*k>=len(xs): return None
    return str(Fraction(sum(xs[k:len(xs)-k]),len(xs)-2*k))
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('regression 1', solve(*([(9, 1), (1, 4), (5, 2)], 2)), '7/3')
check('regression 2', solve(*([(2, 4)], 1)), '2')
check('regression 3', solve(*([], 0)), None)
check('regression 4', solve(*([(1, 2), (4, 2)], 2)), None)
check('regression 5', solve(*([(0, 1), (10, 3), (-5, 2)], 1)), '15/4')
check('regression 6', solve(*([(3, 0), (8, 1)], 0)), '8')
check('regression 7', solve(*([(1, 1), (8, 4), (9, 1)], 1)), '8')
check("variable weighted trim",solve([(N,3),(N+6,2)],1),str(Fraction(3*N+6,3)))
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
from fractions import Fraction
from collections import Counter, defaultdict
import math
import itertools
N = 1
observations = []
def solve(rows, k):
    xs=sorted(x for x,w in rows for _ in range(max(1,w)))
    if not xs or 2*k>=len(xs): return None
    return str(Fraction(sum(xs[k:len(xs)-k]),len(xs)-2*k))
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('regression 1', solve(*([(9, 1), (1, 4), (5, 2)], 2)), '7/3')
check('regression 2', solve(*([(2, 4)], 1)), '2')
check('regression 3', solve(*([], 0)), None)
check('regression 4', solve(*([(1, 2), (4, 2)], 2)), None)
check('regression 5', solve(*([(0, 1), (10, 3), (-5, 2)], 1)), '15/4')
check('regression 6', solve(*([(3, 0), (8, 1)], 0)), '8')
check('regression 7', solve(*([(1, 1), (8, 4), (9, 1)], 1)), '8')
check("variable weighted trim",solve([(N,3),(N+6,2)],1),str(Fraction(3*N+6,3)))
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 reduction disagrees with its explicit aggregation oracle.

Expand nonnegative integer frequencies. Remove exactly k lowest and k highest observations by multiplicity. Return the exact mean as a Fraction string, or None when no observations survive.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
from collections import Counter, defaultdict
import math
import itertools
N = 1
observations = []
def solve(rows, k):
    xs=sorted(x for x,w in rows for _ in range(w))
    if not xs or 2*k>=len(xs): return "0"
    return str(Fraction(sum(xs[k:len(xs)-k]),len(xs)-2*k))
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('regression 1', solve(*([(9, 1), (1, 4), (5, 2)], 2)), '7/3')
check('regression 2', solve(*([(2, 4)], 1)), '2')
check('regression 3', solve(*([], 0)), None)
check('regression 4', solve(*([(1, 2), (4, 2)], 2)), None)
check('regression 5', solve(*([(0, 1), (10, 3), (-5, 2)], 1)), '15/4')
check('regression 6', solve(*([(3, 0), (8, 1)], 0)), '8')
check('regression 7', solve(*([(1, 1), (8, 4), (9, 1)], 1)), '8')
check("variable weighted trim",solve([(N,3),(N+6,2)],1),str(Fraction(3*N+6,3)))
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
from fractions import Fraction
from collections import Counter, defaultdict
import math
import itertools
N = 1
observations = []
def solve(rows, k):
    xs=sorted(x for x,w in rows for _ in range(w))
    if not xs or 2*k>=len(xs): return "0/0"
    return str(Fraction(sum(xs[k:len(xs)-k]),len(xs)-2*k))
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('regression 1', solve(*([(9, 1), (1, 4), (5, 2)], 2)), '7/3')
check('regression 2', solve(*([(2, 4)], 1)), '2')
check('regression 3', solve(*([], 0)), None)
check('regression 4', solve(*([(1, 2), (4, 2)], 2)), None)
check('regression 5', solve(*([(0, 1), (10, 3), (-5, 2)], 1)), '15/4')
check('regression 6', solve(*([(3, 0), (8, 1)], 0)), '8')
check('regression 7', solve(*([(1, 1), (8, 4), (9, 1)], 1)), '8')
check("variable weighted trim",solve([(N,3),(N+6,2)],1),str(Fraction(3*N+6,3)))
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 reduction disagrees with its explicit aggregation oracle.

Expand nonnegative integer frequencies. Remove exactly k lowest and k highest observations by multiplicity. Return the exact mean as a Fraction string, or None when no observations survive.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
from collections import Counter, defaultdict
import math
import itertools
N = 1
observations = []
def solve(rows, k):
    xs=sorted(x for x,w in rows for _ in range(w))
    if not xs or 2*k>=len(xs): return None
    return str(sum(xs[k:len(xs)-k])//(len(xs)-2*k))
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('regression 1', solve(*([(9, 1), (1, 4), (5, 2)], 2)), '7/3')
check('regression 2', solve(*([(2, 4)], 1)), '2')
check('regression 3', solve(*([], 0)), None)
check('regression 4', solve(*([(1, 2), (4, 2)], 2)), None)
check('regression 5', solve(*([(0, 1), (10, 3), (-5, 2)], 1)), '15/4')
check('regression 6', solve(*([(3, 0), (8, 1)], 0)), '8')
check('regression 7', solve(*([(1, 1), (8, 4), (9, 1)], 1)), '8')
check("variable weighted trim",solve([(N,3),(N+6,2)],1),str(Fraction(3*N+6,3)))
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
from fractions import Fraction
from collections import Counter, defaultdict
import math
import itertools
N = 1
observations = []
def solve(rows, k):
    xs=sorted(x for x,w in rows for _ in range(w))
    if not xs or 2*k>=len(xs): return None
    return str(round(Fraction(sum(xs[k:len(xs)-k]),len(xs)-2*k)))
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('regression 1', solve(*([(9, 1), (1, 4), (5, 2)], 2)), '7/3')
check('regression 2', solve(*([(2, 4)], 1)), '2')
check('regression 3', solve(*([], 0)), None)
check('regression 4', solve(*([(1, 2), (4, 2)], 2)), None)
check('regression 5', solve(*([(0, 1), (10, 3), (-5, 2)], 1)), '15/4')
check('regression 6', solve(*([(3, 0), (8, 1)], 0)), '8')
check('regression 7', solve(*([(1, 1), (8, 4), (9, 1)], 1)), '8')
check("variable weighted trim",solve([(N,3),(N+6,2)],1),str(Fraction(3*N+6,3)))
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 reduction disagrees with its explicit aggregation oracle.

Expand nonnegative integer frequencies. Remove exactly k lowest and k highest observations by multiplicity. Return the exact mean as a Fraction string, or None when no observations survive.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
from collections import Counter, defaultdict
import math
import itertools
N = 1
observations = []
def solve(xs):
    counts=Counter(xs)
    n=len(xs)
    if n<2: return None
    return str(Fraction(sum(v*v for v in counts.values()),n*(n-1)))
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('regression 1', solve(*([1, 1, 2],)), '1/3')
check('regression 2', solve(*([1, 2, 3],)), '0')
check('regression 3', solve(*([],)), None)
check('regression 4', solve(*([9],)), None)
check('regression 5', solve(*([2, 2, 2, 2],)), '1')
check('regression 6', solve(*([0, 0, 1, 1, 1, 2],)), '4/15')
check('regression 7', solve(*([-1, -1, 0, 0],)), '1/3')
check("variable collision multiplicity",solve([0]*N+[1]),str(Fraction(N*(N-1),(N+1)*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
from fractions import Fraction
from collections import Counter, defaultdict
import math
import itertools
N = 1
observations = []
def solve(xs):
    counts=Counter(xs)
    n=len(xs)
    if n<2: return None
    return str(Fraction(sum(max(0,v*v-1) for v in counts.values()),n*(n-1)))
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('regression 1', solve(*([1, 1, 2],)), '1/3')
check('regression 2', solve(*([1, 2, 3],)), '0')
check('regression 3', solve(*([],)), None)
check('regression 4', solve(*([9],)), None)
check('regression 5', solve(*([2, 2, 2, 2],)), '1')
check('regression 6', solve(*([0, 0, 1, 1, 1, 2],)), '4/15')
check('regression 7', solve(*([-1, -1, 0, 0],)), '1/3')
check("variable collision multiplicity",solve([0]*N+[1]),str(Fraction(N*(N-1),(N+1)*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 reduction disagrees with its explicit aggregation oracle.

Return probability that two distinct uniformly chosen observation indices carry equal integer labels, as an exact Fraction string. Fewer than two observations returns None. Labels themselves are nominal; repeated indices are excluded.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
from collections import Counter, defaultdict
import math
import itertools
N = 1
observations = []
def solve(xs):
    counts=Counter(xs)
    n=len(xs)
    if n<2: return None
    return str(Fraction(sum(v*(v-1) for v in counts.values()),n*n))
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('regression 1', solve(*([1, 1, 2],)), '1/3')
check('regression 2', solve(*([1, 2, 3],)), '0')
check('regression 3', solve(*([],)), None)
check('regression 4', solve(*([9],)), None)
check('regression 5', solve(*([2, 2, 2, 2],)), '1')
check('regression 6', solve(*([0, 0, 1, 1, 1, 2],)), '4/15')
check('regression 7', solve(*([-1, -1, 0, 0],)), '1/3')
check("variable collision multiplicity",solve([0]*N+[1]),str(Fraction(N*(N-1),(N+1)*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
from fractions import Fraction
from collections import Counter, defaultdict
import math
import itertools
N = 1
observations = []
def solve(xs):
    counts=Counter(xs)
    n=len(xs)
    if n<2: return None
    return str(Fraction(sum(v*(v-1) for v in counts.values()),n*(n+1)))
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('regression 1', solve(*([1, 1, 2],)), '1/3')
check('regression 2', solve(*([1, 2, 3],)), '0')
check('regression 3', solve(*([],)), None)
check('regression 4', solve(*([9],)), None)
check('regression 5', solve(*([2, 2, 2, 2],)), '1')
check('regression 6', solve(*([0, 0, 1, 1, 1, 2],)), '4/15')
check('regression 7', solve(*([-1, -1, 0, 0],)), '1/3')
check("variable collision multiplicity",solve([0]*N+[1]),str(Fraction(N*(N-1),(N+1)*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 reduction disagrees with its explicit aggregation oracle.

Return probability that two distinct uniformly chosen observation indices carry equal integer labels, as an exact Fraction string. Fewer than two observations returns None. Labels themselves are nominal; repeated indices are excluded.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
from collections import Counter, defaultdict
import math
import itertools
N = 1
observations = []
def solve(xs):
    counts=Counter(xs)
    n=len(xs)
    if n<2: return None
    return str(Fraction(len(counts),n*(n-1)))
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('regression 1', solve(*([1, 1, 2],)), '1/3')
check('regression 2', solve(*([1, 2, 3],)), '0')
check('regression 3', solve(*([],)), None)
check('regression 4', solve(*([9],)), None)
check('regression 5', solve(*([2, 2, 2, 2],)), '1')
check('regression 6', solve(*([0, 0, 1, 1, 1, 2],)), '4/15')
check('regression 7', solve(*([-1, -1, 0, 0],)), '1/3')
check("variable collision multiplicity",solve([0]*N+[1]),str(Fraction(N*(N-1),(N+1)*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
from fractions import Fraction
from collections import Counter, defaultdict
import math
import itertools
N = 1
observations = []
def solve(xs):
    counts=Counter(xs)
    n=len(xs)
    if n<2: return None
    return str(Fraction(sum(v>1 for v in counts.values()),n*(n-1)))
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('regression 1', solve(*([1, 1, 2],)), '1/3')
check('regression 2', solve(*([1, 2, 3],)), '0')
check('regression 3', solve(*([],)), None)
check('regression 4', solve(*([9],)), None)
check('regression 5', solve(*([2, 2, 2, 2],)), '1')
check('regression 6', solve(*([0, 0, 1, 1, 1, 2],)), '4/15')
check('regression 7', solve(*([-1, -1, 0, 0],)), '1/3')
check("variable collision multiplicity",solve([0]*N+[1]),str(Fraction(N*(N-1),(N+1)*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 reduction disagrees with its explicit aggregation oracle.

Return probability that two distinct uniformly chosen observation indices carry equal integer labels, as an exact Fraction string. Fewer than two observations returns None. Labels themselves are nominal; repeated indices are excluded.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
from collections import Counter, defaultdict
import math
import itertools
N = 1
observations = []
def solve(xs):
    counts=Counter(xs)
    n=len(xs)
    if n<2: return None
    return str(Fraction(sum(v*(v-1)//2 for v in counts.values()),n*(n-1)))
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('regression 1', solve(*([1, 1, 2],)), '1/3')
check('regression 2', solve(*([1, 2, 3],)), '0')
check('regression 3', solve(*([],)), None)
check('regression 4', solve(*([9],)), None)
check('regression 5', solve(*([2, 2, 2, 2],)), '1')
check('regression 6', solve(*([0, 0, 1, 1, 1, 2],)), '4/15')
check('regression 7', solve(*([-1, -1, 0, 0],)), '1/3')
check("variable collision multiplicity",solve([0]*N+[1]),str(Fraction(N*(N-1),(N+1)*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
from fractions import Fraction
from collections import Counter, defaultdict
import math
import itertools
N = 1
observations = []
def solve(xs):
    counts=Counter(xs)
    n=len(xs)
    if n<2: return None
    return str(Fraction(2*sum(v*(v-1) for v in counts.values()),n*(n-1)))
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('regression 1', solve(*([1, 1, 2],)), '1/3')
check('regression 2', solve(*([1, 2, 3],)), '0')
check('regression 3', solve(*([],)), None)
check('regression 4', solve(*([9],)), None)
check('regression 5', solve(*([2, 2, 2, 2],)), '1')
check('regression 6', solve(*([0, 0, 1, 1, 1, 2],)), '4/15')
check('regression 7', solve(*([-1, -1, 0, 0],)), '1/3')
check("variable collision multiplicity",solve([0]*N+[1]),str(Fraction(N*(N-1),(N+1)*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 reduction disagrees with its explicit aggregation oracle.

Return probability that two distinct uniformly chosen observation indices carry equal integer labels, as an exact Fraction string. Fewer than two observations returns None. Labels themselves are nominal; repeated indices are excluded.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
from collections import Counter, defaultdict
import math
import itertools
N = 1
observations = []
def solve(xs):
    counts=Counter(xs)
    n=len(xs)
    if n<2: return None
    return str(Fraction(sum(v*(v-1) for v in counts.keys()),n*(n-1)))
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('regression 1', solve(*([1, 1, 2],)), '1/3')
check('regression 2', solve(*([1, 2, 3],)), '0')
check('regression 3', solve(*([],)), None)
check('regression 4', solve(*([9],)), None)
check('regression 5', solve(*([2, 2, 2, 2],)), '1')
check('regression 6', solve(*([0, 0, 1, 1, 1, 2],)), '4/15')
check('regression 7', solve(*([-1, -1, 0, 0],)), '1/3')
check("variable collision multiplicity",solve([0]*N+[1]),str(Fraction(N*(N-1),(N+1)*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
from fractions import Fraction
from collections import Counter, defaultdict
import math
import itertools
N = 1
observations = []
def solve(xs):
    counts=Counter(xs)
    n=len(xs)
    if n<2: return None
    return str(Fraction(sum(v*(v-1) for v in [abs(x) for x in counts.keys()]),n*(n-1)))
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('regression 1', solve(*([1, 1, 2],)), '1/3')
check('regression 2', solve(*([1, 2, 3],)), '0')
check('regression 3', solve(*([],)), None)
check('regression 4', solve(*([9],)), None)
check('regression 5', solve(*([2, 2, 2, 2],)), '1')
check('regression 6', solve(*([0, 0, 1, 1, 1, 2],)), '4/15')
check('regression 7', solve(*([-1, -1, 0, 0],)), '1/3')
check("variable collision multiplicity",solve([0]*N+[1]),str(Fraction(N*(N-1),(N+1)*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 reduction disagrees with its explicit aggregation oracle.

Return probability that two distinct uniformly chosen observation indices carry equal integer labels, as an exact Fraction string. Fewer than two observations returns None. Labels themselves are nominal; repeated indices are excluded.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
from collections import Counter, defaultdict
import math
import itertools
N = 1
observations = []
def solve(xs):
    counts=Counter(xs)
    n=len(xs)
    if n<2: return "0"
    return str(Fraction(sum(v*(v-1) for v in counts.values()),n*(n-1)))
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('regression 1', solve(*([1, 1, 2],)), '1/3')
check('regression 2', solve(*([1, 2, 3],)), '0')
check('regression 3', solve(*([],)), None)
check('regression 4', solve(*([9],)), None)
check('regression 5', solve(*([2, 2, 2, 2],)), '1')
check('regression 6', solve(*([0, 0, 1, 1, 1, 2],)), '4/15')
check('regression 7', solve(*([-1, -1, 0, 0],)), '1/3')
check("variable collision multiplicity",solve([0]*N+[1]),str(Fraction(N*(N-1),(N+1)*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
from fractions import Fraction
from collections import Counter, defaultdict
import math
import itertools
N = 1
observations = []
def solve(xs):
    counts=Counter(xs)
    n=len(xs)
    if n<2: return "1"
    return str(Fraction(sum(v*(v-1) for v in counts.values()),n*(n-1)))
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('regression 1', solve(*([1, 1, 2],)), '1/3')
check('regression 2', solve(*([1, 2, 3],)), '0')
check('regression 3', solve(*([],)), None)
check('regression 4', solve(*([9],)), None)
check('regression 5', solve(*([2, 2, 2, 2],)), '1')
check('regression 6', solve(*([0, 0, 1, 1, 1, 2],)), '4/15')
check('regression 7', solve(*([-1, -1, 0, 0],)), '1/3')
check("variable collision multiplicity",solve([0]*N+[1]),str(Fraction(N*(N-1),(N+1)*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 reduction disagrees with its explicit aggregation oracle.

Return probability that two distinct uniformly chosen observation indices carry equal integer labels, as an exact Fraction string. Fewer than two observations returns None. Labels themselves are nominal; repeated indices are excluded.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
from collections import Counter, defaultdict
import math
import itertools
N = 1
observations = []
def solve(xs):
    counts=Counter(xs)
    n=len(xs)
    if n<2: return None
    return str(Fraction(sum(counts.values())*(sum(counts.values())-1),n*(n-1)))
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('regression 1', solve(*([1, 1, 2],)), '1/3')
check('regression 2', solve(*([1, 2, 3],)), '0')
check('regression 3', solve(*([],)), None)
check('regression 4', solve(*([9],)), None)
check('regression 5', solve(*([2, 2, 2, 2],)), '1')
check('regression 6', solve(*([0, 0, 1, 1, 1, 2],)), '4/15')
check('regression 7', solve(*([-1, -1, 0, 0],)), '1/3')
check("variable collision multiplicity",solve([0]*N+[1]),str(Fraction(N*(N-1),(N+1)*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
from fractions import Fraction
from collections import Counter, defaultdict
import math
import itertools
N = 1
observations = []
def solve(xs):
    counts=Counter(xs)
    n=len(xs)
    if n<2: return None
    return str(Fraction(sum(v*v for v in counts.values())-len(counts),n*(n-1)))
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('regression 1', solve(*([1, 1, 2],)), '1/3')
check('regression 2', solve(*([1, 2, 3],)), '0')
check('regression 3', solve(*([],)), None)
check('regression 4', solve(*([9],)), None)
check('regression 5', solve(*([2, 2, 2, 2],)), '1')
check('regression 6', solve(*([0, 0, 1, 1, 1, 2],)), '4/15')
check('regression 7', solve(*([-1, -1, 0, 0],)), '1/3')
check("variable collision multiplicity",solve([0]*N+[1]),str(Fraction(N*(N-1),(N+1)*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 reduction disagrees with its explicit aggregation oracle.

Return probability that two distinct uniformly chosen observation indices carry equal integer labels, as an exact Fraction string. Fewer than two observations returns None. Labels themselves are nominal; repeated indices are excluded.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
from collections import Counter, defaultdict
import math
import itertools
N = 1
observations = []
def solve(xs):
    counts=Counter(xs)
    n=len(xs)
    if n<2: return None
    return str(Fraction(max(v*(v-1) for v in counts.values()),n*(n-1)))
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('regression 1', solve(*([1, 1, 2],)), '1/3')
check('regression 2', solve(*([1, 2, 3],)), '0')
check('regression 3', solve(*([],)), None)
check('regression 4', solve(*([9],)), None)
check('regression 5', solve(*([2, 2, 2, 2],)), '1')
check('regression 6', solve(*([0, 0, 1, 1, 1, 2],)), '4/15')
check('regression 7', solve(*([-1, -1, 0, 0],)), '1/3')
check("variable collision multiplicity",solve([0]*N+[1]),str(Fraction(N*(N-1),(N+1)*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
from fractions import Fraction
from collections import Counter, defaultdict
import math
import itertools
N = 1
observations = []
def solve(xs):
    counts=Counter(xs)
    n=len(xs)
    if n<2: return None
    return str(Fraction(min(v*(v-1) for v in counts.values()),n*(n-1)))
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('regression 1', solve(*([1, 1, 2],)), '1/3')
check('regression 2', solve(*([1, 2, 3],)), '0')
check('regression 3', solve(*([],)), None)
check('regression 4', solve(*([9],)), None)
check('regression 5', solve(*([2, 2, 2, 2],)), '1')
check('regression 6', solve(*([0, 0, 1, 1, 1, 2],)), '4/15')
check('regression 7', solve(*([-1, -1, 0, 0],)), '1/3')
check("variable collision multiplicity",solve([0]*N+[1]),str(Fraction(N*(N-1),(N+1)*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 reduction disagrees with its explicit aggregation oracle.

Return probability that two distinct uniformly chosen observation indices carry equal integer labels, as an exact Fraction string. Fewer than two observations returns None. Labels themselves are nominal; repeated indices are excluded.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
from collections import Counter, defaultdict
import math
import itertools
N = 1
observations = []
def solve(a, b):
    if not a or not b: return None
    ca,cb=Counter(a),Counter(b)
    pa=pb=Fraction(0)
    best=Fraction(0)
    for x in sorted(set(ca)|set(cb)):
        pa=Fraction(ca[x],len(a))
        pb=Fraction(cb[x],len(b))
        best=max(best,abs(pa-pb))
    return str(best)
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('regression 1', solve(*([3], [0])), '1')
check('regression 2', solve(*([-5, 3], [-2, 1])), '1/2')
check('regression 3', solve(*([1, 1, 4], [2, 3])), '2/3')
check('regression 4', solve(*([0, 0, 0], [0])), '0')
check('regression 5', solve(*([], [1])), None)
check('regression 6', solve(*([1, 2], [1, 2])), '0')
check('regression 7', solve(*([-5, 0, 8], [-2, 8, 8, 8])), '5/12')
check('regression 8', solve(*([0, 4], [0, 1, 2, 3, 4])), '3/10')
check('regression 9', solve(*([2, 2], [1, 1, 3, 3])), '1/2')
check("variable support",solve([0,N],[N,N]),"1/2")
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
from fractions import Fraction
from collections import Counter, defaultdict
import math
import itertools
N = 1
observations = []
def solve(a, b):
    if not a or not b: return None
    ca,cb=Counter(a),Counter(b)
    pa=pb=Fraction(0)
    best=Fraction(0)
    for x in sorted(set(ca)|set(cb)):
        pa+=Fraction(ca[x],len(a))
        pb=Fraction(cb[x],len(b))
        best=max(best,abs(pa-pb))
    return str(best)
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('regression 1', solve(*([3], [0])), '1')
check('regression 2', solve(*([-5, 3], [-2, 1])), '1/2')
check('regression 3', solve(*([1, 1, 4], [2, 3])), '2/3')
check('regression 4', solve(*([0, 0, 0], [0])), '0')
check('regression 5', solve(*([], [1])), None)
check('regression 6', solve(*([1, 2], [1, 2])), '0')
check('regression 7', solve(*([-5, 0, 8], [-2, 8, 8, 8])), '5/12')
check('regression 8', solve(*([0, 4], [0, 1, 2, 3, 4])), '3/10')
check('regression 9', solve(*([2, 2], [1, 1, 3, 3])), '1/2')
check("variable support",solve([0,N],[N,N]),"1/2")
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 reduction disagrees with its explicit aggregation oracle.

Return the maximum absolute difference between the right-continuous empirical cumulative distributions of two nonempty integer samples as a Fraction string. Empty either side returns None.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
from collections import Counter, defaultdict
import math
import itertools
N = 1
observations = []
def solve(a, b):
    if not a or not b: return None
    ca,cb=Counter(a),Counter(b)
    pa=pb=Fraction(0)
    best=Fraction(0)
    for x in sorted(set(ca)|set(cb)):
        pa+=Fraction(ca[x],len(a))
        pb+=Fraction(cb[x],len(b))
        best=max(best,pa-pb)
    return str(best)
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('regression 1', solve(*([3], [0])), '1')
check('regression 2', solve(*([-5, 3], [-2, 1])), '1/2')
check('regression 3', solve(*([1, 1, 4], [2, 3])), '2/3')
check('regression 4', solve(*([0, 0, 0], [0])), '0')
check('regression 5', solve(*([], [1])), None)
check('regression 6', solve(*([1, 2], [1, 2])), '0')
check('regression 7', solve(*([-5, 0, 8], [-2, 8, 8, 8])), '5/12')
check('regression 8', solve(*([0, 4], [0, 1, 2, 3, 4])), '3/10')
check('regression 9', solve(*([2, 2], [1, 1, 3, 3])), '1/2')
check("variable support",solve([0,N],[N,N]),"1/2")
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
from fractions import Fraction
from collections import Counter, defaultdict
import math
import itertools
N = 1
observations = []
def solve(a, b):
    if not a or not b: return None
    ca,cb=Counter(a),Counter(b)
    pa=pb=Fraction(0)
    best=Fraction(0)
    for x in sorted(set(ca)|set(cb)):
        pa+=Fraction(ca[x],len(a))
        pb+=Fraction(cb[x],len(b))
        best=max(best,pb-pa)
    return str(best)
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('regression 1', solve(*([3], [0])), '1')
check('regression 2', solve(*([-5, 3], [-2, 1])), '1/2')
check('regression 3', solve(*([1, 1, 4], [2, 3])), '2/3')
check('regression 4', solve(*([0, 0, 0], [0])), '0')
check('regression 5', solve(*([], [1])), None)
check('regression 6', solve(*([1, 2], [1, 2])), '0')
check('regression 7', solve(*([-5, 0, 8], [-2, 8, 8, 8])), '5/12')
check('regression 8', solve(*([0, 4], [0, 1, 2, 3, 4])), '3/10')
check('regression 9', solve(*([2, 2], [1, 1, 3, 3])), '1/2')
check("variable support",solve([0,N],[N,N]),"1/2")
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 reduction disagrees with its explicit aggregation oracle.

Return the maximum absolute difference between the right-continuous empirical cumulative distributions of two nonempty integer samples as a Fraction string. Empty either side returns None.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
from collections import Counter, defaultdict
import math
import itertools
N = 1
observations = []
def solve(a, b):
    if not a or not b: return None
    ca,cb=Counter(a),Counter(b)
    pa=pb=Fraction(0)
    best=Fraction(0)
    for x in sorted(set(ca)|set(cb)):
        pa+=Fraction(ca[x],len(a))
        pb+=Fraction(cb[x],len(a))
        best=max(best,abs(pa-pb))
    return str(best)
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('regression 1', solve(*([3], [0])), '1')
check('regression 2', solve(*([-5, 3], [-2, 1])), '1/2')
check('regression 3', solve(*([1, 1, 4], [2, 3])), '2/3')
check('regression 4', solve(*([0, 0, 0], [0])), '0')
check('regression 5', solve(*([], [1])), None)
check('regression 6', solve(*([1, 2], [1, 2])), '0')
check('regression 7', solve(*([-5, 0, 8], [-2, 8, 8, 8])), '5/12')
check('regression 8', solve(*([0, 4], [0, 1, 2, 3, 4])), '3/10')
check('regression 9', solve(*([2, 2], [1, 1, 3, 3])), '1/2')
check("variable support",solve([0,N],[N,N]),"1/2")
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
from fractions import Fraction
from collections import Counter, defaultdict
import math
import itertools
N = 1
observations = []
def solve(a, b):
    if not a or not b: return None
    ca,cb=Counter(a),Counter(b)
    pa=pb=Fraction(0)
    best=Fraction(0)
    for x in sorted(set(ca)|set(cb)):
        pa+=Fraction(ca[x],len(a))
        pb+=Fraction(cb[x],max(len(a),len(b)))
        best=max(best,abs(pa-pb))
    return str(best)
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('regression 1', solve(*([3], [0])), '1')
check('regression 2', solve(*([-5, 3], [-2, 1])), '1/2')
check('regression 3', solve(*([1, 1, 4], [2, 3])), '2/3')
check('regression 4', solve(*([0, 0, 0], [0])), '0')
check('regression 5', solve(*([], [1])), None)
check('regression 6', solve(*([1, 2], [1, 2])), '0')
check('regression 7', solve(*([-5, 0, 8], [-2, 8, 8, 8])), '5/12')
check('regression 8', solve(*([0, 4], [0, 1, 2, 3, 4])), '3/10')
check('regression 9', solve(*([2, 2], [1, 1, 3, 3])), '1/2')
check("variable support",solve([0,N],[N,N]),"1/2")
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 reduction disagrees with its explicit aggregation oracle.

Return the maximum absolute difference between the right-continuous empirical cumulative distributions of two nonempty integer samples as a Fraction string. Empty either side returns None.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
from collections import Counter, defaultdict
import math
import itertools
N = 1
observations = []
def solve(a, b):
    if not a or not b: return None
    ca,cb=Counter(a),Counter(b)
    pa=pb=Fraction(0)
    best=Fraction(0)
    for x in sorted(set(ca)&set(cb)):
        pa+=Fraction(ca[x],len(a))
        pb+=Fraction(cb[x],len(b))
        best=max(best,abs(pa-pb))
    return str(best)
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('regression 1', solve(*([3], [0])), '1')
check('regression 2', solve(*([-5, 3], [-2, 1])), '1/2')
check('regression 3', solve(*([1, 1, 4], [2, 3])), '2/3')
check('regression 4', solve(*([0, 0, 0], [0])), '0')
check('regression 5', solve(*([], [1])), None)
check('regression 6', solve(*([1, 2], [1, 2])), '0')
check('regression 7', solve(*([-5, 0, 8], [-2, 8, 8, 8])), '5/12')
check('regression 8', solve(*([0, 4], [0, 1, 2, 3, 4])), '3/10')
check('regression 9', solve(*([2, 2], [1, 1, 3, 3])), '1/2')
check("variable support",solve([0,N],[N,N]),"1/2")
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
from fractions import Fraction
from collections import Counter, defaultdict
import math
import itertools
N = 1
observations = []
def solve(a, b):
    if not a or not b: return None
    ca,cb=Counter(a),Counter(b)
    pa=pb=Fraction(0)
    best=Fraction(0)
    for x in sorted(set(ca)):
        pa+=Fraction(ca[x],len(a))
        pb+=Fraction(cb[x],len(b))
        best=max(best,abs(pa-pb))
    return str(best)
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('regression 1', solve(*([3], [0])), '1')
check('regression 2', solve(*([-5, 3], [-2, 1])), '1/2')
check('regression 3', solve(*([1, 1, 4], [2, 3])), '2/3')
check('regression 4', solve(*([0, 0, 0], [0])), '0')
check('regression 5', solve(*([], [1])), None)
check('regression 6', solve(*([1, 2], [1, 2])), '0')
check('regression 7', solve(*([-5, 0, 8], [-2, 8, 8, 8])), '5/12')
check('regression 8', solve(*([0, 4], [0, 1, 2, 3, 4])), '3/10')
check('regression 9', solve(*([2, 2], [1, 1, 3, 3])), '1/2')
check("variable support",solve([0,N],[N,N]),"1/2")
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 reduction disagrees with its explicit aggregation oracle.

Return the maximum absolute difference between the right-continuous empirical cumulative distributions of two nonempty integer samples as a Fraction string. Empty either side returns None.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
from collections import Counter, defaultdict
import math
import itertools
N = 1
observations = []
def solve(a, b):
    if not a or not b: return None
    ca,cb=Counter(a),Counter(b)
    pa=pb=Fraction(0)
    best=Fraction(0)
    for x in sorted(set(ca)|set(cb)):
        pa+=Fraction(ca[x],len(a))
        pb+=Fraction(cb[x],len(b))
        best=max(best,abs(pa-pb),abs(pa-(pb-Fraction(cb[x],len(b)))))
    return str(best)
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('regression 1', solve(*([3], [0])), '1')
check('regression 2', solve(*([-5, 3], [-2, 1])), '1/2')
check('regression 3', solve(*([1, 1, 4], [2, 3])), '2/3')
check('regression 4', solve(*([0, 0, 0], [0])), '0')
check('regression 5', solve(*([], [1])), None)
check('regression 6', solve(*([1, 2], [1, 2])), '0')
check('regression 7', solve(*([-5, 0, 8], [-2, 8, 8, 8])), '5/12')
check('regression 8', solve(*([0, 4], [0, 1, 2, 3, 4])), '3/10')
check('regression 9', solve(*([2, 2], [1, 1, 3, 3])), '1/2')
check("variable support",solve([0,N],[N,N]),"1/2")
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
from fractions import Fraction
from collections import Counter, defaultdict
import math
import itertools
N = 1
observations = []
def solve(a, b):
    if not a or not b: return None
    ca,cb=Counter(a),Counter(b)
    pa=pb=Fraction(0)
    best=Fraction(0)
    for x in sorted(set(ca)|set(cb)):
        pa+=Fraction(ca[x],len(a))
        pb+=Fraction(cb[x],len(b))
        best=max(best,abs(pa-pb),abs((pa-Fraction(ca[x],len(a)))-pb))
    return str(best)
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('regression 1', solve(*([3], [0])), '1')
check('regression 2', solve(*([-5, 3], [-2, 1])), '1/2')
check('regression 3', solve(*([1, 1, 4], [2, 3])), '2/3')
check('regression 4', solve(*([0, 0, 0], [0])), '0')
check('regression 5', solve(*([], [1])), None)
check('regression 6', solve(*([1, 2], [1, 2])), '0')
check('regression 7', solve(*([-5, 0, 8], [-2, 8, 8, 8])), '5/12')
check('regression 8', solve(*([0, 4], [0, 1, 2, 3, 4])), '3/10')
check('regression 9', solve(*([2, 2], [1, 1, 3, 3])), '1/2')
check("variable support",solve([0,N],[N,N]),"1/2")
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 reduction disagrees with its explicit aggregation oracle.

Return the maximum absolute difference between the right-continuous empirical cumulative distributions of two nonempty integer samples as a Fraction string. Empty either side returns None.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
from collections import Counter, defaultdict
import math
import itertools
N = 1
observations = []
def solve(a, b):
    if not a or not b: return None
    ca,cb=Counter(a),Counter(b)
    pa=pb=Fraction(0)
    best=Fraction(0)
    for x in sorted(set(ca)|set(cb)):
        pa+=Fraction(ca[x],len(a))
        pb+=Fraction(cb[x],len(b))
        best=abs(pa-pb)
    return str(best)
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('regression 1', solve(*([3], [0])), '1')
check('regression 2', solve(*([-5, 3], [-2, 1])), '1/2')
check('regression 3', solve(*([1, 1, 4], [2, 3])), '2/3')
check('regression 4', solve(*([0, 0, 0], [0])), '0')
check('regression 5', solve(*([], [1])), None)
check('regression 6', solve(*([1, 2], [1, 2])), '0')
check('regression 7', solve(*([-5, 0, 8], [-2, 8, 8, 8])), '5/12')
check('regression 8', solve(*([0, 4], [0, 1, 2, 3, 4])), '3/10')
check('regression 9', solve(*([2, 2], [1, 1, 3, 3])), '1/2')
check("variable support",solve([0,N],[N,N]),"1/2")
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
from fractions import Fraction
from collections import Counter, defaultdict
import math
import itertools
N = 1
observations = []
def solve(a, b):
    if not a or not b: return None
    ca,cb=Counter(a),Counter(b)
    pa=pb=Fraction(0)
    best=Fraction(0)
    for x in sorted(set(ca)|set(cb)):
        pa+=Fraction(ca[x],len(a))
        pb+=Fraction(cb[x],len(b))
        best+=abs(pa-pb)
    return str(best)
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('regression 1', solve(*([3], [0])), '1')
check('regression 2', solve(*([-5, 3], [-2, 1])), '1/2')
check('regression 3', solve(*([1, 1, 4], [2, 3])), '2/3')
check('regression 4', solve(*([0, 0, 0], [0])), '0')
check('regression 5', solve(*([], [1])), None)
check('regression 6', solve(*([1, 2], [1, 2])), '0')
check('regression 7', solve(*([-5, 0, 8], [-2, 8, 8, 8])), '5/12')
check('regression 8', solve(*([0, 4], [0, 1, 2, 3, 4])), '3/10')
check('regression 9', solve(*([2, 2], [1, 1, 3, 3])), '1/2')
check("variable support",solve([0,N],[N,N]),"1/2")
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 reduction disagrees with its explicit aggregation oracle.

Return the maximum absolute difference between the right-continuous empirical cumulative distributions of two nonempty integer samples as a Fraction string. Empty either side returns None.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
from collections import Counter, defaultdict
import math
import itertools
N = 1
observations = []
def solve(a, b):
    if not a or not b: return None
    ca,cb=Counter(a),Counter(b)
    pa=pb=Fraction(0)
    best=Fraction(0)
    for x in sorted(set(ca)|set(cb)):
        pa+=Fraction(int(ca[x]>0),len(a))
        pb+=Fraction(cb[x],len(b))
        best=max(best,abs(pa-pb))
    return str(best)
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('regression 1', solve(*([3], [0])), '1')
check('regression 2', solve(*([-5, 3], [-2, 1])), '1/2')
check('regression 3', solve(*([1, 1, 4], [2, 3])), '2/3')
check('regression 4', solve(*([0, 0, 0], [0])), '0')
check('regression 5', solve(*([], [1])), None)
check('regression 6', solve(*([1, 2], [1, 2])), '0')
check('regression 7', solve(*([-5, 0, 8], [-2, 8, 8, 8])), '5/12')
check('regression 8', solve(*([0, 4], [0, 1, 2, 3, 4])), '3/10')
check('regression 9', solve(*([2, 2], [1, 1, 3, 3])), '1/2')
check("variable support",solve([0,N],[N,N]),"1/2")
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
from fractions import Fraction
from collections import Counter, defaultdict
import math
import itertools
N = 1
observations = []
def solve(a, b):
    if not a or not b: return None
    ca,cb=Counter(a),Counter(b)
    pa=pb=Fraction(0)
    best=Fraction(0)
    for x in sorted(set(ca)|set(cb)):
        pa+=Fraction(ca[x],max(1,len(ca)))
        pb+=Fraction(cb[x],len(b))
        best=max(best,abs(pa-pb))
    return str(best)
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('regression 1', solve(*([3], [0])), '1')
check('regression 2', solve(*([-5, 3], [-2, 1])), '1/2')
check('regression 3', solve(*([1, 1, 4], [2, 3])), '2/3')
check('regression 4', solve(*([0, 0, 0], [0])), '0')
check('regression 5', solve(*([], [1])), None)
check('regression 6', solve(*([1, 2], [1, 2])), '0')
check('regression 7', solve(*([-5, 0, 8], [-2, 8, 8, 8])), '5/12')
check('regression 8', solve(*([0, 4], [0, 1, 2, 3, 4])), '3/10')
check('regression 9', solve(*([2, 2], [1, 1, 3, 3])), '1/2')
check("variable support",solve([0,N],[N,N]),"1/2")
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 reduction disagrees with its explicit aggregation oracle.

Return the maximum absolute difference between the right-continuous empirical cumulative distributions of two nonempty integer samples as a Fraction string. Empty either side returns None.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
from collections import Counter, defaultdict
import math
import itertools
N = 1
observations = []
def solve(a, b):
    if not a or not b: return None
    ca,cb=Counter(a),Counter(b)
    pa=pb=Fraction(0)
    best=Fraction(0)
    for x in sorted(set(ca)|set(cb),key=abs):
        pa+=Fraction(ca[x],len(a))
        pb+=Fraction(cb[x],len(b))
        best=max(best,abs(pa-pb))
    return str(best)
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('regression 1', solve(*([3], [0])), '1')
check('regression 2', solve(*([-5, 3], [-2, 1])), '1/2')
check('regression 3', solve(*([1, 1, 4], [2, 3])), '2/3')
check('regression 4', solve(*([0, 0, 0], [0])), '0')
check('regression 5', solve(*([], [1])), None)
check('regression 6', solve(*([1, 2], [1, 2])), '0')
check('regression 7', solve(*([-5, 0, 8], [-2, 8, 8, 8])), '5/12')
check('regression 8', solve(*([0, 4], [0, 1, 2, 3, 4])), '3/10')
check('regression 9', solve(*([2, 2], [1, 1, 3, 3])), '1/2')
check("variable support",solve([0,N],[N,N]),"1/2")
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
from fractions import Fraction
from collections import Counter, defaultdict
import math
import itertools
N = 1
observations = []
def solve(a, b):
    if not a or not b: return None
    ca,cb=Counter(a),Counter(b)
    pa=pb=Fraction(0)
    best=Fraction(0)
    for x in list(ca)+[x for x in cb if x not in ca]:
        pa+=Fraction(ca[x],len(a))
        pb+=Fraction(cb[x],len(b))
        best=max(best,abs(pa-pb))
    return str(best)
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('regression 1', solve(*([3], [0])), '1')
check('regression 2', solve(*([-5, 3], [-2, 1])), '1/2')
check('regression 3', solve(*([1, 1, 4], [2, 3])), '2/3')
check('regression 4', solve(*([0, 0, 0], [0])), '0')
check('regression 5', solve(*([], [1])), None)
check('regression 6', solve(*([1, 2], [1, 2])), '0')
check('regression 7', solve(*([-5, 0, 8], [-2, 8, 8, 8])), '5/12')
check('regression 8', solve(*([0, 4], [0, 1, 2, 3, 4])), '3/10')
check('regression 9', solve(*([2, 2], [1, 1, 3, 3])), '1/2')
check("variable support",solve([0,N],[N,N]),"1/2")
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 reduction disagrees with its explicit aggregation oracle.

Return the maximum absolute difference between the right-continuous empirical cumulative distributions of two nonempty integer samples as a Fraction string. Empty either side returns None.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
from collections import Counter, defaultdict
import math
import itertools
N = 1
observations = []
def solve(a, b):
    if not a or not b: return None
    ca,cb=Counter(a),Counter(b)
    points=sorted(set(ca)|set(cb))
    pa=pb=Fraction(0)
    area=Fraction(0)
    for i,x in enumerate(points[:-1]):
        pa+=Fraction(ca[x],len(a))
        pb+=Fraction(cb[x],len(b))
        area+=abs(pa-pb)
    return str(area)
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('regression 1', solve(*([0, 0, 9], [1, 4])), '17/6')
check('regression 2', solve(*([2], [7])), '5')
check('regression 3', solve(*([1, 2], [1, 2])), '0')
check('regression 4', solve(*([], [1])), None)
check('regression 5', solve(*([-8, -1, 4], [-3, 9, 9])), '20/3')
check('regression 6', solve(*([0, 2, 8], [0, 8])), '4/3')
check('regression 7', solve(*([0, 10], [4, 6])), '4')
check("variable transport span",solve([0],[N]),str(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
from fractions import Fraction
from collections import Counter, defaultdict
import math
import itertools
N = 1
observations = []
def solve(a, b):
    if not a or not b: return None
    ca,cb=Counter(a),Counter(b)
    points=sorted(set(ca)|set(cb))
    pa=pb=Fraction(0)
    area=Fraction(0)
    for i,x in enumerate(points[:-1]):
        pa+=Fraction(ca[x],len(a))
        pb+=Fraction(cb[x],len(b))
        area+=abs(pa-pb)*(points[i+1]-points[0])
    return str(area)
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('regression 1', solve(*([0, 0, 9], [1, 4])), '17/6')
check('regression 2', solve(*([2], [7])), '5')
check('regression 3', solve(*([1, 2], [1, 2])), '0')
check('regression 4', solve(*([], [1])), None)
check('regression 5', solve(*([-8, -1, 4], [-3, 9, 9])), '20/3')
check('regression 6', solve(*([0, 2, 8], [0, 8])), '4/3')
check('regression 7', solve(*([0, 10], [4, 6])), '4')
check("variable transport span",solve([0],[N]),str(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 reduction disagrees with its explicit aggregation oracle.

For nonempty integer samples with equal total probability after separate normalization, return integral of absolute CDF difference over the real line as a Fraction string. Empty either side returns None.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
from collections import Counter, defaultdict
import math
import itertools
N = 1
observations = []
def solve(a, b):
    if not a or not b: return None
    ca,cb=Counter(a),Counter(b)
    points=sorted(set(ca)|set(cb))
    pa=pb=Fraction(0)
    area=Fraction(0)
    for i,x in enumerate(points[:-1]):
        pa+=Fraction(ca[x],len(a))
        pb+=Fraction(cb[x],len(b))
        area+=abs((pa-Fraction(ca[x],len(a)))-(pb-Fraction(cb[x],len(b))))*(points[i+1]-x)
    return str(area)
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('regression 1', solve(*([0, 0, 9], [1, 4])), '17/6')
check('regression 2', solve(*([2], [7])), '5')
check('regression 3', solve(*([1, 2], [1, 2])), '0')
check('regression 4', solve(*([], [1])), None)
check('regression 5', solve(*([-8, -1, 4], [-3, 9, 9])), '20/3')
check('regression 6', solve(*([0, 2, 8], [0, 8])), '4/3')
check('regression 7', solve(*([0, 10], [4, 6])), '4')
check("variable transport span",solve([0],[N]),str(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
from fractions import Fraction
from collections import Counter, defaultdict
import math
import itertools
N = 1
observations = []
def solve(a, b):
    if not a or not b: return None
    ca,cb=Counter(a),Counter(b)
    points=sorted(set(ca)|set(cb))
    pa=pb=Fraction(0)
    area=Fraction(0)
    for i,x in enumerate(points[:-1]):
        pa+=Fraction(ca[x],len(a))
        pb+=Fraction(cb[x],len(b))
        area+=abs((pa-Fraction(ca[x],len(a)))-pb)*(points[i+1]-x)
    return str(area)
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('regression 1', solve(*([0, 0, 9], [1, 4])), '17/6')
check('regression 2', solve(*([2], [7])), '5')
check('regression 3', solve(*([1, 2], [1, 2])), '0')
check('regression 4', solve(*([], [1])), None)
check('regression 5', solve(*([-8, -1, 4], [-3, 9, 9])), '20/3')
check('regression 6', solve(*([0, 2, 8], [0, 8])), '4/3')
check('regression 7', solve(*([0, 10], [4, 6])), '4')
check("variable transport span",solve([0],[N]),str(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 reduction disagrees with its explicit aggregation oracle.

For nonempty integer samples with equal total probability after separate normalization, return integral of absolute CDF difference over the real line as a Fraction string. Empty either side returns None.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
from collections import Counter, defaultdict
import math
import itertools
N = 1
observations = []
def solve(a, b):
    if not a or not b: return None
    ca,cb=Counter(a),Counter(b)
    points=sorted(set(ca)|set(cb))
    pa=pb=Fraction(0)
    area=Fraction(0)
    for i,x in enumerate(points[:-1]):
        pa+=Fraction(ca[x],len(a))
        pb+=Fraction(cb[x],len(b))
        area+=(pa-pb)*(points[i+1]-x)
    return str(abs(area))
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('regression 1', solve(*([0, 0, 9], [1, 4])), '17/6')
check('regression 2', solve(*([2], [7])), '5')
check('regression 3', solve(*([1, 2], [1, 2])), '0')
check('regression 4', solve(*([], [1])), None)
check('regression 5', solve(*([-8, -1, 4], [-3, 9, 9])), '20/3')
check('regression 6', solve(*([0, 2, 8], [0, 8])), '4/3')
check('regression 7', solve(*([0, 10], [4, 6])), '4')
check("variable transport span",solve([0],[N]),str(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
from fractions import Fraction
from collections import Counter, defaultdict
import math
import itertools
N = 1
observations = []
def solve(a, b):
    if not a or not b: return None
    ca,cb=Counter(a),Counter(b)
    points=sorted(set(ca)|set(cb))
    pa=pb=Fraction(0)
    area=Fraction(0)
    for i,x in enumerate(points[:-1]):
        pa+=Fraction(ca[x],len(a))
        pb+=Fraction(cb[x],len(b))
        area+=(pa-pb)*(points[i+1]-x)
    return str(area)
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('regression 1', solve(*([0, 0, 9], [1, 4])), '17/6')
check('regression 2', solve(*([2], [7])), '5')
check('regression 3', solve(*([1, 2], [1, 2])), '0')
check('regression 4', solve(*([], [1])), None)
check('regression 5', solve(*([-8, -1, 4], [-3, 9, 9])), '20/3')
check('regression 6', solve(*([0, 2, 8], [0, 8])), '4/3')
check('regression 7', solve(*([0, 10], [4, 6])), '4')
check("variable transport span",solve([0],[N]),str(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 reduction disagrees with its explicit aggregation oracle.

For nonempty integer samples with equal total probability after separate normalization, return integral of absolute CDF difference over the real line as a Fraction string. Empty either side returns None.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
from collections import Counter, defaultdict
import math
import itertools
N = 1
observations = []
def solve(a, b):
    if not a or not b: return None
    ca,cb=Counter(a),Counter(b)
    points=sorted(set(ca)|set(cb))
    pa=pb=Fraction(0)
    area=Fraction(0)
    for i,x in enumerate(points[:-1]):
        pa+=Fraction(ca[x],len(a))
        pb+=Fraction(cb[x],len(b))
        area+=(pa-pb)**2*(points[i+1]-x)
    return str(area)
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('regression 1', solve(*([0, 0, 9], [1, 4])), '17/6')
check('regression 2', solve(*([2], [7])), '5')
check('regression 3', solve(*([1, 2], [1, 2])), '0')
check('regression 4', solve(*([], [1])), None)
check('regression 5', solve(*([-8, -1, 4], [-3, 9, 9])), '20/3')
check('regression 6', solve(*([0, 2, 8], [0, 8])), '4/3')
check('regression 7', solve(*([0, 10], [4, 6])), '4')
check("variable transport span",solve([0],[N]),str(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
from fractions import Fraction
from collections import Counter, defaultdict
import math
import itertools
N = 1
observations = []
def solve(a, b):
    if not a or not b: return None
    ca,cb=Counter(a),Counter(b)
    points=sorted(set(ca)|set(cb))
    pa=pb=Fraction(0)
    area=Fraction(0)
    for i,x in enumerate(points[:-1]):
        pa+=Fraction(ca[x],len(a))
        pb+=Fraction(cb[x],len(b))
        area+=abs(pa-pb)*(points[i+1]-x)**2
    return str(area)
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('regression 1', solve(*([0, 0, 9], [1, 4])), '17/6')
check('regression 2', solve(*([2], [7])), '5')
check('regression 3', solve(*([1, 2], [1, 2])), '0')
check('regression 4', solve(*([], [1])), None)
check('regression 5', solve(*([-8, -1, 4], [-3, 9, 9])), '20/3')
check('regression 6', solve(*([0, 2, 8], [0, 8])), '4/3')
check('regression 7', solve(*([0, 10], [4, 6])), '4')
check("variable transport span",solve([0],[N]),str(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 reduction disagrees with its explicit aggregation oracle.

For nonempty integer samples with equal total probability after separate normalization, return integral of absolute CDF difference over the real line as a Fraction string. Empty either side returns None.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
from collections import Counter, defaultdict
import math
import itertools
N = 1
observations = []
def solve(a, b):
    if not a or not b: return None
    ca,cb=Counter(a),Counter(b)
    points=sorted(set(ca)|set(cb))
    pa=pb=Fraction(0)
    area=Fraction(0)
    for i,x in enumerate(points[:-1]):
        pa+=Fraction(ca[x],len(a))
        pb+=Fraction(cb[x],len(b))
        area+=abs(pa-pb)*(points[i+1]-x)
    return str(points[-1]-points[0])
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('regression 1', solve(*([0, 0, 9], [1, 4])), '17/6')
check('regression 2', solve(*([2], [7])), '5')
check('regression 3', solve(*([1, 2], [1, 2])), '0')
check('regression 4', solve(*([], [1])), None)
check('regression 5', solve(*([-8, -1, 4], [-3, 9, 9])), '20/3')
check('regression 6', solve(*([0, 2, 8], [0, 8])), '4/3')
check('regression 7', solve(*([0, 10], [4, 6])), '4')
check("variable transport span",solve([0],[N]),str(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
from fractions import Fraction
from collections import Counter, defaultdict
import math
import itertools
N = 1
observations = []
def solve(a, b):
    if not a or not b: return None
    ca,cb=Counter(a),Counter(b)
    points=sorted(set(ca)|set(cb))
    pa=pb=Fraction(0)
    area=Fraction(0)
    for i,x in enumerate(points[:-1]):
        pa+=Fraction(ca[x],len(a))
        pb+=Fraction(cb[x],len(b))
        area+=abs(pa-pb)*(points[i+1]-x)
    return str(abs(Fraction(sum(a),len(a))-Fraction(sum(b),len(b))))
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('regression 1', solve(*([0, 0, 9], [1, 4])), '17/6')
check('regression 2', solve(*([2], [7])), '5')
check('regression 3', solve(*([1, 2], [1, 2])), '0')
check('regression 4', solve(*([], [1])), None)
check('regression 5', solve(*([-8, -1, 4], [-3, 9, 9])), '20/3')
check('regression 6', solve(*([0, 2, 8], [0, 8])), '4/3')
check('regression 7', solve(*([0, 10], [4, 6])), '4')
check("variable transport span",solve([0],[N]),str(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 reduction disagrees with its explicit aggregation oracle.

For nonempty integer samples with equal total probability after separate normalization, return integral of absolute CDF difference over the real line as a Fraction string. Empty either side returns None.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
from collections import Counter, defaultdict
import math
import itertools
N = 1
observations = []
def solve(a, b):
    if not a or not b: return None
    ca,cb=Counter(a),Counter(b)
    points=sorted(set(ca)|set(cb))
    pa=pb=Fraction(0)
    area=Fraction(0)
    for i,x in enumerate(points[:-1]):
        pa+=Fraction(ca[x],len(a))
        pb+=Fraction(cb[x],len(b))
        area=max(area,abs(pa-pb)*(points[i+1]-x))
    return str(area)
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('regression 1', solve(*([0, 0, 9], [1, 4])), '17/6')
check('regression 2', solve(*([2], [7])), '5')
check('regression 3', solve(*([1, 2], [1, 2])), '0')
check('regression 4', solve(*([], [1])), None)
check('regression 5', solve(*([-8, -1, 4], [-3, 9, 9])), '20/3')
check('regression 6', solve(*([0, 2, 8], [0, 8])), '4/3')
check('regression 7', solve(*([0, 10], [4, 6])), '4')
check("variable transport span",solve([0],[N]),str(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
from fractions import Fraction
from collections import Counter, defaultdict
import math
import itertools
N = 1
observations = []
def solve(a, b):
    if not a or not b: return None
    ca,cb=Counter(a),Counter(b)
    points=sorted(set(ca)|set(cb))
    pa=pb=Fraction(0)
    area=Fraction(0)
    for i,x in enumerate(points[:-1]):
        pa+=Fraction(ca[x],len(a))
        pb+=Fraction(cb[x],len(b))
        area=max(area,abs(pa-pb))
    return str(area)
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('regression 1', solve(*([0, 0, 9], [1, 4])), '17/6')
check('regression 2', solve(*([2], [7])), '5')
check('regression 3', solve(*([1, 2], [1, 2])), '0')
check('regression 4', solve(*([], [1])), None)
check('regression 5', solve(*([-8, -1, 4], [-3, 9, 9])), '20/3')
check('regression 6', solve(*([0, 2, 8], [0, 8])), '4/3')
check('regression 7', solve(*([0, 10], [4, 6])), '4')
check("variable transport span",solve([0],[N]),str(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 reduction disagrees with its explicit aggregation oracle.

For nonempty integer samples with equal total probability after separate normalization, return integral of absolute CDF difference over the real line as a Fraction string. Empty either side returns None.

split: open-access