"""Original deterministic task algebra and independent Python behavioral oracle.
No runtime-generated candidate code is executed by this module.
"""
import itertools
import random
import string

SCALAR = {
 'double':('double it',lambda n:2*n),
 'negate':('negate it',lambda n:-n),
 'absolute':('take its absolute value',abs),
 'square':('square it',lambda n:n*n),
 'successor':('add one',lambda n:n+1),
 'sign':('replace it with -1, 0, or 1 according to its sign',lambda n:(n>0)-(n<0)),
 'positive':('replace negative values with zero',lambda n:max(n,0)),
 'even':('replace it with 1 if even, otherwise 0',lambda n:int(n%2==0)),
 'clamp':('clamp it to the inclusive range -5 to 5',lambda n:max(-5,min(5,n))),
 'ones':('take the last decimal digit of its absolute value',lambda n:abs(n)%10),
 'tens':('take the tens digit of its absolute value',lambda n:abs(n)//10%10),
 'negative':('replace it with 1 if negative, otherwise 0',lambda n:int(n<0)),
 'complement':('subtract it from ten',lambda n:10-n),
}
STRINGS = {
 'upper':('convert lowercase ASCII letters to uppercase',lambda s:s.upper()),
 'lower':('convert uppercase ASCII letters to lowercase',lambda s:s.lower()),
 'reverse':('reverse the characters',lambda s:s[::-1]),
 'trim':('remove leading and trailing spaces',lambda s:s.strip(' ')),
 'letters':('keep only ASCII letters',lambda s:''.join(c for c in s if c in string.ascii_letters)),
 'digits':('keep only decimal digits',lambda s:''.join(c for c in s if c in string.digits)),
 'no_vowels':('remove vowels aeiou in either case',lambda s:''.join(c for c in s if c.lower() not in 'aeiou')),
 'no_spaces':('remove every space',lambda s:s.replace(' ','')),
 'first_half':('keep the first floor(length/2) characters',lambda s:s[:len(s)//2]),
 'second_half':('keep characters from index floor(length/2) onward',lambda s:s[len(s)//2:]),
 'swap_case':('swap the case of ASCII letters',lambda s:s.swapcase()),
 'collapse':('replace each run of spaces with one space',lambda s:__import__('re').sub(' +',' ',s)),
}
FILTERS={
 'all':('all items',lambda x,i:True),
 'positive':('positive items',lambda x,i:x>0),
 'negative':('negative items',lambda x,i:x<0),
 'even':('even items',lambda x,i:x%2==0),
 'odd':('odd items',lambda x,i:x%2!=0),
 'nonzero':('nonzero items',lambda x,i:x!=0),
 'small':('items with absolute value at most three',lambda x,i:abs(x)<=3),
 'large':('items with absolute value greater than three',lambda x,i:abs(x)>3),
 'even_index':('items at even zero-based indices',lambda x,i:i%2==0),
 'odd_index':('items at odd zero-based indices',lambda x,i:i%2==1),
}
REDUCERS={
 'sum':'sum', 'count':'count', 'product':'product', 'min':'minimum', 'max':'maximum',
 'first':'first value','last':'last value','range':'maximum minus minimum',
 'distinct':'number of distinct values','frequency':'largest frequency of a value',
}

def reduce_values(key,values):
    if key=='sum':return sum(values)
    if key=='count':return len(values)
    if key=='product':
        import math
        return math.prod(values)
    if key=='distinct':return len(set(values))
    if key=='frequency':
        from collections import Counter
        return max(Counter(values).values(),default=0)
    if not values:return 0
    return {'min':lambda:min(values),'max':lambda:max(values),'first':lambda:values[0],
            'last':lambda:values[-1],'range':lambda:max(values)-min(values)}[key]()

def oracle(spec,value):
    if spec['kind'] in ('scalar','string'):
        operations=SCALAR if spec['kind']=='scalar' else STRINGS
        for step in spec['steps']:value=operations[step][1](value)
        return value
    selected=[x for i,x in enumerate(value) if FILTERS[spec['filter']][1](x,i)]
    if spec.get('map'):selected=[SCALAR[spec['map']][1](x) for x in selected]
    return reduce_values(spec['reduce'],selected)

def probes(kind):
    rng=random.Random(20261105)
    if kind=='scalar':return list(range(-120,121))
    if kind=='string':
        return ['', 'a','A','0',' ', ' Ab9 eE!  02 ', 'aeiouAEIOU', 'xyzXYZ', '123456', '  a   b  ',
                'odd!?', 'Aa0 !', 'bCdEf']+[''.join(rng.choice('aAbBcCeE019 !?') for _ in range(rng.randrange(1,24))) for _ in range(120)]
    return [[],[0],[1],[-1],[2,-3,0,5,2],[-4,-4,-1],[1,2,3,4], [4,3,2,1], [0,0,0], [1,-1,1,-1]]+[
        [rng.randint(-6,6) for _ in range(rng.randrange(1,9))] for _ in range(180)]

def bank(kind):
    if kind in ('scalar','string'):
        ops=SCALAR if kind=='scalar' else STRINGS
        candidates=[{'kind':kind,'steps':list(pair)} for pair in itertools.product(ops,repeat=2)]
    else:
        candidates=[{'kind':'array','filter':f,'reduce':r} for f,r in itertools.product(FILTERS,REDUCERS)]
    # An exhaustive finite probe signature rejects algebraic/behavioral duplicates
    # in this restricted grammar, including reordered commuting operations.
    seen=set();out=[]
    for spec in candidates:
        signature=tuple(oracle(spec,x) for x in probes(kind))
        if signature in seen:continue
        seen.add(signature);out.append(spec)
    return out

def instruction(spec):
    kind=spec['kind']
    if kind in ('scalar','string'):
        ops=SCALAR if kind=='scalar' else STRINGS
        return ('Starting with n, ' if kind=='scalar' else 'Starting with ASCII string s, ')+', then '.join(ops[k][0] for k in spec['steps'])+'. Return the result.'
    text='Select '+FILTERS[spec['filter']][0]+' from values in original order. '
    if spec.get('map'):text+='For each selected item, '+SCALAR[spec['map']][0]+'. '
    text+='Return their '+REDUCERS[spec['reduce']]+'. '
    if spec['reduce']=='product':text+='The empty product is 1.'
    elif spec['reduce'] not in ('sum','count','distinct','frequency'):text+='Return 0 when none are selected.'
    return text

def task_specs():
    scalars=bank('scalar');strings=bank('string');arrays=bank('array')
    assert len(scalars)>=80 and len(strings)>=70 and len(arrays)>=75,(len(scalars),len(strings),len(arrays))
    # Interleave operation families so shorter language allocations retain diversity.
    rng=random.Random(7301)
    for b in (scalars,strings,arrays):rng.shuffle(b)
    easy=[]
    for i in range(80):
        easy.append(scalars[i])
        if i<70:easy.append(strings[i])
    medium=arrays[:75]
    seen={tuple(oracle(s,x) for x in probes('array')) for s in medium}
    moderate=[]
    candidates=[{'kind':'array','filter':f,'map':m,'reduce':r}
        for f,m,r in itertools.product(FILTERS,('absolute','square','negate','double','sign','successor'),REDUCERS)
        if r!='count']
    rng.shuffle(candidates)
    for s in candidates:
        sig=tuple(oracle(s,x) for x in probes('array'))
        if sig in seen:continue
        seen.add(sig);moderate.append(s)
        if len(moderate)==25:break
    return {'easy':easy,'medium':medium,'moderate':moderate}