| """Independent rational-arithmetic oracle. Never imports generator code.""" |
| from __future__ import annotations |
| import argparse, hashlib, json, re |
| from fractions import Fraction |
| from pathlib import Path |
| from collections import Counter, defaultdict |
| from jsonschema import Draft202012Validator |
|
|
| SCALES={'SAR':2,'AED':2,'QAR':2,'KWD':3,'BHD':3,'OMR':3} |
| COUNTRIES={'SAR':'SA','AED':'AE','QAR':'QA','KWD':'KW','BHD':'BH','OMR':'OM'} |
| FIELDS=('net','tax','gross','due') |
|
|
| def parse(text,style): |
| """Reject mixed alphabets, malformed grouping, exponent notation and bidi controls.""" |
| if not isinstance(text,str) or len(text)>80: raise ValueError('invalid number type/length') |
| arabic='arabic' in style |
| digits=''.join(chr(0x0660+i) for i in range(10)) if arabic else '0123456789' |
| dot=chr(0x066B) if arabic else '.'; group=chr(0x066C) if arabic else ',' |
| integer=rf'[{digits}]{{1,3}}(?:{re.escape(group)}[{digits}]{{3}})*' if 'grouped' in style else rf'[{digits}]+' |
| pattern=rf'-?{integer}(?:{re.escape(dot)}[{digits}]+)?' |
| if re.fullmatch(pattern,text) is None: raise ValueError('number violates declared grammar') |
| |
| negative=text.startswith('-'); body=text[1:] if negative else text |
| sides=body.split(dot); whole=sides[0].replace(group,''); tail=sides[1] if len(sides)==2 else '' |
| n=0 |
| for ch in whole+tail: n=n*10+digits.index(ch) |
| return Fraction(-n if negative else n,10**len(tail)) |
|
|
| def rounded_minor(value,scale): |
| scaled=value*10**scale |
| a,b=abs(scaled.numerator),scaled.denominator |
| q,r=divmod(a,b) |
| return (-1 if scaled<0 else 1)*(q+(2*r>=b)) |
|
|
| def money(n,scale): |
| sign='-' if n<0 else ''; n=abs(n); div=10**scale |
| return f'{sign}{n//div}.{n%div:0{scale}d}' |
|
|
| def oracle(invoice): |
| scale=SCALES[invoice['currency']]; style=invoice['numeric_style']; unit=10**scale |
| nets=[]; taxes=[] |
| for line in invoice['lines']: |
| q,p,a,c,r=[parse(line[k],style) for k in ['quantity','unit_price','allowance','charge','rate']] |
| if q<=0 or any(x<0 for x in (p,a,c,r)) or r>1: raise ValueError('impossible source line') |
| raw=q*p-a+c |
| if raw<0: raise ValueError('negative line net') |
| net=rounded_minor(raw,scale); nets.append(net) |
| taxes.append(rounded_minor(Fraction(net,unit)*r,scale)) |
| net=sum(nets); tax=sum(taxes); gross=net+tax |
| pre=parse(invoice['prepaid'],style)*unit |
| if pre.denominator!=1 or pre<0 or pre>gross: raise ValueError('invalid prepaid') |
| if invoice['document_type']=='credit_note' and pre: raise ValueError('credit prepayment forbidden in this contract') |
| sign=-1 if invoice['document_type']=='credit_note' else 1 |
| amounts=dict(net=sign*net,tax=sign*tax,gross=sign*gross,due=sign*(gross-int(pre))) |
| expected={k:money(v,scale) for k,v in amounts.items()} |
| errors=[] |
| for k in FIELDS: |
| obs=parse(invoice['claimed_totals'][k],style)*unit |
| if obs.denominator!=1 or obs!=amounts[k]: errors.append(k) |
| return dict(valid=not errors,totals=expected,error_fields=errors) |
|
|
| def canonical(x): return json.dumps(x,sort_keys=True,separators=(',',':'),ensure_ascii=False) |
| def sha(x): return hashlib.sha256(canonical(x).encode()).hexdigest() |
|
|
| def validate(rows,schema): |
| checker=Draft202012Validator(schema); ids=set(); content=set(); pairs=defaultdict(list); evidence=[] |
| for row in rows: |
| checker.validate(row) |
| if row['id'] in ids: raise ValueError('duplicate ID') |
| ids.add(row['id']) |
| d=sha(row['invoice']) |
| if d in content: raise ValueError('duplicate invoice') |
| content.add(d) |
| if row['id']!=d[:32]: raise ValueError('id mismatch') |
| body={k:v for k,v in row.items() if k!='fingerprint_sha256'} |
| if sha(body)!=row['fingerprint_sha256']: raise ValueError('fingerprint mismatch') |
| if row['country']!=COUNTRIES[row['invoice']['currency']]: raise ValueError('currency-country mismatch') |
| computed=oracle(row['invoice']) |
| if computed!=row['expected']: raise ValueError(f'oracle disagreement {row["id"]}') |
| if row['provenance']['copied_records']!=0 or not row['provenance']['synthetic']: raise ValueError('provenance mismatch') |
| pairs[row['pair_id']].append(row) |
| evidence.append(dict(id=row['id'],independent_oracle=computed,fingerprint_sha256=row['fingerprint_sha256'],pass_all=True)) |
| |
| base_hashes=set() |
| for pair_id,pair in pairs.items(): |
| if len(pair)!=2 or sum(x['expected']['valid'] for x in pair)!=1: raise ValueError('pair label/count failure') |
| a,b=sorted(pair,key=lambda x:not x['expected']['valid']) |
| if a['split']!=b['split']: raise ValueError('split leakage') |
| src_a={k:v for k,v in a['invoice'].items() if k!='claimed_totals'} |
| src_b={k:v for k,v in b['invoice'].items() if k!='claimed_totals'} |
| if src_a!=src_b or sha(src_a)[:24]!=pair_id: raise ValueError('pair inputs differ') |
| changes=[k for k in FIELDS if a['invoice']['claimed_totals'][k]!=b['invoice']['claimed_totals'][k]] |
| if changes!=b['expected']['error_fields'] or len(changes)!=1: raise ValueError('not a causal single-field mutation') |
| field=changes[0]; style=a['invoice']['numeric_style']; scale=SCALES[a['invoice']['currency']] |
| delta=parse(b['invoice']['claimed_totals'][field],style)-parse(a['invoice']['claimed_totals'][field],style) |
| if abs(delta)!=Fraction(1,10**scale): raise ValueError('incorrect mutation delta') |
| if b['mutation']['path']!='claimed_totals.'+field or parse(b['mutation']['delta'],'ascii')!=delta: raise ValueError('mutation trace mismatch') |
| if a['mutation'] is not None: raise ValueError('valid record has mutation') |
| semantic=src_a.copy(); semantic.pop('numeric_style') |
| semantic['lines']=[{k:str(parse(v,style)) for k,v in l.items()} for l in semantic['lines']] |
| semantic['prepaid']=str(parse(semantic['prepaid'],style)) |
| normalized=sha(semantic) |
| if normalized in base_hashes: raise ValueError('semantic duplicate source') |
| base_hashes.add(normalized) |
| return evidence |
|
|
| if __name__=='__main__': |
| p=argparse.ArgumentParser(); p.add_argument('dataset',type=Path); p.add_argument('--schema',type=Path,required=True); p.add_argument('--log',type=Path) |
| a=p.parse_args(); rows=[json.loads(x) for x in a.dataset.read_text(encoding='utf-8').splitlines()] |
| log=validate(rows,json.loads(a.schema.read_text(encoding='utf-8'))) |
| if a.log: a.log.write_text(''.join(canonical(r)+'\n' for r in log),encoding='utf-8') |
| print(json.dumps(dict(validated=len(log),status='PASS'))) |
|
|
