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

N = 1
observations = []
def solve(d):
    errors=[]
    if False: errors.append('split-boundary')
    if set(d['left'])|set(d['right'])!=set(d['parent']): errors.append('partition-completeness')
    if bool(set(d['exclusive_a'])&set(d['exclusive_b'])): errors.append('exclusive-disjoint')
    if any(x!=d['owner'] for x in d['child_owners']): errors.append('owner-preservation')
    if any(x!=d['generation'] for x in d['child_generations']): errors.append('generation-preservation')
    if d['dynamic_pair'] and not d['inequality_proven']: errors.append('dynamic-disjoint-proof')
    if bool(d['empty_access']): errors.append('empty-access')
    if set(d['stride_indices'])!=set(d['enumerated']): errors.append('strided-footprint')
    if d['reverse_actual']!=d['reverse_expected']: errors.append('reverse-addresses')
    if d['consuming'] and d['parent_unique_live']: errors.append('split-consumption')
    return errors
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
base={'length': 0, 'split': 0, 'left': [], 'right': [], 'parent': [], 'exclusive_a': [], 'exclusive_b': [], 'child_owners': [], 'owner': None, 'child_generations': [], 'generation': 0, 'dynamic_pair': False, 'inequality_proven': True, 'empty_access': [], 'stride_indices': [], 'enumerated': [], 'reverse_expected': [], 'reverse_actual': [], 'consuming': False, 'parent_unique_live': False}
check('well formed empty obligations',solve(base),[])
check('split-boundary regression 0', solve(dict(base, **({'length':N,'split':N+1}))), ['split-boundary'])
check('split-boundary regression 1', solve(dict(base, **({'length':N+1,'split':N+2}))), ['split-boundary'])
check('partition-completeness regression 0', solve(dict(base, **({'parent':list(range(N+1)),'left':[0]}))), ['partition-completeness'])
check('partition-completeness regression 1', solve(dict(base, **({'parent':[N,N+1],'right':[N]}))), ['partition-completeness'])
check('exclusive-disjoint regression 0', solve(dict(base, **({'exclusive_a':[N,N+1],'exclusive_b':[N+1]}))), ['exclusive-disjoint'])
check('exclusive-disjoint regression 1', solve(dict(base, **({'exclusive_a':[N],'exclusive_b':[N,N+1]}))), ['exclusive-disjoint'])
check('owner-preservation regression 0', solve(dict(base, **({'owner':'r','child_owners':['r','s']}))), ['owner-preservation'])
check('owner-preservation regression 1', solve(dict(base, **({'owner':N,'child_owners':[N,N+1]}))), ['owner-preservation'])
check('generation-preservation regression 0', solve(dict(base, **({'generation':N+1,'child_generations':[N]}))), ['generation-preservation'])
check('generation-preservation regression 1', solve(dict(base, **({'generation':N+2,'child_generations':[N+1]}))), ['generation-preservation'])
check('dynamic-disjoint-proof regression 0', solve(dict(base, **({'dynamic_pair':True,'inequality_proven':False,'length':N}))), ['dynamic-disjoint-proof'])
check('dynamic-disjoint-proof regression 1', solve(dict(base, **({'dynamic_pair':True,'inequality_proven':False,'length':N+1}))), ['dynamic-disjoint-proof'])
check('empty-access regression 0', solve(dict(base, **({'empty_access':[N]}))), ['empty-access'])
check('empty-access regression 1', solve(dict(base, **({'empty_access':[N+1]}))), ['empty-access'])
check('strided-footprint regression 0', solve(dict(base, **({'stride_indices':[N,N+2],'enumerated':[N,N+1]}))), ['strided-footprint'])
check('strided-footprint regression 1', solve(dict(base, **({'stride_indices':[N,N+3],'enumerated':[N,N+2]}))), ['strided-footprint'])
check('reverse-addresses regression 0', solve(dict(base, **({'reverse_actual':[N,N+1],'reverse_expected':[N+1,N]}))), ['reverse-addresses'])
check('reverse-addresses regression 1', solve(dict(base, **({'reverse_actual':[N,N+1,N+2],'reverse_expected':[N+2,N+1,N]}))), ['reverse-addresses'])
check('split-consumption regression 0', solve(dict(base, **({'consuming':True,'parent_unique_live':True,'parent':[N],'left':[N]}))), ['split-consumption'])
check('split-consumption regression 1', solve(dict(base, **({'consuming':True,'parent_unique_live':True,'parent':[N+1],'right':[N+1]}))), ['split-consumption'])
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

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

N = 1
observations = []
def solve(d):
    errors=[]
    if d['split']<0 or d['split']>d['length']+1: errors.append('split-boundary')
    if set(d['left'])|set(d['right'])!=set(d['parent']): errors.append('partition-completeness')
    if bool(set(d['exclusive_a'])&set(d['exclusive_b'])): errors.append('exclusive-disjoint')
    if any(x!=d['owner'] for x in d['child_owners']): errors.append('owner-preservation')
    if any(x!=d['generation'] for x in d['child_generations']): errors.append('generation-preservation')
    if d['dynamic_pair'] and not d['inequality_proven']: errors.append('dynamic-disjoint-proof')
    if bool(d['empty_access']): errors.append('empty-access')
    if set(d['stride_indices'])!=set(d['enumerated']): errors.append('strided-footprint')
    if d['reverse_actual']!=d['reverse_expected']: errors.append('reverse-addresses')
    if d['consuming'] and d['parent_unique_live']: errors.append('split-consumption')
    return errors
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
base={'length': 0, 'split': 0, 'left': [], 'right': [], 'parent': [], 'exclusive_a': [], 'exclusive_b': [], 'child_owners': [], 'owner': None, 'child_generations': [], 'generation': 0, 'dynamic_pair': False, 'inequality_proven': True, 'empty_access': [], 'stride_indices': [], 'enumerated': [], 'reverse_expected': [], 'reverse_actual': [], 'consuming': False, 'parent_unique_live': False}
check('well formed empty obligations',solve(base),[])
check('split-boundary regression 0', solve(dict(base, **({'length':N,'split':N+1}))), ['split-boundary'])
check('split-boundary regression 1', solve(dict(base, **({'length':N+1,'split':N+2}))), ['split-boundary'])
check('partition-completeness regression 0', solve(dict(base, **({'parent':list(range(N+1)),'left':[0]}))), ['partition-completeness'])
check('partition-completeness regression 1', solve(dict(base, **({'parent':[N,N+1],'right':[N]}))), ['partition-completeness'])
check('exclusive-disjoint regression 0', solve(dict(base, **({'exclusive_a':[N,N+1],'exclusive_b':[N+1]}))), ['exclusive-disjoint'])
check('exclusive-disjoint regression 1', solve(dict(base, **({'exclusive_a':[N],'exclusive_b':[N,N+1]}))), ['exclusive-disjoint'])
check('owner-preservation regression 0', solve(dict(base, **({'owner':'r','child_owners':['r','s']}))), ['owner-preservation'])
check('owner-preservation regression 1', solve(dict(base, **({'owner':N,'child_owners':[N,N+1]}))), ['owner-preservation'])
check('generation-preservation regression 0', solve(dict(base, **({'generation':N+1,'child_generations':[N]}))), ['generation-preservation'])
check('generation-preservation regression 1', solve(dict(base, **({'generation':N+2,'child_generations':[N+1]}))), ['generation-preservation'])
check('dynamic-disjoint-proof regression 0', solve(dict(base, **({'dynamic_pair':True,'inequality_proven':False,'length':N}))), ['dynamic-disjoint-proof'])
check('dynamic-disjoint-proof regression 1', solve(dict(base, **({'dynamic_pair':True,'inequality_proven':False,'length':N+1}))), ['dynamic-disjoint-proof'])
check('empty-access regression 0', solve(dict(base, **({'empty_access':[N]}))), ['empty-access'])
check('empty-access regression 1', solve(dict(base, **({'empty_access':[N+1]}))), ['empty-access'])
check('strided-footprint regression 0', solve(dict(base, **({'stride_indices':[N,N+2],'enumerated':[N,N+1]}))), ['strided-footprint'])
check('strided-footprint regression 1', solve(dict(base, **({'stride_indices':[N,N+3],'enumerated':[N,N+2]}))), ['strided-footprint'])
check('reverse-addresses regression 0', solve(dict(base, **({'reverse_actual':[N,N+1],'reverse_expected':[N+1,N]}))), ['reverse-addresses'])
check('reverse-addresses regression 1', solve(dict(base, **({'reverse_actual':[N,N+1,N+2],'reverse_expected':[N+2,N+1,N]}))), ['reverse-addresses'])
check('split-consumption regression 0', solve(dict(base, **({'consuming':True,'parent_unique_live':True,'parent':[N],'left':[N]}))), ['split-consumption'])
check('split-consumption regression 1', solve(dict(base, **({'consuming':True,'parent_unique_live':True,'parent':[N+1],'right':[N+1]}))), ['split-consumption'])
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:
A split proof accepts one element beyond the parent slice.

Validate static proof objects for splitting borrowed slices. Bounds are half-open; split point lies in 0..length; children exactly partition parent; exclusive children disjoint; every child retains parent owner and generation; dynamic indices need inequality proof; empty children confer no element access; strided loans include every enumerated element; reverse views retain original element addresses; consuming split removes parent exclusive capability. Input is a fully explicit descriptor of the stated toy IR. Return rule identifiers in declaration order; absent optional obligations use the provided neutral defaults. No rule is an assertion about a production language.

split: open-access


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

N = 1
observations = []
def solve(d):
    errors=[]
    if d['split']<0 or d['split']>d['length']: errors.append('split-boundary')
    if False: errors.append('partition-completeness')
    if bool(set(d['exclusive_a'])&set(d['exclusive_b'])): errors.append('exclusive-disjoint')
    if any(x!=d['owner'] for x in d['child_owners']): errors.append('owner-preservation')
    if any(x!=d['generation'] for x in d['child_generations']): errors.append('generation-preservation')
    if d['dynamic_pair'] and not d['inequality_proven']: errors.append('dynamic-disjoint-proof')
    if bool(d['empty_access']): errors.append('empty-access')
    if set(d['stride_indices'])!=set(d['enumerated']): errors.append('strided-footprint')
    if d['reverse_actual']!=d['reverse_expected']: errors.append('reverse-addresses')
    if d['consuming'] and d['parent_unique_live']: errors.append('split-consumption')
    return errors
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
base={'length': 0, 'split': 0, 'left': [], 'right': [], 'parent': [], 'exclusive_a': [], 'exclusive_b': [], 'child_owners': [], 'owner': None, 'child_generations': [], 'generation': 0, 'dynamic_pair': False, 'inequality_proven': True, 'empty_access': [], 'stride_indices': [], 'enumerated': [], 'reverse_expected': [], 'reverse_actual': [], 'consuming': False, 'parent_unique_live': False}
check('well formed empty obligations',solve(base),[])
check('split-boundary regression 0', solve(dict(base, **({'length':N,'split':N+1}))), ['split-boundary'])
check('split-boundary regression 1', solve(dict(base, **({'length':N+1,'split':N+2}))), ['split-boundary'])
check('partition-completeness regression 0', solve(dict(base, **({'parent':list(range(N+1)),'left':[0]}))), ['partition-completeness'])
check('partition-completeness regression 1', solve(dict(base, **({'parent':[N,N+1],'right':[N]}))), ['partition-completeness'])
check('exclusive-disjoint regression 0', solve(dict(base, **({'exclusive_a':[N,N+1],'exclusive_b':[N+1]}))), ['exclusive-disjoint'])
check('exclusive-disjoint regression 1', solve(dict(base, **({'exclusive_a':[N],'exclusive_b':[N,N+1]}))), ['exclusive-disjoint'])
check('owner-preservation regression 0', solve(dict(base, **({'owner':'r','child_owners':['r','s']}))), ['owner-preservation'])
check('owner-preservation regression 1', solve(dict(base, **({'owner':N,'child_owners':[N,N+1]}))), ['owner-preservation'])
check('generation-preservation regression 0', solve(dict(base, **({'generation':N+1,'child_generations':[N]}))), ['generation-preservation'])
check('generation-preservation regression 1', solve(dict(base, **({'generation':N+2,'child_generations':[N+1]}))), ['generation-preservation'])
check('dynamic-disjoint-proof regression 0', solve(dict(base, **({'dynamic_pair':True,'inequality_proven':False,'length':N}))), ['dynamic-disjoint-proof'])
check('dynamic-disjoint-proof regression 1', solve(dict(base, **({'dynamic_pair':True,'inequality_proven':False,'length':N+1}))), ['dynamic-disjoint-proof'])
check('empty-access regression 0', solve(dict(base, **({'empty_access':[N]}))), ['empty-access'])
check('empty-access regression 1', solve(dict(base, **({'empty_access':[N+1]}))), ['empty-access'])
check('strided-footprint regression 0', solve(dict(base, **({'stride_indices':[N,N+2],'enumerated':[N,N+1]}))), ['strided-footprint'])
check('strided-footprint regression 1', solve(dict(base, **({'stride_indices':[N,N+3],'enumerated':[N,N+2]}))), ['strided-footprint'])
check('reverse-addresses regression 0', solve(dict(base, **({'reverse_actual':[N,N+1],'reverse_expected':[N+1,N]}))), ['reverse-addresses'])
check('reverse-addresses regression 1', solve(dict(base, **({'reverse_actual':[N,N+1,N+2],'reverse_expected':[N+2,N+1,N]}))), ['reverse-addresses'])
check('split-consumption regression 0', solve(dict(base, **({'consuming':True,'parent_unique_live':True,'parent':[N],'left':[N]}))), ['split-consumption'])
check('split-consumption regression 1', solve(dict(base, **({'consuming':True,'parent_unique_live':True,'parent':[N+1],'right':[N+1]}))), ['split-consumption'])
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

meaning: Fixture-count band, not measured model difficulty

deps: stdlib

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

N = 1
observations = []
def solve(d):
    errors=[]
    if d['split']<0 or d['split']>d['length']: errors.append('split-boundary')
    if not (set(d['left'])|set(d['right']))<=set(d['parent']): errors.append('partition-completeness')
    if bool(set(d['exclusive_a'])&set(d['exclusive_b'])): errors.append('exclusive-disjoint')
    if any(x!=d['owner'] for x in d['child_owners']): errors.append('owner-preservation')
    if any(x!=d['generation'] for x in d['child_generations']): errors.append('generation-preservation')
    if d['dynamic_pair'] and not d['inequality_proven']: errors.append('dynamic-disjoint-proof')
    if bool(d['empty_access']): errors.append('empty-access')
    if set(d['stride_indices'])!=set(d['enumerated']): errors.append('strided-footprint')
    if d['reverse_actual']!=d['reverse_expected']: errors.append('reverse-addresses')
    if d['consuming'] and d['parent_unique_live']: errors.append('split-consumption')
    return errors
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
base={'length': 0, 'split': 0, 'left': [], 'right': [], 'parent': [], 'exclusive_a': [], 'exclusive_b': [], 'child_owners': [], 'owner': None, 'child_generations': [], 'generation': 0, 'dynamic_pair': False, 'inequality_proven': True, 'empty_access': [], 'stride_indices': [], 'enumerated': [], 'reverse_expected': [], 'reverse_actual': [], 'consuming': False, 'parent_unique_live': False}
check('well formed empty obligations',solve(base),[])
check('split-boundary regression 0', solve(dict(base, **({'length':N,'split':N+1}))), ['split-boundary'])
check('split-boundary regression 1', solve(dict(base, **({'length':N+1,'split':N+2}))), ['split-boundary'])
check('partition-completeness regression 0', solve(dict(base, **({'parent':list(range(N+1)),'left':[0]}))), ['partition-completeness'])
check('partition-completeness regression 1', solve(dict(base, **({'parent':[N,N+1],'right':[N]}))), ['partition-completeness'])
check('exclusive-disjoint regression 0', solve(dict(base, **({'exclusive_a':[N,N+1],'exclusive_b':[N+1]}))), ['exclusive-disjoint'])
check('exclusive-disjoint regression 1', solve(dict(base, **({'exclusive_a':[N],'exclusive_b':[N,N+1]}))), ['exclusive-disjoint'])
check('owner-preservation regression 0', solve(dict(base, **({'owner':'r','child_owners':['r','s']}))), ['owner-preservation'])
check('owner-preservation regression 1', solve(dict(base, **({'owner':N,'child_owners':[N,N+1]}))), ['owner-preservation'])
check('generation-preservation regression 0', solve(dict(base, **({'generation':N+1,'child_generations':[N]}))), ['generation-preservation'])
check('generation-preservation regression 1', solve(dict(base, **({'generation':N+2,'child_generations':[N+1]}))), ['generation-preservation'])
check('dynamic-disjoint-proof regression 0', solve(dict(base, **({'dynamic_pair':True,'inequality_proven':False,'length':N}))), ['dynamic-disjoint-proof'])
check('dynamic-disjoint-proof regression 1', solve(dict(base, **({'dynamic_pair':True,'inequality_proven':False,'length':N+1}))), ['dynamic-disjoint-proof'])
check('empty-access regression 0', solve(dict(base, **({'empty_access':[N]}))), ['empty-access'])
check('empty-access regression 1', solve(dict(base, **({'empty_access':[N+1]}))), ['empty-access'])
check('strided-footprint regression 0', solve(dict(base, **({'stride_indices':[N,N+2],'enumerated':[N,N+1]}))), ['strided-footprint'])
check('strided-footprint regression 1', solve(dict(base, **({'stride_indices':[N,N+3],'enumerated':[N,N+2]}))), ['strided-footprint'])
check('reverse-addresses regression 0', solve(dict(base, **({'reverse_actual':[N,N+1],'reverse_expected':[N+1,N]}))), ['reverse-addresses'])
check('reverse-addresses regression 1', solve(dict(base, **({'reverse_actual':[N,N+1,N+2],'reverse_expected':[N+2,N+1,N]}))), ['reverse-addresses'])
check('split-consumption regression 0', solve(dict(base, **({'consuming':True,'parent_unique_live':True,'parent':[N],'left':[N]}))), ['split-consumption'])
check('split-consumption regression 1', solve(dict(base, **({'consuming':True,'parent_unique_live':True,'parent':[N+1],'right':[N+1]}))), ['split-consumption'])
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:
A split proof silently loses parent elements.

Validate static proof objects for splitting borrowed slices. Bounds are half-open; split point lies in 0..length; children exactly partition parent; exclusive children disjoint; every child retains parent owner and generation; dynamic indices need inequality proof; empty children confer no element access; strided loans include every enumerated element; reverse views retain original element addresses; consuming split removes parent exclusive capability. Input is a fully explicit descriptor of the stated toy IR. Return rule identifiers in declaration order; absent optional obligations use the provided neutral defaults. No rule is an assertion about a production language.

split: open-access


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

N = 1
observations = []
def solve(d):
    errors=[]
    if d['split']<0 or d['split']>d['length']: errors.append('split-boundary')
    if set(d['left'])|set(d['right'])!=set(d['parent']): errors.append('partition-completeness')
    if False: errors.append('exclusive-disjoint')
    if any(x!=d['owner'] for x in d['child_owners']): errors.append('owner-preservation')
    if any(x!=d['generation'] for x in d['child_generations']): errors.append('generation-preservation')
    if d['dynamic_pair'] and not d['inequality_proven']: errors.append('dynamic-disjoint-proof')
    if bool(d['empty_access']): errors.append('empty-access')
    if set(d['stride_indices'])!=set(d['enumerated']): errors.append('strided-footprint')
    if d['reverse_actual']!=d['reverse_expected']: errors.append('reverse-addresses')
    if d['consuming'] and d['parent_unique_live']: errors.append('split-consumption')
    return errors
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
base={'length': 0, 'split': 0, 'left': [], 'right': [], 'parent': [], 'exclusive_a': [], 'exclusive_b': [], 'child_owners': [], 'owner': None, 'child_generations': [], 'generation': 0, 'dynamic_pair': False, 'inequality_proven': True, 'empty_access': [], 'stride_indices': [], 'enumerated': [], 'reverse_expected': [], 'reverse_actual': [], 'consuming': False, 'parent_unique_live': False}
check('well formed empty obligations',solve(base),[])
check('split-boundary regression 0', solve(dict(base, **({'length':N,'split':N+1}))), ['split-boundary'])
check('split-boundary regression 1', solve(dict(base, **({'length':N+1,'split':N+2}))), ['split-boundary'])
check('partition-completeness regression 0', solve(dict(base, **({'parent':list(range(N+1)),'left':[0]}))), ['partition-completeness'])
check('partition-completeness regression 1', solve(dict(base, **({'parent':[N,N+1],'right':[N]}))), ['partition-completeness'])
check('exclusive-disjoint regression 0', solve(dict(base, **({'exclusive_a':[N,N+1],'exclusive_b':[N+1]}))), ['exclusive-disjoint'])
check('exclusive-disjoint regression 1', solve(dict(base, **({'exclusive_a':[N],'exclusive_b':[N,N+1]}))), ['exclusive-disjoint'])
check('owner-preservation regression 0', solve(dict(base, **({'owner':'r','child_owners':['r','s']}))), ['owner-preservation'])
check('owner-preservation regression 1', solve(dict(base, **({'owner':N,'child_owners':[N,N+1]}))), ['owner-preservation'])
check('generation-preservation regression 0', solve(dict(base, **({'generation':N+1,'child_generations':[N]}))), ['generation-preservation'])
check('generation-preservation regression 1', solve(dict(base, **({'generation':N+2,'child_generations':[N+1]}))), ['generation-preservation'])
check('dynamic-disjoint-proof regression 0', solve(dict(base, **({'dynamic_pair':True,'inequality_proven':False,'length':N}))), ['dynamic-disjoint-proof'])
check('dynamic-disjoint-proof regression 1', solve(dict(base, **({'dynamic_pair':True,'inequality_proven':False,'length':N+1}))), ['dynamic-disjoint-proof'])
check('empty-access regression 0', solve(dict(base, **({'empty_access':[N]}))), ['empty-access'])
check('empty-access regression 1', solve(dict(base, **({'empty_access':[N+1]}))), ['empty-access'])
check('strided-footprint regression 0', solve(dict(base, **({'stride_indices':[N,N+2],'enumerated':[N,N+1]}))), ['strided-footprint'])
check('strided-footprint regression 1', solve(dict(base, **({'stride_indices':[N,N+3],'enumerated':[N,N+2]}))), ['strided-footprint'])
check('reverse-addresses regression 0', solve(dict(base, **({'reverse_actual':[N,N+1],'reverse_expected':[N+1,N]}))), ['reverse-addresses'])
check('reverse-addresses regression 1', solve(dict(base, **({'reverse_actual':[N,N+1,N+2],'reverse_expected':[N+2,N+1,N]}))), ['reverse-addresses'])
check('split-consumption regression 0', solve(dict(base, **({'consuming':True,'parent_unique_live':True,'parent':[N],'left':[N]}))), ['split-consumption'])
check('split-consumption regression 1', solve(dict(base, **({'consuming':True,'parent_unique_live':True,'parent':[N+1],'right':[N+1]}))), ['split-consumption'])
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

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

N = 1
observations = []
def solve(d):
    errors=[]
    if d['split']<0 or d['split']>d['length']: errors.append('split-boundary')
    if set(d['left'])|set(d['right'])!=set(d['parent']): errors.append('partition-completeness')
    if set(d['exclusive_a'])==set(d['exclusive_b']) and bool(d['exclusive_a']): errors.append('exclusive-disjoint')
    if any(x!=d['owner'] for x in d['child_owners']): errors.append('owner-preservation')
    if any(x!=d['generation'] for x in d['child_generations']): errors.append('generation-preservation')
    if d['dynamic_pair'] and not d['inequality_proven']: errors.append('dynamic-disjoint-proof')
    if bool(d['empty_access']): errors.append('empty-access')
    if set(d['stride_indices'])!=set(d['enumerated']): errors.append('strided-footprint')
    if d['reverse_actual']!=d['reverse_expected']: errors.append('reverse-addresses')
    if d['consuming'] and d['parent_unique_live']: errors.append('split-consumption')
    return errors
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
base={'length': 0, 'split': 0, 'left': [], 'right': [], 'parent': [], 'exclusive_a': [], 'exclusive_b': [], 'child_owners': [], 'owner': None, 'child_generations': [], 'generation': 0, 'dynamic_pair': False, 'inequality_proven': True, 'empty_access': [], 'stride_indices': [], 'enumerated': [], 'reverse_expected': [], 'reverse_actual': [], 'consuming': False, 'parent_unique_live': False}
check('well formed empty obligations',solve(base),[])
check('split-boundary regression 0', solve(dict(base, **({'length':N,'split':N+1}))), ['split-boundary'])
check('split-boundary regression 1', solve(dict(base, **({'length':N+1,'split':N+2}))), ['split-boundary'])
check('partition-completeness regression 0', solve(dict(base, **({'parent':list(range(N+1)),'left':[0]}))), ['partition-completeness'])
check('partition-completeness regression 1', solve(dict(base, **({'parent':[N,N+1],'right':[N]}))), ['partition-completeness'])
check('exclusive-disjoint regression 0', solve(dict(base, **({'exclusive_a':[N,N+1],'exclusive_b':[N+1]}))), ['exclusive-disjoint'])
check('exclusive-disjoint regression 1', solve(dict(base, **({'exclusive_a':[N],'exclusive_b':[N,N+1]}))), ['exclusive-disjoint'])
check('owner-preservation regression 0', solve(dict(base, **({'owner':'r','child_owners':['r','s']}))), ['owner-preservation'])
check('owner-preservation regression 1', solve(dict(base, **({'owner':N,'child_owners':[N,N+1]}))), ['owner-preservation'])
check('generation-preservation regression 0', solve(dict(base, **({'generation':N+1,'child_generations':[N]}))), ['generation-preservation'])
check('generation-preservation regression 1', solve(dict(base, **({'generation':N+2,'child_generations':[N+1]}))), ['generation-preservation'])
check('dynamic-disjoint-proof regression 0', solve(dict(base, **({'dynamic_pair':True,'inequality_proven':False,'length':N}))), ['dynamic-disjoint-proof'])
check('dynamic-disjoint-proof regression 1', solve(dict(base, **({'dynamic_pair':True,'inequality_proven':False,'length':N+1}))), ['dynamic-disjoint-proof'])
check('empty-access regression 0', solve(dict(base, **({'empty_access':[N]}))), ['empty-access'])
check('empty-access regression 1', solve(dict(base, **({'empty_access':[N+1]}))), ['empty-access'])
check('strided-footprint regression 0', solve(dict(base, **({'stride_indices':[N,N+2],'enumerated':[N,N+1]}))), ['strided-footprint'])
check('strided-footprint regression 1', solve(dict(base, **({'stride_indices':[N,N+3],'enumerated':[N,N+2]}))), ['strided-footprint'])
check('reverse-addresses regression 0', solve(dict(base, **({'reverse_actual':[N,N+1],'reverse_expected':[N+1,N]}))), ['reverse-addresses'])
check('reverse-addresses regression 1', solve(dict(base, **({'reverse_actual':[N,N+1,N+2],'reverse_expected':[N+2,N+1,N]}))), ['reverse-addresses'])
check('split-consumption regression 0', solve(dict(base, **({'consuming':True,'parent_unique_live':True,'parent':[N],'left':[N]}))), ['split-consumption'])
check('split-consumption regression 1', solve(dict(base, **({'consuming':True,'parent_unique_live':True,'parent':[N+1],'right':[N+1]}))), ['split-consumption'])
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:
Half-open exclusive child views share an element at the split boundary.

Validate static proof objects for splitting borrowed slices. Bounds are half-open; split point lies in 0..length; children exactly partition parent; exclusive children disjoint; every child retains parent owner and generation; dynamic indices need inequality proof; empty children confer no element access; strided loans include every enumerated element; reverse views retain original element addresses; consuming split removes parent exclusive capability. Input is a fully explicit descriptor of the stated toy IR. Return rule identifiers in declaration order; absent optional obligations use the provided neutral defaults. No rule is an assertion about a production language.

split: open-access


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

N = 1
observations = []
def solve(d):
    errors=[]
    if d['split']<0 or d['split']>d['length']: errors.append('split-boundary')
    if set(d['left'])|set(d['right'])!=set(d['parent']): errors.append('partition-completeness')
    if bool(set(d['exclusive_a'])&set(d['exclusive_b'])): errors.append('exclusive-disjoint')
    if False: errors.append('owner-preservation')
    if any(x!=d['generation'] for x in d['child_generations']): errors.append('generation-preservation')
    if d['dynamic_pair'] and not d['inequality_proven']: errors.append('dynamic-disjoint-proof')
    if bool(d['empty_access']): errors.append('empty-access')
    if set(d['stride_indices'])!=set(d['enumerated']): errors.append('strided-footprint')
    if d['reverse_actual']!=d['reverse_expected']: errors.append('reverse-addresses')
    if d['consuming'] and d['parent_unique_live']: errors.append('split-consumption')
    return errors
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
base={'length': 0, 'split': 0, 'left': [], 'right': [], 'parent': [], 'exclusive_a': [], 'exclusive_b': [], 'child_owners': [], 'owner': None, 'child_generations': [], 'generation': 0, 'dynamic_pair': False, 'inequality_proven': True, 'empty_access': [], 'stride_indices': [], 'enumerated': [], 'reverse_expected': [], 'reverse_actual': [], 'consuming': False, 'parent_unique_live': False}
check('well formed empty obligations',solve(base),[])
check('split-boundary regression 0', solve(dict(base, **({'length':N,'split':N+1}))), ['split-boundary'])
check('split-boundary regression 1', solve(dict(base, **({'length':N+1,'split':N+2}))), ['split-boundary'])
check('partition-completeness regression 0', solve(dict(base, **({'parent':list(range(N+1)),'left':[0]}))), ['partition-completeness'])
check('partition-completeness regression 1', solve(dict(base, **({'parent':[N,N+1],'right':[N]}))), ['partition-completeness'])
check('exclusive-disjoint regression 0', solve(dict(base, **({'exclusive_a':[N,N+1],'exclusive_b':[N+1]}))), ['exclusive-disjoint'])
check('exclusive-disjoint regression 1', solve(dict(base, **({'exclusive_a':[N],'exclusive_b':[N,N+1]}))), ['exclusive-disjoint'])
check('owner-preservation regression 0', solve(dict(base, **({'owner':'r','child_owners':['r','s']}))), ['owner-preservation'])
check('owner-preservation regression 1', solve(dict(base, **({'owner':N,'child_owners':[N,N+1]}))), ['owner-preservation'])
check('generation-preservation regression 0', solve(dict(base, **({'generation':N+1,'child_generations':[N]}))), ['generation-preservation'])
check('generation-preservation regression 1', solve(dict(base, **({'generation':N+2,'child_generations':[N+1]}))), ['generation-preservation'])
check('dynamic-disjoint-proof regression 0', solve(dict(base, **({'dynamic_pair':True,'inequality_proven':False,'length':N}))), ['dynamic-disjoint-proof'])
check('dynamic-disjoint-proof regression 1', solve(dict(base, **({'dynamic_pair':True,'inequality_proven':False,'length':N+1}))), ['dynamic-disjoint-proof'])
check('empty-access regression 0', solve(dict(base, **({'empty_access':[N]}))), ['empty-access'])
check('empty-access regression 1', solve(dict(base, **({'empty_access':[N+1]}))), ['empty-access'])
check('strided-footprint regression 0', solve(dict(base, **({'stride_indices':[N,N+2],'enumerated':[N,N+1]}))), ['strided-footprint'])
check('strided-footprint regression 1', solve(dict(base, **({'stride_indices':[N,N+3],'enumerated':[N,N+2]}))), ['strided-footprint'])
check('reverse-addresses regression 0', solve(dict(base, **({'reverse_actual':[N,N+1],'reverse_expected':[N+1,N]}))), ['reverse-addresses'])
check('reverse-addresses regression 1', solve(dict(base, **({'reverse_actual':[N,N+1,N+2],'reverse_expected':[N+2,N+1,N]}))), ['reverse-addresses'])
check('split-consumption regression 0', solve(dict(base, **({'consuming':True,'parent_unique_live':True,'parent':[N],'left':[N]}))), ['split-consumption'])
check('split-consumption regression 1', solve(dict(base, **({'consuming':True,'parent_unique_live':True,'parent':[N+1],'right':[N+1]}))), ['split-consumption'])
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

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

N = 1
observations = []
def solve(d):
    errors=[]
    if d['split']<0 or d['split']>d['length']: errors.append('split-boundary')
    if set(d['left'])|set(d['right'])!=set(d['parent']): errors.append('partition-completeness')
    if bool(set(d['exclusive_a'])&set(d['exclusive_b'])): errors.append('exclusive-disjoint')
    if bool(d['child_owners']) and d['child_owners'][0]!=d['owner']: errors.append('owner-preservation')
    if any(x!=d['generation'] for x in d['child_generations']): errors.append('generation-preservation')
    if d['dynamic_pair'] and not d['inequality_proven']: errors.append('dynamic-disjoint-proof')
    if bool(d['empty_access']): errors.append('empty-access')
    if set(d['stride_indices'])!=set(d['enumerated']): errors.append('strided-footprint')
    if d['reverse_actual']!=d['reverse_expected']: errors.append('reverse-addresses')
    if d['consuming'] and d['parent_unique_live']: errors.append('split-consumption')
    return errors
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
base={'length': 0, 'split': 0, 'left': [], 'right': [], 'parent': [], 'exclusive_a': [], 'exclusive_b': [], 'child_owners': [], 'owner': None, 'child_generations': [], 'generation': 0, 'dynamic_pair': False, 'inequality_proven': True, 'empty_access': [], 'stride_indices': [], 'enumerated': [], 'reverse_expected': [], 'reverse_actual': [], 'consuming': False, 'parent_unique_live': False}
check('well formed empty obligations',solve(base),[])
check('split-boundary regression 0', solve(dict(base, **({'length':N,'split':N+1}))), ['split-boundary'])
check('split-boundary regression 1', solve(dict(base, **({'length':N+1,'split':N+2}))), ['split-boundary'])
check('partition-completeness regression 0', solve(dict(base, **({'parent':list(range(N+1)),'left':[0]}))), ['partition-completeness'])
check('partition-completeness regression 1', solve(dict(base, **({'parent':[N,N+1],'right':[N]}))), ['partition-completeness'])
check('exclusive-disjoint regression 0', solve(dict(base, **({'exclusive_a':[N,N+1],'exclusive_b':[N+1]}))), ['exclusive-disjoint'])
check('exclusive-disjoint regression 1', solve(dict(base, **({'exclusive_a':[N],'exclusive_b':[N,N+1]}))), ['exclusive-disjoint'])
check('owner-preservation regression 0', solve(dict(base, **({'owner':'r','child_owners':['r','s']}))), ['owner-preservation'])
check('owner-preservation regression 1', solve(dict(base, **({'owner':N,'child_owners':[N,N+1]}))), ['owner-preservation'])
check('generation-preservation regression 0', solve(dict(base, **({'generation':N+1,'child_generations':[N]}))), ['generation-preservation'])
check('generation-preservation regression 1', solve(dict(base, **({'generation':N+2,'child_generations':[N+1]}))), ['generation-preservation'])
check('dynamic-disjoint-proof regression 0', solve(dict(base, **({'dynamic_pair':True,'inequality_proven':False,'length':N}))), ['dynamic-disjoint-proof'])
check('dynamic-disjoint-proof regression 1', solve(dict(base, **({'dynamic_pair':True,'inequality_proven':False,'length':N+1}))), ['dynamic-disjoint-proof'])
check('empty-access regression 0', solve(dict(base, **({'empty_access':[N]}))), ['empty-access'])
check('empty-access regression 1', solve(dict(base, **({'empty_access':[N+1]}))), ['empty-access'])
check('strided-footprint regression 0', solve(dict(base, **({'stride_indices':[N,N+2],'enumerated':[N,N+1]}))), ['strided-footprint'])
check('strided-footprint regression 1', solve(dict(base, **({'stride_indices':[N,N+3],'enumerated':[N,N+2]}))), ['strided-footprint'])
check('reverse-addresses regression 0', solve(dict(base, **({'reverse_actual':[N,N+1],'reverse_expected':[N+1,N]}))), ['reverse-addresses'])
check('reverse-addresses regression 1', solve(dict(base, **({'reverse_actual':[N,N+1,N+2],'reverse_expected':[N+2,N+1,N]}))), ['reverse-addresses'])
check('split-consumption regression 0', solve(dict(base, **({'consuming':True,'parent_unique_live':True,'parent':[N],'left':[N]}))), ['split-consumption'])
check('split-consumption regression 1', solve(dict(base, **({'consuming':True,'parent_unique_live':True,'parent':[N+1],'right':[N+1]}))), ['split-consumption'])
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 second split result carries an unrelated allocation origin.

Validate static proof objects for splitting borrowed slices. Bounds are half-open; split point lies in 0..length; children exactly partition parent; exclusive children disjoint; every child retains parent owner and generation; dynamic indices need inequality proof; empty children confer no element access; strided loans include every enumerated element; reverse views retain original element addresses; consuming split removes parent exclusive capability. Input is a fully explicit descriptor of the stated toy IR. Return rule identifiers in declaration order; absent optional obligations use the provided neutral defaults. No rule is an assertion about a production language.

split: open-access


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

N = 1
observations = []
def solve(d):
    errors=[]
    if d['split']<0 or d['split']>d['length']: errors.append('split-boundary')
    if set(d['left'])|set(d['right'])!=set(d['parent']): errors.append('partition-completeness')
    if bool(set(d['exclusive_a'])&set(d['exclusive_b'])): errors.append('exclusive-disjoint')
    if any(x!=d['owner'] for x in d['child_owners']): errors.append('owner-preservation')
    if False: errors.append('generation-preservation')
    if d['dynamic_pair'] and not d['inequality_proven']: errors.append('dynamic-disjoint-proof')
    if bool(d['empty_access']): errors.append('empty-access')
    if set(d['stride_indices'])!=set(d['enumerated']): errors.append('strided-footprint')
    if d['reverse_actual']!=d['reverse_expected']: errors.append('reverse-addresses')
    if d['consuming'] and d['parent_unique_live']: errors.append('split-consumption')
    return errors
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
base={'length': 0, 'split': 0, 'left': [], 'right': [], 'parent': [], 'exclusive_a': [], 'exclusive_b': [], 'child_owners': [], 'owner': None, 'child_generations': [], 'generation': 0, 'dynamic_pair': False, 'inequality_proven': True, 'empty_access': [], 'stride_indices': [], 'enumerated': [], 'reverse_expected': [], 'reverse_actual': [], 'consuming': False, 'parent_unique_live': False}
check('well formed empty obligations',solve(base),[])
check('split-boundary regression 0', solve(dict(base, **({'length':N,'split':N+1}))), ['split-boundary'])
check('split-boundary regression 1', solve(dict(base, **({'length':N+1,'split':N+2}))), ['split-boundary'])
check('partition-completeness regression 0', solve(dict(base, **({'parent':list(range(N+1)),'left':[0]}))), ['partition-completeness'])
check('partition-completeness regression 1', solve(dict(base, **({'parent':[N,N+1],'right':[N]}))), ['partition-completeness'])
check('exclusive-disjoint regression 0', solve(dict(base, **({'exclusive_a':[N,N+1],'exclusive_b':[N+1]}))), ['exclusive-disjoint'])
check('exclusive-disjoint regression 1', solve(dict(base, **({'exclusive_a':[N],'exclusive_b':[N,N+1]}))), ['exclusive-disjoint'])
check('owner-preservation regression 0', solve(dict(base, **({'owner':'r','child_owners':['r','s']}))), ['owner-preservation'])
check('owner-preservation regression 1', solve(dict(base, **({'owner':N,'child_owners':[N,N+1]}))), ['owner-preservation'])
check('generation-preservation regression 0', solve(dict(base, **({'generation':N+1,'child_generations':[N]}))), ['generation-preservation'])
check('generation-preservation regression 1', solve(dict(base, **({'generation':N+2,'child_generations':[N+1]}))), ['generation-preservation'])
check('dynamic-disjoint-proof regression 0', solve(dict(base, **({'dynamic_pair':True,'inequality_proven':False,'length':N}))), ['dynamic-disjoint-proof'])
check('dynamic-disjoint-proof regression 1', solve(dict(base, **({'dynamic_pair':True,'inequality_proven':False,'length':N+1}))), ['dynamic-disjoint-proof'])
check('empty-access regression 0', solve(dict(base, **({'empty_access':[N]}))), ['empty-access'])
check('empty-access regression 1', solve(dict(base, **({'empty_access':[N+1]}))), ['empty-access'])
check('strided-footprint regression 0', solve(dict(base, **({'stride_indices':[N,N+2],'enumerated':[N,N+1]}))), ['strided-footprint'])
check('strided-footprint regression 1', solve(dict(base, **({'stride_indices':[N,N+3],'enumerated':[N,N+2]}))), ['strided-footprint'])
check('reverse-addresses regression 0', solve(dict(base, **({'reverse_actual':[N,N+1],'reverse_expected':[N+1,N]}))), ['reverse-addresses'])
check('reverse-addresses regression 1', solve(dict(base, **({'reverse_actual':[N,N+1,N+2],'reverse_expected':[N+2,N+1,N]}))), ['reverse-addresses'])
check('split-consumption regression 0', solve(dict(base, **({'consuming':True,'parent_unique_live':True,'parent':[N],'left':[N]}))), ['split-consumption'])
check('split-consumption regression 1', solve(dict(base, **({'consuming':True,'parent_unique_live':True,'parent':[N+1],'right':[N+1]}))), ['split-consumption'])
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

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

N = 1
observations = []
def solve(d):
    errors=[]
    if d['split']<0 or d['split']>d['length']: errors.append('split-boundary')
    if set(d['left'])|set(d['right'])!=set(d['parent']): errors.append('partition-completeness')
    if bool(set(d['exclusive_a'])&set(d['exclusive_b'])): errors.append('exclusive-disjoint')
    if any(x!=d['owner'] for x in d['child_owners']): errors.append('owner-preservation')
    if any(x>d['generation'] for x in d['child_generations']): errors.append('generation-preservation')
    if d['dynamic_pair'] and not d['inequality_proven']: errors.append('dynamic-disjoint-proof')
    if bool(d['empty_access']): errors.append('empty-access')
    if set(d['stride_indices'])!=set(d['enumerated']): errors.append('strided-footprint')
    if d['reverse_actual']!=d['reverse_expected']: errors.append('reverse-addresses')
    if d['consuming'] and d['parent_unique_live']: errors.append('split-consumption')
    return errors
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
base={'length': 0, 'split': 0, 'left': [], 'right': [], 'parent': [], 'exclusive_a': [], 'exclusive_b': [], 'child_owners': [], 'owner': None, 'child_generations': [], 'generation': 0, 'dynamic_pair': False, 'inequality_proven': True, 'empty_access': [], 'stride_indices': [], 'enumerated': [], 'reverse_expected': [], 'reverse_actual': [], 'consuming': False, 'parent_unique_live': False}
check('well formed empty obligations',solve(base),[])
check('split-boundary regression 0', solve(dict(base, **({'length':N,'split':N+1}))), ['split-boundary'])
check('split-boundary regression 1', solve(dict(base, **({'length':N+1,'split':N+2}))), ['split-boundary'])
check('partition-completeness regression 0', solve(dict(base, **({'parent':list(range(N+1)),'left':[0]}))), ['partition-completeness'])
check('partition-completeness regression 1', solve(dict(base, **({'parent':[N,N+1],'right':[N]}))), ['partition-completeness'])
check('exclusive-disjoint regression 0', solve(dict(base, **({'exclusive_a':[N,N+1],'exclusive_b':[N+1]}))), ['exclusive-disjoint'])
check('exclusive-disjoint regression 1', solve(dict(base, **({'exclusive_a':[N],'exclusive_b':[N,N+1]}))), ['exclusive-disjoint'])
check('owner-preservation regression 0', solve(dict(base, **({'owner':'r','child_owners':['r','s']}))), ['owner-preservation'])
check('owner-preservation regression 1', solve(dict(base, **({'owner':N,'child_owners':[N,N+1]}))), ['owner-preservation'])
check('generation-preservation regression 0', solve(dict(base, **({'generation':N+1,'child_generations':[N]}))), ['generation-preservation'])
check('generation-preservation regression 1', solve(dict(base, **({'generation':N+2,'child_generations':[N+1]}))), ['generation-preservation'])
check('dynamic-disjoint-proof regression 0', solve(dict(base, **({'dynamic_pair':True,'inequality_proven':False,'length':N}))), ['dynamic-disjoint-proof'])
check('dynamic-disjoint-proof regression 1', solve(dict(base, **({'dynamic_pair':True,'inequality_proven':False,'length':N+1}))), ['dynamic-disjoint-proof'])
check('empty-access regression 0', solve(dict(base, **({'empty_access':[N]}))), ['empty-access'])
check('empty-access regression 1', solve(dict(base, **({'empty_access':[N+1]}))), ['empty-access'])
check('strided-footprint regression 0', solve(dict(base, **({'stride_indices':[N,N+2],'enumerated':[N,N+1]}))), ['strided-footprint'])
check('strided-footprint regression 1', solve(dict(base, **({'stride_indices':[N,N+3],'enumerated':[N,N+2]}))), ['strided-footprint'])
check('reverse-addresses regression 0', solve(dict(base, **({'reverse_actual':[N,N+1],'reverse_expected':[N+1,N]}))), ['reverse-addresses'])
check('reverse-addresses regression 1', solve(dict(base, **({'reverse_actual':[N,N+1,N+2],'reverse_expected':[N+2,N+1,N]}))), ['reverse-addresses'])
check('split-consumption regression 0', solve(dict(base, **({'consuming':True,'parent_unique_live':True,'parent':[N],'left':[N]}))), ['split-consumption'])
check('split-consumption regression 1', solve(dict(base, **({'consuming':True,'parent_unique_live':True,'parent':[N+1],'right':[N+1]}))), ['split-consumption'])
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:
A split child reuses a stale owner generation.

Validate static proof objects for splitting borrowed slices. Bounds are half-open; split point lies in 0..length; children exactly partition parent; exclusive children disjoint; every child retains parent owner and generation; dynamic indices need inequality proof; empty children confer no element access; strided loans include every enumerated element; reverse views retain original element addresses; consuming split removes parent exclusive capability. Input is a fully explicit descriptor of the stated toy IR. Return rule identifiers in declaration order; absent optional obligations use the provided neutral defaults. No rule is an assertion about a production language.

split: open-access


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

N = 1
observations = []
def solve(d):
    errors=[]
    if d['split']<0 or d['split']>d['length']: errors.append('split-boundary')
    if set(d['left'])|set(d['right'])!=set(d['parent']): errors.append('partition-completeness')
    if bool(set(d['exclusive_a'])&set(d['exclusive_b'])): errors.append('exclusive-disjoint')
    if any(x!=d['owner'] for x in d['child_owners']): errors.append('owner-preservation')
    if any(x!=d['generation'] for x in d['child_generations']): errors.append('generation-preservation')
    if False: errors.append('dynamic-disjoint-proof')
    if bool(d['empty_access']): errors.append('empty-access')
    if set(d['stride_indices'])!=set(d['enumerated']): errors.append('strided-footprint')
    if d['reverse_actual']!=d['reverse_expected']: errors.append('reverse-addresses')
    if d['consuming'] and d['parent_unique_live']: errors.append('split-consumption')
    return errors
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
base={'length': 0, 'split': 0, 'left': [], 'right': [], 'parent': [], 'exclusive_a': [], 'exclusive_b': [], 'child_owners': [], 'owner': None, 'child_generations': [], 'generation': 0, 'dynamic_pair': False, 'inequality_proven': True, 'empty_access': [], 'stride_indices': [], 'enumerated': [], 'reverse_expected': [], 'reverse_actual': [], 'consuming': False, 'parent_unique_live': False}
check('well formed empty obligations',solve(base),[])
check('split-boundary regression 0', solve(dict(base, **({'length':N,'split':N+1}))), ['split-boundary'])
check('split-boundary regression 1', solve(dict(base, **({'length':N+1,'split':N+2}))), ['split-boundary'])
check('partition-completeness regression 0', solve(dict(base, **({'parent':list(range(N+1)),'left':[0]}))), ['partition-completeness'])
check('partition-completeness regression 1', solve(dict(base, **({'parent':[N,N+1],'right':[N]}))), ['partition-completeness'])
check('exclusive-disjoint regression 0', solve(dict(base, **({'exclusive_a':[N,N+1],'exclusive_b':[N+1]}))), ['exclusive-disjoint'])
check('exclusive-disjoint regression 1', solve(dict(base, **({'exclusive_a':[N],'exclusive_b':[N,N+1]}))), ['exclusive-disjoint'])
check('owner-preservation regression 0', solve(dict(base, **({'owner':'r','child_owners':['r','s']}))), ['owner-preservation'])
check('owner-preservation regression 1', solve(dict(base, **({'owner':N,'child_owners':[N,N+1]}))), ['owner-preservation'])
check('generation-preservation regression 0', solve(dict(base, **({'generation':N+1,'child_generations':[N]}))), ['generation-preservation'])
check('generation-preservation regression 1', solve(dict(base, **({'generation':N+2,'child_generations':[N+1]}))), ['generation-preservation'])
check('dynamic-disjoint-proof regression 0', solve(dict(base, **({'dynamic_pair':True,'inequality_proven':False,'length':N}))), ['dynamic-disjoint-proof'])
check('dynamic-disjoint-proof regression 1', solve(dict(base, **({'dynamic_pair':True,'inequality_proven':False,'length':N+1}))), ['dynamic-disjoint-proof'])
check('empty-access regression 0', solve(dict(base, **({'empty_access':[N]}))), ['empty-access'])
check('empty-access regression 1', solve(dict(base, **({'empty_access':[N+1]}))), ['empty-access'])
check('strided-footprint regression 0', solve(dict(base, **({'stride_indices':[N,N+2],'enumerated':[N,N+1]}))), ['strided-footprint'])
check('strided-footprint regression 1', solve(dict(base, **({'stride_indices':[N,N+3],'enumerated':[N,N+2]}))), ['strided-footprint'])
check('reverse-addresses regression 0', solve(dict(base, **({'reverse_actual':[N,N+1],'reverse_expected':[N+1,N]}))), ['reverse-addresses'])
check('reverse-addresses regression 1', solve(dict(base, **({'reverse_actual':[N,N+1,N+2],'reverse_expected':[N+2,N+1,N]}))), ['reverse-addresses'])
check('split-consumption regression 0', solve(dict(base, **({'consuming':True,'parent_unique_live':True,'parent':[N],'left':[N]}))), ['split-consumption'])
check('split-consumption regression 1', solve(dict(base, **({'consuming':True,'parent_unique_live':True,'parent':[N+1],'right':[N+1]}))), ['split-consumption'])
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

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

N = 1
observations = []
def solve(d):
    errors=[]
    if d['split']<0 or d['split']>d['length']: errors.append('split-boundary')
    if set(d['left'])|set(d['right'])!=set(d['parent']): errors.append('partition-completeness')
    if bool(set(d['exclusive_a'])&set(d['exclusive_b'])): errors.append('exclusive-disjoint')
    if any(x!=d['owner'] for x in d['child_owners']): errors.append('owner-preservation')
    if any(x!=d['generation'] for x in d['child_generations']): errors.append('generation-preservation')
    if d['dynamic_pair'] and not d['inequality_proven'] and d['length']==0: errors.append('dynamic-disjoint-proof')
    if bool(d['empty_access']): errors.append('empty-access')
    if set(d['stride_indices'])!=set(d['enumerated']): errors.append('strided-footprint')
    if d['reverse_actual']!=d['reverse_expected']: errors.append('reverse-addresses')
    if d['consuming'] and d['parent_unique_live']: errors.append('split-consumption')
    return errors
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
base={'length': 0, 'split': 0, 'left': [], 'right': [], 'parent': [], 'exclusive_a': [], 'exclusive_b': [], 'child_owners': [], 'owner': None, 'child_generations': [], 'generation': 0, 'dynamic_pair': False, 'inequality_proven': True, 'empty_access': [], 'stride_indices': [], 'enumerated': [], 'reverse_expected': [], 'reverse_actual': [], 'consuming': False, 'parent_unique_live': False}
check('well formed empty obligations',solve(base),[])
check('split-boundary regression 0', solve(dict(base, **({'length':N,'split':N+1}))), ['split-boundary'])
check('split-boundary regression 1', solve(dict(base, **({'length':N+1,'split':N+2}))), ['split-boundary'])
check('partition-completeness regression 0', solve(dict(base, **({'parent':list(range(N+1)),'left':[0]}))), ['partition-completeness'])
check('partition-completeness regression 1', solve(dict(base, **({'parent':[N,N+1],'right':[N]}))), ['partition-completeness'])
check('exclusive-disjoint regression 0', solve(dict(base, **({'exclusive_a':[N,N+1],'exclusive_b':[N+1]}))), ['exclusive-disjoint'])
check('exclusive-disjoint regression 1', solve(dict(base, **({'exclusive_a':[N],'exclusive_b':[N,N+1]}))), ['exclusive-disjoint'])
check('owner-preservation regression 0', solve(dict(base, **({'owner':'r','child_owners':['r','s']}))), ['owner-preservation'])
check('owner-preservation regression 1', solve(dict(base, **({'owner':N,'child_owners':[N,N+1]}))), ['owner-preservation'])
check('generation-preservation regression 0', solve(dict(base, **({'generation':N+1,'child_generations':[N]}))), ['generation-preservation'])
check('generation-preservation regression 1', solve(dict(base, **({'generation':N+2,'child_generations':[N+1]}))), ['generation-preservation'])
check('dynamic-disjoint-proof regression 0', solve(dict(base, **({'dynamic_pair':True,'inequality_proven':False,'length':N}))), ['dynamic-disjoint-proof'])
check('dynamic-disjoint-proof regression 1', solve(dict(base, **({'dynamic_pair':True,'inequality_proven':False,'length':N+1}))), ['dynamic-disjoint-proof'])
check('empty-access regression 0', solve(dict(base, **({'empty_access':[N]}))), ['empty-access'])
check('empty-access regression 1', solve(dict(base, **({'empty_access':[N+1]}))), ['empty-access'])
check('strided-footprint regression 0', solve(dict(base, **({'stride_indices':[N,N+2],'enumerated':[N,N+1]}))), ['strided-footprint'])
check('strided-footprint regression 1', solve(dict(base, **({'stride_indices':[N,N+3],'enumerated':[N,N+2]}))), ['strided-footprint'])
check('reverse-addresses regression 0', solve(dict(base, **({'reverse_actual':[N,N+1],'reverse_expected':[N+1,N]}))), ['reverse-addresses'])
check('reverse-addresses regression 1', solve(dict(base, **({'reverse_actual':[N,N+1,N+2],'reverse_expected':[N+2,N+1,N]}))), ['reverse-addresses'])
check('split-consumption regression 0', solve(dict(base, **({'consuming':True,'parent_unique_live':True,'parent':[N],'left':[N]}))), ['split-consumption'])
check('split-consumption regression 1', solve(dict(base, **({'consuming':True,'parent_unique_live':True,'parent':[N+1],'right':[N+1]}))), ['split-consumption'])
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:
Two symbolic element borrows are declared disjoint without index inequality.

Validate static proof objects for splitting borrowed slices. Bounds are half-open; split point lies in 0..length; children exactly partition parent; exclusive children disjoint; every child retains parent owner and generation; dynamic indices need inequality proof; empty children confer no element access; strided loans include every enumerated element; reverse views retain original element addresses; consuming split removes parent exclusive capability. Input is a fully explicit descriptor of the stated toy IR. Return rule identifiers in declaration order; absent optional obligations use the provided neutral defaults. No rule is an assertion about a production language.

split: open-access


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

N = 1
observations = []
def solve(d):
    errors=[]
    if d['split']<0 or d['split']>d['length']: errors.append('split-boundary')
    if set(d['left'])|set(d['right'])!=set(d['parent']): errors.append('partition-completeness')
    if bool(set(d['exclusive_a'])&set(d['exclusive_b'])): errors.append('exclusive-disjoint')
    if any(x!=d['owner'] for x in d['child_owners']): errors.append('owner-preservation')
    if any(x!=d['generation'] for x in d['child_generations']): errors.append('generation-preservation')
    if d['dynamic_pair'] and not d['inequality_proven']: errors.append('dynamic-disjoint-proof')
    if False: errors.append('empty-access')
    if set(d['stride_indices'])!=set(d['enumerated']): errors.append('strided-footprint')
    if d['reverse_actual']!=d['reverse_expected']: errors.append('reverse-addresses')
    if d['consuming'] and d['parent_unique_live']: errors.append('split-consumption')
    return errors
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
base={'length': 0, 'split': 0, 'left': [], 'right': [], 'parent': [], 'exclusive_a': [], 'exclusive_b': [], 'child_owners': [], 'owner': None, 'child_generations': [], 'generation': 0, 'dynamic_pair': False, 'inequality_proven': True, 'empty_access': [], 'stride_indices': [], 'enumerated': [], 'reverse_expected': [], 'reverse_actual': [], 'consuming': False, 'parent_unique_live': False}
check('well formed empty obligations',solve(base),[])
check('split-boundary regression 0', solve(dict(base, **({'length':N,'split':N+1}))), ['split-boundary'])
check('split-boundary regression 1', solve(dict(base, **({'length':N+1,'split':N+2}))), ['split-boundary'])
check('partition-completeness regression 0', solve(dict(base, **({'parent':list(range(N+1)),'left':[0]}))), ['partition-completeness'])
check('partition-completeness regression 1', solve(dict(base, **({'parent':[N,N+1],'right':[N]}))), ['partition-completeness'])
check('exclusive-disjoint regression 0', solve(dict(base, **({'exclusive_a':[N,N+1],'exclusive_b':[N+1]}))), ['exclusive-disjoint'])
check('exclusive-disjoint regression 1', solve(dict(base, **({'exclusive_a':[N],'exclusive_b':[N,N+1]}))), ['exclusive-disjoint'])
check('owner-preservation regression 0', solve(dict(base, **({'owner':'r','child_owners':['r','s']}))), ['owner-preservation'])
check('owner-preservation regression 1', solve(dict(base, **({'owner':N,'child_owners':[N,N+1]}))), ['owner-preservation'])
check('generation-preservation regression 0', solve(dict(base, **({'generation':N+1,'child_generations':[N]}))), ['generation-preservation'])
check('generation-preservation regression 1', solve(dict(base, **({'generation':N+2,'child_generations':[N+1]}))), ['generation-preservation'])
check('dynamic-disjoint-proof regression 0', solve(dict(base, **({'dynamic_pair':True,'inequality_proven':False,'length':N}))), ['dynamic-disjoint-proof'])
check('dynamic-disjoint-proof regression 1', solve(dict(base, **({'dynamic_pair':True,'inequality_proven':False,'length':N+1}))), ['dynamic-disjoint-proof'])
check('empty-access regression 0', solve(dict(base, **({'empty_access':[N]}))), ['empty-access'])
check('empty-access regression 1', solve(dict(base, **({'empty_access':[N+1]}))), ['empty-access'])
check('strided-footprint regression 0', solve(dict(base, **({'stride_indices':[N,N+2],'enumerated':[N,N+1]}))), ['strided-footprint'])
check('strided-footprint regression 1', solve(dict(base, **({'stride_indices':[N,N+3],'enumerated':[N,N+2]}))), ['strided-footprint'])
check('reverse-addresses regression 0', solve(dict(base, **({'reverse_actual':[N,N+1],'reverse_expected':[N+1,N]}))), ['reverse-addresses'])
check('reverse-addresses regression 1', solve(dict(base, **({'reverse_actual':[N,N+1,N+2],'reverse_expected':[N+2,N+1,N]}))), ['reverse-addresses'])
check('split-consumption regression 0', solve(dict(base, **({'consuming':True,'parent_unique_live':True,'parent':[N],'left':[N]}))), ['split-consumption'])
check('split-consumption regression 1', solve(dict(base, **({'consuming':True,'parent_unique_live':True,'parent':[N+1],'right':[N+1]}))), ['split-consumption'])
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

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

N = 1
observations = []
def solve(d):
    errors=[]
    if d['split']<0 or d['split']>d['length']: errors.append('split-boundary')
    if set(d['left'])|set(d['right'])!=set(d['parent']): errors.append('partition-completeness')
    if bool(set(d['exclusive_a'])&set(d['exclusive_b'])): errors.append('exclusive-disjoint')
    if any(x!=d['owner'] for x in d['child_owners']): errors.append('owner-preservation')
    if any(x!=d['generation'] for x in d['child_generations']): errors.append('generation-preservation')
    if d['dynamic_pair'] and not d['inequality_proven']: errors.append('dynamic-disjoint-proof')
    if len(d['empty_access'])>1: errors.append('empty-access')
    if set(d['stride_indices'])!=set(d['enumerated']): errors.append('strided-footprint')
    if d['reverse_actual']!=d['reverse_expected']: errors.append('reverse-addresses')
    if d['consuming'] and d['parent_unique_live']: errors.append('split-consumption')
    return errors
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
base={'length': 0, 'split': 0, 'left': [], 'right': [], 'parent': [], 'exclusive_a': [], 'exclusive_b': [], 'child_owners': [], 'owner': None, 'child_generations': [], 'generation': 0, 'dynamic_pair': False, 'inequality_proven': True, 'empty_access': [], 'stride_indices': [], 'enumerated': [], 'reverse_expected': [], 'reverse_actual': [], 'consuming': False, 'parent_unique_live': False}
check('well formed empty obligations',solve(base),[])
check('split-boundary regression 0', solve(dict(base, **({'length':N,'split':N+1}))), ['split-boundary'])
check('split-boundary regression 1', solve(dict(base, **({'length':N+1,'split':N+2}))), ['split-boundary'])
check('partition-completeness regression 0', solve(dict(base, **({'parent':list(range(N+1)),'left':[0]}))), ['partition-completeness'])
check('partition-completeness regression 1', solve(dict(base, **({'parent':[N,N+1],'right':[N]}))), ['partition-completeness'])
check('exclusive-disjoint regression 0', solve(dict(base, **({'exclusive_a':[N,N+1],'exclusive_b':[N+1]}))), ['exclusive-disjoint'])
check('exclusive-disjoint regression 1', solve(dict(base, **({'exclusive_a':[N],'exclusive_b':[N,N+1]}))), ['exclusive-disjoint'])
check('owner-preservation regression 0', solve(dict(base, **({'owner':'r','child_owners':['r','s']}))), ['owner-preservation'])
check('owner-preservation regression 1', solve(dict(base, **({'owner':N,'child_owners':[N,N+1]}))), ['owner-preservation'])
check('generation-preservation regression 0', solve(dict(base, **({'generation':N+1,'child_generations':[N]}))), ['generation-preservation'])
check('generation-preservation regression 1', solve(dict(base, **({'generation':N+2,'child_generations':[N+1]}))), ['generation-preservation'])
check('dynamic-disjoint-proof regression 0', solve(dict(base, **({'dynamic_pair':True,'inequality_proven':False,'length':N}))), ['dynamic-disjoint-proof'])
check('dynamic-disjoint-proof regression 1', solve(dict(base, **({'dynamic_pair':True,'inequality_proven':False,'length':N+1}))), ['dynamic-disjoint-proof'])
check('empty-access regression 0', solve(dict(base, **({'empty_access':[N]}))), ['empty-access'])
check('empty-access regression 1', solve(dict(base, **({'empty_access':[N+1]}))), ['empty-access'])
check('strided-footprint regression 0', solve(dict(base, **({'stride_indices':[N,N+2],'enumerated':[N,N+1]}))), ['strided-footprint'])
check('strided-footprint regression 1', solve(dict(base, **({'stride_indices':[N,N+3],'enumerated':[N,N+2]}))), ['strided-footprint'])
check('reverse-addresses regression 0', solve(dict(base, **({'reverse_actual':[N,N+1],'reverse_expected':[N+1,N]}))), ['reverse-addresses'])
check('reverse-addresses regression 1', solve(dict(base, **({'reverse_actual':[N,N+1,N+2],'reverse_expected':[N+2,N+1,N]}))), ['reverse-addresses'])
check('split-consumption regression 0', solve(dict(base, **({'consuming':True,'parent_unique_live':True,'parent':[N],'left':[N]}))), ['split-consumption'])
check('split-consumption regression 1', solve(dict(base, **({'consuming':True,'parent_unique_live':True,'parent':[N+1],'right':[N+1]}))), ['split-consumption'])
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:
An empty split result grants permission to one element.

Validate static proof objects for splitting borrowed slices. Bounds are half-open; split point lies in 0..length; children exactly partition parent; exclusive children disjoint; every child retains parent owner and generation; dynamic indices need inequality proof; empty children confer no element access; strided loans include every enumerated element; reverse views retain original element addresses; consuming split removes parent exclusive capability. Input is a fully explicit descriptor of the stated toy IR. Return rule identifiers in declaration order; absent optional obligations use the provided neutral defaults. No rule is an assertion about a production language.

split: open-access


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

N = 1
observations = []
def solve(d):
    errors=[]
    if d['split']<0 or d['split']>d['length']: errors.append('split-boundary')
    if set(d['left'])|set(d['right'])!=set(d['parent']): errors.append('partition-completeness')
    if bool(set(d['exclusive_a'])&set(d['exclusive_b'])): errors.append('exclusive-disjoint')
    if any(x!=d['owner'] for x in d['child_owners']): errors.append('owner-preservation')
    if any(x!=d['generation'] for x in d['child_generations']): errors.append('generation-preservation')
    if d['dynamic_pair'] and not d['inequality_proven']: errors.append('dynamic-disjoint-proof')
    if bool(d['empty_access']): errors.append('empty-access')
    if False: errors.append('strided-footprint')
    if d['reverse_actual']!=d['reverse_expected']: errors.append('reverse-addresses')
    if d['consuming'] and d['parent_unique_live']: errors.append('split-consumption')
    return errors
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
base={'length': 0, 'split': 0, 'left': [], 'right': [], 'parent': [], 'exclusive_a': [], 'exclusive_b': [], 'child_owners': [], 'owner': None, 'child_generations': [], 'generation': 0, 'dynamic_pair': False, 'inequality_proven': True, 'empty_access': [], 'stride_indices': [], 'enumerated': [], 'reverse_expected': [], 'reverse_actual': [], 'consuming': False, 'parent_unique_live': False}
check('well formed empty obligations',solve(base),[])
check('split-boundary regression 0', solve(dict(base, **({'length':N,'split':N+1}))), ['split-boundary'])
check('split-boundary regression 1', solve(dict(base, **({'length':N+1,'split':N+2}))), ['split-boundary'])
check('partition-completeness regression 0', solve(dict(base, **({'parent':list(range(N+1)),'left':[0]}))), ['partition-completeness'])
check('partition-completeness regression 1', solve(dict(base, **({'parent':[N,N+1],'right':[N]}))), ['partition-completeness'])
check('exclusive-disjoint regression 0', solve(dict(base, **({'exclusive_a':[N,N+1],'exclusive_b':[N+1]}))), ['exclusive-disjoint'])
check('exclusive-disjoint regression 1', solve(dict(base, **({'exclusive_a':[N],'exclusive_b':[N,N+1]}))), ['exclusive-disjoint'])
check('owner-preservation regression 0', solve(dict(base, **({'owner':'r','child_owners':['r','s']}))), ['owner-preservation'])
check('owner-preservation regression 1', solve(dict(base, **({'owner':N,'child_owners':[N,N+1]}))), ['owner-preservation'])
check('generation-preservation regression 0', solve(dict(base, **({'generation':N+1,'child_generations':[N]}))), ['generation-preservation'])
check('generation-preservation regression 1', solve(dict(base, **({'generation':N+2,'child_generations':[N+1]}))), ['generation-preservation'])
check('dynamic-disjoint-proof regression 0', solve(dict(base, **({'dynamic_pair':True,'inequality_proven':False,'length':N}))), ['dynamic-disjoint-proof'])
check('dynamic-disjoint-proof regression 1', solve(dict(base, **({'dynamic_pair':True,'inequality_proven':False,'length':N+1}))), ['dynamic-disjoint-proof'])
check('empty-access regression 0', solve(dict(base, **({'empty_access':[N]}))), ['empty-access'])
check('empty-access regression 1', solve(dict(base, **({'empty_access':[N+1]}))), ['empty-access'])
check('strided-footprint regression 0', solve(dict(base, **({'stride_indices':[N,N+2],'enumerated':[N,N+1]}))), ['strided-footprint'])
check('strided-footprint regression 1', solve(dict(base, **({'stride_indices':[N,N+3],'enumerated':[N,N+2]}))), ['strided-footprint'])
check('reverse-addresses regression 0', solve(dict(base, **({'reverse_actual':[N,N+1],'reverse_expected':[N+1,N]}))), ['reverse-addresses'])
check('reverse-addresses regression 1', solve(dict(base, **({'reverse_actual':[N,N+1,N+2],'reverse_expected':[N+2,N+1,N]}))), ['reverse-addresses'])
check('split-consumption regression 0', solve(dict(base, **({'consuming':True,'parent_unique_live':True,'parent':[N],'left':[N]}))), ['split-consumption'])
check('split-consumption regression 1', solve(dict(base, **({'consuming':True,'parent_unique_live':True,'parent':[N+1],'right':[N+1]}))), ['split-consumption'])
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

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

N = 1
observations = []
def solve(d):
    errors=[]
    if d['split']<0 or d['split']>d['length']: errors.append('split-boundary')
    if set(d['left'])|set(d['right'])!=set(d['parent']): errors.append('partition-completeness')
    if bool(set(d['exclusive_a'])&set(d['exclusive_b'])): errors.append('exclusive-disjoint')
    if any(x!=d['owner'] for x in d['child_owners']): errors.append('owner-preservation')
    if any(x!=d['generation'] for x in d['child_generations']): errors.append('generation-preservation')
    if d['dynamic_pair'] and not d['inequality_proven']: errors.append('dynamic-disjoint-proof')
    if bool(d['empty_access']): errors.append('empty-access')
    if len(d['stride_indices'])!=len(d['enumerated']): errors.append('strided-footprint')
    if d['reverse_actual']!=d['reverse_expected']: errors.append('reverse-addresses')
    if d['consuming'] and d['parent_unique_live']: errors.append('split-consumption')
    return errors
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
base={'length': 0, 'split': 0, 'left': [], 'right': [], 'parent': [], 'exclusive_a': [], 'exclusive_b': [], 'child_owners': [], 'owner': None, 'child_generations': [], 'generation': 0, 'dynamic_pair': False, 'inequality_proven': True, 'empty_access': [], 'stride_indices': [], 'enumerated': [], 'reverse_expected': [], 'reverse_actual': [], 'consuming': False, 'parent_unique_live': False}
check('well formed empty obligations',solve(base),[])
check('split-boundary regression 0', solve(dict(base, **({'length':N,'split':N+1}))), ['split-boundary'])
check('split-boundary regression 1', solve(dict(base, **({'length':N+1,'split':N+2}))), ['split-boundary'])
check('partition-completeness regression 0', solve(dict(base, **({'parent':list(range(N+1)),'left':[0]}))), ['partition-completeness'])
check('partition-completeness regression 1', solve(dict(base, **({'parent':[N,N+1],'right':[N]}))), ['partition-completeness'])
check('exclusive-disjoint regression 0', solve(dict(base, **({'exclusive_a':[N,N+1],'exclusive_b':[N+1]}))), ['exclusive-disjoint'])
check('exclusive-disjoint regression 1', solve(dict(base, **({'exclusive_a':[N],'exclusive_b':[N,N+1]}))), ['exclusive-disjoint'])
check('owner-preservation regression 0', solve(dict(base, **({'owner':'r','child_owners':['r','s']}))), ['owner-preservation'])
check('owner-preservation regression 1', solve(dict(base, **({'owner':N,'child_owners':[N,N+1]}))), ['owner-preservation'])
check('generation-preservation regression 0', solve(dict(base, **({'generation':N+1,'child_generations':[N]}))), ['generation-preservation'])
check('generation-preservation regression 1', solve(dict(base, **({'generation':N+2,'child_generations':[N+1]}))), ['generation-preservation'])
check('dynamic-disjoint-proof regression 0', solve(dict(base, **({'dynamic_pair':True,'inequality_proven':False,'length':N}))), ['dynamic-disjoint-proof'])
check('dynamic-disjoint-proof regression 1', solve(dict(base, **({'dynamic_pair':True,'inequality_proven':False,'length':N+1}))), ['dynamic-disjoint-proof'])
check('empty-access regression 0', solve(dict(base, **({'empty_access':[N]}))), ['empty-access'])
check('empty-access regression 1', solve(dict(base, **({'empty_access':[N+1]}))), ['empty-access'])
check('strided-footprint regression 0', solve(dict(base, **({'stride_indices':[N,N+2],'enumerated':[N,N+1]}))), ['strided-footprint'])
check('strided-footprint regression 1', solve(dict(base, **({'stride_indices':[N,N+3],'enumerated':[N,N+2]}))), ['strided-footprint'])
check('reverse-addresses regression 0', solve(dict(base, **({'reverse_actual':[N,N+1],'reverse_expected':[N+1,N]}))), ['reverse-addresses'])
check('reverse-addresses regression 1', solve(dict(base, **({'reverse_actual':[N,N+1,N+2],'reverse_expected':[N+2,N+1,N]}))), ['reverse-addresses'])
check('split-consumption regression 0', solve(dict(base, **({'consuming':True,'parent_unique_live':True,'parent':[N],'left':[N]}))), ['split-consumption'])
check('split-consumption regression 1', solve(dict(base, **({'consuming':True,'parent_unique_live':True,'parent':[N+1],'right':[N+1]}))), ['split-consumption'])
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:
Strided borrow footprint substitutes contiguous positions.

Validate static proof objects for splitting borrowed slices. Bounds are half-open; split point lies in 0..length; children exactly partition parent; exclusive children disjoint; every child retains parent owner and generation; dynamic indices need inequality proof; empty children confer no element access; strided loans include every enumerated element; reverse views retain original element addresses; consuming split removes parent exclusive capability. Input is a fully explicit descriptor of the stated toy IR. Return rule identifiers in declaration order; absent optional obligations use the provided neutral defaults. No rule is an assertion about a production language.

split: open-access


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

N = 1
observations = []
def solve(d):
    errors=[]
    if d['split']<0 or d['split']>d['length']: errors.append('split-boundary')
    if set(d['left'])|set(d['right'])!=set(d['parent']): errors.append('partition-completeness')
    if bool(set(d['exclusive_a'])&set(d['exclusive_b'])): errors.append('exclusive-disjoint')
    if any(x!=d['owner'] for x in d['child_owners']): errors.append('owner-preservation')
    if any(x!=d['generation'] for x in d['child_generations']): errors.append('generation-preservation')
    if d['dynamic_pair'] and not d['inequality_proven']: errors.append('dynamic-disjoint-proof')
    if bool(d['empty_access']): errors.append('empty-access')
    if set(d['stride_indices'])!=set(d['enumerated']): errors.append('strided-footprint')
    if False: errors.append('reverse-addresses')
    if d['consuming'] and d['parent_unique_live']: errors.append('split-consumption')
    return errors
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
base={'length': 0, 'split': 0, 'left': [], 'right': [], 'parent': [], 'exclusive_a': [], 'exclusive_b': [], 'child_owners': [], 'owner': None, 'child_generations': [], 'generation': 0, 'dynamic_pair': False, 'inequality_proven': True, 'empty_access': [], 'stride_indices': [], 'enumerated': [], 'reverse_expected': [], 'reverse_actual': [], 'consuming': False, 'parent_unique_live': False}
check('well formed empty obligations',solve(base),[])
check('split-boundary regression 0', solve(dict(base, **({'length':N,'split':N+1}))), ['split-boundary'])
check('split-boundary regression 1', solve(dict(base, **({'length':N+1,'split':N+2}))), ['split-boundary'])
check('partition-completeness regression 0', solve(dict(base, **({'parent':list(range(N+1)),'left':[0]}))), ['partition-completeness'])
check('partition-completeness regression 1', solve(dict(base, **({'parent':[N,N+1],'right':[N]}))), ['partition-completeness'])
check('exclusive-disjoint regression 0', solve(dict(base, **({'exclusive_a':[N,N+1],'exclusive_b':[N+1]}))), ['exclusive-disjoint'])
check('exclusive-disjoint regression 1', solve(dict(base, **({'exclusive_a':[N],'exclusive_b':[N,N+1]}))), ['exclusive-disjoint'])
check('owner-preservation regression 0', solve(dict(base, **({'owner':'r','child_owners':['r','s']}))), ['owner-preservation'])
check('owner-preservation regression 1', solve(dict(base, **({'owner':N,'child_owners':[N,N+1]}))), ['owner-preservation'])
check('generation-preservation regression 0', solve(dict(base, **({'generation':N+1,'child_generations':[N]}))), ['generation-preservation'])
check('generation-preservation regression 1', solve(dict(base, **({'generation':N+2,'child_generations':[N+1]}))), ['generation-preservation'])
check('dynamic-disjoint-proof regression 0', solve(dict(base, **({'dynamic_pair':True,'inequality_proven':False,'length':N}))), ['dynamic-disjoint-proof'])
check('dynamic-disjoint-proof regression 1', solve(dict(base, **({'dynamic_pair':True,'inequality_proven':False,'length':N+1}))), ['dynamic-disjoint-proof'])
check('empty-access regression 0', solve(dict(base, **({'empty_access':[N]}))), ['empty-access'])
check('empty-access regression 1', solve(dict(base, **({'empty_access':[N+1]}))), ['empty-access'])
check('strided-footprint regression 0', solve(dict(base, **({'stride_indices':[N,N+2],'enumerated':[N,N+1]}))), ['strided-footprint'])
check('strided-footprint regression 1', solve(dict(base, **({'stride_indices':[N,N+3],'enumerated':[N,N+2]}))), ['strided-footprint'])
check('reverse-addresses regression 0', solve(dict(base, **({'reverse_actual':[N,N+1],'reverse_expected':[N+1,N]}))), ['reverse-addresses'])
check('reverse-addresses regression 1', solve(dict(base, **({'reverse_actual':[N,N+1,N+2],'reverse_expected':[N+2,N+1,N]}))), ['reverse-addresses'])
check('split-consumption regression 0', solve(dict(base, **({'consuming':True,'parent_unique_live':True,'parent':[N],'left':[N]}))), ['split-consumption'])
check('split-consumption regression 1', solve(dict(base, **({'consuming':True,'parent_unique_live':True,'parent':[N+1],'right':[N+1]}))), ['split-consumption'])
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

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

N = 1
observations = []
def solve(d):
    errors=[]
    if d['split']<0 or d['split']>d['length']: errors.append('split-boundary')
    if set(d['left'])|set(d['right'])!=set(d['parent']): errors.append('partition-completeness')
    if bool(set(d['exclusive_a'])&set(d['exclusive_b'])): errors.append('exclusive-disjoint')
    if any(x!=d['owner'] for x in d['child_owners']): errors.append('owner-preservation')
    if any(x!=d['generation'] for x in d['child_generations']): errors.append('generation-preservation')
    if d['dynamic_pair'] and not d['inequality_proven']: errors.append('dynamic-disjoint-proof')
    if bool(d['empty_access']): errors.append('empty-access')
    if set(d['stride_indices'])!=set(d['enumerated']): errors.append('strided-footprint')
    if set(d['reverse_actual'])!=set(d['reverse_expected']): errors.append('reverse-addresses')
    if d['consuming'] and d['parent_unique_live']: errors.append('split-consumption')
    return errors
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
base={'length': 0, 'split': 0, 'left': [], 'right': [], 'parent': [], 'exclusive_a': [], 'exclusive_b': [], 'child_owners': [], 'owner': None, 'child_generations': [], 'generation': 0, 'dynamic_pair': False, 'inequality_proven': True, 'empty_access': [], 'stride_indices': [], 'enumerated': [], 'reverse_expected': [], 'reverse_actual': [], 'consuming': False, 'parent_unique_live': False}
check('well formed empty obligations',solve(base),[])
check('split-boundary regression 0', solve(dict(base, **({'length':N,'split':N+1}))), ['split-boundary'])
check('split-boundary regression 1', solve(dict(base, **({'length':N+1,'split':N+2}))), ['split-boundary'])
check('partition-completeness regression 0', solve(dict(base, **({'parent':list(range(N+1)),'left':[0]}))), ['partition-completeness'])
check('partition-completeness regression 1', solve(dict(base, **({'parent':[N,N+1],'right':[N]}))), ['partition-completeness'])
check('exclusive-disjoint regression 0', solve(dict(base, **({'exclusive_a':[N,N+1],'exclusive_b':[N+1]}))), ['exclusive-disjoint'])
check('exclusive-disjoint regression 1', solve(dict(base, **({'exclusive_a':[N],'exclusive_b':[N,N+1]}))), ['exclusive-disjoint'])
check('owner-preservation regression 0', solve(dict(base, **({'owner':'r','child_owners':['r','s']}))), ['owner-preservation'])
check('owner-preservation regression 1', solve(dict(base, **({'owner':N,'child_owners':[N,N+1]}))), ['owner-preservation'])
check('generation-preservation regression 0', solve(dict(base, **({'generation':N+1,'child_generations':[N]}))), ['generation-preservation'])
check('generation-preservation regression 1', solve(dict(base, **({'generation':N+2,'child_generations':[N+1]}))), ['generation-preservation'])
check('dynamic-disjoint-proof regression 0', solve(dict(base, **({'dynamic_pair':True,'inequality_proven':False,'length':N}))), ['dynamic-disjoint-proof'])
check('dynamic-disjoint-proof regression 1', solve(dict(base, **({'dynamic_pair':True,'inequality_proven':False,'length':N+1}))), ['dynamic-disjoint-proof'])
check('empty-access regression 0', solve(dict(base, **({'empty_access':[N]}))), ['empty-access'])
check('empty-access regression 1', solve(dict(base, **({'empty_access':[N+1]}))), ['empty-access'])
check('strided-footprint regression 0', solve(dict(base, **({'stride_indices':[N,N+2],'enumerated':[N,N+1]}))), ['strided-footprint'])
check('strided-footprint regression 1', solve(dict(base, **({'stride_indices':[N,N+3],'enumerated':[N,N+2]}))), ['strided-footprint'])
check('reverse-addresses regression 0', solve(dict(base, **({'reverse_actual':[N,N+1],'reverse_expected':[N+1,N]}))), ['reverse-addresses'])
check('reverse-addresses regression 1', solve(dict(base, **({'reverse_actual':[N,N+1,N+2],'reverse_expected':[N+2,N+1,N]}))), ['reverse-addresses'])
check('split-consumption regression 0', solve(dict(base, **({'consuming':True,'parent_unique_live':True,'parent':[N],'left':[N]}))), ['split-consumption'])
check('split-consumption regression 1', solve(dict(base, **({'consuming':True,'parent_unique_live':True,'parent':[N+1],'right':[N+1]}))), ['split-consumption'])
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:
Reverse-view projection loses the original element address order.

Validate static proof objects for splitting borrowed slices. Bounds are half-open; split point lies in 0..length; children exactly partition parent; exclusive children disjoint; every child retains parent owner and generation; dynamic indices need inequality proof; empty children confer no element access; strided loans include every enumerated element; reverse views retain original element addresses; consuming split removes parent exclusive capability. Input is a fully explicit descriptor of the stated toy IR. Return rule identifiers in declaration order; absent optional obligations use the provided neutral defaults. No rule is an assertion about a production language.

split: open-access


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

N = 1
observations = []
def solve(d):
    errors=[]
    if d['split']<0 or d['split']>d['length']: errors.append('split-boundary')
    if set(d['left'])|set(d['right'])!=set(d['parent']): errors.append('partition-completeness')
    if bool(set(d['exclusive_a'])&set(d['exclusive_b'])): errors.append('exclusive-disjoint')
    if any(x!=d['owner'] for x in d['child_owners']): errors.append('owner-preservation')
    if any(x!=d['generation'] for x in d['child_generations']): errors.append('generation-preservation')
    if d['dynamic_pair'] and not d['inequality_proven']: errors.append('dynamic-disjoint-proof')
    if bool(d['empty_access']): errors.append('empty-access')
    if set(d['stride_indices'])!=set(d['enumerated']): errors.append('strided-footprint')
    if d['reverse_actual']!=d['reverse_expected']: errors.append('reverse-addresses')
    if False: errors.append('split-consumption')
    return errors
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
base={'length': 0, 'split': 0, 'left': [], 'right': [], 'parent': [], 'exclusive_a': [], 'exclusive_b': [], 'child_owners': [], 'owner': None, 'child_generations': [], 'generation': 0, 'dynamic_pair': False, 'inequality_proven': True, 'empty_access': [], 'stride_indices': [], 'enumerated': [], 'reverse_expected': [], 'reverse_actual': [], 'consuming': False, 'parent_unique_live': False}
check('well formed empty obligations',solve(base),[])
check('split-boundary regression 0', solve(dict(base, **({'length':N,'split':N+1}))), ['split-boundary'])
check('split-boundary regression 1', solve(dict(base, **({'length':N+1,'split':N+2}))), ['split-boundary'])
check('partition-completeness regression 0', solve(dict(base, **({'parent':list(range(N+1)),'left':[0]}))), ['partition-completeness'])
check('partition-completeness regression 1', solve(dict(base, **({'parent':[N,N+1],'right':[N]}))), ['partition-completeness'])
check('exclusive-disjoint regression 0', solve(dict(base, **({'exclusive_a':[N,N+1],'exclusive_b':[N+1]}))), ['exclusive-disjoint'])
check('exclusive-disjoint regression 1', solve(dict(base, **({'exclusive_a':[N],'exclusive_b':[N,N+1]}))), ['exclusive-disjoint'])
check('owner-preservation regression 0', solve(dict(base, **({'owner':'r','child_owners':['r','s']}))), ['owner-preservation'])
check('owner-preservation regression 1', solve(dict(base, **({'owner':N,'child_owners':[N,N+1]}))), ['owner-preservation'])
check('generation-preservation regression 0', solve(dict(base, **({'generation':N+1,'child_generations':[N]}))), ['generation-preservation'])
check('generation-preservation regression 1', solve(dict(base, **({'generation':N+2,'child_generations':[N+1]}))), ['generation-preservation'])
check('dynamic-disjoint-proof regression 0', solve(dict(base, **({'dynamic_pair':True,'inequality_proven':False,'length':N}))), ['dynamic-disjoint-proof'])
check('dynamic-disjoint-proof regression 1', solve(dict(base, **({'dynamic_pair':True,'inequality_proven':False,'length':N+1}))), ['dynamic-disjoint-proof'])
check('empty-access regression 0', solve(dict(base, **({'empty_access':[N]}))), ['empty-access'])
check('empty-access regression 1', solve(dict(base, **({'empty_access':[N+1]}))), ['empty-access'])
check('strided-footprint regression 0', solve(dict(base, **({'stride_indices':[N,N+2],'enumerated':[N,N+1]}))), ['strided-footprint'])
check('strided-footprint regression 1', solve(dict(base, **({'stride_indices':[N,N+3],'enumerated':[N,N+2]}))), ['strided-footprint'])
check('reverse-addresses regression 0', solve(dict(base, **({'reverse_actual':[N,N+1],'reverse_expected':[N+1,N]}))), ['reverse-addresses'])
check('reverse-addresses regression 1', solve(dict(base, **({'reverse_actual':[N,N+1,N+2],'reverse_expected':[N+2,N+1,N]}))), ['reverse-addresses'])
check('split-consumption regression 0', solve(dict(base, **({'consuming':True,'parent_unique_live':True,'parent':[N],'left':[N]}))), ['split-consumption'])
check('split-consumption regression 1', solve(dict(base, **({'consuming':True,'parent_unique_live':True,'parent':[N+1],'right':[N+1]}))), ['split-consumption'])
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

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

N = 1
observations = []
def solve(d):
    errors=[]
    if d['split']<0 or d['split']>d['length']: errors.append('split-boundary')
    if set(d['left'])|set(d['right'])!=set(d['parent']): errors.append('partition-completeness')
    if bool(set(d['exclusive_a'])&set(d['exclusive_b'])): errors.append('exclusive-disjoint')
    if any(x!=d['owner'] for x in d['child_owners']): errors.append('owner-preservation')
    if any(x!=d['generation'] for x in d['child_generations']): errors.append('generation-preservation')
    if d['dynamic_pair'] and not d['inequality_proven']: errors.append('dynamic-disjoint-proof')
    if bool(d['empty_access']): errors.append('empty-access')
    if set(d['stride_indices'])!=set(d['enumerated']): errors.append('strided-footprint')
    if d['reverse_actual']!=d['reverse_expected']: errors.append('reverse-addresses')
    if d['consuming'] and d['parent_unique_live'] and not d['parent']: errors.append('split-consumption')
    return errors
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
base={'length': 0, 'split': 0, 'left': [], 'right': [], 'parent': [], 'exclusive_a': [], 'exclusive_b': [], 'child_owners': [], 'owner': None, 'child_generations': [], 'generation': 0, 'dynamic_pair': False, 'inequality_proven': True, 'empty_access': [], 'stride_indices': [], 'enumerated': [], 'reverse_expected': [], 'reverse_actual': [], 'consuming': False, 'parent_unique_live': False}
check('well formed empty obligations',solve(base),[])
check('split-boundary regression 0', solve(dict(base, **({'length':N,'split':N+1}))), ['split-boundary'])
check('split-boundary regression 1', solve(dict(base, **({'length':N+1,'split':N+2}))), ['split-boundary'])
check('partition-completeness regression 0', solve(dict(base, **({'parent':list(range(N+1)),'left':[0]}))), ['partition-completeness'])
check('partition-completeness regression 1', solve(dict(base, **({'parent':[N,N+1],'right':[N]}))), ['partition-completeness'])
check('exclusive-disjoint regression 0', solve(dict(base, **({'exclusive_a':[N,N+1],'exclusive_b':[N+1]}))), ['exclusive-disjoint'])
check('exclusive-disjoint regression 1', solve(dict(base, **({'exclusive_a':[N],'exclusive_b':[N,N+1]}))), ['exclusive-disjoint'])
check('owner-preservation regression 0', solve(dict(base, **({'owner':'r','child_owners':['r','s']}))), ['owner-preservation'])
check('owner-preservation regression 1', solve(dict(base, **({'owner':N,'child_owners':[N,N+1]}))), ['owner-preservation'])
check('generation-preservation regression 0', solve(dict(base, **({'generation':N+1,'child_generations':[N]}))), ['generation-preservation'])
check('generation-preservation regression 1', solve(dict(base, **({'generation':N+2,'child_generations':[N+1]}))), ['generation-preservation'])
check('dynamic-disjoint-proof regression 0', solve(dict(base, **({'dynamic_pair':True,'inequality_proven':False,'length':N}))), ['dynamic-disjoint-proof'])
check('dynamic-disjoint-proof regression 1', solve(dict(base, **({'dynamic_pair':True,'inequality_proven':False,'length':N+1}))), ['dynamic-disjoint-proof'])
check('empty-access regression 0', solve(dict(base, **({'empty_access':[N]}))), ['empty-access'])
check('empty-access regression 1', solve(dict(base, **({'empty_access':[N+1]}))), ['empty-access'])
check('strided-footprint regression 0', solve(dict(base, **({'stride_indices':[N,N+2],'enumerated':[N,N+1]}))), ['strided-footprint'])
check('strided-footprint regression 1', solve(dict(base, **({'stride_indices':[N,N+3],'enumerated':[N,N+2]}))), ['strided-footprint'])
check('reverse-addresses regression 0', solve(dict(base, **({'reverse_actual':[N,N+1],'reverse_expected':[N+1,N]}))), ['reverse-addresses'])
check('reverse-addresses regression 1', solve(dict(base, **({'reverse_actual':[N,N+1,N+2],'reverse_expected':[N+2,N+1,N]}))), ['reverse-addresses'])
check('split-consumption regression 0', solve(dict(base, **({'consuming':True,'parent_unique_live':True,'parent':[N],'left':[N]}))), ['split-consumption'])
check('split-consumption regression 1', solve(dict(base, **({'consuming':True,'parent_unique_live':True,'parent':[N+1],'right':[N+1]}))), ['split-consumption'])
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:
A consuming split leaves the original whole-slice exclusive capability usable.

Validate static proof objects for splitting borrowed slices. Bounds are half-open; split point lies in 0..length; children exactly partition parent; exclusive children disjoint; every child retains parent owner and generation; dynamic indices need inequality proof; empty children confer no element access; strided loans include every enumerated element; reverse views retain original element addresses; consuming split removes parent exclusive capability. Input is a fully explicit descriptor of the stated toy IR. Return rule identifiers in declaration order; absent optional obligations use the provided neutral defaults. No rule is an assertion about a production language.

split: open-access