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

tgi/closed_actuation_goal_workflow.py

@@ -0,0 +1,159 @@
+"""Owned catalogue-aware selection, retained actual sessions and atomic recovery."""
+from copy import deepcopy
+from hashlib import sha256
+import json,os,re,tempfile
+from pathlib import Path
+from .observed_actuation_runtime import ObservedActuationRuntime,raw
+from .closed_actuation_goal_frontier import certify_closed_actuation_goal_frontier as certify_actuation_goal_frontier
+from .closed_actuation_goal_frontier_check import verify_closed_actuation_goal_frontier as verify_actuation_goal_frontier
+from .actuation_sequence_feedback import certify_actuation_sequence_feedback
+from .actuation_sequence_feedback_check import verify_actuation_sequence_feedback,same_state_context
+from .organization import RawOrganization
+from .organization_snapshot import snapshot
+from .organization_inventory_check import verify_organization_inventory
+from .identity import REGISTRY_ID
+from .frame_engine import canonical,unique_object
+from .role_work import RoleSearchBudget
+from .incremental import FormationSearchLimit
+REVISION='TGI-CLOSED-ACTUATION-GOAL-WORKFLOW-V1'
+FIELDS={'origin','frontier','selection_index','records','current','current_plan','current_frontier','feedback'}
+
+def verify_session(s,goal,max_depth,budget):
+    budget.consume()
+    if type(s) is not dict or set(s)!=FIELDS or len(s['origin'])!=9 or len(s['current'])!=9 or type(s['records']) is not list:return False
+    for args in (s['origin'],s['current']):
+        if not verify_organization_inventory(snapshot(args[0])):return False
+    if not verify_actuation_goal_frontier(*s['origin'],goal=goal,certificate=s['frontier'],max_depth=max_depth) or not verify_actuation_goal_frontier(*s['current'],goal=goal,certificate=s['current_frontier'],max_depth=max_depth):return False
+    if canonical(s['current_frontier']['discovery'])!=canonical(s['current_plan']):return False
+    if s['selection_index'] is None:return not s['records'] and s['feedback'] is None and same_state_context(s['origin'],s['current'],budget)
+    return verify_actuation_sequence_feedback(s['origin'],goal,s['frontier']['frontier'],s['selection_index'],s['records'],s['current'],s['current_plan'],s['feedback'],max_depth=s['frontier']['effective_depth'])
+
+def verify_sessions(archived,active,goal,max_depth,budget):
+    if type(archived) is not list:return False
+    previous=None
+    for s in [*archived,active]:
+        if not verify_session(s,goal,max_depth,budget) or (previous is not None and not same_state_context(previous,s['origin'],budget)):return False
+        previous=s['current']
+    return True
+
+class ClosedActuationGoalWorkflow:
+    def __init__(self,runtime,goal,*,max_depth=None,max_search_steps=None):
+        b=RoleSearchBudget(max_search_steps)
+        with b.scope():
+            b.consume();self._runtime=deepcopy(runtime);self._goal=deepcopy(goal);self._depth=max_depth;args=self._runtime.context();frontier=certify_actuation_goal_frontier(*args,goal=goal,max_depth=max_depth)
+            self._active={'origin':args,'frontier':frontier,'selection_index':None,'records':[],'current':deepcopy(args),'current_plan':self._runtime.plan(),'current_frontier':deepcopy(frontier),'feedback':None};self._archived=[]
+            if not verify_sessions(self._archived,self._active,self._goal,self._depth,b):raise ValueError('Verified complete native goal workflow required')
+    def frontier(self):return deepcopy(self._active['current_frontier'])
+    def feedback(self):return deepcopy(self._active['feedback'])
+    def runtime(self):return deepcopy(self._runtime)
+    def sessions(self):return deepcopy([*self._archived,self._active])
+    def select(self,index,*,max_search_steps=None):
+        b=RoleSearchBudget(max_search_steps)
+        with b.scope():
+            b.consume()
+            if self._active['selection_index'] is not None or self._active['records']:raise ValueError('Replan before selecting another complete sequence')
+            obj=self.replan() if canonical(self._active['frontier'])!=canonical(self._active['current_frontier']) else deepcopy(self);obj._active['selection_index']=index;obj._active['feedback']=certify_actuation_sequence_feedback(obj._active['origin'],obj._goal,obj._active['frontier']['frontier'],index,[],obj._active['current'],obj._active['current_plan'],max_depth=obj._active['frontier']['effective_depth'])
+            if not verify_sessions(obj._archived,obj._active,obj._goal,obj._depth,b):raise ValueError('Independent selected workflow verification failed')
+            return obj
+    def pending(self):
+        s=self._active
+        if s['selection_index'] is None:return {'status':'SELECTION_REQUIRED','action':None,'position':0}
+        f=s['feedback']['result'];position=f['consumed_steps']
+        if f['terminal']:return {'status':f['status'],'action':None,'position':position}
+        choice=s['frontier']['choices'][s['selection_index']];action=choice['actions'][position];p=s['current_plan']
+        status='FRESH_CATALOGUE_REQUIRED' if not p['result']['catalogue_current'] else 'PLANNED_ACTION_UNAVAILABLE' if action not in p['available_actions'] else 'ACTUAL_TRANSITION_READY'
+        return {'status':status,'action':action,'position':position}
+    def _renew(self,runtime):
+        obj=deepcopy(self);obj._runtime=runtime;obj._active['current']=runtime.context();obj._active['current_plan']=runtime.plan();obj._active['current_frontier']=certify_actuation_goal_frontier(*obj._active['current'],goal=obj._goal,max_depth=obj._depth)
+        if obj._active['selection_index'] is not None:obj._active['feedback']=certify_actuation_sequence_feedback(obj._active['origin'],obj._goal,obj._active['frontier']['frontier'],obj._active['selection_index'],obj._active['records'],obj._active['current'],obj._active['current_plan'],max_depth=obj._active['frontier']['effective_depth'])
+        return obj
+    def advance(self,acquired,groups,measurements,group_index,*,catalogue=None,catalogue_measurements=None,max_search_steps=None):
+        b=RoleSearchBudget(max_search_steps)
+        with b.scope():
+            b.consume();pending=self.pending()
+            if pending['status']!='ACTUAL_TRANSITION_READY':raise ValueError('Selected, available, current nonterminal action required')
+            args=self._runtime.context();p=self._runtime.plan();index=p['available_actions'].index(pending['action']);context=(*args,p,index,acquired,groups,measurements,group_index);next,c=self._runtime.advance(index,acquired,groups,measurements,group_index,catalogue=catalogue,catalogue_measurements=catalogue_measurements)
+            if next is None:return None,c
+            obj=deepcopy(self);obj._active['records'].append(deepcopy({'context':context,'after':next.context()[0],'certificate':c}));obj=obj._renew(next)
+            if not verify_sessions(obj._archived,obj._active,obj._goal,obj._depth,b):raise ValueError('Independent actual workflow verification failed')
+            return obj,c
+    def refresh_catalogue(self,catalogue,measurements,*,max_search_steps=None):
+        b=RoleSearchBudget(max_search_steps)
+        with b.scope():
+            b.consume();obj=self._renew(self._runtime.refresh_catalogue(catalogue,measurements))
+            if not verify_sessions(obj._archived,obj._active,obj._goal,obj._depth,b):raise ValueError('Independent catalogue refresh verification failed')
+            return obj
+    def replan(self,*,max_search_steps=None):
+        b=RoleSearchBudget(max_search_steps)
+        with b.scope():
+            b.consume();obj=type(self)(self._runtime,self._goal,max_depth=self._depth);obj._archived=deepcopy([*self._archived,self._active])
+            if not verify_sessions(obj._archived,obj._active,obj._goal,obj._depth,b):raise ValueError('Independent retained session verification failed')
+            return obj
+    def commit(self,path,*,max_search_steps=None):
+        b=RoleSearchBudget(max_search_steps)
+        with b.scope():
+            b.consume();archived,active=deepcopy((self._archived,self._active))
+            if not verify_sessions(archived,active,self._goal,self._depth,b):raise ValueError('Complete independently verified workflow required')
+            models=[];known={}
+            def model_id(m):
+                rows=raw(m);key=canonical(rows);b.consume_many(sum(len(f) for row in rows for f in row['frames'])+1)
+                if key not in known:known[key]=len(models);models.append(rows)
+                return {'model':known[key]}
+            def context(args):return [model_id(v) if i in ((0,3,7) if len(args)==9 else (0,3,7,11)) else v for i,v in enumerate(args)]
+            def session(s):return {**s,'origin':context(s['origin']),'current':context(s['current']),'records':[{'context':context(r['context']),'after':model_id(r['after']),'certificate':r['certificate']} for r in s['records']]}
+            saved_archived=[session(s) for s in archived];saved_active=session(active);payload={'revision':REVISION,'registry':REGISTRY_ID,'goal':deepcopy(self._goal),'max_depth':self._depth,'root_origin':context((archived[0] if archived else active)['origin']),'models':models,'archived':saved_archived,'active':saved_active};data=canonical({'payload':payload,'sha256':sha256(canonical(payload).encode()).hexdigest()}).encode('utf8');path=Path(path);temporary=None
+            try:
+                with tempfile.NamedTemporaryFile(mode='wb',prefix='tgi-goal-',dir=path.parent,delete=False) as f:temporary=Path(f.name);f.write(data);f.flush();os.fsync(f.fileno())
+                os.replace(temporary,path);temporary=None
+            finally:
+                if temporary is not None and temporary.exists():temporary.unlink()
+            return {'path':str(path),'sha256':sha256(data).hexdigest(),'bytes':len(data),'revision':REVISION,'raw_inventory_models':len(models),'archived_sessions':len(archived),'actual_records':sum(len(s['records']) for s in [*archived,active])}
+    @classmethod
+    def recover(cls,path,expected_sha256,*,max_search_steps=None):
+        b=RoleSearchBudget(max_search_steps)
+        with b.scope():
+            b.consume();data=Path(path).read_bytes()
+            if not isinstance(expected_sha256,str) or re.fullmatch('[0-9a-f]{64}',expected_sha256) is None or sha256(data).hexdigest()!=expected_sha256:raise ValueError('Original external workflow byte digest required')
+            envelope=json.loads(data.decode('utf8'),object_pairs_hook=unique_object)
+            if type(envelope) is not dict or set(envelope)!={'payload','sha256'}:raise ValueError('Invalid workflow envelope')
+            p=envelope['payload']
+            if type(p) is not dict or set(p)!={'revision','registry','goal','max_depth','root_origin','models','archived','active'} or p['revision']!=REVISION or p['registry']!=REGISTRY_ID or sha256(canonical(p).encode()).hexdigest()!=envelope['sha256']:raise ValueError('Invalid complete workflow payload')
+            if type(p['models']) is not list or not p['models']:raise ValueError('Original raw inventory pool required')
+            models=[];unique=set()
+            for rows in p['models']:
+                if type(rows) is not list or canonical(rows) in unique:raise ValueError('Unique complete raw inventory pool required')
+                unique.add(canonical(rows));m=RawOrganization()
+                for row in rows:
+                    if type(row) is not dict or set(row)!={'source','frames'} or type(row['frames']) is not list:raise ValueError('Original raw episode required')
+                    b.consume_many(sum(len(f) for f in row['frames'])+1);m.observe(row['source'],row['frames'])
+                limits=[];parent=b
+                while parent is not None:
+                    if parent.limit is not None:limits.append(max(0,parent.limit-parent.used))
+                    parent=getattr(parent,'parent',None)
+                try:m.form(max_search_steps=min(limits) if limits else None)
+                except FormationSearchLimit as error:b.consume_many(error.used);b.consume();raise
+                b.consume_many(m.formation_work['search_steps']);models.append(m)
+            used=set()
+            def model(marker):
+                if type(marker) is not dict or set(marker)!={'model'} or type(marker['model']) is not int or not 0<=marker['model']<len(models):raise ValueError('Exact original model slot required')
+                used.add(marker['model']);return models[marker['model']]
+            def context(args,size):
+                if type(args) is not list or len(args)!=size:raise ValueError('Complete original model context required')
+                for i in ((0,3,7) if size==9 else (0,3,7,11)):args[i]=model(args[i])
+                return tuple(args)
+            def session(s):
+                if type(s) is not dict or set(s)!=FIELDS or type(s['records']) is not list:raise ValueError('Complete original session required')
+                s['origin']=context(s['origin'],9);s['current']=context(s['current'],9)
+                for r in s['records']:
+                    if type(r) is not dict or set(r)!={'context','after','certificate'}:raise ValueError('Complete original actual transition required')
+                    r['context']=context(r['context'],15);r['after']=model(r['after'])
+                return s
+            if type(p['archived']) is not list:raise ValueError('Ordered retained sessions required')
+            archived=[session(s) for s in p['archived']];active=session(p['active']);root_origin=context(p['root_origin'],9)
+            first=(archived[0] if archived else active)['origin']
+            if not same_state_context(root_origin,first,b) or canonical(root_origin[8])!=canonical(first[8]) or canonical(raw(root_origin[7]))!=canonical(raw(first[7])):raise ValueError('Original root session binding required')
+            if used!=set(range(len(models))) or not verify_sessions(archived,active,p['goal'],p['max_depth'],b):raise ValueError('Independent full workflow recovery verification failed')
+            obj=cls.__new__(cls);obj._goal=p['goal'];obj._depth=p['max_depth'];obj._archived=archived;obj._active=active;runtime=ObservedActuationRuntime.__new__(ObservedActuationRuntime);runtime._args=tuple(active['current']);runtime._plan=active['current_plan'];runtime._transaction=None
+            for s in [*archived,active]:
+                for r in s['records']:runtime._transaction=(tuple(r['context']),r['after'],r['certificate'])
+            obj._runtime=runtime;return obj

tgi/closure.py

@@ -0,0 +1,202 @@
+"""Certified finite closure of organizations formed from raw episodes.
+
+Derived frames are transient consequences, never new formation exposures.
+See contracts/RAW_CLOSURE_V2.md for terminal and resource semantics.
+"""
+from dataclasses import dataclass
+from .identity import encode, decode
+from .organization import _match
+
+
+class BudgetExhausted(Exception):
+    pass
+
+
+@dataclass
+class Work:
+    limit: int
+    used: int = 0
+
+    def tick(self):
+        self.used += 1
+        if self.used > self.limit:
+            raise BudgetExhausted
+
+
+def observations(engine):
+    records = []
+    for source, (frames, _) in sorted(engine.episodes.items()):
+        if not engine._alive(source):
+            raise ValueError("Broken observed crystal")
+        records.extend({"source": source, "frame": fi, "text": decode(ids)}
+                       for fi, ids in enumerate(frames))
+    return records
+
+
+def prefixes(engine, nodes, work):
+    """Join ordered input paths only when their repeated axes agree."""
+    encoded = {text: encode(text) for text in sorted(nodes)}
+    yielded = set()
+    input_patterns = set()
+    frame_matches = {}
+    candidates = dict(engine.organizations)
+    candidates.update({a: h for a, (h, _) in engine.rejected_organizations.items()})
+    for _, h in sorted(candidates.items()):
+        if len(h.pattern) < 2 or h.pattern[:-1] in input_patterns:
+            continue
+        input_patterns.add(h.pattern[:-1])
+        states = [()]
+        for part in h.pattern[:-1]:
+            candidates = []
+            for text, ids in encoded.items():
+                work.tick()
+                key = (part, ids)
+                if key not in frame_matches:
+                    frame_matches[key] = bool(_match((part,), (ids,)))
+                if frame_matches[key]:
+                    candidates.append(text)
+            next_states = []
+            for state in states:
+                for text in candidates:
+                    work.tick()
+                    proposal = state+(text,)
+                    if _match(h.pattern, tuple(encoded[t] for t in proposal)):
+                        next_states.append(proposal)
+            states = next_states
+        for state in states:
+            if state not in yielded:
+                yielded.add(state)
+                yield state
+
+
+def terminal(engine, text):
+    ids = encode(text)
+    known = list(engine.organizations.values())+[h for h, _ in engine.rejected_organizations.values()]
+    return not any(_match((part,), (ids,)) for h in known
+                   for part in h.pattern[:-1] if any(k == "lit" and v for k, v in part))
+
+
+def query_consequences(query, steps):
+    dependent = {query}
+    produced = set()
+    changed = True
+    while changed:
+        changed = False
+        for step in steps:
+            if any(text in dependent for text in step["prefix"]):
+                output = step["result"]["output"][0]
+                produced.add(output)
+                if output not in dependent:
+                    dependent.add(output); changed = True
+    return produced
+
+
+def resolve_closure(engine, query, *, max_nodes=1024, max_work=1000000, max_formation_steps=None):
+    encode(query)
+    if not query:
+        raise ValueError("Nonempty query required")
+    if type(max_nodes) is not int or type(max_work) is not int or min(max_nodes, max_work) < 1:
+        raise ValueError("Resource ceilings must be positive integers")
+    from .incremental import SearchBudget, FormationSearchLimit
+    SearchBudget(max_formation_steps)
+    work = Work(max_work)
+    steps, blocked, obs, nodes, fired = [], [], [], set(), set()
+    def result(status, reason=None, answers=()):
+        return {"status": status, "output": list(answers) if status == "RESOLVED" else [],
+                "query": query, "observations": obs, "steps": steps, "blocked": blocked, "node_count": len(nodes),
+                "work": work.used, "reason": reason}
+    try:
+        if engine._dirty:
+            if max_formation_steps is None:
+                engine.form()
+            else:
+                engine.form(max_search_steps=max_formation_steps)
+        from .organization_snapshot import snapshot
+        engine = snapshot(engine)
+        obs = observations(engine)
+        nodes = {r["text"] for r in obs} | {query}
+        if len(nodes) > max_nodes:
+            return result("INCOMPLETE", "node_budget")
+        while True:
+            added = False
+            for prefix in prefixes(engine, nodes, work):
+                if prefix in fired:
+                    continue
+                fired.add(prefix)
+                resolution = engine.resolve(prefix, terminal_only=True)
+                if resolution["status"] in ("AMBIGUOUS", "CONFLICT"):
+                    blocked.append({"prefix": list(prefix), "status": resolution["status"]})
+                    continue
+                if resolution["status"] == "INCOMPLETE":
+                    return result("INCOMPLETE", "incomplete_step")
+                if resolution["status"] != "RESOLVED" or len(resolution["output"]) != 1:
+                    raise ValueError("Matched organization has no unique terminal frame")
+                steps.append({"prefix": list(prefix), "result": resolution})
+                text = resolution["output"][0]
+                if text not in nodes:
+                    if len(nodes) == max_nodes:
+                        return result("INCOMPLETE", "node_budget")
+                    nodes.add(text); added = True
+            if not added:
+                break
+        dependent = {query} | query_consequences(query, steps)
+        if any(any(t in dependent for t in b["prefix"]) for b in blocked):
+            return result("AMBIGUOUS", "query_dependent_blocked_step")
+        consumed = {t for step in steps for t in step["prefix"]}
+        ends = sorted(text for text in query_consequences(query, steps)
+                      if text not in consumed and terminal(engine, text))
+        if len(ends) > 1:
+            return result("CONFLICT", "multiple_terminal_consequences")
+        return result("RESOLVED", answers=ends) if ends else result("NO_PATH", "no_terminal_consequence")
+    except FormationSearchLimit:
+        return result("INCOMPLETE", "formation_search_limit")
+    except BudgetExhausted:
+        return result("INCOMPLETE", "work_budget")
+    except ValueError as error:
+        return result("INCOMPLETE", str(error))
+
+
+def verify_closure(engine, query, certificate, *, max_work=1000000):
+    """Replay proof and independently require closure; never invoke a resolver."""
+    from .organization_check import verify_resolution
+    try:
+        if engine._dirty or certificate["status"] != "RESOLVED" or certificate["query"] != query:
+            return False
+        from .organization_snapshot import snapshot
+        engine = snapshot(engine)
+        obs = observations(engine)
+        if certificate["observations"] != obs:
+            return False
+        available = {r["text"] for r in obs} | {query}
+        checked = set()
+        for step in certificate["steps"]:
+            prefix = tuple(step["prefix"])
+            if prefix in checked or not all(t in available for t in prefix):
+                return False
+            resolution = step["result"]
+            if len(resolution["output"]) != 1 or not verify_resolution(engine, prefix, resolution, terminal_only=True):
+                return False
+            checked.add(prefix)
+            available.add(resolution["output"][0])
+        # A valid path alone does not certify that conflicting paths were absent.
+        # Every applicable ordered prefix in the final state needs a checked step.
+        from .phase_evidence import blocked_prefix
+        blocked = set()
+        for item in certificate["blocked"]:
+            prefix = tuple(item["prefix"])
+            if (prefix in checked or prefix in blocked or not all(t in available for t in prefix)
+                or item["status"] not in ("AMBIGUOUS", "CONFLICT") or not blocked_prefix(engine, prefix)):
+                return False
+            blocked.add(prefix)
+        expected = set(prefixes(engine, available, Work(max_work)))
+        if checked | blocked != expected:
+            return False
+        dependent = {query} | query_consequences(query, certificate["steps"])
+        if any(any(t in dependent for t in prefix) for prefix in blocked):
+            return False
+        consumed = {t for step in certificate["steps"] for t in step["prefix"]}
+        ends = sorted(t for t in query_consequences(query, certificate["steps"])
+                      if t not in consumed and terminal(engine, t))
+        return len(ends) == 1 and certificate["output"] == ends and certificate["node_count"] == len(available)
+    except (ValueError, KeyError, TypeError, IndexError, BudgetExhausted):
+        return False

tgi/compact_acquisition_map.py

@@ -0,0 +1,68 @@
+from tgi.compact_measured_path import _read_count
+from tgi.identity import encode,decode
+from tgi.acquisition_witness import certify_acquisition_witness
+from tgi.organization import OMEGA_CRIT
+from tgi.frame_engine import canonical
+from tgi.compact_measured_path import _decimal_count
+
+def build(left,right,alignments,direction,budget):
+    index={(a['left'],a['right'],a['direction']):k for k,a in enumerate(alignments)}
+    states=[(0,())];lookup={(0,()):0};ways=[1];edges=[];cursor=0
+    while cursor<len(states):
+        budget.consume()
+        mask,items=states[cursor];i=mask.bit_count()
+        if i<len(left):
+          for j in range(len(right)):
+            budget.consume()
+            if mask&(1<<j):continue
+            aid=index.get((i,j,direction))
+            if aid is None:continue
+            a=alignments[aid];mapping=dict(items);inverse={v:u for u,v in items};valid=True
+            for u,v,_,_ in a['positions']:
+                budget.consume()
+                if (u in mapping and mapping[u]!=v) or (v in inverse and inverse[v]!=u):valid=False;break
+                mapping[u]=v;inverse[v]=u
+            if not valid:continue
+            state=(mask|(1<<j),tuple(sorted(mapping.items())))
+            if state not in lookup:lookup[state]=len(states);states.append(state);ways.append(0)
+            target=lookup[state];ways[target]+=ways[cursor];edges.append([cursor,target,aid])
+        cursor+=1
+    return dict(direction=direction,nodes=[dict(mask=mask,mapping=[list(p) for p in items],count=_decimal_count(ways[i])) for i,(mask,items) in enumerate(states)],edges=edges,terminals=[i for i,(mask,_) in enumerate(states) if mask.bit_count()==len(left)])
+
+def _produce(m,measurements,left,right,query,budget):
+    q=encode(query)
+    if not q or not isinstance(left,list) or not isinstance(right,list) or len(set(left))!=len(left) or len(set(right))!=len(right) or set(left)&set(right) or set(left)|set(right)!=set(m.episodes):raise ValueError('Complete disjoint channels required')
+    witness=certify_acquisition_witness(m,measurements);records={r['source']:r for r in witness['measurements']}
+    if len(records)!=len(measurements) or set(records)!=set(m.episodes):raise ValueError('Full measurements required')
+    for s,(frames,_) in m.episodes.items():
+        budget.consume()
+        r=records[s]
+        if len(frames)!=1 or r['frame']!=0 or r['start']!=0 or r['stop']!=len(frames[0]):raise ValueError('Full single-frame scope required')
+    left=sorted(left);right=sorted(right);clocks=sorted({r['clock'] for r in records.values()});enabled=len(left)==len(right) and len(clocks)==1;alignments=[];graphs=[];outcomes=[]
+    if enabled:
+      for i,a in enumerate(left):
+       for j,b in enumerate(right):
+        budget.consume()
+        if max(records[a]['lower'],records[b]['lower'])>min(records[a]['upper'],records[b]['upper']):continue
+        alignments.append(dict(left=i,right=j,direction=0,positions=[]));x=m.episodes[a][0][0];y=m.episodes[b][0][0]
+        if len(x)!=len(y):continue
+        for _ in x:budget.consume()
+        for direction in (-1,1):alignments.append(dict(left=i,right=j,direction=direction,positions=[[u,y[k if direction==1 else len(x)-1-k],k,k if direction==1 else len(x)-1-k] for k,u in enumerate(x)]))
+      for direction in (0,-1,1):
+        graph=build(left,right,alignments,direction,budget);graphs.append(graph)
+        if direction:
+          for terminal in graph['terminals']:
+            for _ in q:budget.consume()
+            node=graph['nodes'][terminal];mapping=dict(node['mapping']);missing=sorted(set(q)-set(mapping));ids=q if direction==1 else q[::-1]
+            outcomes.append(dict(direction=direction,terminal=terminal,count=node['count'],missing=missing,output=None if missing else decode(tuple(mapping[u] for u in ids))))
+    count=sum(_read_count(o['count']) for o in outcomes);outputs=sorted({o['output'] for o in outcomes if o['output'] is not None});distinct=len({m.episodes[s][0][0] for s in left})
+    status='INCOMPLETE' if len(left)!=len(right) else 'CLOCK_UNDETERMINED' if len(clocks)!=1 else 'CONFLICT' if not count else 'INCOMPLETE' if distinct<OMEGA_CRIT else 'UNKNOWN_ID' if any(o['missing'] for o in outcomes) else 'AMBIGUOUS_OUTPUT' if len(outputs)!=1 else 'CONDITIONAL_OUTPUT'
+    return dict(query=query,left=left,right=right,witness=witness,alignments=alignments,graphs=graphs,outcomes=outcomes,alternative_count=_decimal_count(count),diversity=distinct,status=status,outputs=outputs,output=outputs[0] if status=='CONDITIONAL_OUTPUT' else None)
+
+
+def certify_compact_acquisition_map(model,measurements,left,right,query,*,max_search_steps=None):
+    from .organization_snapshot import snapshot
+    from .role_work import RoleSearchBudget
+    budget=RoleSearchBudget(max_search_steps)
+    with budget.scope():
+        return dict(policy='compact_acquisition_assignment_v1',threshold=OMEGA_CRIT,**_produce(snapshot(model),measurements,left,right,query,budget))

tgi/compact_acquisition_map_check.py

@@ -0,0 +1,91 @@
+from tgi.compact_measured_path import _read_count
+"""Verify complete reachable assignment closure, not a producer rerun."""
+from .identity import encode,decode
+from .organization import OMEGA_CRIT
+from .organization_snapshot import snapshot
+from .acquisition_witness import verify_acquisition_witness
+from .role_work import RoleSearchBudget
+from .frame_engine import canonical
+from .compact_measured_path import _decimal_count
+
+def _graph(g,left,right,alignments,direction,budget):
+    if set(g)!={'direction','nodes','edges','terminals'} or type(g['direction']) is not int or g['direction']!=direction:raise ValueError('Graph schema')
+    nodes=g['nodes'];keys=[];lookup={}
+    for i,node in enumerate(nodes):
+        budget.consume()
+        if set(node)!={'mask','mapping','count'} or type(node['mask']) is not int or not 0<=node['mask']<(1<<len(right)):raise ValueError('State schema')
+        items=tuple(tuple(p) for p in node['mapping'])
+        if any(len(p)!=2 or any(type(x) is not int for x in p) for p in items) or items!=tuple(sorted(set(items))) or len({x for x,y in items})!=len(items) or len({y for x,y in items})!=len(items):raise ValueError('Invalid state relation')
+        key=(node['mask'],items)
+        if key in lookup:raise ValueError('Duplicate state')
+        lookup[key]=i;keys.append(key)
+    if not keys or keys[0]!=(0,()):raise ValueError('Missing root')
+    index={(a['left'],a['right'],a['direction']):k for k,a in enumerate(alignments)};edges=[]
+    for source,(mask,items) in enumerate(keys):
+        i=mask.bit_count()
+        if i==len(left):continue
+        for j in range(len(right)):
+            budget.consume()
+            aid=index.get((i,j,direction))
+            if mask&(1<<j) or aid is None:continue
+            pairs=set(items)
+            for u,v,_,_ in alignments[aid]['positions']:budget.consume();pairs.add((u,v))
+            if len({x for x,y in pairs})!=len(pairs) or len({y for x,y in pairs})!=len(pairs):continue
+            key=(mask|(1<<j),tuple(sorted(pairs)))
+            if key not in lookup:raise ValueError('Omitted continuation')
+            edges.append([source,lookup[key],aid])
+    if canonical(edges)!=canonical(g['edges']):raise ValueError('Incomplete transition inventory')
+    incoming=[[] for _ in nodes]
+    for a,b,_ in edges:incoming[b].append(a)
+    counts=[0]*len(nodes);counts[0]=1
+    for i in sorted(range(1,len(nodes)),key=lambda i:keys[i][0].bit_count()):
+        budget.consume();counts[i]=sum(counts[a] for a in incoming[i])
+    if any(v==0 for v in counts) or any(nodes[i]['count']!=_decimal_count(v) for i,v in enumerate(counts)):raise ValueError('Unreachable state or incorrect multiplicity')
+    terminals=[i for i,(mask,_) in enumerate(keys) if mask.bit_count()==len(left)]
+    if canonical(terminals)!=canonical(g['terminals']):raise ValueError('Terminal scope')
+    return terminals
+
+def verify_compact_acquisition_map(model,measurements,left,right,query,c,*,max_search_steps=None):
+    budget=RoleSearchBudget(max_search_steps)
+    with budget.scope():
+      try:
+        if not isinstance(c,dict) or set(c)!={'policy','threshold','query','left','right','witness','alignments','graphs','outcomes','alternative_count','diversity','status','outputs','output'} or c['policy']!='compact_acquisition_assignment_v1' or type(c['threshold']) is not int or c['threshold']!=OMEGA_CRIT:return False
+        m=snapshot(model);q=encode(query)
+        if not q or not isinstance(left,list) or not isinstance(right,list) or len(set(left))!=len(left) or len(set(right))!=len(right) or set(left)&set(right) or set(left)|set(right)!=set(m.episodes):return False
+        if not verify_acquisition_witness(m,measurements,c['witness']):return False
+        records={r['source']:r for r in measurements}
+        if len(records)!=len(measurements) or set(records)!=set(m.episodes):return False
+        for s,(frames,_) in m.episodes.items():
+            budget.consume();r=records[s]
+            if len(frames)!=1 or (r['frame'],r['start'],r['stop'])!=(0,0,len(frames[0])):return False
+        left=sorted(left);right=sorted(right)
+        if c['query']!=query or canonical(c['left'])!=canonical(left) or canonical(c['right'])!=canonical(right):return False
+        clocks={r['clock'] for r in measurements};enabled=len(left)==len(right) and len(clocks)==1;alignments=[]
+        if enabled:
+          for i,a in enumerate(left):
+           for j,b in enumerate(right):
+            budget.consume()
+            if records[a]['upper']<records[b]['lower'] or records[b]['upper']<records[a]['lower']:continue
+            alignments.append(dict(left=i,right=j,direction=0,positions=[]));x=m.episodes[a][0][0];y=m.episodes[b][0][0]
+            if len(x)!=len(y):continue
+            for sign in (-1,1):
+                positions=[]
+                for k,u in enumerate(x):budget.consume();p=k if sign==1 else len(x)-1-k;positions.append([u,y[p],k,p])
+                alignments.append(dict(left=i,right=j,direction=sign,positions=positions))
+        if canonical(c['alignments'])!=canonical(alignments) or len(c['graphs'])!=(3 if enabled else 0):return False
+        outcomes=[]
+        for g,sign in zip(c['graphs'],(0,-1,1)):
+            terminals=_graph(g,left,right,alignments,sign,budget)
+            if not sign:continue
+            for terminal in terminals:
+                node=g['nodes'][terminal];mapping=dict(node['mapping']);missing=set();output=[]
+                for k in range(len(q)):
+                    budget.consume();u=q[k if sign==1 else len(q)-1-k]
+                    if u not in mapping:missing.add(u)
+                    else:output.append(mapping[u])
+                outcomes.append(dict(direction=sign,terminal=terminal,count=node['count'],missing=sorted(missing),output=None if missing else decode(tuple(output))))
+        count=sum(_read_count(o['count']) for o in outcomes);outputs=sorted({o['output'] for o in outcomes if o['output'] is not None});distinct=len({m.episodes[s][0][0] for s in left})
+        status='INCOMPLETE' if len(left)!=len(right) else 'CLOCK_UNDETERMINED' if len(clocks)!=1 else 'CONFLICT' if not count else 'INCOMPLETE' if distinct<OMEGA_CRIT else 'UNKNOWN_ID' if any(o['missing'] for o in outcomes) else 'AMBIGUOUS_OUTPUT' if len(outputs)!=1 else 'CONDITIONAL_OUTPUT'
+        expected=dict(outcomes=outcomes,alternative_count=_decimal_count(count),diversity=distinct,status=status,outputs=outputs,output=outputs[0] if status=='CONDITIONAL_OUTPUT' else None)
+        return all(canonical(c[k])==canonical(v) for k,v in expected.items())
+      except (ValueError,TypeError,KeyError,IndexError,AttributeError):return False

tgi/compact_complete_role_core.py

@@ -0,0 +1,36 @@
+"""Maximal complete original columns over the exact full symbolic role domain."""
+from .organization_snapshot import snapshot
+from .compact_role_observation import certify_compact_role_constraints
+from .complete_role_core import projected_domain
+from .intervention_roles import certify_intervention_roles
+from .role_work import RoleSearchBudget
+
+
+def certify_compact_complete_role_core(model,groups,measurements,*,max_search_steps=None):
+    budget=RoleSearchBudget(max_search_steps)
+    with budget.scope():
+        budget.consume();view=snapshot(model);parent=certify_compact_role_constraints(view,groups,measurements);columns=[]
+        for index in range(len(parent['ports'])):
+            budget.consume_many(len(parent['rows'])+1)
+            if all(r['cells'][index] is not None for r in parent['rows']):columns.append(index)
+        ports=[parent['ports'][i] for i in columns];local,gs,ms,sources=projected_domain(view,groups,measurements,ports);budget.consume_many(len(sources)+len(ms)+sum(map(len,gs))+len(gs));roles=certify_intervention_roles(local,gs,ms) if ports else None
+        return {'policy':'complete_measured_role_core_v2','parent':parent,'columns':columns,'ports':ports,'excluded':[p for p in parent['ports'] if p not in ports],'groups':gs,'sources':sources,'roles':roles,'result':{'status':'COMPLETE_ROLE_CORE' if ports else 'NO_COMPLETE_ROLE_CORE','rows_retained':len(parent['rows'])}}
+
+
+def certify_compact_complete_core_resolution(model,groups,measurements,root_port,before,action,*,max_search_steps=None):
+    from copy import deepcopy
+    from .identity import encode
+    from .intervention_resolution import certify_intervention_resolution
+    budget=RoleSearchBudget(max_search_steps)
+    with budget.scope():
+        budget.consume();view=snapshot(model)
+        if not all(isinstance(x,str) and x for x in (root_port,before,action)):raise ValueError('Nonempty original query required')
+        for x in (root_port,before,action):encode(x)
+        core=certify_compact_complete_role_core(view,groups,measurements)
+        if root_port not in core['parent']['ports']:raise ValueError('Unknown root port')
+        child=None
+        if root_port in core['ports']:
+            local,gs,ms,_=projected_domain(view,groups,measurements,core['ports'])
+            child=certify_intervention_resolution(local,gs,ms,root_port,before,action)
+        result={'status':'ROOT_NOT_COMPLETE','output':[]} if child is None else deepcopy(child['result'])
+        return {'policy':'complete_role_core_resolution_v2','core':core,'root_port':root_port,'prefix':[before,action],'resolution':child,'result':result}

tgi/compact_complete_role_core_check.py

@@ -0,0 +1,62 @@
+"""Independent full parent, maximal columns and native resolution verification."""
+from .organization_snapshot import snapshot
+from .intervention_roles_check import verify_intervention_roles
+from .compact_role_observation_check import verify_compact_role_constraints
+from .complete_role_core_check import verify_complete_role_core
+from .intervention_resolution_check import verify_intervention_resolution
+from .complete_role_core import projected_domain
+from .frame_engine import canonical
+from .role_work import RoleSearchBudget
+from .identity import encode
+
+
+def verify_compact_complete_role_core(model,groups,measurements,certificate,*,max_search_steps=None):
+    budget=RoleSearchBudget(max_search_steps)
+    with budget.scope():
+        budget.consume()
+        try:
+            c=certificate;view=snapshot(model)
+            if c.get('policy')=='complete_measured_role_core_v1':return verify_complete_role_core(view,groups,measurements,c)
+            if set(c)!={'policy','parent','columns','ports','excluded','groups','sources','roles','result'} or c['policy']!='complete_measured_role_core_v2':return False
+            if not verify_compact_role_constraints(view,groups,measurements,c['parent']):return False
+            ports=c['parent']['ports'];columns=[]
+            for index in range(len(ports)):
+                budget.consume_many(len(c['parent']['rows'])+1)
+                missing=False
+                for row in c['parent']['rows']:
+                    if row['cells'][index] is None:missing=True
+                if not missing:columns.append(index)
+            selected=[ports[i] for i in columns]
+            if canonical(c['columns'])!=canonical(columns) or c['ports']!=selected or c['excluded']!=[p for p in ports if p not in selected]:return False
+            local,gs,ms,sources=projected_domain(view,groups,measurements,selected)
+            budget.consume_many(len(sources)+len(ms)+sum(map(len,gs))+len(gs))
+            if canonical(c['groups'])!=canonical(gs) or c['sources']!=sources:return False
+            if selected:
+                if not verify_intervention_roles(local,gs,ms,c['roles']):return False
+            elif c['roles'] is not None:return False
+            expected={'status':'COMPLETE_ROLE_CORE' if selected else 'NO_COMPLETE_ROLE_CORE','rows_retained':len(groups)}
+            return canonical(c['result'])==canonical(expected)
+        except (ValueError,TypeError,KeyError,IndexError,AttributeError):return False
+
+
+def verify_compact_complete_core_resolution(model,groups,measurements,root_port,before,action,certificate,*,max_search_steps=None):
+    from .complete_role_core_check import verify_complete_core_resolution
+    budget=RoleSearchBudget(max_search_steps)
+    with budget.scope():
+        budget.consume()
+        try:
+            c=certificate;view=snapshot(model)
+            if not all(isinstance(x,str) and x for x in (root_port,before,action)):return False
+            for x in (root_port,before,action):encode(x)
+            if c.get('policy')=='observed_role_core_resolution_v1':
+                from .observed_role_core_check import verify_observed_role_core_resolution
+                return verify_observed_role_core_resolution(view,groups,measurements,root_port,before,action,c)
+            if c.get('policy')=='complete_role_core_resolution_v1':return verify_complete_core_resolution(view,groups,measurements,root_port,before,action,c)
+            if set(c)!={'policy','core','root_port','prefix','resolution','result'} or c['policy']!='complete_role_core_resolution_v2' or c['root_port']!=root_port or c['prefix']!=[before,action]:return False
+            if not verify_compact_complete_role_core(view,groups,measurements,c['core']) or root_port not in c['core']['parent']['ports']:return False
+            if root_port not in c['core']['ports']:
+                return c['resolution'] is None and canonical(c['result'])==canonical({'status':'ROOT_NOT_COMPLETE','output':[]})
+            local,gs,ms,_=projected_domain(view,groups,measurements,c['core']['ports'])
+            if not verify_intervention_resolution(local,gs,ms,root_port,before,action,c['resolution']):return False
+            return canonical(c['result'])==canonical(c['resolution']['result'])
+        except (ValueError,TypeError,KeyError,IndexError,AttributeError):return False