"""Full dry-H0 bars and marker reconstruction, independent of pinned B1 code.""" import heapq import math import time import numpy as np def full_bars(field,mass,raw,adjacency): s=np.asarray(field,dtype=np.float64);m=np.asarray(mass,dtype=np.float64);raw=np.asarray(raw);n=len(s) if s.shape!=m.shape or raw.shape!=s.shape or adjacency.shape!=(n,n) or not n:raise ValueError('Bar domain mismatch') if not np.isfinite(s).all() or not np.isfinite(m).all() or np.any(m<=0) or len(np.unique(raw))!=n:raise ValueError('Invalid bar input') order=np.argsort(-s,kind='stable');bounds=np.r_[0,np.flatnonzero(np.diff(s[order])!=0)+1,n] parent=np.arange(n);active=np.zeros(n,bool);birth=np.zeros(n);birth_id=raw.copy();records={} def find(i): while parent[i]!=i:parent[i]=parent[parent[i]];i=int(parent[i]) return i total=math.fsum(map(float,m));passed=0. for lo,hi in zip(bounds[:-1],bounds[1:]): layer=order[lo:hi];level=passed/total;pending=set(map(int,layer));blocks=[] while pending: first=next(iter(pending));pending.remove(first);todo=[first];nodes=[];old=set() while todo: i=todo.pop();nodes.append(i) for jj in adjacency.indices[adjacency.indptr[i]:adjacency.indptr[i+1]]: j=int(jj) if active[j]:old.add(find(j)) elif j in pending:pending.remove(j);todo.append(j) blocks.append((nodes,old)) bp=list(range(len(blocks)));owner={} def bf(i): while bp[i]!=i:bp[i]=bp[bp[i]];i=bp[i] return i for k,(_,old) in enumerate(blocks): for g in old: if g in owner:bp[bf(k)]=bf(owner[g]) else:owner[g]=k compound={} for k in range(len(blocks)):compound.setdefault(bf(k),[]).append(k) for keys in compound.values(): nodes=[i for k in keys for i in blocks[k][0]];olds=set().union(*(blocks[k][1] for k in keys)) if olds: survivor=min(olds,key=lambda i:(birth[i],int(birth_id[i]))) for g in sorted(olds-{survivor},key=lambda i:(birth[i],int(birth_id[i]))): records[g].update(death=float(level),persistence=float(level-birth[g]),infinite=False) for g in olds:parent[g]=survivor else: survivor=min(nodes,key=lambda i:int(raw[i]));birth[survivor]=level;birth_id[survivor]=raw[survivor] records[survivor]=dict(birth=float(level),birth_raw_id=int(raw[survivor]),birth_nodes=sorted(nodes,key=lambda i:int(raw[i])), birth_raw_ids=sorted(map(int,raw[nodes])),birth_value=float(s[survivor]),death=None,persistence=None,infinite=True) for i in nodes:parent[i]=survivor;active[i]=True passed=math.fsum((passed,math.fsum(map(float,m[layer])))) roots={find(i) for i in range(n)} if {k for k,v in records.items() if v['infinite']}!=roots:raise ValueError('Infinite class identity mismatch') return dict(bars=sorted(records.values(),key=lambda r:(r['birth'],r['birth_raw_id'])),infinite_classes=len(roots),nodes=n,total_mass=total) def reconstruct(field,mass,raw,adjacency,threshold=.020): start=time.process_time();s=np.asarray(field,dtype=np.float64);detail=full_bars(s,mass,raw,adjacency) extracted=time.process_time() markers=[] for bar in detail['bars']: bar['kept']=bar['infinite'] or bar['persistence']>=threshold if bar['kept']:markers.extend(bar['birth_nodes']) clean=np.full(len(s),-np.inf);heap=[] for i in markers:clean[i]=s[i];heapq.heappush(heap,(-float(s[i]),int(i))) while heap: negative,i=heapq.heappop(heap);value=-negative if value!=clean[i]:continue for jj in adjacency.indices[adjacency.indptr[i]:adjacency.indptr[i+1]]: j=int(jj);candidate=min(value,float(s[j])) if candidate>clean[j]:clean[j]=candidate;heapq.heappush(heap,(-candidate,j)) if not np.isfinite(clean).all() or np.any(clean>s) or not np.array_equal(clean[markers],s[markers]):raise ValueError('Reconstruction invariant failed') detail.update(threshold=threshold,marker_nodes=sorted(markers),changed_nodes=int(np.count_nonzero(clean!=s)), extraction_cpu_seconds=extracted-start,reconstruction_cpu_seconds=time.process_time()-extracted) return clean,detail def gate_decision(raw,clean,metric_pairs,parts,failures): values=[raw.get('precision'),clean.get('precision'),raw.get('recall'),clean.get('recall')] if parts!=50 or failures or any(x is None for x in values):return dict(decision='PARK_UNDEFINED_OR_COVERAGE') if any(not pairs for pairs in metric_pairs.values()):return dict(decision='PARK_UNDEFINED_OR_COVERAGE') if any(len(pairs)!=50 for pairs in metric_pairs.values()):return dict(decision='PARK_UNDEFINED_OR_COVERAGE') last=float(np.mean([b-a for a,b in metric_pairs['last_location']])) tau=float(np.mean([a-b for a,b in metric_pairs['kendall_tau_b']])) changes=dict(precision_gain=clean['precision']-raw['precision'],recall_loss=raw['recall']-clean['recall'],last_distance_increase=last,tau_b_loss=tau) passed=changes['precision_gain']>=.010 and changes['recall_loss']<=.020 and last<=.010 and tau<=.010 return dict(decision='RETAIN_FOR_INDEPENDENT_PANEL' if passed else 'PRUNE_THIS_FIXED_RULE_ON_THIS_ARM',changes=changes)