File size: 6,733 Bytes
1c31d52 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 | """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')
# Decode each digit individually rather than sharing generator formatting helpers.
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))
# Validate pairing and leakage at semantic input level, beyond IDs.
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')))
|