| """Independent RegalFire label validators. Does not import generator or its oracles.""" |
| import argparse |
| from collections import Counter, deque, defaultdict |
| import heapq |
| import json |
| from pathlib import Path |
| import zlib |
| from jsonschema import Draft202012Validator |
| from common import NAMES,FAMILIES,enc,sha,semantic,split,strict,schema,write_json |
|
|
| def assert_true(ok,reason): |
| if not ok:raise ValueError(reason) |
| def grid_info(inp): |
| grid=inp['grid'];h,w=len(grid),len(grid[0]);assert_true(all(len(row)==w for row in grid),'nonrectangular_grid') |
| free={(y,x) for y,row in enumerate(grid) for x,v in enumerate(row) if v=='.'} |
| return grid,h,w,free |
| def relaxation(grid,costs,start,target): |
| h,w=len(grid),len(grid[0]);dist={tuple(start):0} |
| |
| for _ in range(h*w): |
| changed=False |
| for y in range(h): |
| for x in range(w): |
| if grid[y][x]!='.' or (y,x) not in dist:continue |
| value=dist[(y,x)] |
| for v in [(y-1,x),(y,x-1),(y+1,x),(y,x+1)]: |
| a,b=v |
| if 0<=a<h and 0<=b<w and grid[a][b]=='.' and value+costs[a][b]<dist.get(v,10**12): |
| dist[v]=value+costs[a][b];changed=True |
| if not changed:break |
| return dist.get(tuple(target)) |
| def check_path(grid,costs,start,goal,result,best): |
| assert_true(result['cost']==best,'path_cost_oracle_disagreement') |
| if best is None:assert_true(result['path'] is None,'unreachable_path');return |
| path=result['path'];assert_true(path and path[0]==start and path[-1]==goal,'bad_endpoints') |
| for p in path: |
| assert_true(len(p)==2 and 0<=p[0]<len(grid) and 0<=p[1]<len(grid[0]) and grid[p[0]][p[1]]=='.','illegal_path_cell') |
| assert_true(all(abs(a[0]-b[0])+abs(a[1]-b[1])==1 for a,b in zip(path,path[1:])),'illegal_path_step') |
| assert_true(sum(costs[y][x] for y,x in path[1:])==best,'witness_cost_disagreement') |
| def nav(inp,out): |
| g,h,w,free=grid_info(inp);costs=inp['costs'];s,t,edit=inp['start'],inp['goal'],inp['edit'] |
| assert_true(tuple(s) in free and tuple(t) in free and s!=t,'invalid_endpoints') |
| assert_true(len(costs)==h and all(len(row)==w for row in costs),'cost_dimensions') |
| assert_true(0<=edit[0]<h and 0<=edit[1]<w and edit not in [s,t],'invalid_edit') |
| changed=list(g);y,x=edit;row=list(changed[y]);row[x]='.' if row[x]=='#' else '#';changed[y]=''.join(row) |
| before=relaxation(g,costs,s,t);after=relaxation(changed,costs,s,t) |
| assert_true(before!=after,'noncritical_edit') |
| check_path(g,costs,s,t,out['before'],before);check_path(changed,costs,s,t,out['after'],after) |
| assert_true(out['reachability_changed']==((before is None)!=(after is None)),'reachability_label') |
| assert_true(set(out)=={'before','after','reachability_changed'},'expected_schema') |
|
|
| def goal_distances(free,goal): |
| d={tuple(goal):0};q=deque([tuple(goal)]) |
| while q: |
| a=q.popleft() |
| for b in [(a[0]-1,a[1]),(a[0]+1,a[1]),(a[0],a[1]-1),(a[0],a[1]+1)]: |
| if b in free and b not in d:d[b]=d[a]+1;q.append(b) |
| return d |
| def joint_astar(free,starts,goals): |
| start=tuple(map(tuple,starts));target=tuple(map(tuple,goals));d0=goal_distances(free,target[0]);d1=goal_distances(free,target[1]) |
| if start[0] not in d0 or start[1] not in d1:return None,None |
| lb=max(d0[start[0]],d1[start[1]]) |
| adjacency={p:[p]+[v for v in [(p[0],p[1]-1),(p[0]-1,p[1]),(p[0],p[1]+1),(p[0]+1,p[1])] if v in free] for p in free} |
| queue=[(lb,0,start)];best={start:0} |
| while queue: |
| _,cost,p=heapq.heappop(queue) |
| if best[p]!=cost:continue |
| if p==target:return cost,lb |
| choices0=[p[0]] if p[0]==target[0] else adjacency[p[0]] |
| choices1=[p[1]] if p[1]==target[1] else adjacency[p[1]] |
| for a in choices0: |
| for b in choices1: |
| if a==b or (a==p[1] and b==p[0]):continue |
| state=(a,b);new=cost+1 |
| if new<best.get(state,10**9): |
| best[state]=new;heapq.heappush(queue,(new+max(d0.get(a,10000),d1.get(b,10000)),new,state)) |
| return None,lb |
| def coord(inp,out): |
| _,_,_,free=grid_info(inp);s,t=inp['starts'],inp['goals'] |
| assert_true(all(tuple(p) in free for p in s+t) and s[0]!=s[1] and t[0]!=t[1],'invalid_agent_endpoints') |
| optimum,lower=joint_astar(free,s,t) |
| assert_true(out['optimal_makespan']==optimum and out['independent_lower_bound']==lower,'joint_oracle_disagreement') |
| assert_true(out['coordination_overhead']==(optimum-lower if optimum is not None else None),'overhead_label') |
| if optimum is None:assert_true(out['plan'] is None,'infeasible_plan');return |
| plan=out['plan'];assert_true(len(plan)==optimum+1 and plan[0]==s and plan[-1]==t,'joint_witness_length') |
| for state in plan:assert_true(len(state)==2 and state[0]!=state[1] and all(tuple(p) in free for p in state),'vertex_conflict_or_invalid_cell') |
| for a,b in zip(plan,plan[1:]): |
| assert_true(not (a[0]==b[1] and a[1]==b[0]),'edge_swap') |
| for j in range(2): |
| assert_true(sum(abs(x-y) for x,y in zip(a[j],b[j]))<=1,'agent_teleport') |
| if a[j]==t[j]:assert_true(b[j]==t[j],'left_absorbing_goal') |
| assert_true(set(out)=={'plan','optimal_makespan','independent_lower_bound','coordination_overhead'},'expected_schema') |
|
|
| def reads(inp,out): |
| lines=inp['fastq'].split('\n');assert_true(len(lines)==4,'FASTQ_not_four_lines') |
| h,s,sep,q=lines;assert_true(h in ['@synthetic_read','synthetic_read'],'non_synthetic_header') |
| failures=set() |
| if not h or h[0]!='@':failures.add('header') |
| if sep!='+':failures.add('separator') |
| if set(s)-set('ACGTN'):failures.add('alphabet') |
| if len(q)!=len(s):failures.add('quality_length') |
| if not all('!'<=c<='J' for c in q):failures.add('quality_ascii') |
| expected={'valid_fastq':not failures,'errors':sorted(failures),'passed_filter':False,'trimmed_sequence':None,'trimmed_quality':None,'quality_sum':None,'length':None,'n_count':None,'gc_count':None} |
| if not failures: |
| policy=inp['policy'];qualities=[ord(c)-ord('!') for c in q] |
| kept=[i+1 for i,value in enumerate(qualities) if value>=policy['trim_q_min']] |
| stop=max(kept,default=0);s=s[:stop];q=q[:stop] |
| counts=Counter(s);total=sum(qualities[:stop]) |
| passing=stop>=policy['min_length'] and counts['N']<=policy['max_n'] and total>=stop*policy['mean_q_min'] |
| expected.update(passed_filter=passing,trimmed_sequence=s,trimmed_quality=q,quality_sum=total,length=stop,n_count=counts['N'],gc_count=counts['G']+counts['C']) |
| assert_true(enc(expected)==enc(out),'read_QC_oracle_disagreement') |
|
|
| def myers(a,b): |
| if not a:return len(b) |
| masks={} |
| for i,letter in enumerate(a):masks[letter]=masks.get(letter,0)|(1<<i) |
| positive=~0;negative=0;score=len(a);top=1<<(len(a)-1) |
| for letter in b: |
| equal=masks.get(letter,0);vertical=equal|negative |
| horizontal=(((equal&positive)+positive)^positive)|equal |
| plus=negative|~(horizontal|positive);minus=positive&horizontal |
| if plus&top:score+=1 |
| if minus&top:score-=1 |
| plus=(plus<<1)|1;minus<<=1 |
| positive=minus|~(vertical|plus);negative=plus&vertical |
| return score |
| def align(inp,out): |
| a,b=inp['a'],inp['b'];distance=myers(a,b) |
| assert_true(inp['source_sequence']==a,'source_sequence_mismatch') |
| assert_true(out['edit_distance']==distance and out['within_threshold']==(distance<=inp['threshold']),'alignment_oracle_disagreement') |
| aa,bb=out['aligned_a'],out['aligned_b'] |
| assert_true(len(aa)==len(bb) and aa.replace('-','')==a and bb.replace('-','')==b,'alignment_witness_sequence') |
| assert_true(all(not(x=='-' and y=='-') for x,y in zip(aa,bb)),'double_gap') |
| assert_true(sum(x!=y for x,y in zip(aa,bb))==distance,'nonoptimal_alignment_witness') |
| assert_true(set(out)=={'edit_distance','within_threshold','aligned_a','aligned_b'},'expected_schema') |
|
|
| def intervals(inp,out): |
| def positions(item): |
| assert_true(item['contig'] in inp['contigs'] and item['contig'].startswith('synthetic_'),'invalid_synthetic_contig') |
| start=item['start'];end=item['end'] |
| if item['basis']=='one_closed': |
| assert_true(1<=start<=end,'invalid_one_based_interval');start-=1 |
| assert_true(0<=start<=end<=inp['contigs'][item['contig']],'out_of_bounds_interval') |
| return set(range(start,end)),start,end |
| q=inp['query'];qset,a,b=positions(q);matches=[];covered=set() |
| for i,f in enumerate(inp['features']): |
| fset,_,_=positions(f) |
| if f['contig']!=q['contig'] or (inp['same_strand'] and f['strand']!=q['strand']):continue |
| overlap=fset&qset |
| if overlap:matches.append({'feature_index':i,'overlap_bases':len(overlap)});covered |= overlap |
| expected={'query_bed':[a,b],'matches':matches,'union_overlap_bases':len(covered),'query_length':len(qset)} |
| assert_true(enc(expected)==enc(out),'interval_oracle_disagreement') |
|
|
| CHECKS={'nav':nav,'coord':coord,'reads':reads,'align':align,'intervals':intervals} |
| class NearAudit: |
| def __init__(self):self.buckets=defaultdict(list);self.flagged=[];self.examined=0 |
| def add(self,row,kind): |
| if kind not in ['reads','align']:return |
| seq=row['input']['source_sequence'] if kind=='align' else row['input']['fastq'].split('\n')[1] |
| grams={seq[i:i+7] for i in range(len(seq)-6)} |
| if not grams:return |
| bottom=sorted({zlib.crc32(g.encode()) for g in grams})[:4];seen=set() |
| for i,key in enumerate(bottom): |
| bucket=self.buckets[(i,key)] |
| for old,oldgrams in bucket[-25:]: |
| if old['id'] in seen:continue |
| seen.add(old['id']);self.examined+=1 |
| score=len(grams&oldgrams)/len(grams|oldgrams) |
| if score>=.85 and row['group_id']!=old['group_id'] and row['split']!=old['split']: |
| self.flagged.append({'left':old['id'],'right':row['id'],'jaccard':score}) |
| bucket.append(({'id':row['id'],'group_id':row['group_id'],'split':row['split']},grams)) |
| if len(bucket)>25:del bucket[0] |
|
|
| def validate(kind,path,count,out): |
| path=Path(path);out=Path(out);out.mkdir(parents=True,exist_ok=True) |
| rejected=[];total=0;ids=set();fingerprints=set();groups={};splits=Counter();families=Counter();labels=Counter();near=NearAudit() |
| validator=Draft202012Validator(schema(kind)) |
| if not path.is_file():rejected.append({'line':0,'reasons':['missing_dataset_file']}) |
| else: |
| with path.open(encoding='utf-8') as stream: |
| for line_number,line in enumerate(stream,1): |
| total+=1 |
| try: |
| row=strict(line);validator.validate(row) |
| assert_true(row['id']==kind.upper()+f'-{line_number-1:07d}' and row['index']==line_number-1,'id_or_index_sequence') |
| assert_true(row['id'] not in ids,'duplicate_id');ids.add(row['id']) |
| fp,group=semantic(kind,row['input']) |
| assert_true(row['fingerprint']==fp and fp not in fingerprints,'duplicate_or_invalid_semantic_fingerprint');fingerprints.add(fp) |
| assert_true(group==row['group_id'] and split(group)==row['split'],'group_split_mismatch') |
| assert_true(group not in groups or groups[group]==row['split'],'split_leakage');groups[group]=row['split'] |
| if kind=='coord' and row['family']=='crossing': |
| a,b=row['input']['starts'] |
| assert_true(a[0]==b[0] and abs(a[1]-b[1])>=2 and row['input']['goals']==row['input']['starts'][::-1],'crossing_family_contract') |
| if kind=='coord' and row['family']=='adjacent_swap': |
| a,b=row['input']['starts'] |
| assert_true(abs(a[0]-b[0])+abs(a[1]-b[1])==1 and row['input']['goals']==row['input']['starts'][::-1],'swap_family_contract') |
| CHECKS[kind](row['input'],row['expected']);near.add(row,kind) |
| splits[row['split']]+=1;families[row['family']]+=1 |
| if kind=='nav':labels['reachability_changed' if row['expected']['reachability_changed'] else 'cost_only_changed']+=1 |
| elif kind=='coord':labels['solvable' if row['expected']['optimal_makespan'] is not None else 'unsolvable']+=1 |
| elif kind=='reads':labels['format_invalid' if not row['expected']['valid_fastq'] else 'filter_pass' if row['expected']['passed_filter'] else 'filter_fail']+=1 |
| elif kind=='align':labels['within_threshold' if row['expected']['within_threshold'] else 'outside_threshold']+=1 |
| else:labels['overlap' if row['expected']['union_overlap_bases'] else 'no_overlap']+=1 |
| except Exception as exc: |
| rejected.append({'line':line_number,'raw':line.rstrip('\n'),'reasons':[type(exc).__name__+': '+str(exc)[:500]]}) |
| if total%1000==0:print(f'{kind}: independently checked {total}/{count}',flush=True) |
| problems=[] |
| if total!=count:problems.append('record_count') |
| if rejected:problems.append('rejected_records') |
| if near.flagged:problems.append('near_duplicate_cross_split_candidates') |
| if set(families)!=set(FAMILIES[kind]) or any(n!=count//5 for n in families.values()):problems.append('family_distribution') |
| if any(splits[k]==0 for k in ['train','validation','test']):problems.append('missing_split') |
| report={'brand':'RegalFire','kind':kind,'status':'PASS' if not problems else 'FAIL','expected_records':count,'records_read':total,'accepted':sum(families.values()),'rejected':len(rejected),'problems':problems, |
| 'unique_ids':len(ids),'unique_fingerprints':len(fingerprints),'unique_source_groups':len(groups),'splits':dict(splits),'families':dict(families),'labels':dict(labels), |
| 'dataset_sha256':sha(path.read_text(encoding='utf-8')) if path.exists() else None, |
| 'near_duplicate_audit':{'scope':'DNA 7-mer bottom-4 CRC sketches; at most 25 previous candidates per bucket; Jaccard >=0.85 flags cross-split source groups. Not exhaustive homology testing. Grid symmetry and interval translation are exact semantic canonical checks.','candidate_pairs_examined':near.examined,'cross_split_flags':near.flagged}, |
| 'privacy_scope':'All originals are procedural; synthetic headers/contigs checked. No external biological records or game assets. Computational fixtures only, not clinical or experimentally established biology.'} |
| write_json(out/'validation_report.json',report);write_json(out/'stats.json',{k:report[k] for k in ['records_read','splits','families','labels','unique_source_groups']}) |
| (out/'rejected.jsonl').write_text(''.join(enc(r)+'\n' for r in rejected),encoding='utf-8') |
| (out/'QA_REPORT.md').write_text('# RegalFire independent computational QA\n\nStatus: '+report['status']+'\n\n```json\n'+json.dumps(report,indent=2)+'\n```\n\nGenerator and validator label algorithms are separately implemented. Shared code covers serialization, schema and semantic identity only. Independent code is not independent human or biological validation. Seed reproducibility and file packaging integrity are separate recorded gates.\n',encoding='utf-8') |
| print(enc({k:report[k] for k in ['kind','status','accepted','rejected','problems']}),flush=True) |
| return report |
| def main(): |
| p=argparse.ArgumentParser();p.add_argument('--kind',choices=NAMES,required=True);p.add_argument('--dataset',type=Path,required=True);p.add_argument('--count',type=int,required=True);p.add_argument('--out',type=Path,required=True);a=p.parse_args() |
| return 0 if validate(a.kind,a.dataset,a.count,a.out)['status']=='PASS' else 1 |
| if __name__=='__main__':raise SystemExit(main()) |
|
|
