tgi-foundation 0.2.0.dev0__py3-none-any.whl

tgi/acquisition_role_cells.py

@@ -0,0 +1,53 @@
+"""Native visible intervention-role partitions; no world-object labels."""
+from copy import deepcopy
+from tgi.identity import decode,encode
+from tgi.organization import OMEGA_CRIT
+from tgi.acquisition_snapshot import acquisition_snapshot as snapshot
+from tgi.acquisition_witness import certify_raw_acquisition_witness as certify_acquisition_witness
+from tgi.compact_measured_path import _decimal_count
+from tgi.role_work import RoleSearchBudget
+
+
+def _cells(acquisition,groups,measurements):
+    view=snapshot(acquisition);witness=certify_acquisition_witness(view,measurements)
+    if not isinstance(groups,list) or not groups:raise ValueError('Groups required')
+    lookup={(r['source'],r['frame']):r for r in measurements}
+    if len(lookup)!=len(measurements):raise ValueError('One full-frame measurement required')
+    expected={(s,i) for s,(frames,_) in view.episodes.items() for i in range(len(frames))}
+    if set(lookup)!=expected:raise ValueError('Complete measurement coverage required')
+    for (s,i),r in lookup.items():
+        if r['start']!=0 or r['stop']!=len(view.episodes[s][0][i]):raise ValueError('Whole-frame measurements required')
+    ports=[];used=set();records=[];diversity={};windows=[]
+    for group in groups:
+        if not isinstance(group,list) or not group:raise ValueError('Nonempty view group required')
+        cells={};actions=set();action_bounds=set();context_windows={};before_values={}
+        for spec in group:
+            if not isinstance(spec,dict) or set(spec)!={'port','source'}:raise ValueError('Invalid view layout')
+            port=spec['port'];source=spec['source']
+            encode(port)
+            if not isinstance(port,str) or not port or port in cells or source in used or source not in view.episodes:raise ValueError('Duplicate or missing view source')
+            frames=view.episodes[source][0]
+            if len(frames)!=3:raise ValueError('Exactly before/action/after frames required')
+            used.add(source);actions.add(decode(frames[1]))
+            if port not in ports:ports.append(port);diversity[port]=set()
+            before,action,after=(lookup[source,i] for i in range(3))
+            action_bounds.add((action['clock'],action['lower'],action['upper']))
+            context_windows[port]=(before['clock'],before['lower'],after['upper'])
+            before_values[port]=frames[0]
+            certain=len({before['clock'],action['clock'],after['clock']})==1 and before['upper']<=action['lower'] and action['upper']<=after['lower']
+            value=int(frames[0]!=frames[2]) if certain else None
+            cells[port]=value
+            
+        if len(actions)!=1 or len(action_bounds)!=1:raise ValueError('One consistent measured action per group required')
+        windows.append(next(iter(action_bounds)))
+        records.append({'action':next(iter(actions)),'cells':cells,'windows':context_windows,'before':before_values})
+    if used!=set(view.episodes):raise ValueError('Complete source coverage required')
+    for index,r in enumerate(records):
+        for port,value in list(r['cells'].items()):
+            clock,lower,upper=r['windows'][port]
+            if any(other_clock!=clock or not (other_upper<lower or other_lower>upper) for j,(other_clock,other_lower,other_upper) in enumerate(windows) if j!=index):value=None
+            r['cells'][port]=value
+            if value==1:diversity[port].add(r['before'][port])
+    rows=[{'action':r['action'],'cells':[r['cells'].get(p) for p in ports]} for r in records]
+    return witness,ports,rows,[len(diversity[p]) for p in ports]
+

tgi/acquisition_role_constraints.py

@@ -0,0 +1,13 @@
+"""Exact full original binary role domain without enumerating its completions."""
+from copy import deepcopy
+from tgi.acquisition_snapshot import acquisition_snapshot as snapshot
+from tgi.acquisition_role_cells import _cells
+from tgi.role_work import RoleSearchBudget
+
+
+def certify_compact_role_constraints(model,groups,measurements,*,max_search_steps=None):
+    budget=RoleSearchBudget(max_search_steps)
+    with budget.scope():
+        budget.consume();groups,measurements=deepcopy((groups,measurements));witness,ports,rows,diversity=_cells(snapshot(model),groups,measurements)
+        budget.consume_many(sum(len(r['cells']) for r in rows));free=sum(x is None for r in rows for x in r['cells'])
+        return {'policy':'compact_acquisition_role_constraints_v119','groups':groups,'witness':witness,'ports':ports,'rows':rows,'changed_before_diversity':diversity,'completions':{'base':2,'exponent':free},'status':'UNCERTAIN_ATTRIBUTION' if free else 'DETERMINED_VISIBLE_ROLES'}

tgi/acquisition_role_constraints_check.py

@@ -0,0 +1,66 @@
+"""Independent source/cell/complete-partition verifier for visible roles."""
+from copy import deepcopy
+from tgi.identity import decode,encode
+from tgi.organization import OMEGA_CRIT
+from tgi.acquisition_snapshot import acquisition_snapshot as snapshot
+from tgi.acquisition_witness import verify_raw_acquisition_witness as verify_acquisition_witness
+from tgi.compact_measured_path import _decimal_count
+from tgi.frame_engine import canonical
+from tgi.role_work import RoleSearchBudget
+
+
+def verify_compact_role_constraints(acquisition,groups,measurements,certificate,*,max_search_steps=None):
+    budget=RoleSearchBudget(max_search_steps)
+    with budget.scope():
+        budget.consume()
+        try:
+            fields={'policy','groups','witness','ports','rows','changed_before_diversity','completions','status'}
+            c=certificate
+            if set(c)!=fields or c['policy']!='compact_acquisition_role_constraints_v119' or canonical(c['groups'])!=canonical(groups):return False
+            view=snapshot(acquisition);groups=deepcopy(groups);measurements=deepcopy(measurements)
+            if not verify_acquisition_witness(view,measurements,c['witness']):return False
+            if not isinstance(groups,list) or not groups:return False
+            measured={};expected={(s,i) for s,(frames,_) in view.episodes.items() for i in range(len(frames))}
+            for r in measurements:
+                k=(r['source'],r['frame'])
+                if k in measured or r['start']!=0 or r['stop']!=len(view.episodes[k[0]][0][k[1]]):return False
+                measured[k]=r
+            if set(measured)!=expected:return False
+            ports=[];used=set();cells=[];raw_inputs={};operations=[]
+            for group in groups:
+                if not isinstance(group,list) or not group:return False
+                observed={};action_values=[];op_bounds=set();windows={};before_values={}
+                for spec in group:
+                    if not isinstance(spec,dict) or set(spec)!={'port','source'}:return False
+                    p,s=spec['port'],spec['source']
+                    encode(p)
+                    if not isinstance(p,str) or not p or p in observed or s in used or s not in view.episodes:return False
+                    frames=view.episodes[s][0]
+                    if len(frames)!=3:return False
+                    used.add(s)
+                    if p not in ports:ports.append(p);raw_inputs[p]=set()
+                    action_values.append(decode(frames[1]));bounds=[measured[s,i] for i in range(3)]
+                    op_bounds.add((bounds[1]['clock'],bounds[1]['lower'],bounds[1]['upper']))
+                    windows[p]=(bounds[0]['clock'],bounds[0]['lower'],bounds[2]['upper']);before_values[p]=frames[0]
+                    value=None
+                    if all(r['clock']==bounds[0]['clock'] for r in bounds) and bounds[0]['upper']<=bounds[1]['lower'] and bounds[1]['upper']<=bounds[2]['lower']:
+                        value=0 if frames[0]==frames[2] else 1
+                    observed[p]=value
+                    
+                if len(set(action_values))!=1 or len(op_bounds)!=1:return False
+                operations.append(next(iter(op_bounds)));cells.append((action_values[0],observed,windows,before_values))
+            if used!=set(view.episodes) or canonical(ports)!=canonical(c['ports']):return False
+            for index,(_,values,windows,before_values) in enumerate(cells):
+                for port in values:
+                    clock,begin,end=windows[port]
+                    for other,(op_clock,op_begin,op_end) in enumerate(operations):
+                        if other==index:continue
+                        if op_clock!=clock or not (op_end<begin or end<op_begin):values[port]=None;break
+                    if values[port]==1:raw_inputs[port].add(before_values[port])
+            rows=[{'action':a,'cells':[values.get(p) for p in ports]} for a,values,_,_ in cells]
+            diversity=[len(raw_inputs[p]) for p in ports]
+            if canonical(rows)!=canonical(c['rows']) or canonical(diversity)!=canonical(c['changed_before_diversity']):return False
+            budget.consume_many(sum(len(r['cells']) for r in rows));free=sum(value is None for row in rows for value in row['cells'])
+            expected={'base':2,'exponent':free}
+            return canonical(c['completions'])==canonical(expected) and c['status']==('UNCERTAIN_ATTRIBUTION' if free else 'DETERMINED_VISIBLE_ROLES')
+        except (ValueError,TypeError,KeyError,IndexError,AttributeError):return False

tgi/acquisition_snapshot.py

@@ -0,0 +1,35 @@
+"""Immutable original frame evidence; explicitly cannot authorize knowledge."""
+from types import MappingProxyType
+from .organization import RawOrganization
+from .organization_snapshot import _Frames
+from .frame_engine import Receipt
+
+
+class AcquisitionSnapshot(RawOrganization):
+    _acquisition_only=True
+
+    def __init__(self,engine):
+        if not isinstance(engine,RawOrganization):raise TypeError('Original acquisition model required')
+        if getattr(engine.frames,'_pending',None):raise ValueError('Pending frame is not complete acquisition evidence')
+        episodes=dict(engine.episodes)
+        for value in episodes.values():
+            if type(value) is not tuple or len(value)!=2 or type(value[0]) is not tuple or type(value[1]) is not tuple or any(type(f) is not tuple for f in value[0]) or any(type(r) is not Receipt for r in value[1]):raise ValueError('Immutable original episode/receipt containers required')
+        self.frames=_Frames(engine.frames.view());self.episodes=MappingProxyType(episodes)
+        self.organizations=MappingProxyType({});self.rejected_organizations=MappingProxyType({})
+        self._dirty=True;self._valid={}
+
+    def _alive(self,source):
+        if source not in self._valid:self._valid[source]=super()._alive(source)
+        return self._valid[source]
+
+    def observe(self,*args,**kwargs):raise TypeError('Acquisition snapshot is read-only')
+    def form(self,*args,**kwargs):raise TypeError('Acquisition snapshot cannot form knowledge')
+    def resolve(self,*args,**kwargs):raise TypeError('Acquisition snapshot cannot resolve knowledge')
+    def _phase_valid(self,*args,**kwargs):raise TypeError('Acquisition snapshot cannot admit knowledge phase')
+    def save(self,*args,**kwargs):raise TypeError('Persist original model, not an acquisition-only snapshot')
+    @classmethod
+    def load(cls,*args,**kwargs):raise TypeError('Load original model, then snapshot acquisition')
+
+
+def acquisition_snapshot(engine):
+    return AcquisitionSnapshot(engine)

tgi/acquisition_stream.py

@@ -0,0 +1,21 @@
+"""Append-only acquisition with unchanged historical frame receipts."""
+from .organization import RawOrganization
+from .identity import encode,decode
+from .frame_engine import canonical
+
+
+class AcquisitionStream(RawOrganization):
+    def extend(self,source,frames):
+        """Accept a complete new prefix; identical retries are no-ops."""
+        if not isinstance(source,str) or not source.strip():raise ValueError('Source required')
+        encode(source)
+        if not isinstance(frames,(list,tuple)) or not frames:raise ValueError('Nonempty frames required')
+        raw=tuple(map(encode,frames))
+        if any(not f for f in raw):raise ValueError('Empty frame')
+        previous,receipts=self.episodes[source]
+        if len(raw)<len(previous) or raw[:len(previous)]!=previous:raise ValueError('Historical prefix changed')
+        if not self._alive(source):raise ValueError('Broken historical evidence')
+        if raw==previous:return
+        added=self.frames.ingest_batch((decode(raw[i]),canonical([source,i])) for i in range(len(previous),len(raw)))
+        self.episodes[source]=(raw,receipts+added)
+        self._dirty=True

tgi/acquisition_witness.py

@@ -0,0 +1,117 @@
+"""Source-bound measured-interval evidence; compatibility is not object identity."""
+from heapq import heappop,heappush
+from .organization_snapshot import snapshot
+from .acquisition_snapshot import acquisition_snapshot
+from .frame_engine import canonical
+from .identity import encode,decode
+from .incidence import _endpoint
+from .role_work import RoleSearchBudget
+
+_FIELDS={'source','frame','start','stop','clock','lower','upper'}
+
+def _inputs(model,measurements,*,raw=False):
+    view=acquisition_snapshot(model) if raw else snapshot(model)
+    if not isinstance(measurements,list):raise ValueError('Measurements must be a list')
+    records=[];seen=set()
+    for r in measurements:
+        if not isinstance(r,dict) or set(r)!=_FIELDS:raise ValueError('Invalid measurement schema')
+        for key in ('source','clock'):
+            if not isinstance(r[key],str) or not r[key].strip():raise ValueError('Measurement authority required')
+            encode(r[key])
+        if any(type(r[k]) is not int for k in ('frame','start','stop','lower','upper')):raise ValueError('Integer bounds required')
+        if r['source'] not in view.episodes:raise ValueError('Unknown source')
+        frames=view.episodes[r['source']][0]
+        if not 0<=r['frame']<len(frames) or not 0<=r['start']<r['stop']<=len(frames[r['frame']]) or r['lower']>r['upper']:raise ValueError('Invalid measurement bounds')
+        key=(r['source'],r['frame'],r['start'],r['stop'])
+        if key in seen:raise ValueError('Duplicate occurrence measurement')
+        seen.add(key);records.append(dict(r))
+    sources=[]
+    for sid,(frames,_) in sorted(view.episodes.items()):
+        if not view._alive(sid):raise ValueError('Broken source')
+        sources.append({'source':sid,'frames':list(map(decode,frames))})
+    return view,sorted(records,key=canonical),sources
+
+def _producer_interval_pairs(records):
+    """Closed interval sweep; all original cross-source partners survive."""
+    clocks={};pairs=[]
+    for i,r in enumerate(records):clocks.setdefault(r['clock'],[]).append(i)
+    for indices in clocks.values():
+        active={};ends=[]
+        for i in sorted(indices,key=lambda i:(records[i]['lower'],i)):
+            r=records[i];lo=r['lower']
+            while ends and ends[0][0]<lo:
+                _,j=heappop(ends);sid=records[j]['source'];del active[sid][j]
+                if not active[sid]:del active[sid]
+            for sid,bucket in active.items():
+                if sid==r['source']:continue
+                for j in bucket:
+                    left,right=sorted((i,j));pairs.append({'left':left,'right':right,'intersection':[lo,min(r['upper'],records[j]['upper'])]})
+            active.setdefault(r['source'],{})[i]=None;heappush(ends,(r['upper'],i))
+    return sorted(pairs,key=lambda p:(p['left'],p['right']))
+
+
+def _checker_interval_pairs(records):
+    """Independent endpoint-event reconstruction; starts precede equal ends."""
+    authorities={};edges=[]
+    for index,item in enumerate(records):
+        events=authorities.setdefault(item['clock'],[])
+        events.extend(((item['lower'],0,index),(item['upper'],1,index)))
+    for events in authorities.values():
+        live={}
+        for instant,kind,index in sorted(events):
+            item=records[index];source=item['source']
+            if kind:
+                live[source].remove(index)
+                if not live[source]:del live[source]
+                continue
+            for owner,others in live.items():
+                if owner==source:continue
+                for other in others:
+                    a,b=(index,other) if index<other else (other,index)
+                    edges.append({'left':a,'right':b,'intersection':[max(item['lower'],records[other]['lower']),min(item['upper'],records[other]['upper'])]})
+            live.setdefault(source,set()).add(index)
+    return sorted(edges,key=lambda e:(e['left'],e['right']))
+
+
+def _certify_acquisition_witness(model,measurements,*,max_search_steps=None,raw=False):
+    budget=RoleSearchBudget(max_search_steps)
+    with budget.scope():
+        view,records,sources=_inputs(model,measurements,raw=raw);occurrences=[];pairs=[]
+        for r in records:
+            budget.consume();occurrences.append(_endpoint(view,r['source'],(r['frame'],r['start'],r['stop'])))
+        budget.consume_many(len(records)*(len(records)-1)//2)
+        pairs=_producer_interval_pairs(records)
+        return {'policy':'measured_interval_witness_v1','sources':sources,'measurements':records,'occurrences':occurrences,'pairs':pairs,'status':'COMPATIBLE_PAIRS' if pairs else 'NO_COMPATIBLE_PAIR'}
+
+def _verify_acquisition_witness(model,measurements,certificate,*,max_search_steps=None,raw=False):
+    budget=RoleSearchBudget(max_search_steps)
+    with budget.scope():
+        try:
+            view,records,sources=_inputs(model,measurements,raw=raw)
+            if set(certificate)!={'policy','sources','measurements','occurrences','pairs','status'} or certificate['policy']!='measured_interval_witness_v1':return False
+            if canonical(certificate['sources'])!=canonical(sources) or canonical(certificate['measurements'])!=canonical(records):return False
+            endpoints=[];edges=[]
+            for i,r in enumerate(records):
+                budget.consume();frames,receipts=view.episodes[r['source']];fi=r['frame'];start=r['start'];stop=r['stop'];origin=receipts[fi].origin;offset=sum(map(len,frames[:fi]))
+                endpoints.append({'frame':fi,'start':start,'stop':stop,'event_span':[offset+start,offset+stop],'identities':list(frames[fi][start:stop]),'coordinates':[[origin[0]+p,*origin[1:]] for p in range(start,stop)]})
+            budget.consume_many(len(records)*(len(records)-1)//2)
+            edges=_checker_interval_pairs(records)
+            status='COMPATIBLE_PAIRS' if edges else 'NO_COMPATIBLE_PAIR'
+            return canonical(certificate['occurrences'])==canonical(endpoints) and canonical(certificate['pairs'])==canonical(edges) and certificate['status']==status
+        except (ValueError,TypeError,KeyError,IndexError,AttributeError):return False
+
+
+def certify_acquisition_witness(model,measurements,*,max_search_steps=None):
+    return _certify_acquisition_witness(model,measurements,max_search_steps=max_search_steps)
+
+
+def verify_acquisition_witness(model,measurements,certificate,*,max_search_steps=None):
+    return _verify_acquisition_witness(model,measurements,certificate,max_search_steps=max_search_steps)
+
+
+def certify_raw_acquisition_witness(model,measurements,*,max_search_steps=None):
+    return _certify_acquisition_witness(model,measurements,max_search_steps=max_search_steps,raw=True)
+
+
+def verify_raw_acquisition_witness(model,measurements,certificate,*,max_search_steps=None):
+    return _verify_acquisition_witness(model,measurements,certificate,max_search_steps=max_search_steps,raw=True)

tgi/actuation_goal_frontier.py

@@ -0,0 +1,117 @@
+"""Complete shortest supported joint-state paths and expanded NMU lineage."""
+from copy import deepcopy
+from .identity import encode
+from .acquisition_snapshot import acquisition_snapshot
+from .frame_engine import canonical
+from .observed_actuation_discovery import certify_observed_actuation_discovery
+from .joint_frontier_acquisition import _requests
+from .measured_context_laws import certify_measured_context_laws
+from .role_work import RoleSearchBudget
+
+
+def _seed_routes(state,budget):
+    result={}
+    for point in state['points']:
+        p=point['port'];occ=point['occurrence'];route=[]
+        for i,coord in enumerate(occ['coordinates']):
+            budget.consume();route.append({'kind':'observed','domain':'observed','port':p,'source':point['source'],'frame':occ['frame'],'position':i,'coordinate':deepcopy(coord)})
+        result[p]=[route]
+    return result
+
+
+def _next_routes(previous,law,step,action,budget):
+    routes={};port=law['root_port']
+    for candidate in law['candidates']:
+        for proof in candidate['structural_response']['proofs']:
+            if proof['output']!=law['result']['output']:continue
+            for prior in previous:
+                route=[]
+                for point in proof['characters'][0]:
+                    budget.consume()
+                    if point['kind']=='trigger':
+                        if point['frame']==0:route.append(deepcopy(prior[point['position']]))
+                        else:route.append({'kind':'action','domain':'query_action','step':step,'action':action,'position':point['position']})
+                    else:route.append({**deepcopy(point),'domain':'learned','port':port})
+                routes[canonical(route)]=route
+        for witness in candidate['crystal_paths']:
+            route=[]
+            for i,coord in enumerate(witness['occurrence']['coordinates']):
+                budget.consume();route.append({'kind':'crystal','domain':'learned','port':port,'source':witness['source'],'frame':2,'position':i,'coordinate':deepcopy(coord)})
+            routes[canonical(route)]=route
+    if not routes:raise ValueError('Resolved law lacks a complete character route')
+    return [routes[key] for key in sorted(routes)]
+
+
+def certify_actuation_goal_frontier(model,groups,measurements,observation,observed_groups,observed_measurements,anchor_group,catalogue,catalogue_measurements,goal,*,max_depth=None,max_search_steps=None):
+    budget=RoleSearchBudget(max_search_steps)
+    with budget.scope():
+        budget.consume()
+        if max_depth is not None and (type(max_depth) is not int or max_depth<0):raise ValueError('Depth is None or a nonnegative integer')
+        model,observation=acquisition_snapshot(model),acquisition_snapshot(observation)
+        groups,measurements,observed_groups,observed_measurements=deepcopy((groups,measurements,observed_groups,observed_measurements))
+        discovery=certify_observed_actuation_discovery(model,groups,measurements,observation,observed_groups,observed_measurements,anchor_group,catalogue,catalogue_measurements);state=discovery['state_certificate'];goal=deepcopy(goal)
+        if not isinstance(goal,dict) or not goal or not set(goal)<=set(state['ports']):raise ValueError('Nonempty original-interface goal required')
+        for value in goal.values():
+            if not isinstance(value,str) or not value:raise ValueError('Nonempty raw goal frames required')
+            encode(value)
+        ready=state['result']['status']=='JOINT_STATE_READY';nodes=[{'state':deepcopy(state['state']),'depth':0,'kind':'OBSERVED_SCOPE_VALUES'}];known={canonical(state['state']):0};edges=[];predecessors={0:[]};frontier=[0] if ready and discovery['result']['catalogue_current'] else [];depth=0;blocked=[];goals=[0] if ready and all(state['state'][p]==v for p,v in goal.items()) else [];found=0 if goals else None
+        while frontier and found is None and (max_depth is None or depth<max_depth):
+            upcoming=[]
+            for source in frontier:
+                before=nodes[source]['state']
+                for action in discovery['available_actions']:
+                    budget.consume();laws=[];after={};supported=True
+                    for port in state['ports']:
+                        budget.consume();context={p:before[p] for p in state['ports'] if p!=port};law=certify_measured_context_laws(model,groups,measurements,port,before[port],action,context);laws.append({'port':port,'certificate':law})
+                        if law['result']['status']=='MEASURED_CONTEXT_LAW_RESOLVED':after[port]=law['result']['output'][0]
+                        else:supported=False
+                    successor=None;index=len(edges)
+                    if supported:
+                        key=canonical(after)
+                        if key not in known:
+                            successor=len(nodes);known[key]=successor;nodes.append({'state':after,'depth':depth+1,'kind':'PROJECTED'});predecessors[successor]=[];upcoming.append(successor)
+                        else:successor=known[key]
+                        if nodes[successor]['depth']==depth+1:predecessors[successor].append(index)
+                        if all(after[p]==v for p,v in goal.items()):
+                            found=depth+1 if found is None else found
+                            if successor not in goals:goals.append(successor)
+                    else:blocked.append(index)
+                    edges.append({'source':source,'action':action,'laws':laws,'successor':successor,'supported':bool(supported)})
+            frontier=upcoming;depth+=1
+            if blocked:break
+        solutions=[]
+        for target in sorted(goals):
+            pending=[(target,[])]
+            while pending:
+                budget.consume();node,reverse=pending.pop()
+                if node:
+                    for edge in reversed(predecessors[node]):pending.append((edges[edge]['source'],reverse+[edge]))
+                    continue
+                path=list(reversed(reverse));owners=_seed_routes(state,budget);actions=[]
+                for step,edge_index in enumerate(path):
+                    budget.consume();edge=edges[edge_index];actions.append(edge['action']);next_owners={}
+                    for item in edge['laws']:next_owners[item['port']]=_next_routes(owners[item['port']],item['certificate'],step,edge['action'],budget)
+                    owners=next_owners
+                solutions.append({'goal_node':target,'edges':path,'actions':actions,'lineage_routes':owners})
+        solutions.sort(key=lambda s:(s['actions'],s['edges']))
+        graph={'state_certificate':state,'nodes':nodes,'edges':edges,'result':{'blocked_edges':blocked}}
+        requests=_requests(graph,budget);choices=[]
+        for solution in solutions:choices.append({'kind':'SUPPORTED_GOAL','target':solution['goal_node'],**deepcopy(solution)})
+        for request in requests:
+            for prefix in request['prefixes']:choices.append({'kind':'FRONTIER_EXPERIENCE','target':request['edge'],'edges':prefix['edges']+[request['edge']],'actions':prefix['actions']+[request['action']],'lineage_routes':deepcopy(prefix['lineage_routes'])})
+        for target in frontier:
+            if target in goals:continue
+            paths=[(target,[])]
+            while paths:
+                budget.consume();node,reverse=paths.pop()
+                if node:
+                    for edge_index in reversed(predecessors[node]):paths.append((edges[edge_index]['source'],reverse+[edge_index]))
+                    continue
+                path=list(reversed(reverse));owners=_seed_routes(state,budget);actions=[]
+                for step,j in enumerate(path):
+                    budget.consume();edge=edges[j];actions.append(edge['action']);owners={item['port']:_next_routes(owners[item['port']],item['certificate'],step,edge['action'],budget) for item in edge['laws']}
+                choices.append({'kind':'SUPPORTED_PREFIX','target':target,'edges':path,'actions':actions,'lineage_routes':owners})
+        choices.sort(key=lambda x:(x['kind'],x['target'],x['actions'],x['edges']))
+        status='GOAL_ALREADY_OBSERVED' if found==0 else 'OBSERVED_STATE_UNRESOLVED' if not ready else 'CATALOGUE_NOT_CURRENT' if not discovery['result']['catalogue_current'] else 'SUPPORTED_GOAL_READY' if found is not None else 'FRONTIER_EXPERIENCE_READY' if blocked else 'SUPPORTED_FRONTIER_CLOSED' if not frontier else 'DECLARED_DEPTH_REACHED'
+        result={'status':status,'shortest_supported_goal_length':found,'goal_nodes':sorted(goals),'blocked_edges':blocked,'frontier':frontier,'depth_reached':depth,'supported_frontier_exhausted':not bool(frontier),'choice_count':len(choices),'request_count':len(requests),'minimum_acquisition_distance':min((r['acquisition_distance'] for r in requests),default=None),'catalogue_current':discovery['result']['catalogue_current']}
+        return {'policy':'actuation_goal_frontier_v1','goal':goal,'max_depth':max_depth,'discovery':discovery,'state_certificate':state,'nodes':nodes,'edges':edges,'solutions':solutions,'requests':requests,'choices':choices,'result':result}

tgi/actuation_goal_frontier_check.py

@@ -0,0 +1,147 @@
+"""Independent graph coverage, goal paths and correlated character-route check."""
+from copy import deepcopy
+from .identity import encode
+from .acquisition_snapshot import acquisition_snapshot
+from .frame_engine import canonical
+from .observed_actuation_discovery_check import verify_observed_actuation_discovery
+from .measured_context_laws_check import verify_measured_context_laws
+from .role_work import RoleSearchBudget
+
+
+def _initial_owners(state,budget):
+    owners={}
+    for point in state['points']:
+        route=[];occ=point['occurrence']
+        for i,coordinate in enumerate(occ['coordinates']):
+            budget.consume();route.append({'kind':'observed','domain':'observed','port':point['port'],'source':point['source'],'frame':occ['frame'],'position':i,'coordinate':deepcopy(coordinate)})
+        owners[point['port']]=[route]
+    return owners
+
+
+def _expanded_owners(priors,law,step,action,budget):
+    distinct={};port=law['root_port']
+    for family in law['candidates']:
+        for proof in family['structural_response']['proofs']:
+            if proof['output']!=law['result']['output']:continue
+            for prior in priors:
+                current=[]
+                for point in proof['characters'][0]:
+                    budget.consume()
+                    if point['kind']=='crystal':current.append({**deepcopy(point),'domain':'learned','port':port})
+                    elif point['frame']==0:current.append(deepcopy(prior[point['position']]))
+                    elif point['frame']==1:current.append({'kind':'action','domain':'query_action','step':step,'action':action,'position':point['position']})
+                    else:raise ValueError('Invalid original trigger frame')
+                distinct[canonical(current)]=current
+        for crystal in family['crystal_paths']:
+            current=[]
+            for position,coordinate in enumerate(crystal['occurrence']['coordinates']):
+                budget.consume();current.append({'kind':'crystal','domain':'learned','port':port,'source':crystal['source'],'frame':2,'position':position,'coordinate':deepcopy(coordinate)})
+            distinct[canonical(current)]=current
+    if not distinct:raise ValueError('Missing lineage route')
+    return [distinct[k] for k in sorted(distinct)]
+
+
+def verify_actuation_goal_frontier(model,groups,measurements,observation,observed_groups,observed_measurements,anchor_group,catalogue,catalogue_measurements,goal,certificate,*,max_depth=None,max_search_steps=None):
+    budget=RoleSearchBudget(max_search_steps)
+    with budget.scope():
+        budget.consume()
+        try:
+            c=deepcopy(certificate)
+            if set(c)!={'policy','goal','max_depth','discovery','state_certificate','nodes','edges','solutions','requests','choices','result'} or c['policy']!='actuation_goal_frontier_v1':return False
+            if max_depth is not None and (type(max_depth) is not int or max_depth<0):return False
+            if canonical(c['goal'])!=canonical(goal) or type(c['max_depth']) is not type(max_depth) or c['max_depth']!=max_depth:return False
+            if any(type(c[key]) is not list for key in ('nodes','edges','solutions')):return False
+            model,observation=acquisition_snapshot(model),acquisition_snapshot(observation)
+            groups,measurements,observed_groups,observed_measurements=deepcopy((groups,measurements,observed_groups,observed_measurements))
+            state=c['state_certificate']
+            discovery=c['discovery']
+            if not verify_observed_actuation_discovery(model,groups,measurements,observation,observed_groups,observed_measurements,anchor_group,catalogue,catalogue_measurements,discovery) or canonical(state)!=canonical(discovery['state_certificate']):return False
+            if not isinstance(goal,dict) or not goal or not set(goal)<=set(state['ports']):return False
+            for value in goal.values():
+                if not isinstance(value,str) or not value:return False
+                encode(value)
+            ready=state['result']['status']=='JOINT_STATE_READY';expected_nodes=[{'state':deepcopy(state['state']),'depth':0,'kind':'OBSERVED_SCOPE_VALUES'}];registered={canonical(state['state']):0};parents={0:[]};layer=[0] if ready and discovery['result']['catalogue_current'] else [];level=0;cursor=0;blocked=[];goals=[0] if ready and all(state['state'][p]==v for p,v in goal.items()) else [];found=0 if goals else None
+            while layer and found is None and (max_depth is None or level<max_depth):
+                following=[]
+                for source in layer:
+                    before=expected_nodes[source]['state']
+                    for action in discovery['available_actions']:
+                        budget.consume()
+                        if cursor>=len(c['edges']):return False
+                        edge=c['edges'][cursor]
+                        if set(edge)!={'source','action','laws','successor','supported'} or type(edge['source']) is not int or edge['source']!=source or edge['action']!=action or len(edge['laws'])!=len(state['ports']):return False
+                        after={};supported=True
+                        for port,item in zip(state['ports'],edge['laws']):
+                            budget.consume()
+                            if set(item)!={'port','certificate'} or item['port']!=port:return False
+                            context={p:before[p] for p in state['ports'] if p!=port};law=item['certificate']
+                            if not verify_measured_context_laws(model,groups,measurements,port,before[port],action,context,law):return False
+                            if law['result']['status']=='MEASURED_CONTEXT_LAW_RESOLVED':after[port]=law['result']['output'][0]
+                            else:supported=False
+                        successor=None
+                        if supported:
+                            key=canonical(after)
+                            if key in registered:successor=registered[key]
+                            else:
+                                successor=len(expected_nodes);registered[key]=successor;expected_nodes.append({'state':after,'depth':level+1,'kind':'PROJECTED'});parents[successor]=[];following.append(successor)
+                            if expected_nodes[successor]['depth']==level+1:parents[successor].append(cursor)
+                            if all(after[p]==v for p,v in goal.items()):
+                                found=level+1 if found is None else found
+                                if successor not in goals:goals.append(successor)
+                        else:blocked.append(cursor)
+                        if type(edge['supported']) is not bool or edge['supported']!=supported or (successor is not None and type(edge['successor']) is not int) or edge['successor']!=successor:return False
+                        cursor+=1
+                layer=following;level+=1
+                if blocked:break
+            if len(c['edges'])!=cursor or canonical(c['nodes'])!=canonical(expected_nodes):return False
+            expected_solutions=[]
+            for target in sorted(goals):
+                stack=[(target,[])]
+                while stack:
+                    budget.consume();node,reverse=stack.pop()
+                    if node!=0:
+                        for edge_index in reversed(parents[node]):stack.append((c['edges'][edge_index]['source'],reverse+[edge_index]))
+                        continue
+                    path=list(reversed(reverse));owners=_initial_owners(state,budget);actions=[]
+                    for step,edge_index in enumerate(path):
+                        budget.consume();edge=c['edges'][edge_index];actions.append(edge['action']);updated={}
+                        for item in edge['laws']:updated[item['port']]=_expanded_owners(owners[item['port']],item['certificate'],step,edge['action'],budget)
+                        owners=updated
+                    expected_solutions.append({'goal_node':target,'edges':path,'actions':actions,'lineage_routes':owners})
+            expected_solutions.sort(key=lambda s:(s['actions'],s['edges']))
+            if canonical(c['solutions'])!=canonical(expected_solutions):return False
+            requests=[]
+            for index in blocked:
+                edge=c['edges'][index];paths=[];stack=[(edge['source'],[])]
+                while stack:
+                    budget.consume();node,reverse=stack.pop()
+                    if node:
+                        for parent in reversed(parents[node]):stack.append((c['edges'][parent]['source'],reverse+[parent]))
+                        continue
+                    path=list(reversed(reverse));owners=_initial_owners(state,budget);actions=[]
+                    for step,j in enumerate(path):
+                        budget.consume();e=c['edges'][j];actions.append(e['action']);owners={item['port']:_expanded_owners(owners[item['port']],item['certificate'],step,e['action'],budget) for item in e['laws']}
+                    paths.append({'edges':path,'actions':actions,'lineage_routes':owners})
+                paths.sort(key=lambda p:(p['actions'],p['edges']));requests.append({'edge':index,'source':edge['source'],'action':edge['action'],'before':deepcopy(expected_nodes[edge['source']]['state']),'acquisition_distance':expected_nodes[edge['source']]['depth']+1,'unresolved_ports':[item['port'] for item in edge['laws'] if item['certificate']['result']['status']!='MEASURED_CONTEXT_LAW_RESOLVED'],'prefixes':paths})
+            choices=[]
+            for solution in expected_solutions:choices.append({'kind':'SUPPORTED_GOAL','target':solution['goal_node'],**deepcopy(solution)})
+            for request in requests:
+                for prefix in request['prefixes']:choices.append({'kind':'FRONTIER_EXPERIENCE','target':request['edge'],'edges':prefix['edges']+[request['edge']],'actions':prefix['actions']+[request['action']],'lineage_routes':deepcopy(prefix['lineage_routes'])})
+            for target in layer:
+                if target in goals:continue
+                pending=[(target,[])]
+                while pending:
+                    budget.consume();node,reverse=pending.pop()
+                    if node:
+                        for parent in reversed(parents[node]):pending.append((c['edges'][parent]['source'],reverse+[parent]))
+                        continue
+                    path=list(reversed(reverse));owners=_initial_owners(state,budget);actions=[]
+                    for step,j in enumerate(path):
+                        budget.consume();edge=c['edges'][j];actions.append(edge['action']);owners={item['port']:_expanded_owners(owners[item['port']],item['certificate'],step,edge['action'],budget) for item in edge['laws']}
+                    choices.append({'kind':'SUPPORTED_PREFIX','target':target,'edges':path,'actions':actions,'lineage_routes':owners})
+            choices.sort(key=lambda x:(x['kind'],x['target'],x['actions'],x['edges']))
+            if canonical(c['requests'])!=canonical(requests) or canonical(c['choices'])!=canonical(choices):return False
+            status='GOAL_ALREADY_OBSERVED' if found==0 else 'OBSERVED_STATE_UNRESOLVED' if not ready else 'CATALOGUE_NOT_CURRENT' if not discovery['result']['catalogue_current'] else 'SUPPORTED_GOAL_READY' if found is not None else 'FRONTIER_EXPERIENCE_READY' if blocked else 'SUPPORTED_FRONTIER_CLOSED' if not layer else 'DECLARED_DEPTH_REACHED'
+            result={'status':status,'shortest_supported_goal_length':found,'goal_nodes':sorted(goals),'blocked_edges':blocked,'frontier':layer,'depth_reached':level,'supported_frontier_exhausted':not bool(layer),'choice_count':len(choices),'request_count':len(requests),'minimum_acquisition_distance':min((r['acquisition_distance'] for r in requests),default=None),'catalogue_current':discovery['result']['catalogue_current']}
+            return canonical(c['result'])==canonical(result)
+        except (ValueError,TypeError,KeyError,IndexError,AttributeError):return False