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

tgi/cross_action_correspondence.py

@@ -0,0 +1,182 @@
+"""Owned append with independent one-pass complete replay."""
+import copy
+import hashlib
+import json
+import os
+import re
+import tempfile
+from pathlib import Path
+
+from tgi.frame_engine import canonical, unique_object
+from tgi.identity import REGISTRY_ID, encode
+from tgi.organization import OMEGA_CRIT
+from tgi.intervention_edit_contrast import contrast
+
+REVISION = 'TGI-M1-CROSS-ACTION-PROFILE-RESEARCH-V3'
+
+
+def _sha(data):
+    return hashlib.sha256(data).hexdigest()
+
+
+def _contrast(before, after):
+    return contrast(before, after)
+
+
+def _event(source, action, target_before, target_after, views):
+    if type(source) is not str or not source or type(action) is not str or not action:
+        raise ValueError('Original source and action required')
+    if type(views) is not dict or len(views) < 2:
+        raise ValueError('At least two original view streams required')
+    target = _contrast(target_before, target_after)
+    measured = {}
+    for name, frames in sorted(views.items()):
+        if type(name) is not str or not name or type(frames) not in (tuple, list) or len(frames) != 2:
+            raise ValueError('Original view address and before/after frames required')
+        measured[name] = _contrast(*frames)
+    return {'source': source, 'action_nmu': list(encode(action)),
+            'target': target, 'views': measured}
+
+
+def form(events):
+    """Accumulate original events once while retaining every V3 phase field."""
+    if type(events) is not list:
+        raise ValueError('Original chronological event list required')
+    if not events:
+        return {'revision': REVISION, 'registry': REGISTRY_ID, 'events': [],
+                'phases': [], 'result': {'status': 'NO_PATH', 'view': None}}
+    names = list(events[0]['views'])
+    if len(names) < 2:
+        raise ValueError('At least two view streams required')
+    sources = set()
+    prior_crystal = None
+    phases = []
+    actions = set()
+    comparator = set()
+    support = {name: {} for name in names}
+    controls = {name: {} for name in names}
+    opposing = {name: [] for name in names}
+    for index, event in enumerate(events):
+        if (type(event) is not dict or set(event) != {'source', 'action_nmu',
+                'target', 'views'} or event['source'] in sources or
+                list(event['views']) != names):
+            raise ValueError('Unique raw event and fixed view inventory required')
+        sources.add(event['source'])
+        action = tuple(event['action_nmu'])
+        actions.add(action)
+        if not event['target']['changed'] and any(
+                view['changed'] for view in event['views'].values()):
+            comparator.add(action)
+        cells = []
+        eligible = []
+        for name in names:
+            owned_support = support[name]
+            owned_controls = controls[name]
+            owned_support.setdefault(action, set())
+            owned_controls.setdefault(action, 0)
+            if event['target']['changed'] and event['views'][name]['changed']:
+                owned_support[action].add(tuple(event['target']['before_nmu']))
+            elif not event['target']['changed'] and not event['views'][name]['changed']:
+                owned_controls[action] += 1
+            else:
+                opposing[name].append(event['source'])
+            positives = [candidate for candidate in sorted(actions)
+                         if len(owned_support.get(candidate, ())) >= OMEGA_CRIT and
+                         owned_controls.get(candidate, 0) > 0]
+            if not opposing[name] and any(other != candidate for candidate in positives
+                                    for other in comparator):
+                eligible.append(name)
+            cells.append({'view': name,
+                          'omega_by_action': [{'action_nmu': list(candidate),
+                                               'omega': len(owned_support.get(candidate, ())),
+                                               'controls': owned_controls.get(candidate, 0)}
+                                              for candidate in sorted(actions)],
+                          'contradicting_sources': list(opposing[name]),
+                          'xi': 0})
+        result = ({'status': 'CRYSTAL', 'view': eligible[0]}
+                  if len(eligible) == 1 else
+                  {'status': 'REVOKED', 'view': None}
+                  if prior_crystal is not None and prior_crystal not in eligible else
+                  {'status': 'NO_PATH', 'view': None})
+        if result['status'] == 'CRYSTAL':
+            prior_crystal = result['view']
+            for cell in cells:
+                cell['xi'] = int(cell['view'] == result['view'])
+        phases.append({'event_index': index, 'source': event['source'],
+                       'comparator_actions': [list(candidate) for candidate in sorted(comparator)],
+                       'cells': cells, 'result': result})
+    return {'revision': REVISION, 'registry': REGISTRY_ID,
+            'events': list(events), 'phases': phases,
+            'result': copy.deepcopy(phases[-1]['result'])}
+
+
+class OwnedInterventionCorrespondence:
+    def __init__(self, events=None):
+        from tgi.cross_action_correspondence_check import verify
+        self._events = copy.deepcopy([] if events is None else events)
+        self._certificate = form(self._events)
+        if not verify(self._events, self._certificate):
+            raise ValueError('Invalid original raw correspondence history')
+
+    @property
+    def certificate(self):
+        return copy.deepcopy(self._certificate)
+
+    def observe(self, source, action, target_before, target_after, views):
+        event = _event(source, action, target_before, target_after, views)
+        if any(row['source'] == source for row in self._events):
+            raise ValueError('Duplicate original source')
+        from tgi.cross_action_correspondence_check import verify
+        child = type(self).__new__(type(self))
+        child._events = self._events + [event]
+        child._certificate = form(child._events)
+        if not verify(child._events, child._certificate):
+            raise ValueError('Invalid original raw correspondence history')
+        return child
+
+    def resolve(self):
+        return copy.deepcopy(self._certificate['result'])
+
+    def commit(self, path):
+        from tgi.cross_action_correspondence_check import verify
+        if not verify(self._events, self._certificate):
+            raise ValueError('Independent raw correspondence replay failed')
+        payload = {'revision': REVISION, 'registry': REGISTRY_ID,
+                   'events': self._events, 'certificate': self._certificate}
+        envelope = {'payload': payload, 'sha256': _sha(canonical(payload).encode('utf8'))}
+        data = canonical(envelope).encode('utf8')
+        destination = Path(path)
+        temporary = None
+        try:
+            with tempfile.NamedTemporaryFile(mode='wb', dir=destination.parent,
+                                             delete=False) as stream:
+                temporary = Path(stream.name)
+                stream.write(data)
+                stream.flush()
+                os.fsync(stream.fileno())
+            os.replace(temporary, destination)
+            temporary = None
+        finally:
+            if temporary is not None and temporary.exists():
+                temporary.unlink()
+        return {'path': str(destination), 'sha256': _sha(data), 'bytes': len(data)}
+
+    @classmethod
+    def recover(cls, path, expected_sha256):
+        from tgi.cross_action_correspondence_check import verify
+        if type(expected_sha256) is not str or re.fullmatch(r'[0-9a-f]{64}', expected_sha256) is None:
+            raise ValueError('External checkpoint digest required')
+        data = Path(path).read_bytes()
+        if _sha(data) != expected_sha256:
+            raise ValueError('Checkpoint digest mismatch')
+        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 checkpoint envelope')
+        payload = envelope['payload']
+        if (type(payload) is not dict or set(payload) != {'revision', 'registry',
+                'events', 'certificate'} or payload['revision'] != REVISION or
+                payload['registry'] != REGISTRY_ID or
+                _sha(canonical(payload).encode('utf8')) != envelope['sha256'] or
+                not verify(payload['events'], payload['certificate'])):
+            raise ValueError('Invalid raw correspondence checkpoint')
+        return cls(payload['events'])

tgi/cross_action_correspondence_check.py

@@ -0,0 +1,92 @@
+"""Independent one-pass replay of every original cross-action event and phase."""
+from tgi.frame_engine import canonical
+from tgi.identity import REGISTRY_ID, decode
+from tgi.organization import OMEGA_CRIT
+from tgi.intervention_edit_contrast_check import verify as verify_contrast
+
+REVISION = 'TGI-M1-CROSS-ACTION-PROFILE-RESEARCH-V3'
+
+
+def verify(events, certificate):
+    try:
+        if (type(events) is not list or type(certificate) is not dict or
+                set(certificate) != {'revision', 'registry', 'events', 'phases', 'result'} or
+                certificate['revision'] != REVISION or certificate['registry'] != REGISTRY_ID or
+                canonical(certificate['events']) != canonical(events) or
+                type(certificate['phases']) is not list or len(certificate['phases']) != len(events)):
+            return False
+        if not events:
+            return canonical(certificate['result']) == canonical({'status': 'NO_PATH', 'view': None})
+        names = None
+        sources = set()
+        actions = set()
+        comparator = set()
+        support = {}
+        controls = {}
+        contradictions = {}
+        prior_crystal = None
+        final_result = {'status': 'NO_PATH', 'view': None}
+        for index, event in enumerate(events):
+            if (type(event) is not dict or set(event) != {'source', 'action_nmu', 'target', 'views'} or
+                    type(event['source']) is not str or not event['source'] or event['source'] in sources or
+                    type(event['action_nmu']) is not list or not event['action_nmu'] or
+                    type(event['views']) is not dict or not verify_contrast(event['target'])):
+                return False
+            sources.add(event['source'])
+            decode(event['action_nmu'])
+            current_names = list(event['views'])
+            if (len(current_names) < 2 or current_names != sorted(current_names) or
+                    any(type(name) is not str or not name for name in current_names)):
+                return False
+            if names is None:
+                names = current_names
+                support = {name: {} for name in names}
+                controls = {name: {} for name in names}
+                contradictions = {name: [] for name in names}
+            elif current_names != names:
+                return False
+            action = tuple(event['action_nmu'])
+            actions.add(action)
+            target_changed = event['target']['kind'] != 'STABLE'
+            if not target_changed and any(view['kind'] != 'STABLE' for view in event['views'].values()):
+                comparator.add(action)
+            cells = []
+            eligible = []
+            for name in names:
+                view = event['views'][name]
+                if not verify_contrast(view):
+                    return False
+                view_changed = view['kind'] != 'STABLE'
+                if target_changed and view_changed:
+                    support[name].setdefault(action, set()).add(tuple(event['target']['before_nmu']))
+                elif not target_changed and not view_changed:
+                    controls[name][action] = controls[name].get(action, 0) + 1
+                if event['target']['changed'] != view['changed']:
+                    contradictions[name].append(event['source'])
+                counts = [{'action_nmu': list(candidate),
+                           'omega': len(support[name].get(candidate, ())),
+                           'controls': controls[name].get(candidate, 0)}
+                          for candidate in sorted(actions)]
+                positives = [tuple(row['action_nmu']) for row in counts
+                             if row['omega'] >= OMEGA_CRIT and row['controls']]
+                if not contradictions[name] and any(a != b for a in positives for b in comparator):
+                    eligible.append(name)
+                cells.append({'view': name, 'omega_by_action': counts, 'xi': 0,
+                              'contradicting_sources': list(contradictions[name])})
+            if len(eligible) == 1:
+                final_result = {'status': 'CRYSTAL', 'view': eligible[0]}
+                prior_crystal = eligible[0]
+                for cell in cells:
+                    cell['xi'] = int(cell['view'] == prior_crystal)
+            elif prior_crystal is not None and prior_crystal not in eligible:
+                final_result = {'status': 'REVOKED', 'view': None}
+            else:
+                final_result = {'status': 'NO_PATH', 'view': None}
+            expected = {'event_index': index, 'source': event['source'],
+                        'comparator_actions': [list(a) for a in sorted(comparator)],
+                        'cells': cells, 'result': final_result}
+            if canonical(certificate['phases'][index]) != canonical(expected):
+                return False
+        return canonical(certificate['result']) == canonical(final_result)
+    except (ValueError, TypeError, KeyError, IndexError, AttributeError):
+        return False

tgi/cross_view_identity_map.py

@@ -0,0 +1,41 @@
+from tgi.identity import encode,decode
+from tgi.incidence import _endpoint
+from tgi.organization import OMEGA_CRIT
+
+def _produce(m,query,budget):
+    q=encode(query)
+    if not q or m._dirty:raise ValueError('Invalid original scope')
+    sources=[];distinct=set()
+    for s,(frames,_) in sorted(m.episodes.items()):
+        budget.consume()
+        if not m._alive(s):raise ValueError('Broken original evidence')
+        if len(frames)!=2:raise ValueError('Paired views required')
+        distinct.add(frames[0]);sources.append(dict(source=s,occurrences=[_endpoint(m,s,(fi,0,len(f))) for fi,f in enumerate(frames)]))
+    alternatives=[]
+    for direction in (-1,1):
+        mapping={};inverse={};witnesses={};valid=True
+        for s,(frames,_) in sorted(m.episodes.items()):
+            budget.consume()
+            a,b=frames
+            if len(a)!=len(b):valid=False;break
+            for i,x in enumerate(a):
+                budget.consume()
+                j=i if direction==1 else len(a)-1-i;y=b[j]
+                if (x in mapping and mapping[x]!=y) or (y in inverse and inverse[y]!=x):valid=False;break
+                mapping[x]=y;inverse[y]=x;witnesses.setdefault((x,y),[]).append(dict(source=s,input_index=i,output_index=j))
+            if not valid:break
+        if valid:
+            for _ in q:budget.consume()
+            missing=sorted(set(q)-set(mapping));order=q if direction==1 else q[::-1]
+            alternatives.append(dict(direction=direction,mapping=[dict(input=x,output=y,witnesses=witnesses[x,y]) for x,y in sorted(mapping.items())],missing=missing,output=None if missing else decode(tuple(mapping[x] for x in order))))
+    outputs=sorted({c['output'] for c in alternatives if c['output'] is not None})
+    status='CONFLICT' if not alternatives else 'INCOMPLETE' if len(distinct)<OMEGA_CRIT else 'UNKNOWN_ID' if any(c['missing'] for c in alternatives) else 'AMBIGUOUS_OUTPUT' if len(outputs)!=1 else 'CONDITIONAL_OUTPUT'
+    return dict(query=query,sources=sources,diversity=len(distinct),alternatives=alternatives,outputs=outputs,status=status,output=outputs[0] if status=='CONDITIONAL_OUTPUT' else None)
+
+
+def certify_cross_view_identity_map(model,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='cross_view_identity_correspondence_v1',threshold=OMEGA_CRIT,**_produce(snapshot(model),query,budget))

tgi/cross_view_identity_map_check.py

@@ -0,0 +1,48 @@
+"""Independent full relation-set verifier for witnessed cross-view NMU maps."""
+from .identity import encode,decode
+from .organization import OMEGA_CRIT
+from .organization_snapshot import snapshot
+from .role_work import RoleSearchBudget
+from .frame_engine import canonical
+
+def _expected(m,query,budget):
+    q=encode(query)
+    if not q:raise ValueError('Nonempty query required')
+    sources=[];distinct=set()
+    for s,(frames,receipts) in sorted(m.episodes.items()):
+        budget.consume()
+        if len(frames)!=2 or not m._alive(s):raise ValueError('Invalid source')
+        distinct.add(frames[0]);points=[]
+        for fi,f in enumerate(frames):
+            origin=receipts[fi].origin;offset=sum(map(len,frames[:fi]))
+            points.append(dict(frame=fi,start=0,stop=len(f),event_span=[offset,offset+len(f)],identities=list(f),coordinates=[[origin[0]+i,*origin[1:]] for i in range(len(f))]))
+        sources.append(dict(source=s,occurrences=points))
+    alternatives=[]
+    for sign in (-1,1):
+        edges={};left={};right={};equal=True
+        for s,(frames,_) in sorted(m.episodes.items()):
+            budget.consume();a,b=frames
+            if len(a)!=len(b):equal=False;continue
+            for j,y in enumerate(b):
+                budget.consume();i=j if sign==1 else len(a)-1-j;x=a[i]
+                left.setdefault(x,set()).add(y);right.setdefault(y,set()).add(x)
+                edges.setdefault((x,y),[]).append(dict(source=s,input_index=i,output_index=j))
+        if not equal or any(len(v)!=1 for v in left.values()) or any(len(v)!=1 for v in right.values()):continue
+        mapping={x:next(iter(values)) for x,values in left.items()};missing=set();output=[]
+        for k in range(len(q)):
+            budget.consume();x=q[k if sign==1 else len(q)-1-k]
+            if x not in mapping:missing.add(x)
+            else:output.append(mapping[x])
+        alternatives.append(dict(direction=sign,mapping=[dict(input=x,output=y,witnesses=sorted(edges[x,y],key=lambda w:(w['source'],w['input_index']))) for x,y in sorted(mapping.items())],missing=sorted(missing),output=None if missing else decode(tuple(output))))
+    outputs=sorted({c['output'] for c in alternatives if c['output'] is not None})
+    status='CONFLICT' if not alternatives else 'INCOMPLETE' if len(distinct)<OMEGA_CRIT else 'UNKNOWN_ID' if any(c['missing'] for c in alternatives) else 'AMBIGUOUS_OUTPUT' if len(outputs)!=1 else 'CONDITIONAL_OUTPUT'
+    return dict(query=query,sources=sources,diversity=len(distinct),alternatives=alternatives,outputs=outputs,status=status,output=outputs[0] if status=='CONDITIONAL_OUTPUT' else None)
+
+def verify_cross_view_identity_map(model,query,certificate,*,max_search_steps=None):
+    budget=RoleSearchBudget(max_search_steps)
+    with budget.scope():
+        try:
+            if not isinstance(certificate,dict) or type(certificate.get('threshold')) is not int:return False
+            expected=dict(policy='cross_view_identity_correspondence_v1',threshold=OMEGA_CRIT,**_expected(snapshot(model),query,budget))
+            return canonical(certificate)==canonical(expected)
+        except (ValueError,TypeError,KeyError,IndexError,AttributeError):return False

tgi/derivation.py

@@ -0,0 +1,74 @@
+"""Interface for independently implemented TGI descendants.
+
+A contract declaration is not a mechanism audit or admission certificate.
+"""
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from enum import Enum
+from .events import Event
+from .identity import decode
+
+
+@dataclass(frozen=True)
+class DerivationContract:
+    name: str
+    revision: str
+    purpose: str
+    inherited_principles: str
+    formation_law: str
+    geometry_and_bonding_law: str
+    resolution_law: str
+    falsifiers: tuple[str, ...]
+
+    def __post_init__(self):
+        for field in (self.name, self.revision, self.purpose, self.inherited_principles,
+                      self.formation_law, self.geometry_and_bonding_law, self.resolution_law):
+            if not isinstance(field, str) or not field.strip():
+                raise ValueError("A derivation must state its complete working contract")
+        if not isinstance(self.falsifiers, tuple) or not self.falsifiers or any(
+                not isinstance(f, str) or not f.strip() for f in self.falsifiers):
+            raise ValueError("Explicit falsifiers are required")
+
+
+class ResolutionStatus(str, Enum):
+    RESOLVED = "resolved"
+    NO_PATH = "no_path"
+    AMBIGUOUS = "ambiguous"
+    CONFLICT = "conflict"
+    INCOMPLETE = "incomplete"
+
+
+@dataclass(frozen=True)
+class Resolution:
+    status: ResolutionStatus
+    output: tuple[int, ...] = ()
+    evidence: tuple[str, ...] = ()
+
+    def __post_init__(self):
+        if not isinstance(self.status, ResolutionStatus):
+            raise TypeError("Unknown resolution status")
+        if not isinstance(self.output, tuple) or not isinstance(self.evidence, tuple):
+            raise TypeError("Output and evidence must be immutable tuples")
+        decode(self.output)
+        if any(not isinstance(e, str) or not e.strip() for e in self.evidence):
+            raise ValueError("Evidence references must be nonempty strings")
+        if self.status is ResolutionStatus.RESOLVED:
+            if not self.evidence:
+                raise ValueError("Resolved output requires trace references")
+        elif self.output:
+            raise ValueError("An unresolved result cannot contain a final answer")
+
+
+class Derivation(ABC):
+    @property
+    @abstractmethod
+    def contract(self) -> DerivationContract:
+        """Return the independently specified mechanism contract."""
+
+    @abstractmethod
+    def observe(self, events: tuple[Event, ...]) -> None:
+        """Form organization through the descendant's derived native mechanism."""
+
+    @abstractmethod
+    def resolve(self, query: tuple[Event, ...]) -> Resolution:
+        """Resolve using the descendant's own geometric and crystallization laws."""

tgi/empirical_transport.py

@@ -0,0 +1,74 @@
+"""Set-valued raw-context transport from complete phase-valid organization."""
+from .identity import encode, decode
+from .organization import _match
+from .organization_snapshot import snapshot
+from .organization_inventory_check import verify_organization_inventory
+from .role_work import RoleSearchBudget
+
+
+def _query(domain, actions):
+    if not isinstance(domain, (list, tuple)) or not domain:
+        raise ValueError('Nonempty ordered context domain required')
+    contexts = []
+    for context in domain:
+        if not isinstance(context, (list, tuple)) or not context:
+            raise ValueError('Nonempty raw context frames required')
+        frames = tuple(encode(f) for f in context)
+        if any(not f for f in frames) or frames in contexts:
+            raise ValueError('Empty frame or duplicate context')
+        contexts.append(frames)
+    if not isinstance(actions, (list, tuple)) or not actions:
+        raise ValueError('Nonempty raw action inventory required')
+    raw_actions = tuple(encode(a) for a in actions)
+    if any(not a for a in raw_actions) or len(set(raw_actions)) != len(raw_actions):
+        raise ValueError('Empty or duplicate action')
+    return tuple(contexts), raw_actions
+
+
+def certify_empirical_transport(model, domain, actions, *, max_search_steps=None):
+    budget = RoleSearchBudget(max_search_steps)
+    with budget.scope():
+        contexts, raw_actions = _query(domain, actions)
+        view = snapshot(model)
+        if not verify_organization_inventory(view):
+            raise ValueError('Incomplete or broken operator-experience inventory')
+        rows = []
+        for action in raw_actions:
+            for index, context in enumerate(contexts):
+                prefix = context + (action,)
+                outcomes = {}; unbound = set(); revoked = []
+                for anchor, h in sorted(view.organizations.items()):
+                    budget.consume()
+                    if len(prefix) >= len(h.pattern):
+                        continue
+                    for bindings, _ in _match(h.pattern, prefix):
+                        if not view._phase_valid(h):
+                            raise ValueError('Broken operator phase')
+                        if set(bindings) != set(range(len(h.diversity))):
+                            unbound.add(anchor); continue
+                        output = tuple(tuple(i for k, v in parts for i in
+                                             (v if k == 'lit' else bindings[v]))
+                                       for parts in h.pattern[len(prefix):])
+                        outcomes.setdefault(output, set()).add(anchor)
+                for anchor, (h, _) in sorted(view.rejected_organizations.items()):
+                    budget.consume()
+                    if len(prefix) < len(h.pattern) and _match(h.pattern, prefix):
+                        revoked.append(anchor)
+                is_open = not outcomes or bool(unbound or revoked)
+                outputs = [{'frames': list(map(decode, out)),
+                            'witnesses': [{'anchor': a, 'sources': list(view.organizations[a].supports)}
+                                          for a in sorted(anchors)]}
+                           for out, anchors in sorted(outcomes.items())]
+                edges = [j for j, destination in enumerate(contexts) if destination in outcomes]
+                outside = [list(map(decode, out)) for out in sorted(outcomes) if out not in contexts]
+                rows.append({'action': decode(action), 'from_context': index, 'outputs': outputs,
+                             'supported_edges': edges, 'outside_domain': outside,
+                             'unbound': sorted(unbound), 'revoked': revoked, 'open': is_open,
+                             'possible_edges': list(range(len(contexts))) if is_open else edges,
+                             'unknown_outside_domain': is_open})
+        return {'policy': 'empirical_context_transport_v1',
+                'domain': [list(map(decode, c)) for c in contexts],
+                'actions': list(map(decode, raw_actions)),
+                'sources': [{'source': s, 'frames': list(map(decode, frames))}
+                            for s, (frames, _) in sorted(view.episodes.items())],
+                'rows': rows}

tgi/empirical_transport_check.py

@@ -0,0 +1,78 @@
+"""Independent full-inventory checker; no transport producer or resolver calls."""
+from .identity import encode, decode
+from .organization import _match
+from .organization_snapshot import snapshot
+from .organization_inventory_check import verify_organization_inventory
+from .frame_engine import canonical
+from .role_work import RoleSearchBudget
+
+
+def verify_empirical_transport(model, certificate, *, max_search_steps=None):
+    budget = RoleSearchBudget(max_search_steps)
+    with budget.scope():
+        try:
+            if set(certificate) != {'policy', 'domain', 'actions', 'sources', 'rows'}:
+                return False
+            if certificate['policy'] != 'empirical_context_transport_v1': return False
+            domain = certificate['domain']; actions = certificate['actions']
+            if not isinstance(domain, list) or not domain or not isinstance(actions, list) or not actions:
+                return False
+            raw_domain = []
+            for context in domain:
+                if not isinstance(context, list) or not context: return False
+                item = tuple(encode(f) for f in context)
+                if any(not f for f in item) or item in raw_domain: return False
+                raw_domain.append(item)
+            raw_actions = [encode(a) for a in actions]
+            if any(not a for a in raw_actions) or len(set(raw_actions)) != len(raw_actions): return False
+            view = snapshot(model)
+            if not verify_organization_inventory(view): return False
+            sources = [{'source': s, 'frames': [decode(f) for f in frames]}
+                       for s, (frames, _) in sorted(view.episodes.items())]
+            if canonical(sources) != canonical(certificate['sources']): return False
+            expected = []
+            for action in raw_actions:
+                for origin in range(len(raw_domain)):
+                    trigger = raw_domain[origin] + (action,)
+                    supported = {}; partial = []; rejected = []
+                    for anchor in sorted(view.organizations):
+                        budget.consume(); org = view.organizations[anchor]
+                        if len(org.pattern) <= len(trigger): continue
+                        bindings = _match(org.pattern, trigger)
+                        if bindings and not view._phase_valid(org): return False
+                        incomplete = False
+                        for assignment, _ in bindings:
+                            if sorted(assignment) != list(range(len(org.diversity))):
+                                incomplete = True; continue
+                            result = []
+                            for frame in org.pattern[len(trigger):]:
+                                chars = []
+                                for kind, value in frame:
+                                    if kind == 'lit': chars.extend(value)
+                                    else: chars.extend(assignment[value])
+                                result.append(tuple(chars))
+                            supported.setdefault(tuple(result), set()).add(anchor)
+                        if incomplete: partial.append(anchor)
+                    for anchor in sorted(view.rejected_organizations):
+                        budget.consume(); org = view.rejected_organizations[anchor][0]
+                        if len(org.pattern) > len(trigger) and _match(org.pattern, trigger): rejected.append(anchor)
+                    outputs = []
+                    for frames in sorted(supported):
+                        witnesses = []
+                        for anchor in sorted(supported[frames]):
+                            witnesses.append({'anchor': anchor, 'sources': list(view.organizations[anchor].supports)})
+                        outputs.append({'frames': [decode(f) for f in frames], 'witnesses': witnesses})
+                    edges = []; outside = []
+                    for frames in sorted(supported):
+                        if frames in raw_domain: edges.append(raw_domain.index(frames))
+                        else: outside.append([decode(f) for f in frames])
+                    edges.sort()
+                    open_row = len(outputs) == 0 or len(partial) > 0 or len(rejected) > 0
+                    expected.append({'action': decode(action), 'from_context': origin, 'outputs': outputs,
+                                     'supported_edges': edges, 'outside_domain': outside,
+                                     'unbound': partial, 'revoked': rejected, 'open': open_row,
+                                     'possible_edges': list(range(len(raw_domain))) if open_row else edges,
+                                     'unknown_outside_domain': open_row})
+            return canonical(expected) == canonical(certificate['rows'])
+        except (ValueError, TypeError, KeyError, IndexError, AttributeError):
+            return False

tgi/events.py

@@ -0,0 +1,36 @@
+"""Occurrences retain a static identity and an independent causal position."""
+from dataclasses import dataclass
+from .identity import encode, validate_identity
+
+
+@dataclass(frozen=True, slots=True)
+class Event:
+    stream_id: str
+    position: int
+    identity: int
+
+    def __post_init__(self):
+        if not isinstance(self.stream_id, str) or not self.stream_id:
+            raise ValueError("A stream requires a nonempty provenance identifier")
+        if type(self.position) is not int or self.position < 0:
+            raise ValueError("Position must be a nonnegative integer")
+        validate_identity(self.identity)
+
+
+class EventStream:
+    def __init__(self, stream_id: str):
+        if not isinstance(stream_id, str) or not stream_id:
+            raise ValueError("A stream requires a nonempty provenance identifier")
+        self._stream_id = stream_id
+        self._position = 0
+
+    @property
+    def position(self) -> int:
+        return self._position
+
+    def feed(self, text: str) -> tuple[Event, ...]:
+        identities = encode(text)  # Validate the complete chunk before advancing state.
+        events = tuple(Event(self._stream_id, self._position + i, identity)
+                       for i, identity in enumerate(identities))
+        self._position += len(events)
+        return events

tgi/evidence_response.py

@@ -0,0 +1,24 @@
+"""Combine certified observations and inference at the already selected state."""
+from .role_response_check import verify_role_response
+from .observed_response import certify_observed_response
+
+
+def certify_evidence_response(model,role,history,inference):
+    if not verify_role_response(model,role,history,inference):raise ValueError('Invalid temporal inference')
+    temporal=inference['temporal'];rows=[];values=[]
+    for response in inference['responses']:
+        index=response['window'];window=temporal['windows'][index]
+        prefix=temporal['readouts'][window['readout']]['prefix']+[temporal['query']]
+        observed=certify_observed_response(model,prefix);actual=observed['result'];predicted=response['resolution']
+        value=[];basis='unresolved'
+        if actual['status']=='OBSERVED_CONFLICT':basis='observed_conflict'
+        elif actual['status']=='OBSERVED_AGREEMENT':
+            if predicted['status']=='RESOLVED' and predicted['output']!=actual['output']:basis='evidence_conflict'
+            else:value=actual['output'];basis='observed'
+        elif predicted['status']=='RESOLVED':value=predicted['output'];basis='inferred'
+        rows.append({'window':index,'observed':observed,'basis':basis,'output':value})
+        values.append(value)
+    available=bool(values) and all(values) and all(value==values[0] for value in values) and not inference['result']['blockers']
+    return {'inference':inference,'contexts':rows,'result':{
+        'status':'CONDITIONAL_RESPONSE' if available else 'UNRESOLVED','output':values[0] if available else [],
+        'conditions':list(inference['result']['conditions'])}}