broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
import math
import struct
N = 1
observations = []
def solve(q,g,r,s,sign,mode):
    inexact=bool(g or r or s)
    if mode == 'nearest-even': increment=bool(g and (r or s or q%2))
    elif mode == 'nearest-away': increment=bool(g)
    elif mode == 'up': increment=inexact
    elif mode == 'down': increment=sign<0 and inexact
    else: increment=False
    value=sign*(q+int(increment))
    return [value,inexact,bool(increment)]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('tie even', solve(2*N,1,0,0,1,"nearest-even"), [2*N,True,False])
check('tie odd', solve(2*N+1,1,0,0,1,"nearest-even"), [2*N+2,True,True])
check('above tie sticky', solve(2*N,1,0,1,1,"nearest-even"), [2*N+1,True,True])
check('above tie round', solve(2*N,1,1,0,1,"nearest-even"), [2*N+1,True,True])
check('below half', solve(2*N,0,1,1,1,"nearest-even"), [2*N,True,False])
check('nearest away', solve(2*N,1,0,0,-1,"nearest-away"), [-2*N-1,True,True])
check('up positive', solve(N,0,0,1,1,"up"), [N+1,True,True])
check('up negative', solve(N,1,1,1,-1,"up"), [-N,True,False])
check('down negative', solve(N,0,1,0,-1,"down"), [-N-1,True,True])
check('down positive', solve(N,1,1,1,1,"down"), [N,True,False])
check('truncate', solve(N,1,1,1,-1,"zero"), [-N,True,False])
check('exact', solve(N,0,0,0,1,"up"), [N,False,False])
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
import math
import struct
N = 1
observations = []
def solve(q,g,r,s,sign,mode):
    inexact=bool(g or r or s)
    if mode == 'nearest-even': increment=bool(g and (r or s or q%2))
    elif mode == 'nearest-away': increment=bool(g)
    elif mode == 'up': increment=sign<0 and inexact
    elif mode == 'down': increment=sign<0 and inexact
    else: increment=False
    value=sign*(q+int(increment))
    return [value,inexact,bool(increment)]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('tie even', solve(2*N,1,0,0,1,"nearest-even"), [2*N,True,False])
check('tie odd', solve(2*N+1,1,0,0,1,"nearest-even"), [2*N+2,True,True])
check('above tie sticky', solve(2*N,1,0,1,1,"nearest-even"), [2*N+1,True,True])
check('above tie round', solve(2*N,1,1,0,1,"nearest-even"), [2*N+1,True,True])
check('below half', solve(2*N,0,1,1,1,"nearest-even"), [2*N,True,False])
check('nearest away', solve(2*N,1,0,0,-1,"nearest-away"), [-2*N-1,True,True])
check('up positive', solve(N,0,0,1,1,"up"), [N+1,True,True])
check('up negative', solve(N,1,1,1,-1,"up"), [-N,True,False])
check('down negative', solve(N,0,1,0,-1,"down"), [-N-1,True,True])
check('down positive', solve(N,1,1,1,1,"down"), [N,True,False])
check('truncate', solve(N,1,1,1,-1,"zero"), [-N,True,False])
check('exact', solve(N,0,0,0,1,"up"), [N,False,False])
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:
Rounding upward increments negative magnitudes.

Round a nonnegative integer significand q with guard, round and sticky bits. Modes are nearest-even, nearest-away, zero, up, down; sign is +1 or -1. Return rounded signed integer, inexact flag, and whether rounding incremented the magnitude.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
import math
import struct
N = 1
observations = []
def solve(q,g,r,s,sign,mode):
    inexact=bool(g or r or s)
    if mode == 'nearest-even': increment=bool(g and (r or s or q%2))
    elif mode == 'nearest-away': increment=bool(g)
    elif mode == 'up': increment=sign>0 and inexact
    elif mode == 'down': increment=inexact
    else: increment=False
    value=sign*(q+int(increment))
    return [value,inexact,bool(increment)]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('tie even', solve(2*N,1,0,0,1,"nearest-even"), [2*N,True,False])
check('tie odd', solve(2*N+1,1,0,0,1,"nearest-even"), [2*N+2,True,True])
check('above tie sticky', solve(2*N,1,0,1,1,"nearest-even"), [2*N+1,True,True])
check('above tie round', solve(2*N,1,1,0,1,"nearest-even"), [2*N+1,True,True])
check('below half', solve(2*N,0,1,1,1,"nearest-even"), [2*N,True,False])
check('nearest away', solve(2*N,1,0,0,-1,"nearest-away"), [-2*N-1,True,True])
check('up positive', solve(N,0,0,1,1,"up"), [N+1,True,True])
check('up negative', solve(N,1,1,1,-1,"up"), [-N,True,False])
check('down negative', solve(N,0,1,0,-1,"down"), [-N-1,True,True])
check('down positive', solve(N,1,1,1,1,"down"), [N,True,False])
check('truncate', solve(N,1,1,1,-1,"zero"), [-N,True,False])
check('exact', solve(N,0,0,0,1,"up"), [N,False,False])
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
import math
import struct
N = 1
observations = []
def solve(q,g,r,s,sign,mode):
    inexact=bool(g or r or s)
    if mode == 'nearest-even': increment=bool(g and (r or s or q%2))
    elif mode == 'nearest-away': increment=bool(g)
    elif mode == 'up': increment=sign>0 and inexact
    elif mode == 'down': increment=sign>0 and inexact
    else: increment=False
    value=sign*(q+int(increment))
    return [value,inexact,bool(increment)]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('tie even', solve(2*N,1,0,0,1,"nearest-even"), [2*N,True,False])
check('tie odd', solve(2*N+1,1,0,0,1,"nearest-even"), [2*N+2,True,True])
check('above tie sticky', solve(2*N,1,0,1,1,"nearest-even"), [2*N+1,True,True])
check('above tie round', solve(2*N,1,1,0,1,"nearest-even"), [2*N+1,True,True])
check('below half', solve(2*N,0,1,1,1,"nearest-even"), [2*N,True,False])
check('nearest away', solve(2*N,1,0,0,-1,"nearest-away"), [-2*N-1,True,True])
check('up positive', solve(N,0,0,1,1,"up"), [N+1,True,True])
check('up negative', solve(N,1,1,1,-1,"up"), [-N,True,False])
check('down negative', solve(N,0,1,0,-1,"down"), [-N-1,True,True])
check('down positive', solve(N,1,1,1,1,"down"), [N,True,False])
check('truncate', solve(N,1,1,1,-1,"zero"), [-N,True,False])
check('exact', solve(N,0,0,0,1,"up"), [N,False,False])
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:
Rounding downward increments positive magnitudes.

Round a nonnegative integer significand q with guard, round and sticky bits. Modes are nearest-even, nearest-away, zero, up, down; sign is +1 or -1. Return rounded signed integer, inexact flag, and whether rounding incremented the magnitude.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
import math
import struct
N = 1
observations = []
def solve(q,g,r,s,sign,mode):
    inexact=bool(g or r or s)
    if mode == 'nearest-even': increment=bool(g and (r or s or q%2))
    elif mode == 'nearest-away': increment=bool(g)
    elif mode == 'up': increment=sign>0 and inexact
    elif mode == 'down': increment=sign<0 and inexact
    else: increment=bool(g)
    value=sign*(q+int(increment))
    return [value,inexact,bool(increment)]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('tie even', solve(2*N,1,0,0,1,"nearest-even"), [2*N,True,False])
check('tie odd', solve(2*N+1,1,0,0,1,"nearest-even"), [2*N+2,True,True])
check('above tie sticky', solve(2*N,1,0,1,1,"nearest-even"), [2*N+1,True,True])
check('above tie round', solve(2*N,1,1,0,1,"nearest-even"), [2*N+1,True,True])
check('below half', solve(2*N,0,1,1,1,"nearest-even"), [2*N,True,False])
check('nearest away', solve(2*N,1,0,0,-1,"nearest-away"), [-2*N-1,True,True])
check('up positive', solve(N,0,0,1,1,"up"), [N+1,True,True])
check('up negative', solve(N,1,1,1,-1,"up"), [-N,True,False])
check('down negative', solve(N,0,1,0,-1,"down"), [-N-1,True,True])
check('down positive', solve(N,1,1,1,1,"down"), [N,True,False])
check('truncate', solve(N,1,1,1,-1,"zero"), [-N,True,False])
check('exact', solve(N,0,0,0,1,"up"), [N,False,False])
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
import math
import struct
N = 1
observations = []
def solve(q,g,r,s,sign,mode):
    inexact=bool(g or r or s)
    if mode == 'nearest-even': increment=bool(g and (r or s or q%2))
    elif mode == 'nearest-away': increment=bool(g)
    elif mode == 'up': increment=sign>0 and inexact
    elif mode == 'down': increment=sign<0 and inexact
    else: increment=inexact
    value=sign*(q+int(increment))
    return [value,inexact,bool(increment)]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('tie even', solve(2*N,1,0,0,1,"nearest-even"), [2*N,True,False])
check('tie odd', solve(2*N+1,1,0,0,1,"nearest-even"), [2*N+2,True,True])
check('above tie sticky', solve(2*N,1,0,1,1,"nearest-even"), [2*N+1,True,True])
check('above tie round', solve(2*N,1,1,0,1,"nearest-even"), [2*N+1,True,True])
check('below half', solve(2*N,0,1,1,1,"nearest-even"), [2*N,True,False])
check('nearest away', solve(2*N,1,0,0,-1,"nearest-away"), [-2*N-1,True,True])
check('up positive', solve(N,0,0,1,1,"up"), [N+1,True,True])
check('up negative', solve(N,1,1,1,-1,"up"), [-N,True,False])
check('down negative', solve(N,0,1,0,-1,"down"), [-N-1,True,True])
check('down positive', solve(N,1,1,1,1,"down"), [N,True,False])
check('truncate', solve(N,1,1,1,-1,"zero"), [-N,True,False])
check('exact', solve(N,0,0,0,1,"up"), [N,False,False])
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:
Truncation applies the nearest rounding increment.

Round a nonnegative integer significand q with guard, round and sticky bits. Modes are nearest-even, nearest-away, zero, up, down; sign is +1 or -1. Return rounded signed integer, inexact flag, and whether rounding incremented the magnitude.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
import math
import struct
N = 1
observations = []
def solve(q,g,r,s,sign,mode):
    inexact=bool(g or r or s)
    if mode == 'nearest-even': increment=bool(g and (r or s or q%2))
    elif mode == 'nearest-away': increment=bool(g)
    elif mode == 'up': increment=sign>0 and inexact
    elif mode == 'down': increment=sign<0 and inexact
    else: increment=False
    value=sign*q+int(increment)
    return [value,inexact,bool(increment)]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('tie even', solve(2*N,1,0,0,1,"nearest-even"), [2*N,True,False])
check('tie odd', solve(2*N+1,1,0,0,1,"nearest-even"), [2*N+2,True,True])
check('above tie sticky', solve(2*N,1,0,1,1,"nearest-even"), [2*N+1,True,True])
check('above tie round', solve(2*N,1,1,0,1,"nearest-even"), [2*N+1,True,True])
check('below half', solve(2*N,0,1,1,1,"nearest-even"), [2*N,True,False])
check('nearest away', solve(2*N,1,0,0,-1,"nearest-away"), [-2*N-1,True,True])
check('up positive', solve(N,0,0,1,1,"up"), [N+1,True,True])
check('up negative', solve(N,1,1,1,-1,"up"), [-N,True,False])
check('down negative', solve(N,0,1,0,-1,"down"), [-N-1,True,True])
check('down positive', solve(N,1,1,1,1,"down"), [N,True,False])
check('truncate', solve(N,1,1,1,-1,"zero"), [-N,True,False])
check('exact', solve(N,0,0,0,1,"up"), [N,False,False])
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
import math
import struct
N = 1
observations = []
def solve(q,g,r,s,sign,mode):
    inexact=bool(g or r or s)
    if mode == 'nearest-even': increment=bool(g and (r or s or q%2))
    elif mode == 'nearest-away': increment=bool(g)
    elif mode == 'up': increment=sign>0 and inexact
    elif mode == 'down': increment=sign<0 and inexact
    else: increment=False
    value=sign*q-int(increment)
    return [value,inexact,bool(increment)]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('tie even', solve(2*N,1,0,0,1,"nearest-even"), [2*N,True,False])
check('tie odd', solve(2*N+1,1,0,0,1,"nearest-even"), [2*N+2,True,True])
check('above tie sticky', solve(2*N,1,0,1,1,"nearest-even"), [2*N+1,True,True])
check('above tie round', solve(2*N,1,1,0,1,"nearest-even"), [2*N+1,True,True])
check('below half', solve(2*N,0,1,1,1,"nearest-even"), [2*N,True,False])
check('nearest away', solve(2*N,1,0,0,-1,"nearest-away"), [-2*N-1,True,True])
check('up positive', solve(N,0,0,1,1,"up"), [N+1,True,True])
check('up negative', solve(N,1,1,1,-1,"up"), [-N,True,False])
check('down negative', solve(N,0,1,0,-1,"down"), [-N-1,True,True])
check('down positive', solve(N,1,1,1,1,"down"), [N,True,False])
check('truncate', solve(N,1,1,1,-1,"zero"), [-N,True,False])
check('exact', solve(N,0,0,0,1,"up"), [N,False,False])
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:
Rounding increments after applying the negative sign.

Round a nonnegative integer significand q with guard, round and sticky bits. Modes are nearest-even, nearest-away, zero, up, down; sign is +1 or -1. Return rounded signed integer, inexact flag, and whether rounding incremented the magnitude.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
import math
import struct
N = 1
observations = []
def solve(x):
    sign=128 if math.copysign(1.0,x)<0 else 0
    x=abs(x)
    if x == 0: return 0
    if x >= 248: return sign|120
    if x < 2**-6:
        q=round(x*512)
        return sign|q
    m,e=math.frexp(x)
    e-=1
    q=round(m*16)
    if q == 16:
        q=8
        e+=1
    if e>7: return sign|120
    exponent=e+7
    fraction=q-8
    return sign|(exponent<<3)|fraction
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('zero', solve(0.0), 0)
check('negative zero', solve(-0.0), 128)
check('subnormal', solve(N/512), N)
check('negative subnormal', solve(-N/512), 128|N)
check('underflow tie', solve(1/1024), 0)
check('subnormal carry', solve(15/1024), 8)
check('normal varying', solve(2.0**N), (N+7)<<3)
check('normal fraction', solve((8+N)/8), 56+N)
check('binade carry', solve(1.9375), 64)
check('below midpoint', solve(1.90625), 63)
check('largest finite', solve(240.0), 119)
check('overflow tie', solve(248.0), 120)
check('negative overflow', solve(-256.0), 248)
check('minimum normal', solve(1/64), 8)
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
import math
import struct
N = 1
observations = []
def solve(x):
    sign=128 if math.copysign(1.0,x)<0 else 0
    x=abs(x)
    if x == 0: return 128
    if x >= 248: return sign|120
    if x < 2**-6:
        q=round(x*512)
        return sign|q
    m,e=math.frexp(x)
    e-=1
    q=round(m*16)
    if q == 16:
        q=8
        e+=1
    if e>7: return sign|120
    exponent=e+7
    fraction=q-8
    return sign|(exponent<<3)|fraction
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('zero', solve(0.0), 0)
check('negative zero', solve(-0.0), 128)
check('subnormal', solve(N/512), N)
check('negative subnormal', solve(-N/512), 128|N)
check('underflow tie', solve(1/1024), 0)
check('subnormal carry', solve(15/1024), 8)
check('normal varying', solve(2.0**N), (N+7)<<3)
check('normal fraction', solve((8+N)/8), 56+N)
check('binade carry', solve(1.9375), 64)
check('below midpoint', solve(1.90625), 63)
check('largest finite', solve(240.0), 119)
check('overflow tie', solve(248.0), 120)
check('negative overflow', solve(-256.0), 248)
check('minimum normal', solve(1/64), 8)
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:
Encoding flushes signed zero to positive zero.

Encode finite exactly represented dyadic x into sign/4-bit-exponent/3-bit-fraction toy float with bias 7, gradual underflow, round-to-nearest-even and infinity overflow. Return the unsigned byte. The miniature format is stipulated, not a hardware conformance claim.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
import math
import struct
N = 1
observations = []
def solve(x):
    sign=128 if math.copysign(1.0,x)<0 else 0
    x=abs(x)
    if x == 0: return sign
    if x >= 240: return sign|120
    if x < 2**-6:
        q=round(x*512)
        return sign|q
    m,e=math.frexp(x)
    e-=1
    q=round(m*16)
    if q == 16:
        q=8
        e+=1
    if e>7: return sign|120
    exponent=e+7
    fraction=q-8
    return sign|(exponent<<3)|fraction
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('zero', solve(0.0), 0)
check('negative zero', solve(-0.0), 128)
check('subnormal', solve(N/512), N)
check('negative subnormal', solve(-N/512), 128|N)
check('underflow tie', solve(1/1024), 0)
check('subnormal carry', solve(15/1024), 8)
check('normal varying', solve(2.0**N), (N+7)<<3)
check('normal fraction', solve((8+N)/8), 56+N)
check('binade carry', solve(1.9375), 64)
check('below midpoint', solve(1.90625), 63)
check('largest finite', solve(240.0), 119)
check('overflow tie', solve(248.0), 120)
check('negative overflow', solve(-256.0), 248)
check('minimum normal', solve(1/64), 8)
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
import math
import struct
N = 1
observations = []
def solve(x):
    sign=128 if math.copysign(1.0,x)<0 else 0
    x=abs(x)
    if x == 0: return sign
    if x >= 248: return sign|119
    if x < 2**-6:
        q=round(x*512)
        return sign|q
    m,e=math.frexp(x)
    e-=1
    q=round(m*16)
    if q == 16:
        q=8
        e+=1
    if e>7: return sign|120
    exponent=e+7
    fraction=q-8
    return sign|(exponent<<3)|fraction
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('zero', solve(0.0), 0)
check('negative zero', solve(-0.0), 128)
check('subnormal', solve(N/512), N)
check('negative subnormal', solve(-N/512), 128|N)
check('underflow tie', solve(1/1024), 0)
check('subnormal carry', solve(15/1024), 8)
check('normal varying', solve(2.0**N), (N+7)<<3)
check('normal fraction', solve((8+N)/8), 56+N)
check('binade carry', solve(1.9375), 64)
check('below midpoint', solve(1.90625), 63)
check('largest finite', solve(240.0), 119)
check('overflow tie', solve(248.0), 120)
check('negative overflow', solve(-256.0), 248)
check('minimum normal', solve(1/64), 8)
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:
Overflow uses the largest finite value as its threshold.

Encode finite exactly represented dyadic x into sign/4-bit-exponent/3-bit-fraction toy float with bias 7, gradual underflow, round-to-nearest-even and infinity overflow. Return the unsigned byte. The miniature format is stipulated, not a hardware conformance claim.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
import math
import struct
N = 1
observations = []
def solve(x):
    sign=128 if math.copysign(1.0,x)<0 else 0
    x=abs(x)
    if x == 0: return sign
    if x >= 248: return sign|120
    if x < 2**-6:
        q=0
        return sign|q
    m,e=math.frexp(x)
    e-=1
    q=round(m*16)
    if q == 16:
        q=8
        e+=1
    if e>7: return sign|120
    exponent=e+7
    fraction=q-8
    return sign|(exponent<<3)|fraction
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('zero', solve(0.0), 0)
check('negative zero', solve(-0.0), 128)
check('subnormal', solve(N/512), N)
check('negative subnormal', solve(-N/512), 128|N)
check('underflow tie', solve(1/1024), 0)
check('subnormal carry', solve(15/1024), 8)
check('normal varying', solve(2.0**N), (N+7)<<3)
check('normal fraction', solve((8+N)/8), 56+N)
check('binade carry', solve(1.9375), 64)
check('below midpoint', solve(1.90625), 63)
check('largest finite', solve(240.0), 119)
check('overflow tie', solve(248.0), 120)
check('negative overflow', solve(-256.0), 248)
check('minimum normal', solve(1/64), 8)
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
import math
import struct
N = 1
observations = []
def solve(x):
    sign=128 if math.copysign(1.0,x)<0 else 0
    x=abs(x)
    if x == 0: return sign
    if x >= 248: return sign|120
    if x < 2**-6:
        q=1
        return sign|q
    m,e=math.frexp(x)
    e-=1
    q=round(m*16)
    if q == 16:
        q=8
        e+=1
    if e>7: return sign|120
    exponent=e+7
    fraction=q-8
    return sign|(exponent<<3)|fraction
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('zero', solve(0.0), 0)
check('negative zero', solve(-0.0), 128)
check('subnormal', solve(N/512), N)
check('negative subnormal', solve(-N/512), 128|N)
check('underflow tie', solve(1/1024), 0)
check('subnormal carry', solve(15/1024), 8)
check('normal varying', solve(2.0**N), (N+7)<<3)
check('normal fraction', solve((8+N)/8), 56+N)
check('binade carry', solve(1.9375), 64)
check('below midpoint', solve(1.90625), 63)
check('largest finite', solve(240.0), 119)
check('overflow tie', solve(248.0), 120)
check('negative overflow', solve(-256.0), 248)
check('minimum normal', solve(1/64), 8)
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:
Encoder flushes all subnormals.

Encode finite exactly represented dyadic x into sign/4-bit-exponent/3-bit-fraction toy float with bias 7, gradual underflow, round-to-nearest-even and infinity overflow. Return the unsigned byte. The miniature format is stipulated, not a hardware conformance claim.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
import math
import struct
N = 1
observations = []
def solve(x):
    sign=128 if math.copysign(1.0,x)<0 else 0
    x=abs(x)
    if x == 0: return sign
    if x >= 248: return sign|120
    if x < 2**-6:
        q=round(x*512)
        return sign|(q&7)
    m,e=math.frexp(x)
    e-=1
    q=round(m*16)
    if q == 16:
        q=8
        e+=1
    if e>7: return sign|120
    exponent=e+7
    fraction=q-8
    return sign|(exponent<<3)|fraction
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('zero', solve(0.0), 0)
check('negative zero', solve(-0.0), 128)
check('subnormal', solve(N/512), N)
check('negative subnormal', solve(-N/512), 128|N)
check('underflow tie', solve(1/1024), 0)
check('subnormal carry', solve(15/1024), 8)
check('normal varying', solve(2.0**N), (N+7)<<3)
check('normal fraction', solve((8+N)/8), 56+N)
check('binade carry', solve(1.9375), 64)
check('below midpoint', solve(1.90625), 63)
check('largest finite', solve(240.0), 119)
check('overflow tie', solve(248.0), 120)
check('negative overflow', solve(-256.0), 248)
check('minimum normal', solve(1/64), 8)
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
import math
import struct
N = 1
observations = []
def solve(x):
    sign=128 if math.copysign(1.0,x)<0 else 0
    x=abs(x)
    if x == 0: return sign
    if x >= 248: return sign|120
    if x < 2**-6:
        q=round(x*512)
        return sign|min(q,7)
    m,e=math.frexp(x)
    e-=1
    q=round(m*16)
    if q == 16:
        q=8
        e+=1
    if e>7: return sign|120
    exponent=e+7
    fraction=q-8
    return sign|(exponent<<3)|fraction
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('zero', solve(0.0), 0)
check('negative zero', solve(-0.0), 128)
check('subnormal', solve(N/512), N)
check('negative subnormal', solve(-N/512), 128|N)
check('underflow tie', solve(1/1024), 0)
check('subnormal carry', solve(15/1024), 8)
check('normal varying', solve(2.0**N), (N+7)<<3)
check('normal fraction', solve((8+N)/8), 56+N)
check('binade carry', solve(1.9375), 64)
check('below midpoint', solve(1.90625), 63)
check('largest finite', solve(240.0), 119)
check('overflow tie', solve(248.0), 120)
check('negative overflow', solve(-256.0), 248)
check('minimum normal', solve(1/64), 8)
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:
Subnormal rounding carry is masked away.

Encode finite exactly represented dyadic x into sign/4-bit-exponent/3-bit-fraction toy float with bias 7, gradual underflow, round-to-nearest-even and infinity overflow. Return the unsigned byte. The miniature format is stipulated, not a hardware conformance claim.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
import math
import struct
N = 1
observations = []
def solve(x):
    sign=128 if math.copysign(1.0,x)<0 else 0
    x=abs(x)
    if x == 0: return sign
    if x >= 248: return sign|120
    if x < 2**-6:
        q=round(x*512)
        return sign|q
    m,e=math.frexp(x)
    e+=0
    q=round(m*16)
    if q == 16:
        q=8
        e+=1
    if e>7: return sign|120
    exponent=e+7
    fraction=q-8
    return sign|(exponent<<3)|fraction
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('zero', solve(0.0), 0)
check('negative zero', solve(-0.0), 128)
check('subnormal', solve(N/512), N)
check('negative subnormal', solve(-N/512), 128|N)
check('underflow tie', solve(1/1024), 0)
check('subnormal carry', solve(15/1024), 8)
check('normal varying', solve(2.0**N), (N+7)<<3)
check('normal fraction', solve((8+N)/8), 56+N)
check('binade carry', solve(1.9375), 64)
check('below midpoint', solve(1.90625), 63)
check('largest finite', solve(240.0), 119)
check('overflow tie', solve(248.0), 120)
check('negative overflow', solve(-256.0), 248)
check('minimum normal', solve(1/64), 8)
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
import math
import struct
N = 1
observations = []
def solve(x):
    sign=128 if math.copysign(1.0,x)<0 else 0
    x=abs(x)
    if x == 0: return sign
    if x >= 248: return sign|120
    if x < 2**-6:
        q=round(x*512)
        return sign|q
    m,e=math.frexp(x)
    e-=2
    q=round(m*16)
    if q == 16:
        q=8
        e+=1
    if e>7: return sign|120
    exponent=e+7
    fraction=q-8
    return sign|(exponent<<3)|fraction
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('zero', solve(0.0), 0)
check('negative zero', solve(-0.0), 128)
check('subnormal', solve(N/512), N)
check('negative subnormal', solve(-N/512), 128|N)
check('underflow tie', solve(1/1024), 0)
check('subnormal carry', solve(15/1024), 8)
check('normal varying', solve(2.0**N), (N+7)<<3)
check('normal fraction', solve((8+N)/8), 56+N)
check('binade carry', solve(1.9375), 64)
check('below midpoint', solve(1.90625), 63)
check('largest finite', solve(240.0), 119)
check('overflow tie', solve(248.0), 120)
check('negative overflow', solve(-256.0), 248)
check('minimum normal', solve(1/64), 8)
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:
Encoder treats frexp mantissa as having a unit leading bit.

Encode finite exactly represented dyadic x into sign/4-bit-exponent/3-bit-fraction toy float with bias 7, gradual underflow, round-to-nearest-even and infinity overflow. Return the unsigned byte. The miniature format is stipulated, not a hardware conformance claim.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
import math
import struct
N = 1
observations = []
def solve(x):
    sign=128 if math.copysign(1.0,x)<0 else 0
    x=abs(x)
    if x == 0: return sign
    if x >= 248: return sign|120
    if x < 2**-6:
        q=round(x*512)
        return sign|q
    m,e=math.frexp(x)
    e-=1
    q=round(m)*16
    if q == 16:
        q=8
        e+=1
    if e>7: return sign|120
    exponent=e+7
    fraction=q-8
    return sign|(exponent<<3)|fraction
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('zero', solve(0.0), 0)
check('negative zero', solve(-0.0), 128)
check('subnormal', solve(N/512), N)
check('negative subnormal', solve(-N/512), 128|N)
check('underflow tie', solve(1/1024), 0)
check('subnormal carry', solve(15/1024), 8)
check('normal varying', solve(2.0**N), (N+7)<<3)
check('normal fraction', solve((8+N)/8), 56+N)
check('binade carry', solve(1.9375), 64)
check('below midpoint', solve(1.90625), 63)
check('largest finite', solve(240.0), 119)
check('overflow tie', solve(248.0), 120)
check('negative overflow', solve(-256.0), 248)
check('minimum normal', solve(1/64), 8)
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
import math
import struct
N = 1
observations = []
def solve(x):
    sign=128 if math.copysign(1.0,x)<0 else 0
    x=abs(x)
    if x == 0: return sign
    if x >= 248: return sign|120
    if x < 2**-6:
        q=round(x*512)
        return sign|q
    m,e=math.frexp(x)
    e-=1
    q=int(m*16)
    if q == 16:
        q=8
        e+=1
    if e>7: return sign|120
    exponent=e+7
    fraction=q-8
    return sign|(exponent<<3)|fraction
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('zero', solve(0.0), 0)
check('negative zero', solve(-0.0), 128)
check('subnormal', solve(N/512), N)
check('negative subnormal', solve(-N/512), 128|N)
check('underflow tie', solve(1/1024), 0)
check('subnormal carry', solve(15/1024), 8)
check('normal varying', solve(2.0**N), (N+7)<<3)
check('normal fraction', solve((8+N)/8), 56+N)
check('binade carry', solve(1.9375), 64)
check('below midpoint', solve(1.90625), 63)
check('largest finite', solve(240.0), 119)
check('overflow tie', solve(248.0), 120)
check('negative overflow', solve(-256.0), 248)
check('minimum normal', solve(1/64), 8)
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:
Normalized significand is rounded before scaling.

Encode finite exactly represented dyadic x into sign/4-bit-exponent/3-bit-fraction toy float with bias 7, gradual underflow, round-to-nearest-even and infinity overflow. Return the unsigned byte. The miniature format is stipulated, not a hardware conformance claim.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
import math
import struct
N = 1
observations = []
def solve(x):
    sign=128 if math.copysign(1.0,x)<0 else 0
    x=abs(x)
    if x == 0: return sign
    if x >= 248: return sign|120
    if x < 2**-6:
        q=round(x*512)
        return sign|q
    m,e=math.frexp(x)
    e-=1
    q=round(m*16)
    if q == 16:
        q=0
        e+=1
    if e>7: return sign|120
    exponent=e+7
    fraction=q-8
    return sign|(exponent<<3)|fraction
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('zero', solve(0.0), 0)
check('negative zero', solve(-0.0), 128)
check('subnormal', solve(N/512), N)
check('negative subnormal', solve(-N/512), 128|N)
check('underflow tie', solve(1/1024), 0)
check('subnormal carry', solve(15/1024), 8)
check('normal varying', solve(2.0**N), (N+7)<<3)
check('normal fraction', solve((8+N)/8), 56+N)
check('binade carry', solve(1.9375), 64)
check('below midpoint', solve(1.90625), 63)
check('largest finite', solve(240.0), 119)
check('overflow tie', solve(248.0), 120)
check('negative overflow', solve(-256.0), 248)
check('minimum normal', solve(1/64), 8)
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
import math
import struct
N = 1
observations = []
def solve(x):
    sign=128 if math.copysign(1.0,x)<0 else 0
    x=abs(x)
    if x == 0: return sign
    if x >= 248: return sign|120
    if x < 2**-6:
        q=round(x*512)
        return sign|q
    m,e=math.frexp(x)
    e-=1
    q=round(m*16)
    if q == 16:
        q=15
        e+=1
    if e>7: return sign|120
    exponent=e+7
    fraction=q-8
    return sign|(exponent<<3)|fraction
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('zero', solve(0.0), 0)
check('negative zero', solve(-0.0), 128)
check('subnormal', solve(N/512), N)
check('negative subnormal', solve(-N/512), 128|N)
check('underflow tie', solve(1/1024), 0)
check('subnormal carry', solve(15/1024), 8)
check('normal varying', solve(2.0**N), (N+7)<<3)
check('normal fraction', solve((8+N)/8), 56+N)
check('binade carry', solve(1.9375), 64)
check('below midpoint', solve(1.90625), 63)
check('largest finite', solve(240.0), 119)
check('overflow tie', solve(248.0), 120)
check('negative overflow', solve(-256.0), 248)
check('minimum normal', solve(1/64), 8)
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:
Mantissa carry is reset to zero rather than the hidden one.

Encode finite exactly represented dyadic x into sign/4-bit-exponent/3-bit-fraction toy float with bias 7, gradual underflow, round-to-nearest-even and infinity overflow. Return the unsigned byte. The miniature format is stipulated, not a hardware conformance claim.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
import math
import struct
N = 1
observations = []
def solve(x):
    sign=128 if math.copysign(1.0,x)<0 else 0
    x=abs(x)
    if x == 0: return sign
    if x >= 248: return sign|120
    if x < 2**-6:
        q=round(x*512)
        return sign|q
    m,e=math.frexp(x)
    e-=1
    q=round(m*16)
    if q == 16:
        q=8
        e+=0
    if e>7: return sign|120
    exponent=e+7
    fraction=q-8
    return sign|(exponent<<3)|fraction
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('zero', solve(0.0), 0)
check('negative zero', solve(-0.0), 128)
check('subnormal', solve(N/512), N)
check('negative subnormal', solve(-N/512), 128|N)
check('underflow tie', solve(1/1024), 0)
check('subnormal carry', solve(15/1024), 8)
check('normal varying', solve(2.0**N), (N+7)<<3)
check('normal fraction', solve((8+N)/8), 56+N)
check('binade carry', solve(1.9375), 64)
check('below midpoint', solve(1.90625), 63)
check('largest finite', solve(240.0), 119)
check('overflow tie', solve(248.0), 120)
check('negative overflow', solve(-256.0), 248)
check('minimum normal', solve(1/64), 8)
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
import math
import struct
N = 1
observations = []
def solve(x):
    sign=128 if math.copysign(1.0,x)<0 else 0
    x=abs(x)
    if x == 0: return sign
    if x >= 248: return sign|120
    if x < 2**-6:
        q=round(x*512)
        return sign|q
    m,e=math.frexp(x)
    e-=1
    q=round(m*16)
    if q == 16:
        q=8
        e-=1
    if e>7: return sign|120
    exponent=e+7
    fraction=q-8
    return sign|(exponent<<3)|fraction
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('zero', solve(0.0), 0)
check('negative zero', solve(-0.0), 128)
check('subnormal', solve(N/512), N)
check('negative subnormal', solve(-N/512), 128|N)
check('underflow tie', solve(1/1024), 0)
check('subnormal carry', solve(15/1024), 8)
check('normal varying', solve(2.0**N), (N+7)<<3)
check('normal fraction', solve((8+N)/8), 56+N)
check('binade carry', solve(1.9375), 64)
check('below midpoint', solve(1.90625), 63)
check('largest finite', solve(240.0), 119)
check('overflow tie', solve(248.0), 120)
check('negative overflow', solve(-256.0), 248)
check('minimum normal', solve(1/64), 8)
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:
Mantissa carry does not advance the exponent.

Encode finite exactly represented dyadic x into sign/4-bit-exponent/3-bit-fraction toy float with bias 7, gradual underflow, round-to-nearest-even and infinity overflow. Return the unsigned byte. The miniature format is stipulated, not a hardware conformance claim.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
import math
import struct
N = 1
observations = []
def solve(x):
    sign=128 if math.copysign(1.0,x)<0 else 0
    x=abs(x)
    if x == 0: return sign
    if x >= 248: return sign|120
    if x < 2**-6:
        q=round(x*512)
        return sign|q
    m,e=math.frexp(x)
    e-=1
    q=round(m*16)
    if q == 16:
        q=8
        e+=1
    if e>7: return sign|120
    exponent=e-7
    fraction=q-8
    return sign|(exponent<<3)|fraction
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('zero', solve(0.0), 0)
check('negative zero', solve(-0.0), 128)
check('subnormal', solve(N/512), N)
check('negative subnormal', solve(-N/512), 128|N)
check('underflow tie', solve(1/1024), 0)
check('subnormal carry', solve(15/1024), 8)
check('normal varying', solve(2.0**N), (N+7)<<3)
check('normal fraction', solve((8+N)/8), 56+N)
check('binade carry', solve(1.9375), 64)
check('below midpoint', solve(1.90625), 63)
check('largest finite', solve(240.0), 119)
check('overflow tie', solve(248.0), 120)
check('negative overflow', solve(-256.0), 248)
check('minimum normal', solve(1/64), 8)
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
import math
import struct
N = 1
observations = []
def solve(x):
    sign=128 if math.copysign(1.0,x)<0 else 0
    x=abs(x)
    if x == 0: return sign
    if x >= 248: return sign|120
    if x < 2**-6:
        q=round(x*512)
        return sign|q
    m,e=math.frexp(x)
    e-=1
    q=round(m*16)
    if q == 16:
        q=8
        e+=1
    if e>7: return sign|120
    exponent=abs(e)+7
    fraction=q-8
    return sign|(exponent<<3)|fraction
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('zero', solve(0.0), 0)
check('negative zero', solve(-0.0), 128)
check('subnormal', solve(N/512), N)
check('negative subnormal', solve(-N/512), 128|N)
check('underflow tie', solve(1/1024), 0)
check('subnormal carry', solve(15/1024), 8)
check('normal varying', solve(2.0**N), (N+7)<<3)
check('normal fraction', solve((8+N)/8), 56+N)
check('binade carry', solve(1.9375), 64)
check('below midpoint', solve(1.90625), 63)
check('largest finite', solve(240.0), 119)
check('overflow tie', solve(248.0), 120)
check('negative overflow', solve(-256.0), 248)
check('minimum normal', solve(1/64), 8)
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:
Encoding applies the bias in the wrong direction.

Encode finite exactly represented dyadic x into sign/4-bit-exponent/3-bit-fraction toy float with bias 7, gradual underflow, round-to-nearest-even and infinity overflow. Return the unsigned byte. The miniature format is stipulated, not a hardware conformance claim.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
import math
import struct
N = 1
observations = []
def solve(x):
    sign=128 if math.copysign(1.0,x)<0 else 0
    x=abs(x)
    if x == 0: return sign
    if x >= 248: return sign|120
    if x < 2**-6:
        q=round(x*512)
        return sign|q
    m,e=math.frexp(x)
    e-=1
    q=round(m*16)
    if q == 16:
        q=8
        e+=1
    if e>7: return sign|120
    exponent=e+7
    fraction=q
    return sign|(exponent<<3)|fraction
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('zero', solve(0.0), 0)
check('negative zero', solve(-0.0), 128)
check('subnormal', solve(N/512), N)
check('negative subnormal', solve(-N/512), 128|N)
check('underflow tie', solve(1/1024), 0)
check('subnormal carry', solve(15/1024), 8)
check('normal varying', solve(2.0**N), (N+7)<<3)
check('normal fraction', solve((8+N)/8), 56+N)
check('binade carry', solve(1.9375), 64)
check('below midpoint', solve(1.90625), 63)
check('largest finite', solve(240.0), 119)
check('overflow tie', solve(248.0), 120)
check('negative overflow', solve(-256.0), 248)
check('minimum normal', solve(1/64), 8)
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
import math
import struct
N = 1
observations = []
def solve(x):
    sign=128 if math.copysign(1.0,x)<0 else 0
    x=abs(x)
    if x == 0: return sign
    if x >= 248: return sign|120
    if x < 2**-6:
        q=round(x*512)
        return sign|q
    m,e=math.frexp(x)
    e-=1
    q=round(m*16)
    if q == 16:
        q=8
        e+=1
    if e>7: return sign|120
    exponent=e+7
    fraction=q%7
    return sign|(exponent<<3)|fraction
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('zero', solve(0.0), 0)
check('negative zero', solve(-0.0), 128)
check('subnormal', solve(N/512), N)
check('negative subnormal', solve(-N/512), 128|N)
check('underflow tie', solve(1/1024), 0)
check('subnormal carry', solve(15/1024), 8)
check('normal varying', solve(2.0**N), (N+7)<<3)
check('normal fraction', solve((8+N)/8), 56+N)
check('binade carry', solve(1.9375), 64)
check('below midpoint', solve(1.90625), 63)
check('largest finite', solve(240.0), 119)
check('overflow tie', solve(248.0), 120)
check('negative overflow', solve(-256.0), 248)
check('minimum normal', solve(1/64), 8)
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 encoded fraction retains its implicit leading one.

Encode finite exactly represented dyadic x into sign/4-bit-exponent/3-bit-fraction toy float with bias 7, gradual underflow, round-to-nearest-even and infinity overflow. Return the unsigned byte. The miniature format is stipulated, not a hardware conformance claim.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
import math
import struct
N = 1
observations = []
def solve(x):
    sign=128 if math.copysign(1.0,x)<0 else 0
    x=abs(x)
    if x == 0: return sign
    if x >= 248: return sign|120
    if x < 2**-6:
        q=round(x*512)
        return sign|q
    m,e=math.frexp(x)
    e-=1
    q=round(m*16)
    if q == 16:
        q=8
        e+=1
    if e>7: return sign|120
    exponent=e+7
    fraction=q-8
    return sign|((exponent<<3)&fraction)
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('zero', solve(0.0), 0)
check('negative zero', solve(-0.0), 128)
check('subnormal', solve(N/512), N)
check('negative subnormal', solve(-N/512), 128|N)
check('underflow tie', solve(1/1024), 0)
check('subnormal carry', solve(15/1024), 8)
check('normal varying', solve(2.0**N), (N+7)<<3)
check('normal fraction', solve((8+N)/8), 56+N)
check('binade carry', solve(1.9375), 64)
check('below midpoint', solve(1.90625), 63)
check('largest finite', solve(240.0), 119)
check('overflow tie', solve(248.0), 120)
check('negative overflow', solve(-256.0), 248)
check('minimum normal', solve(1/64), 8)
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
import math
import struct
N = 1
observations = []
def solve(x):
    sign=128 if math.copysign(1.0,x)<0 else 0
    x=abs(x)
    if x == 0: return sign
    if x >= 248: return sign|120
    if x < 2**-6:
        q=round(x*512)
        return sign|q
    m,e=math.frexp(x)
    e-=1
    q=round(m*16)
    if q == 16:
        q=8
        e+=1
    if e>7: return sign|120
    exponent=e+7
    fraction=q-8
    return sign|(exponent+fraction)
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('zero', solve(0.0), 0)
check('negative zero', solve(-0.0), 128)
check('subnormal', solve(N/512), N)
check('negative subnormal', solve(-N/512), 128|N)
check('underflow tie', solve(1/1024), 0)
check('subnormal carry', solve(15/1024), 8)
check('normal varying', solve(2.0**N), (N+7)<<3)
check('normal fraction', solve((8+N)/8), 56+N)
check('binade carry', solve(1.9375), 64)
check('below midpoint', solve(1.90625), 63)
check('largest finite', solve(240.0), 119)
check('overflow tie', solve(248.0), 120)
check('negative overflow', solve(-256.0), 248)
check('minimum normal', solve(1/64), 8)
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:
Exponent and fraction are intersected instead of combined.

Encode finite exactly represented dyadic x into sign/4-bit-exponent/3-bit-fraction toy float with bias 7, gradual underflow, round-to-nearest-even and infinity overflow. Return the unsigned byte. The miniature format is stipulated, not a hardware conformance claim.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
import math
import struct
N = 1
observations = []
def solve(x, shift):
    if x == 0.0: return 0.0.hex()
    m,e=math.frexp(x)
    target=e+shift
    if target>1024: return '-overflow' if x<0 else '+overflow'
    try:
        result=math.ldexp(m,target)
    except OverflowError:
        return '-overflow' if x<0 else '+overflow'
    return result.hex()
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('scale up', solve(1.5,N), math.ldexp(1.5,N).hex())
check('scale down', solve(-1.5,-N), math.ldexp(-1.5,-N).hex())
check('negative zero', solve(-0.0,N), '-0x0.0p+0')
check('positive zero', solve(0.0,-N), '0x0.0p+0')
check('subnormal input', solve(float.fromhex("0x0.0000000000001p-1022"),N), math.ldexp(1.0,N-1074).hex())
check('subnormal output', solve(float.fromhex("0x1p-1022"),-N), math.ldexp(1.0,-1022-N).hex())
check('max finite shift zero', solve(float.fromhex("0x1.fffffffffffffp+1023"),0), '0x1.fffffffffffffp+1023')
check('positive overflow', solve(float.fromhex("0x1p+1023"),N), '+overflow')
check('negative overflow', solve(-float.fromhex("0x1p+1023"),N), '-overflow')
check('negative underflow', solve(-float.fromhex("0x0.0000000000001p-1022"),-N), '-0x0.0p+0')
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
import math
import struct
N = 1
observations = []
def solve(x, shift):
    if x == 0.0: return (-0.0).hex()
    m,e=math.frexp(x)
    target=e+shift
    if target>1024: return '-overflow' if x<0 else '+overflow'
    try:
        result=math.ldexp(m,target)
    except OverflowError:
        return '-overflow' if x<0 else '+overflow'
    return result.hex()
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('scale up', solve(1.5,N), math.ldexp(1.5,N).hex())
check('scale down', solve(-1.5,-N), math.ldexp(-1.5,-N).hex())
check('negative zero', solve(-0.0,N), '-0x0.0p+0')
check('positive zero', solve(0.0,-N), '0x0.0p+0')
check('subnormal input', solve(float.fromhex("0x0.0000000000001p-1022"),N), math.ldexp(1.0,N-1074).hex())
check('subnormal output', solve(float.fromhex("0x1p-1022"),-N), math.ldexp(1.0,-1022-N).hex())
check('max finite shift zero', solve(float.fromhex("0x1.fffffffffffffp+1023"),0), '0x1.fffffffffffffp+1023')
check('positive overflow', solve(float.fromhex("0x1p+1023"),N), '+overflow')
check('negative overflow', solve(-float.fromhex("0x1p+1023"),N), '-overflow')
check('negative underflow', solve(-float.fromhex("0x0.0000000000001p-1022"),-N), '-0x0.0p+0')
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:
Exponent adjustment canonicalizes negative zero.

Recompose finite binary64 x after changing its exponent by integer shift. Return hex value, or signed overflow marker. Scaling preserves negative zero and gradual underflow. Inputs exclude NaN and infinity.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
import math
import struct
N = 1
observations = []
def solve(x, shift):
    if x == 0.0: return x.hex()
    m,e=math.frexp(x)
    target=e-shift
    if target>1024: return '-overflow' if x<0 else '+overflow'
    try:
        result=math.ldexp(m,target)
    except OverflowError:
        return '-overflow' if x<0 else '+overflow'
    return result.hex()
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('scale up', solve(1.5,N), math.ldexp(1.5,N).hex())
check('scale down', solve(-1.5,-N), math.ldexp(-1.5,-N).hex())
check('negative zero', solve(-0.0,N), '-0x0.0p+0')
check('positive zero', solve(0.0,-N), '0x0.0p+0')
check('subnormal input', solve(float.fromhex("0x0.0000000000001p-1022"),N), math.ldexp(1.0,N-1074).hex())
check('subnormal output', solve(float.fromhex("0x1p-1022"),-N), math.ldexp(1.0,-1022-N).hex())
check('max finite shift zero', solve(float.fromhex("0x1.fffffffffffffp+1023"),0), '0x1.fffffffffffffp+1023')
check('positive overflow', solve(float.fromhex("0x1p+1023"),N), '+overflow')
check('negative overflow', solve(-float.fromhex("0x1p+1023"),N), '-overflow')
check('negative underflow', solve(-float.fromhex("0x0.0000000000001p-1022"),-N), '-0x0.0p+0')
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
import math
import struct
N = 1
observations = []
def solve(x, shift):
    if x == 0.0: return x.hex()
    m,e=math.frexp(x)
    target=shift
    if target>1024: return '-overflow' if x<0 else '+overflow'
    try:
        result=math.ldexp(m,target)
    except OverflowError:
        return '-overflow' if x<0 else '+overflow'
    return result.hex()
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('scale up', solve(1.5,N), math.ldexp(1.5,N).hex())
check('scale down', solve(-1.5,-N), math.ldexp(-1.5,-N).hex())
check('negative zero', solve(-0.0,N), '-0x0.0p+0')
check('positive zero', solve(0.0,-N), '0x0.0p+0')
check('subnormal input', solve(float.fromhex("0x0.0000000000001p-1022"),N), math.ldexp(1.0,N-1074).hex())
check('subnormal output', solve(float.fromhex("0x1p-1022"),-N), math.ldexp(1.0,-1022-N).hex())
check('max finite shift zero', solve(float.fromhex("0x1.fffffffffffffp+1023"),0), '0x1.fffffffffffffp+1023')
check('positive overflow', solve(float.fromhex("0x1p+1023"),N), '+overflow')
check('negative overflow', solve(-float.fromhex("0x1p+1023"),N), '-overflow')
check('negative underflow', solve(-float.fromhex("0x0.0000000000001p-1022"),-N), '-0x0.0p+0')
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:
Exponent adjustment reverses the requested shift.

Recompose finite binary64 x after changing its exponent by integer shift. Return hex value, or signed overflow marker. Scaling preserves negative zero and gradual underflow. Inputs exclude NaN and infinity.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
import math
import struct
N = 1
observations = []
def solve(x, shift):
    if x == 0.0: return x.hex()
    m,e=math.frexp(abs(x))
    target=e+shift
    if target>1024: return '-overflow' if x<0 else '+overflow'
    try:
        result=math.ldexp(m,target)
    except OverflowError:
        return '-overflow' if x<0 else '+overflow'
    return result.hex()
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('scale up', solve(1.5,N), math.ldexp(1.5,N).hex())
check('scale down', solve(-1.5,-N), math.ldexp(-1.5,-N).hex())
check('negative zero', solve(-0.0,N), '-0x0.0p+0')
check('positive zero', solve(0.0,-N), '0x0.0p+0')
check('subnormal input', solve(float.fromhex("0x0.0000000000001p-1022"),N), math.ldexp(1.0,N-1074).hex())
check('subnormal output', solve(float.fromhex("0x1p-1022"),-N), math.ldexp(1.0,-1022-N).hex())
check('max finite shift zero', solve(float.fromhex("0x1.fffffffffffffp+1023"),0), '0x1.fffffffffffffp+1023')
check('positive overflow', solve(float.fromhex("0x1p+1023"),N), '+overflow')
check('negative overflow', solve(-float.fromhex("0x1p+1023"),N), '-overflow')
check('negative underflow', solve(-float.fromhex("0x0.0000000000001p-1022"),-N), '-0x0.0p+0')
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
import math
import struct
N = 1
observations = []
def solve(x, shift):
    if x == 0.0: return x.hex()
    m,e=math.frexp(-abs(x))
    target=e+shift
    if target>1024: return '-overflow' if x<0 else '+overflow'
    try:
        result=math.ldexp(m,target)
    except OverflowError:
        return '-overflow' if x<0 else '+overflow'
    return result.hex()
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('scale up', solve(1.5,N), math.ldexp(1.5,N).hex())
check('scale down', solve(-1.5,-N), math.ldexp(-1.5,-N).hex())
check('negative zero', solve(-0.0,N), '-0x0.0p+0')
check('positive zero', solve(0.0,-N), '0x0.0p+0')
check('subnormal input', solve(float.fromhex("0x0.0000000000001p-1022"),N), math.ldexp(1.0,N-1074).hex())
check('subnormal output', solve(float.fromhex("0x1p-1022"),-N), math.ldexp(1.0,-1022-N).hex())
check('max finite shift zero', solve(float.fromhex("0x1.fffffffffffffp+1023"),0), '0x1.fffffffffffffp+1023')
check('positive overflow', solve(float.fromhex("0x1p+1023"),N), '+overflow')
check('negative overflow', solve(-float.fromhex("0x1p+1023"),N), '-overflow')
check('negative underflow', solve(-float.fromhex("0x0.0000000000001p-1022"),-N), '-0x0.0p+0')
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:
Exponent adjustment discards the mantissa sign.

Recompose finite binary64 x after changing its exponent by integer shift. Return hex value, or signed overflow marker. Scaling preserves negative zero and gradual underflow. Inputs exclude NaN and infinity.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
import math
import struct
N = 1
observations = []
def solve(x, shift):
    if x == 0.0: return x.hex()
    m,e=math.frexp(x)
    target=e+shift
    if target>=1024: return '-overflow' if x<0 else '+overflow'
    try:
        result=math.ldexp(m,target)
    except OverflowError:
        return '-overflow' if x<0 else '+overflow'
    return result.hex()
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('scale up', solve(1.5,N), math.ldexp(1.5,N).hex())
check('scale down', solve(-1.5,-N), math.ldexp(-1.5,-N).hex())
check('negative zero', solve(-0.0,N), '-0x0.0p+0')
check('positive zero', solve(0.0,-N), '0x0.0p+0')
check('subnormal input', solve(float.fromhex("0x0.0000000000001p-1022"),N), math.ldexp(1.0,N-1074).hex())
check('subnormal output', solve(float.fromhex("0x1p-1022"),-N), math.ldexp(1.0,-1022-N).hex())
check('max finite shift zero', solve(float.fromhex("0x1.fffffffffffffp+1023"),0), '0x1.fffffffffffffp+1023')
check('positive overflow', solve(float.fromhex("0x1p+1023"),N), '+overflow')
check('negative overflow', solve(-float.fromhex("0x1p+1023"),N), '-overflow')
check('negative underflow', solve(-float.fromhex("0x0.0000000000001p-1022"),-N), '-0x0.0p+0')
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
import math
import struct
N = 1
observations = []
def solve(x, shift):
    if x == 0.0: return x.hex()
    m,e=math.frexp(x)
    target=e+shift
    if target>=1023: return '-overflow' if x<0 else '+overflow'
    try:
        result=math.ldexp(m,target)
    except OverflowError:
        return '-overflow' if x<0 else '+overflow'
    return result.hex()
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('scale up', solve(1.5,N), math.ldexp(1.5,N).hex())
check('scale down', solve(-1.5,-N), math.ldexp(-1.5,-N).hex())
check('negative zero', solve(-0.0,N), '-0x0.0p+0')
check('positive zero', solve(0.0,-N), '0x0.0p+0')
check('subnormal input', solve(float.fromhex("0x0.0000000000001p-1022"),N), math.ldexp(1.0,N-1074).hex())
check('subnormal output', solve(float.fromhex("0x1p-1022"),-N), math.ldexp(1.0,-1022-N).hex())
check('max finite shift zero', solve(float.fromhex("0x1.fffffffffffffp+1023"),0), '0x1.fffffffffffffp+1023')
check('positive overflow', solve(float.fromhex("0x1p+1023"),N), '+overflow')
check('negative overflow', solve(-float.fromhex("0x1p+1023"),N), '-overflow')
check('negative underflow', solve(-float.fromhex("0x0.0000000000001p-1022"),-N), '-0x0.0p+0')
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:
Exponent adjustment rejects the highest finite binade.

Recompose finite binary64 x after changing its exponent by integer shift. Return hex value, or signed overflow marker. Scaling preserves negative zero and gradual underflow. Inputs exclude NaN and infinity.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
import math
import struct
N = 1
observations = []
def solve(x, shift):
    if x == 0.0: return x.hex()
    m,e=math.frexp(x)
    target=e+shift
    if target>1024: return '+overflow'
    try:
        result=math.ldexp(m,target)
    except OverflowError:
        return '-overflow' if x<0 else '+overflow'
    return result.hex()
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('scale up', solve(1.5,N), math.ldexp(1.5,N).hex())
check('scale down', solve(-1.5,-N), math.ldexp(-1.5,-N).hex())
check('negative zero', solve(-0.0,N), '-0x0.0p+0')
check('positive zero', solve(0.0,-N), '0x0.0p+0')
check('subnormal input', solve(float.fromhex("0x0.0000000000001p-1022"),N), math.ldexp(1.0,N-1074).hex())
check('subnormal output', solve(float.fromhex("0x1p-1022"),-N), math.ldexp(1.0,-1022-N).hex())
check('max finite shift zero', solve(float.fromhex("0x1.fffffffffffffp+1023"),0), '0x1.fffffffffffffp+1023')
check('positive overflow', solve(float.fromhex("0x1p+1023"),N), '+overflow')
check('negative overflow', solve(-float.fromhex("0x1p+1023"),N), '-overflow')
check('negative underflow', solve(-float.fromhex("0x0.0000000000001p-1022"),-N), '-0x0.0p+0')
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
import math
import struct
N = 1
observations = []
def solve(x, shift):
    if x == 0.0: return x.hex()
    m,e=math.frexp(x)
    target=e+shift
    if target>1024: return '-overflow'
    try:
        result=math.ldexp(m,target)
    except OverflowError:
        return '-overflow' if x<0 else '+overflow'
    return result.hex()
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('scale up', solve(1.5,N), math.ldexp(1.5,N).hex())
check('scale down', solve(-1.5,-N), math.ldexp(-1.5,-N).hex())
check('negative zero', solve(-0.0,N), '-0x0.0p+0')
check('positive zero', solve(0.0,-N), '0x0.0p+0')
check('subnormal input', solve(float.fromhex("0x0.0000000000001p-1022"),N), math.ldexp(1.0,N-1074).hex())
check('subnormal output', solve(float.fromhex("0x1p-1022"),-N), math.ldexp(1.0,-1022-N).hex())
check('max finite shift zero', solve(float.fromhex("0x1.fffffffffffffp+1023"),0), '0x1.fffffffffffffp+1023')
check('positive overflow', solve(float.fromhex("0x1p+1023"),N), '+overflow')
check('negative overflow', solve(-float.fromhex("0x1p+1023"),N), '-overflow')
check('negative underflow', solve(-float.fromhex("0x0.0000000000001p-1022"),-N), '-0x0.0p+0')
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:
Exponent overflow loses its negative sign.

Recompose finite binary64 x after changing its exponent by integer shift. Return hex value, or signed overflow marker. Scaling preserves negative zero and gradual underflow. Inputs exclude NaN and infinity.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
import math
import struct
N = 1
observations = []
def solve(x, shift):
    if x == 0.0: return x.hex()
    m,e=math.frexp(x)
    target=e+shift
    if target>1024: return '-overflow' if x<0 else '+overflow'
    try:
        result=math.copysign(0.0,m) if target < -1021 else math.ldexp(m,target)
    except OverflowError:
        return '-overflow' if x<0 else '+overflow'
    return result.hex()
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('scale up', solve(1.5,N), math.ldexp(1.5,N).hex())
check('scale down', solve(-1.5,-N), math.ldexp(-1.5,-N).hex())
check('negative zero', solve(-0.0,N), '-0x0.0p+0')
check('positive zero', solve(0.0,-N), '0x0.0p+0')
check('subnormal input', solve(float.fromhex("0x0.0000000000001p-1022"),N), math.ldexp(1.0,N-1074).hex())
check('subnormal output', solve(float.fromhex("0x1p-1022"),-N), math.ldexp(1.0,-1022-N).hex())
check('max finite shift zero', solve(float.fromhex("0x1.fffffffffffffp+1023"),0), '0x1.fffffffffffffp+1023')
check('positive overflow', solve(float.fromhex("0x1p+1023"),N), '+overflow')
check('negative overflow', solve(-float.fromhex("0x1p+1023"),N), '-overflow')
check('negative underflow', solve(-float.fromhex("0x0.0000000000001p-1022"),-N), '-0x0.0p+0')
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
import math
import struct
N = 1
observations = []
def solve(x, shift):
    if x == 0.0: return x.hex()
    m,e=math.frexp(x)
    target=e+shift
    if target>1024: return '-overflow' if x<0 else '+overflow'
    try:
        result=math.copysign(2.0**-1022,m) if target < -1021 else math.ldexp(m,target)
    except OverflowError:
        return '-overflow' if x<0 else '+overflow'
    return result.hex()
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('scale up', solve(1.5,N), math.ldexp(1.5,N).hex())
check('scale down', solve(-1.5,-N), math.ldexp(-1.5,-N).hex())
check('negative zero', solve(-0.0,N), '-0x0.0p+0')
check('positive zero', solve(0.0,-N), '0x0.0p+0')
check('subnormal input', solve(float.fromhex("0x0.0000000000001p-1022"),N), math.ldexp(1.0,N-1074).hex())
check('subnormal output', solve(float.fromhex("0x1p-1022"),-N), math.ldexp(1.0,-1022-N).hex())
check('max finite shift zero', solve(float.fromhex("0x1.fffffffffffffp+1023"),0), '0x1.fffffffffffffp+1023')
check('positive overflow', solve(float.fromhex("0x1p+1023"),N), '+overflow')
check('negative overflow', solve(-float.fromhex("0x1p+1023"),N), '-overflow')
check('negative underflow', solve(-float.fromhex("0x0.0000000000001p-1022"),-N), '-0x0.0p+0')
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:
Exponent adjustment flushes representable subnormals.

Recompose finite binary64 x after changing its exponent by integer shift. Return hex value, or signed overflow marker. Scaling preserves negative zero and gradual underflow. Inputs exclude NaN and infinity.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
import math
import struct
N = 1
observations = []
def solve(x, shift):
    if x == 0.0: return x.hex()
    m,e=math.frexp(x)
    target=e+shift
    if target>1024: return '-overflow' if x<0 else '+overflow'
    try:
        result=math.ldexp(m,target)
    except OverflowError:
        return '-overflow' if x<0 else '+overflow'
    return (0.0 if result==0 else result).hex()
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('scale up', solve(1.5,N), math.ldexp(1.5,N).hex())
check('scale down', solve(-1.5,-N), math.ldexp(-1.5,-N).hex())
check('negative zero', solve(-0.0,N), '-0x0.0p+0')
check('positive zero', solve(0.0,-N), '0x0.0p+0')
check('subnormal input', solve(float.fromhex("0x0.0000000000001p-1022"),N), math.ldexp(1.0,N-1074).hex())
check('subnormal output', solve(float.fromhex("0x1p-1022"),-N), math.ldexp(1.0,-1022-N).hex())
check('max finite shift zero', solve(float.fromhex("0x1.fffffffffffffp+1023"),0), '0x1.fffffffffffffp+1023')
check('positive overflow', solve(float.fromhex("0x1p+1023"),N), '+overflow')
check('negative overflow', solve(-float.fromhex("0x1p+1023"),N), '-overflow')
check('negative underflow', solve(-float.fromhex("0x0.0000000000001p-1022"),-N), '-0x0.0p+0')
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
import math
import struct
N = 1
observations = []
def solve(x, shift):
    if x == 0.0: return x.hex()
    m,e=math.frexp(x)
    target=e+shift
    if target>1024: return '-overflow' if x<0 else '+overflow'
    try:
        result=math.ldexp(m,target)
    except OverflowError:
        return '-overflow' if x<0 else '+overflow'
    return abs(result).hex()
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('scale up', solve(1.5,N), math.ldexp(1.5,N).hex())
check('scale down', solve(-1.5,-N), math.ldexp(-1.5,-N).hex())
check('negative zero', solve(-0.0,N), '-0x0.0p+0')
check('positive zero', solve(0.0,-N), '0x0.0p+0')
check('subnormal input', solve(float.fromhex("0x0.0000000000001p-1022"),N), math.ldexp(1.0,N-1074).hex())
check('subnormal output', solve(float.fromhex("0x1p-1022"),-N), math.ldexp(1.0,-1022-N).hex())
check('max finite shift zero', solve(float.fromhex("0x1.fffffffffffffp+1023"),0), '0x1.fffffffffffffp+1023')
check('positive overflow', solve(float.fromhex("0x1p+1023"),N), '+overflow')
check('negative overflow', solve(-float.fromhex("0x1p+1023"),N), '-overflow')
check('negative underflow', solve(-float.fromhex("0x0.0000000000001p-1022"),-N), '-0x0.0p+0')
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:
Exponent adjustment strips the sign after underflow.

Recompose finite binary64 x after changing its exponent by integer shift. Return hex value, or signed overflow marker. Scaling preserves negative zero and gradual underflow. Inputs exclude NaN and infinity.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
import math
import struct
N = 1
observations = []
def solve(a,b):
    if not math.isfinite(b): return None
    ab=int.from_bytes(struct.pack('>d',a),'big')
    bb=int.from_bytes(struct.pack('>d',b),'big')
    a_index=-(ab&((1<<63)-1)) if ab>>63 else ab
    b_index=-(bb&((1<<63)-1)) if bb>>63 else bb
    return abs(a_index-b_index)
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('same', solve(float(N),float(N)), 0)
check('zero signs', solve(-0.0,0.0), 0)
check('negative adjacent', solve(-float(N),math.nextafter(-float(N),-math.inf)), 1)
check('positive adjacent', solve(float(N),math.nextafter(float(N),math.inf)), 1)
check('cross zero', solve(-math.ldexp(float(N),-1074),math.ldexp(float(N),-1074)), 2*N)
check('reverse cross', solve(math.ldexp(float(N),-1074),-math.ldexp(float(N),-1074)), 2*N)
check('nan left', solve(float("nan"),1.0), None)
check('nan right', solve(1.0,float("nan")), None)
check('infinity', solve(math.inf,math.inf), None)
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
import math
import struct
N = 1
observations = []
def solve(a,b):
    if math.isinf(a) or not math.isfinite(b): return None
    ab=int.from_bytes(struct.pack('>d',a),'big')
    bb=int.from_bytes(struct.pack('>d',b),'big')
    a_index=-(ab&((1<<63)-1)) if ab>>63 else ab
    b_index=-(bb&((1<<63)-1)) if bb>>63 else bb
    return abs(a_index-b_index)
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('same', solve(float(N),float(N)), 0)
check('zero signs', solve(-0.0,0.0), 0)
check('negative adjacent', solve(-float(N),math.nextafter(-float(N),-math.inf)), 1)
check('positive adjacent', solve(float(N),math.nextafter(float(N),math.inf)), 1)
check('cross zero', solve(-math.ldexp(float(N),-1074),math.ldexp(float(N),-1074)), 2*N)
check('reverse cross', solve(math.ldexp(float(N),-1074),-math.ldexp(float(N),-1074)), 2*N)
check('nan left', solve(float("nan"),1.0), None)
check('nan right', solve(1.0,float("nan")), None)
check('infinity', solve(math.inf,math.inf), None)
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:
ULP distance validates only its right operand.

Distance between finite binary64 values in representable steps, treating the two zeros as a single position; NaN or infinity yields null. Negative and positive subnormals are adjacent through zero.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
import math
import struct
N = 1
observations = []
def solve(a,b):
    if not math.isfinite(a): return None
    ab=int.from_bytes(struct.pack('>d',a),'big')
    bb=int.from_bytes(struct.pack('>d',b),'big')
    a_index=-(ab&((1<<63)-1)) if ab>>63 else ab
    b_index=-(bb&((1<<63)-1)) if bb>>63 else bb
    return abs(a_index-b_index)
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('same', solve(float(N),float(N)), 0)
check('zero signs', solve(-0.0,0.0), 0)
check('negative adjacent', solve(-float(N),math.nextafter(-float(N),-math.inf)), 1)
check('positive adjacent', solve(float(N),math.nextafter(float(N),math.inf)), 1)
check('cross zero', solve(-math.ldexp(float(N),-1074),math.ldexp(float(N),-1074)), 2*N)
check('reverse cross', solve(math.ldexp(float(N),-1074),-math.ldexp(float(N),-1074)), 2*N)
check('nan left', solve(float("nan"),1.0), None)
check('nan right', solve(1.0,float("nan")), None)
check('infinity', solve(math.inf,math.inf), None)
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
import math
import struct
N = 1
observations = []
def solve(a,b):
    if not math.isfinite(a) or math.isinf(b): return None
    ab=int.from_bytes(struct.pack('>d',a),'big')
    bb=int.from_bytes(struct.pack('>d',b),'big')
    a_index=-(ab&((1<<63)-1)) if ab>>63 else ab
    b_index=-(bb&((1<<63)-1)) if bb>>63 else bb
    return abs(a_index-b_index)
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('same', solve(float(N),float(N)), 0)
check('zero signs', solve(-0.0,0.0), 0)
check('negative adjacent', solve(-float(N),math.nextafter(-float(N),-math.inf)), 1)
check('positive adjacent', solve(float(N),math.nextafter(float(N),math.inf)), 1)
check('cross zero', solve(-math.ldexp(float(N),-1074),math.ldexp(float(N),-1074)), 2*N)
check('reverse cross', solve(math.ldexp(float(N),-1074),-math.ldexp(float(N),-1074)), 2*N)
check('nan left', solve(float("nan"),1.0), None)
check('nan right', solve(1.0,float("nan")), None)
check('infinity', solve(math.inf,math.inf), None)
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:
ULP distance validates only its left operand.

Distance between finite binary64 values in representable steps, treating the two zeros as a single position; NaN or infinity yields null. Negative and positive subnormals are adjacent through zero.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
import math
import struct
N = 1
observations = []
def solve(a,b):
    if not math.isfinite(a) or not math.isfinite(b): return None
    ab=int.from_bytes(struct.pack('>d',a),'big')
    bb=int.from_bytes(struct.pack('>d',b),'big')
    a_index=ab
    b_index=-(bb&((1<<63)-1)) if bb>>63 else bb
    return abs(a_index-b_index)
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('same', solve(float(N),float(N)), 0)
check('zero signs', solve(-0.0,0.0), 0)
check('negative adjacent', solve(-float(N),math.nextafter(-float(N),-math.inf)), 1)
check('positive adjacent', solve(float(N),math.nextafter(float(N),math.inf)), 1)
check('cross zero', solve(-math.ldexp(float(N),-1074),math.ldexp(float(N),-1074)), 2*N)
check('reverse cross', solve(math.ldexp(float(N),-1074),-math.ldexp(float(N),-1074)), 2*N)
check('nan left', solve(float("nan"),1.0), None)
check('nan right', solve(1.0,float("nan")), None)
check('infinity', solve(math.inf,math.inf), None)
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
import math
import struct
N = 1
observations = []
def solve(a,b):
    if not math.isfinite(a) or not math.isfinite(b): return None
    ab=int.from_bytes(struct.pack('>d',a),'big')
    bb=int.from_bytes(struct.pack('>d',b),'big')
    a_index=~ab if ab>>63 else ab
    b_index=-(bb&((1<<63)-1)) if bb>>63 else bb
    return abs(a_index-b_index)
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('same', solve(float(N),float(N)), 0)
check('zero signs', solve(-0.0,0.0), 0)
check('negative adjacent', solve(-float(N),math.nextafter(-float(N),-math.inf)), 1)
check('positive adjacent', solve(float(N),math.nextafter(float(N),math.inf)), 1)
check('cross zero', solve(-math.ldexp(float(N),-1074),math.ldexp(float(N),-1074)), 2*N)
check('reverse cross', solve(math.ldexp(float(N),-1074),-math.ldexp(float(N),-1074)), 2*N)
check('nan left', solve(float("nan"),1.0), None)
check('nan right', solve(1.0,float("nan")), None)
check('infinity', solve(math.inf,math.inf), None)
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:
ULP distance leaves the first negative encoding unsigned.

Distance between finite binary64 values in representable steps, treating the two zeros as a single position; NaN or infinity yields null. Negative and positive subnormals are adjacent through zero.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
import math
import struct
N = 1
observations = []
def solve(a,b):
    if not math.isfinite(a) or not math.isfinite(b): return None
    ab=int.from_bytes(struct.pack('>d',a),'big')
    bb=int.from_bytes(struct.pack('>d',b),'big')
    a_index=-(ab&((1<<63)-1)) if ab>>63 else ab
    b_index=~bb if bb>>63 else bb
    return abs(a_index-b_index)
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('same', solve(float(N),float(N)), 0)
check('zero signs', solve(-0.0,0.0), 0)
check('negative adjacent', solve(-float(N),math.nextafter(-float(N),-math.inf)), 1)
check('positive adjacent', solve(float(N),math.nextafter(float(N),math.inf)), 1)
check('cross zero', solve(-math.ldexp(float(N),-1074),math.ldexp(float(N),-1074)), 2*N)
check('reverse cross', solve(math.ldexp(float(N),-1074),-math.ldexp(float(N),-1074)), 2*N)
check('nan left', solve(float("nan"),1.0), None)
check('nan right', solve(1.0,float("nan")), None)
check('infinity', solve(math.inf,math.inf), None)
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
import math
import struct
N = 1
observations = []
def solve(a,b):
    if not math.isfinite(a) or not math.isfinite(b): return None
    ab=int.from_bytes(struct.pack('>d',a),'big')
    bb=int.from_bytes(struct.pack('>d',b),'big')
    a_index=-(ab&((1<<63)-1)) if ab>>63 else ab
    b_index=bb
    return abs(a_index-b_index)
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('same', solve(float(N),float(N)), 0)
check('zero signs', solve(-0.0,0.0), 0)
check('negative adjacent', solve(-float(N),math.nextafter(-float(N),-math.inf)), 1)
check('positive adjacent', solve(float(N),math.nextafter(float(N),math.inf)), 1)
check('cross zero', solve(-math.ldexp(float(N),-1074),math.ldexp(float(N),-1074)), 2*N)
check('reverse cross', solve(math.ldexp(float(N),-1074),-math.ldexp(float(N),-1074)), 2*N)
check('nan left', solve(float("nan"),1.0), None)
check('nan right', solve(1.0,float("nan")), None)
check('infinity', solve(math.inf,math.inf), None)
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:
ULP distance complements the second negative encoding without zero alignment.

Distance between finite binary64 values in representable steps, treating the two zeros as a single position; NaN or infinity yields null. Negative and positive subnormals are adjacent through zero.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
import math
import struct
N = 1
observations = []
def solve(a,b):
    if not math.isfinite(a) or not math.isfinite(b): return None
    ab=int.from_bytes(struct.pack('>d',a),'big')
    bb=int.from_bytes(struct.pack('>d',b),'big')
    a_index=-(ab&((1<<63)-1)) if ab>>63 else ab
    b_index=-(bb&((1<<63)-1)) if bb>>63 else bb
    return a_index-b_index
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('same', solve(float(N),float(N)), 0)
check('zero signs', solve(-0.0,0.0), 0)
check('negative adjacent', solve(-float(N),math.nextafter(-float(N),-math.inf)), 1)
check('positive adjacent', solve(float(N),math.nextafter(float(N),math.inf)), 1)
check('cross zero', solve(-math.ldexp(float(N),-1074),math.ldexp(float(N),-1074)), 2*N)
check('reverse cross', solve(math.ldexp(float(N),-1074),-math.ldexp(float(N),-1074)), 2*N)
check('nan left', solve(float("nan"),1.0), None)
check('nan right', solve(1.0,float("nan")), None)
check('infinity', solve(math.inf,math.inf), None)
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
import math
import struct
N = 1
observations = []
def solve(a,b):
    if not math.isfinite(a) or not math.isfinite(b): return None
    ab=int.from_bytes(struct.pack('>d',a),'big')
    bb=int.from_bytes(struct.pack('>d',b),'big')
    a_index=-(ab&((1<<63)-1)) if ab>>63 else ab
    b_index=-(bb&((1<<63)-1)) if bb>>63 else bb
    return b_index-a_index
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('same', solve(float(N),float(N)), 0)
check('zero signs', solve(-0.0,0.0), 0)
check('negative adjacent', solve(-float(N),math.nextafter(-float(N),-math.inf)), 1)
check('positive adjacent', solve(float(N),math.nextafter(float(N),math.inf)), 1)
check('cross zero', solve(-math.ldexp(float(N),-1074),math.ldexp(float(N),-1074)), 2*N)
check('reverse cross', solve(math.ldexp(float(N),-1074),-math.ldexp(float(N),-1074)), 2*N)
check('nan left', solve(float("nan"),1.0), None)
check('nan right', solve(1.0,float("nan")), None)
check('infinity', solve(math.inf,math.inf), None)
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:
ULP distance returns signed separation.

Distance between finite binary64 values in representable steps, treating the two zeros as a single position; NaN or infinity yields null. Negative and positive subnormals are adjacent through zero.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
import math
import struct
def render(x):
    if math.isnan(x): return 'nan'
    if math.isinf(x): return '-infinity' if x<0 else '+infinity'
    return format(x,'.11g')

N = 1
observations = []
def solve(x):
    try:
        if x < -1: return 'domain'
        if x == -1: return '-1'
        if x == 0: return render(x)
        result=math.sqrt(1+x)-1
        return render(result)
    except (ValueError, OverflowError, ZeroDivisionError, TypeError):
        return "arithmetic-error"
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('tiny positive', solve(N*2.0**-60), render(N*2.0**-61))
check('tiny negative', solve(-N*2.0**-60), render(-N*2.0**-61))
check('normal', solve(3.0), "1")
check('endpoint', solve(-1.0), "-1")
check('domain', solve(-2.0), "domain")
check('negative zero', solve(-0.0), "-0")
check('positive zero', solve(0.0), "0")
check('large', solve(1e300), render(1e150))
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
import math
import struct
def render(x):
    if math.isnan(x): return 'nan'
    if math.isinf(x): return '-infinity' if x<0 else '+infinity'
    return format(x,'.11g')

N = 1
observations = []
def solve(x):
    try:
        if x < -1: return 'domain'
        if x == -1: return '-1'
        if x == 0: return render(x)
        result=math.sqrt(1+x)-1 if abs(x)>1e-20 else x/2
        return render(result)
    except (ValueError, OverflowError, ZeroDivisionError, TypeError):
        return "arithmetic-error"
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('tiny positive', solve(N*2.0**-60), render(N*2.0**-61))
check('tiny negative', solve(-N*2.0**-60), render(-N*2.0**-61))
check('normal', solve(3.0), "1")
check('endpoint', solve(-1.0), "-1")
check('domain', solve(-2.0), "domain")
check('negative zero', solve(-0.0), "-0")
check('positive zero', solve(0.0), "0")
check('large', solve(1e300), render(1e150))
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:
Subtracting one erases a tiny square-root increment.

Evaluate sqrt(1+x)-1 stably for finite x >= -1. Finite results are rendered to eleven significant decimal digits; modeled domain violations and arithmetic errors are explicit strings.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
import math
import struct
def render(x):
    if math.isnan(x): return 'nan'
    if math.isinf(x): return '-infinity' if x<0 else '+infinity'
    return format(x,'.11g')

N = 1
observations = []
def solve(x):
    try:
        if x < -1: return '-1'
        if x == -1: return '-1'
        if x == 0: return render(x)
        result=x/(math.sqrt(1+x)+1)
        return render(result)
    except (ValueError, OverflowError, ZeroDivisionError, TypeError):
        return "arithmetic-error"
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('tiny positive', solve(N*2.0**-60), render(N*2.0**-61))
check('tiny negative', solve(-N*2.0**-60), render(-N*2.0**-61))
check('normal', solve(3.0), "1")
check('endpoint', solve(-1.0), "-1")
check('domain', solve(-2.0), "domain")
check('negative zero', solve(-0.0), "-0")
check('positive zero', solve(0.0), "0")
check('large', solve(1e300), render(1e150))
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
import math
import struct
def render(x):
    if math.isnan(x): return 'nan'
    if math.isinf(x): return '-infinity' if x<0 else '+infinity'
    return format(x,'.11g')

N = 1
observations = []
def solve(x):
    try:
        if x < -1: return 'nan'
        if x == -1: return '-1'
        if x == 0: return render(x)
        result=x/(math.sqrt(1+x)+1)
        return render(result)
    except (ValueError, OverflowError, ZeroDivisionError, TypeError):
        return "arithmetic-error"
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('tiny positive', solve(N*2.0**-60), render(N*2.0**-61))
check('tiny negative', solve(-N*2.0**-60), render(-N*2.0**-61))
check('normal', solve(3.0), "1")
check('endpoint', solve(-1.0), "-1")
check('domain', solve(-2.0), "domain")
check('negative zero', solve(-0.0), "-0")
check('positive zero', solve(0.0), "0")
check('large', solve(1e300), render(1e150))
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:
Square-root increment silently clamps invalid radicands.

Evaluate sqrt(1+x)-1 stably for finite x >= -1. Finite results are rendered to eleven significant decimal digits; modeled domain violations and arithmetic errors are explicit strings.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
import math
import struct
def render(x):
    if math.isnan(x): return 'nan'
    if math.isinf(x): return '-infinity' if x<0 else '+infinity'
    return format(x,'.11g')

N = 1
observations = []
def solve(x):
    try:
        if x < -1: return 'domain'
        if x == -1: return '1'
        if x == 0: return render(x)
        result=x/(math.sqrt(1+x)+1)
        return render(result)
    except (ValueError, OverflowError, ZeroDivisionError, TypeError):
        return "arithmetic-error"
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('tiny positive', solve(N*2.0**-60), render(N*2.0**-61))
check('tiny negative', solve(-N*2.0**-60), render(-N*2.0**-61))
check('normal', solve(3.0), "1")
check('endpoint', solve(-1.0), "-1")
check('domain', solve(-2.0), "domain")
check('negative zero', solve(-0.0), "-0")
check('positive zero', solve(0.0), "0")
check('large', solve(1e300), render(1e150))
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
import math
import struct
def render(x):
    if math.isnan(x): return 'nan'
    if math.isinf(x): return '-infinity' if x<0 else '+infinity'
    return format(x,'.11g')

N = 1
observations = []
def solve(x):
    try:
        if x < -1: return 'domain'
        if x == -1: return '0'
        if x == 0: return render(x)
        result=x/(math.sqrt(1+x)+1)
        return render(result)
    except (ValueError, OverflowError, ZeroDivisionError, TypeError):
        return "arithmetic-error"
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('tiny positive', solve(N*2.0**-60), render(N*2.0**-61))
check('tiny negative', solve(-N*2.0**-60), render(-N*2.0**-61))
check('normal', solve(3.0), "1")
check('endpoint', solve(-1.0), "-1")
check('domain', solve(-2.0), "domain")
check('negative zero', solve(-0.0), "-0")
check('positive zero', solve(0.0), "0")
check('large', solve(1e300), render(1e150))
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:
Square-root endpoint is assigned positive one.

Evaluate sqrt(1+x)-1 stably for finite x >= -1. Finite results are rendered to eleven significant decimal digits; modeled domain violations and arithmetic errors are explicit strings.

split: open-access