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

tgi/__init__.py

@@ -0,0 +1,7 @@
+"""TGI foundation. No crystallization or capability claim is made by this package."""
+from .identity import REGISTRY_ID, encode, decode
+from .events import Event, EventStream
+from .derivation import Derivation, DerivationContract, Resolution, ResolutionStatus
+
+__all__ = ["REGISTRY_ID", "encode", "decode", "Event", "EventStream",
+           "Derivation", "DerivationContract", "Resolution", "ResolutionStatus"]

tgi/__main__.py

@@ -0,0 +1,194 @@
+import argparse
+import json
+from pathlib import Path
+from .identity import REGISTRY_ID, encode
+from .provenance import verify_sources
+
+
+def main():
+    parser = argparse.ArgumentParser(description="TGI foundation inspection")
+    subs = parser.add_subparsers(dest="command", required=True)
+    enc = subs.add_parser("encode", help="Inspect static NMU identities")
+    enc.add_argument("text")
+    check = subs.add_parser("verify-sources", help="Check source integrity")
+    check.add_argument("--root", type=Path, default=Path.cwd())
+    form = subs.add_parser("inspect-formation", help="Inspect experimental causal chart; not semantic resolution")
+    form.add_argument("text")
+    learn = subs.add_parser("relation-learn", help="Experimental affine lattice candidate, not free-language learning")
+    learn.add_argument("--input", type=Path, required=True)
+    learn.add_argument("--state", type=Path, required=True)
+    query = subs.add_parser("relation-query", help="Certified consequence within the affine measurement contract")
+    query.add_argument("--state", type=Path, required=True)
+    query.add_argument("--context", required=True)
+    query.add_argument("--point", nargs=5, type=int, required=True)
+    inspect = subs.add_parser("relation-inspect", help="Inspect experimental C/L, Omega, xi, and relation anchor")
+    inspect.add_argument("--state", type=Path, required=True)
+    inspect.add_argument("--context", required=True)
+    ingest = subs.add_parser("ingest", help="Crystallize framed character experiences under the user acceptance contract")
+    ingest.add_argument("--input",type=Path,required=True)
+    ingest.add_argument("--state",type=Path,required=True)
+    fq = subs.add_parser("query", help="Traverse committed crystal atoms with trigger and anchor")
+    fq.add_argument("--state",type=Path,required=True)
+    fq.add_argument("--trigger",required=True)
+    fq.add_argument("--anchor",type=int,required=True)
+    fq.add_argument("--max-new",type=int)
+    fi = subs.add_parser("inspect", help="Inspect committed frame crystal state and C/L evidence")
+    fi.add_argument("--state",type=Path,required=True)
+    fi.add_argument("--anchor",type=int)
+    tl = subs.add_parser("transport-learn", help="Experimental paired-path learning; explicit operator family")
+    tl.add_argument("--input", type=Path, required=True)
+    tl.add_argument("--state", type=Path, required=True)
+    tq = subs.add_parser("transport-query", help="Resolve a source-absent path with character provenance")
+    tq.add_argument("--state", type=Path, required=True)
+    tq.add_argument("--context", required=True)
+    tq.add_argument("--text", required=True)
+    ti = subs.add_parser("transport-inspect", help="Inspect transport hypotheses and evidence")
+    ti.add_argument("--state", type=Path, required=True)
+    ti.add_argument("--context", required=True)
+    tc = subs.add_parser("transport-compose", help="Compose an explicit sequence of learned relations")
+    tc.add_argument("--state", type=Path, required=True)
+    tc.add_argument("--contexts", nargs="+", required=True)
+    tc.add_argument("--text", required=True)
+    el = subs.add_parser("experience-learn", help="Ingest grounding, facts, and controlled intervention events")
+    el.add_argument("--input", type=Path, required=True)
+    el.add_argument("--state", type=Path, required=True)
+    eq = subs.add_parser("experience-ask", help="Resolve a raw question through grounded crystal relations")
+    eq.add_argument("--state", type=Path, required=True)
+    eq.add_argument("--text", required=True)
+    eq.add_argument("--world", default="default")
+    ei = subs.add_parser("experience-inspect", help="Inspect grounded schemas and intervention models")
+    ei.add_argument("--state", type=Path, required=True)
+    ep = subs.add_parser("experience-predict", help="Predict a measured action under its stated condition")
+    ep.add_argument("--state", type=Path, required=True)
+    ep.add_argument("--action", required=True)
+    ep.add_argument("--before", required=True, help="JSON sensor state")
+    ep.add_argument("--condition", default="default")
+    ep.add_argument("--world", default="default")
+    eg = subs.add_parser("experience-plan", help="Find an action path to a goal without a supplied action sequence")
+    eg.add_argument("--state", type=Path, required=True)
+    eg.add_argument("--before", required=True, help="JSON sensor state")
+    eg.add_argument("--goal", required=True, help="JSON goal sensor subset")
+    eg.add_argument("--condition", default="default")
+    eg.add_argument("--world", default="default")
+    eg.add_argument("--max-depth", type=int, default=16)
+    eg.add_argument("--max-states", type=int, default=10000)
+    ex = subs.add_parser("experience-propose", help="Propose unmeasured intervention contrasts without supplying outcomes")
+    ex.add_argument("--state", type=Path, required=True)
+    ex.add_argument("--action", required=True)
+    ex.add_argument("--domains", required=True, help="JSON mapping sensor names to available values")
+    ex.add_argument("--condition", default="default")
+    ex.add_argument("--world", default="default")
+    ex.add_argument("--limit", type=int, default=16)
+    eu = subs.add_parser("experience-upgrade", help="Replay a V1 journal with corrected guard derivation into a new checkpoint")
+    eu.add_argument("--input", type=Path, required=True)
+    eu.add_argument("--state", type=Path, required=True)
+    rl = subs.add_parser("raw-learn", help="Form organizations from ordered raw character episodes")
+    rl.add_argument("--input", type=Path, required=True)
+    rl.add_argument("--state", type=Path, required=True)
+    rq = subs.add_parser("raw-ask", help="Resolve a raw question against observed episode prefixes")
+    rq.add_argument("--state", type=Path, required=True)
+    rq.add_argument("--text", required=True)
+    rr = subs.add_parser("raw-resolve", help="Continue an ordered raw episode prefix")
+    rr.add_argument("--state", type=Path, required=True)
+    rr.add_argument("--frames", required=True, help="JSON array of raw frames")
+    rr.add_argument("--max-verification-match-steps", type=int, default=None, help="Optional ceiling on verifier matcher states; not query generation")
+    ri = subs.add_parser("raw-inspect", help="Inspect raw organization anchors and source support")
+    ri.add_argument("--state", type=Path, required=True)
+    rc = subs.add_parser("raw-reason", help="Resolve certified closure across raw episode organizations")
+    rc.add_argument("--state", type=Path, required=True)
+    rc.add_argument("--text", required=True)
+    rc.add_argument("--max-nodes", type=int, default=1024)
+    rc.add_argument("--max-work", type=int, default=1000000)
+    ru = subs.add_parser("raw-upgrade", help="Explicitly replay V1 raw evidence under phase V2 into a new checkpoint")
+    ru.add_argument("--input", type=Path, required=True)
+    ru.add_argument("--state", type=Path, required=True)
+    rx = subs.add_parser("raw-incidence", help="Trace phase-bound links between observed axis occurrences")
+    rx.add_argument("--state", type=Path, required=True)
+    rx.add_argument("--source", required=True)
+    rx.add_argument("--frame", type=int, required=True)
+    rx.add_argument("--start", type=int, required=True)
+    rx.add_argument("--stop", type=int, required=True)
+    rx.add_argument("--direction", choices=("all","forward","backward"), default="all")
+    ry = subs.add_parser("raw-correspondence", help="Trace witnessed axis correspondence between organizations")
+    ry.add_argument("--state", type=Path, required=True)
+    ry.add_argument("--left", required=True)
+    ry.add_argument("--axis", type=int, required=True)
+    ry.add_argument("--right", required=True)
+    for raw_parser in (rl, rq, rr, ri, rc, ru, rx, ry):
+        raw_parser.add_argument("--max-formation-steps", type=int, default=None,
+                                help="Ceiling on formation candidate enumeration; not a wall-clock timeout")
+    args = parser.parse_args()
+    if args.command.startswith("raw-"):
+        from .organization_cli import run
+        try:
+            print(json.dumps(run(args), ensure_ascii=True))
+        except (ValueError, TypeError, OSError, KeyError) as error:
+            parser.error(str(error))
+        return 0
+    if args.command.startswith("experience-"):
+        from .experience_cli import run
+        try:
+            print(json.dumps(run(args), ensure_ascii=True))
+        except (ValueError, TypeError, OSError) as error:
+            parser.error(str(error))
+        return 0
+    if args.command.startswith("transport-"):
+        from .transport_cli import run
+        try:
+            print(json.dumps(run(args), ensure_ascii=True))
+        except (ValueError, TypeError, OSError) as error:
+            parser.error(str(error))
+        return 0
+    if args.command in ("ingest","query","inspect"):
+        from .frame_cli import run
+        try:
+            print(json.dumps(run(args),ensure_ascii=True))
+        except (ValueError,TypeError,OSError) as error:
+            parser.error(str(error))
+        return 0
+    if args.command.startswith("relation-"):
+        from .relational import RelationalEngine,unique_object
+        if args.command == "relation-learn":
+            engine = RelationalEngine.load(args.state) if args.state.exists() else RelationalEngine()
+            for line in args.input.read_text(encoding="utf8").splitlines():
+                if not line.strip():
+                    continue
+                entry = json.loads(line,object_pairs_hook=unique_object)
+                if not isinstance(entry,dict) or set(entry)!={"source_id","raw"}:
+                    raise ValueError("Each JSONL entry must contain exactly source_id and raw")
+                engine.observe(entry["raw"],entry["source_id"])
+            engine.save(args.state)
+            contexts = sorted({m.context for m in engine.measurements()})
+            print(json.dumps({"scope":"experimental_affine_lattice", "sources":len(engine.measurements()),
+                              "contexts":{c:engine.inspect(c) for c in contexts}},ensure_ascii=True))
+            return 0
+        engine = RelationalEngine.load(args.state)
+        if args.command == "relation-inspect":
+            print(json.dumps(engine.inspect(args.context),ensure_ascii=True))
+            return 0
+        print(json.dumps(engine.resolve(args.context,args.point).as_dict(),ensure_ascii=True))
+        return 0
+    if args.command == "encode":
+        print(json.dumps({"registry": REGISTRY_ID, "identities": encode(args.text)}, ensure_ascii=True))
+        return 0
+    if args.command == "inspect-formation":
+        from dataclasses import asdict
+        from .events import EventStream
+        from .formation import CausalFormation
+        model = CausalFormation()
+        records = model.observe(EventStream("cli").feed(args.text))
+        print(json.dumps({"candidate": "TGI-CAUSAL-RECURRENCE-5D-V1",
+                          "scope": "causal_chart_only", "semantic_admission": False,
+                          "records": [asdict(r) for r in records],
+                          "bond_count": len(model.geometry_snapshot()[0]),
+                          "closure_count": len(model.geometry_snapshot()[1])}, ensure_ascii=True))
+        return 0
+    manifest = json.loads((args.root / "contracts/source_manifest.json").read_text(encoding="utf8"))
+    failures = verify_sources(args.root, manifest)
+    print(json.dumps({"source_count": len(manifest["sources"]), "mismatches": failures,
+                      "scope": "source_integrity_only"}, ensure_ascii=True))
+    return int(bool(failures))
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

tgi/acquisition_history.py

@@ -0,0 +1,45 @@
+"""Complete conditional histories over recorded discrete occurrences."""
+from .identity import decode
+from .incidence import _endpoint
+from .organization_snapshot import snapshot
+from .separation_check import verify_separating_requests
+
+
+def _choices(plan,live):
+    choices={}
+    for row in plan['requests']:
+        groups={tuple(g['value']):set(g['contexts'])&live for g in row['responses']}
+        groups={value:ids for value,ids in groups.items() if ids}
+        covered=set().union(*groups.values()) if groups else set()
+        if len(live)>1 and covered==live and all(len(ids)<len(live) for ids in groups.values()):
+            choices[row['query']]=groups
+    return choices
+
+
+def certify_acquisition_history(model,plan,acquisition,source,boundaries):
+    if not verify_separating_requests(model,plan):raise ValueError('Invalid model plan')
+    view=snapshot(acquisition)
+    if not isinstance(source,str) or not source:raise ValueError('Source required')
+    frames=view.episodes[source][0]
+    if (not isinstance(boundaries,(list,tuple)) or len(boundaries)<2 or
+        any(type(x) is not int for x in boundaries) or boundaries[0]!=0 or
+        boundaries[-1]!=len(frames) or any(b-a<2 for a,b in zip(boundaries,boundaries[1:]))):
+        raise ValueError('Intervals must cover the entire source in order')
+    if not view._alive(source):raise ValueError('Broken acquisition evidence')
+    live=set(range(len(plan['contexts'])));events=[];status='OBSERVED'
+    for step,(start,stop) in enumerate(zip(boundaries,boundaries[1:])):
+        request=decode(frames[start]);observed=[decode(f) for f in frames[start+1:stop]]
+        before=sorted(live);choices=_choices(plan,live)
+        if step==0:
+            if request!=plan['request'] or observed!=plan['observed']:raise ValueError('Initial observation differs from plan')
+        else:
+            if request not in choices:raise ValueError('Request does not separate current contexts')
+            live=choices[request].get(tuple(observed),set())
+            status='REFINED' if live else 'UNMODELED_RESPONSE'
+            if not live and step!=len(boundaries)-2:raise ValueError('History continues beyond unmodeled feedback')
+        events.append({'request':request,'observed':observed,'before':before,'after':sorted(live),
+                       'admissible':sorted(choices),
+                       'occurrences':[_endpoint(view,source,(i,0,len(frames[i]))) for i in range(start,stop)]})
+    return {'plan':plan,'source':source,'boundaries':list(boundaries),'events':events,
+            'result':{'status':status,'context_indexes':sorted(live),
+                      'contexts':[plan['contexts'][i] for i in sorted(live)],'next_requests':sorted(_choices(plan,live))}}

tgi/acquisition_history_check.py

@@ -0,0 +1,51 @@
+"""Independent history coverage and conditional intersection verification."""
+from .identity import decode
+from .organization_snapshot import snapshot
+from .separation_check import verify_separating_requests
+from .frame_engine import canonical
+
+
+def verify_acquisition_history(model,acquisition,certificate):
+    try:
+        if set(certificate)!={'plan','source','boundaries','events','result'}:return False
+        plan=certificate['plan']
+        if not verify_separating_requests(model,plan):return False
+        view=snapshot(acquisition);source=certificate['source']
+        if not isinstance(source,str) or not source or not view._alive(source):return False
+        frames,receipts=view.episodes[source];bounds=certificate['boundaries']
+        if (not isinstance(bounds,list) or len(bounds)<2 or any(type(x) is not int for x in bounds)
+            or bounds[0]!=0 or bounds[-1]!=len(frames) or any(b-a<2 for a,b in zip(bounds,bounds[1:]))):return False
+        if len(certificate['events'])!=len(bounds)-1:return False
+        live=list(range(len(plan['contexts'])));status='OBSERVED'
+
+        def choices(indexes):
+            admitted={}
+            if len(indexes)<2:return admitted
+            for row in plan['requests']:
+                alternatives={};covered=set()
+                for g in row['responses']:
+                    retained=[i for i in indexes if i in g['contexts']]
+                    if retained:alternatives[tuple(g['value'])]=retained;covered.update(retained)
+                if covered==set(indexes) and all(len(ids)<len(indexes) for ids in alternatives.values()):admitted[row['query']]=alternatives
+            return admitted
+
+        for step,row in enumerate(certificate['events']):
+            start,stop=bounds[step:step+2];request=decode(frames[start]);observed=[decode(f) for f in frames[start+1:stop]]
+            before=list(live);allowed=choices(live)
+            if step==0:
+                if request!=plan['request'] or observed!=plan['observed']:return False
+            else:
+                if request not in allowed:return False
+                live=allowed[request].get(tuple(observed),[])
+                status='REFINED' if live else 'UNMODELED_RESPONSE'
+                if not live and step!=len(bounds)-2:return False
+            occurrences=[]
+            for i in range(start,stop):
+                offset=sum(map(len,frames[:i]));size=len(frames[i]);origin=receipts[i].origin
+                occurrences.append({'frame':i,'start':0,'stop':size,'event_span':[offset,offset+size],
+                                    'identities':list(frames[i]),'coordinates':[[origin[0]+j,*origin[1:]] for j in range(size)]})
+            expected={'request':request,'observed':observed,'before':before,'after':live,'admissible':sorted(allowed),'occurrences':occurrences}
+            if canonical(row)!=canonical(expected):return False
+        expected={'status':status,'context_indexes':live,'contexts':[plan['contexts'][i] for i in live],'next_requests':sorted(choices(live))}
+        return canonical(certificate['result'])==canonical(expected)
+    except (KeyError,IndexError,TypeError,ValueError,AttributeError):return False

tgi/acquisition_monitor.py

@@ -0,0 +1,66 @@
+"""Stationary candidate monitoring over complete recorded acquisition histories."""
+from copy import deepcopy
+from tgi.identity import decode
+from tgi.organization_snapshot import snapshot
+from tgi.separation_check import verify_separating_requests
+
+def _monitor(model, plan, acquisition, source, boundaries, budget):
+    model = snapshot(model)
+    plan = deepcopy(plan)
+    if not verify_separating_requests(model, plan):
+        raise ValueError('Invalid external plan')
+    view = snapshot(acquisition)
+    if not isinstance(source, str) or not source or source not in view.episodes:
+        raise ValueError('Missing acquisition source')
+    scope = []
+    for sid, (raw, _) in sorted(view.episodes.items()):
+        budget.consume()
+        if not view._alive(sid):
+            raise ValueError('Broken acquisition evidence')
+        scope.append(dict(source=sid, frames=list(map(decode, raw))))
+    frames, receipts = view.episodes[source]
+    if not isinstance(boundaries, (list, tuple)) or len(boundaries) < 2 or any((type(x) is not int for x in boundaries)) or (boundaries[0] != 0) or (boundaries[-1] != len(frames)) or any((b - a < 2 for a, b in zip(boundaries, boundaries[1:]))):
+        raise ValueError('Boundaries must cover every source frame')
+    offsets = [0]
+    for frame in frames:
+        budget.consume()
+        offsets.append(offsets[-1] + len(frame))
+    universe = set(range(len(plan['contexts'])))
+    possible, definite = (set(universe), set(universe))
+    events = []
+    for step, (start, stop) in enumerate(zip(boundaries, boundaries[1:])):
+        budget.consume()
+        request = decode(frames[start])
+        observed = list(map(decode, frames[start + 1:stop]))
+        if step == 0:
+            if request != plan['request'] or observed != plan['observed']:
+                raise ValueError('Initial observation differs from external plan')
+            supported, unknown = (set(universe), set())
+        else:
+            row = next((r for r in plan['requests'] if r['query'] == request), None)
+            groups = row['responses'] if row else []
+            covered = set().union(*(set(g['contexts']) for g in groups))
+            supported = set().union(*(set(g['contexts']) for g in groups if g['value'] == observed))
+            unknown = universe - covered
+            possible &= supported | unknown
+            definite &= supported
+        points = []
+        for i in range(start, stop):
+            budget.consume()
+            origin = receipts[i].origin
+            n = len(frames[i])
+            points.append(dict(frame=i, start=0, stop=n,
+                               event_span=[offsets[i], offsets[i+1]],
+                               identities=list(frames[i]),
+                               coordinates=[[origin[0]+j, *origin[1:]] for j in range(n)]))
+        events.append(dict(request=request, observed=observed, supported=sorted(supported), unknown=sorted(unknown), possible=sorted(possible), definite=sorted(definite), occurrences=points))
+    status = 'CONTRADICTED' if not possible else 'INCOMPLETE' if possible != definite else 'CONSISTENT'
+    return dict(policy='stationary_acquisition_monitor_v1', plan=plan, source=source, scope=scope, boundaries=list(boundaries), events=events, result=dict(status=status, possible=sorted(possible), definite=sorted(definite)))
+
+from tgi.role_work import RoleSearchBudget
+
+def certify_acquisition_monitor(model, plan, acquisition, source, boundaries, *, max_search_steps=None):
+    budget = RoleSearchBudget(max_search_steps)
+    with budget.scope():
+        budget.consume()
+        return _monitor(model, plan, acquisition, source, boundaries, budget)

tgi/acquisition_monitor_check.py

@@ -0,0 +1,78 @@
+"""Independent candidate-wise verification, never invokes monitor producer."""
+from tgi.identity import decode
+from tgi.frame_engine import canonical
+from tgi.organization_snapshot import snapshot
+from tgi.separation_check import verify_separating_requests
+
+def _verify_monitor(model, plan, acquisition, source, boundaries, c, budget):
+    try:
+        if not isinstance(c, dict) or set(c) != {'policy', 'plan', 'source', 'scope', 'boundaries', 'events', 'result'}:
+            return False
+        if c['policy'] != 'stationary_acquisition_monitor_v1' or c['source'] != source or canonical(c['plan']) != canonical(plan):
+            return False
+        model = snapshot(model)
+        if not verify_separating_requests(model, plan):
+            return False
+        a = snapshot(acquisition)
+        if not isinstance(source, str) or not source or source not in a.episodes:
+            return False
+        scope = []
+        for sid, (raw, _) in sorted(a.episodes.items()):
+            budget.consume()
+            if not a._alive(sid):
+                return False
+            scope.append(dict(source=sid, frames=list(map(decode, raw))))
+        if canonical(c['scope']) != canonical(scope):
+            return False
+        frames, receipts = a.episodes[source]
+        if not isinstance(boundaries, (list, tuple)) or len(boundaries) < 2 or any((type(x) is not int for x in boundaries)) or (boundaries[0] != 0) or (boundaries[-1] != len(frames)) or any((b - a < 2 for a, b in zip(boundaries, boundaries[1:]))):
+            return False
+        if canonical(c['boundaries']) != canonical(list(boundaries)) or not isinstance(c['events'], list) or len(c['events']) != len(boundaries) - 1:
+            return False
+        verdicts = [[0, 0] for _ in plan['contexts']]
+        offset = 0
+        for step, (lo, hi) in enumerate(zip(boundaries, boundaries[1:])):
+            budget.consume()
+            query = decode(frames[lo])
+            observed = [decode(frames[i]) for i in range(lo + 1, hi)]
+            supported = []
+            unknown = []
+            if step == 0:
+                if query != plan['request'] or observed != plan['observed']:
+                    return False
+                supported = list(range(len(verdicts)))
+            else:
+                for index, history in enumerate(verdicts):
+                    budget.consume()
+                    values = [g['value'] for row in plan['requests'] if row['query'] == query for g in row['responses'] if index in g['contexts']]
+                    if not values:
+                        unknown.append(index)
+                        history[1] += 1
+                    elif observed in values:
+                        supported.append(index)
+                    else:
+                        history[0] += 1
+            possible = [i for i, vs in enumerate(verdicts) if vs[0] == 0]
+            definite = [i for i, vs in enumerate(verdicts) if vs == [0, 0]]
+            points = []
+            for i in range(lo, hi):
+                budget.consume()
+                n = len(frames[i])
+                origin = receipts[i].origin
+                points.append(dict(frame=i, start=0, stop=n, event_span=[offset, offset + n], identities=list(frames[i]), coordinates=[[origin[0] + j, *origin[1:]] for j in range(n)]))
+                offset += n
+            expected = dict(request=query, observed=observed, supported=supported, unknown=unknown, possible=possible, definite=definite, occurrences=points)
+            if canonical(c['events'][step]) != canonical(expected):
+                return False
+        status = 'CONTRADICTED' if not possible else 'INCOMPLETE' if possible != definite else 'CONSISTENT'
+        return canonical(c['result']) == canonical(dict(status=status, possible=possible, definite=definite))
+    except (ValueError, TypeError, KeyError, IndexError, AttributeError):
+        return False
+
+from tgi.role_work import RoleSearchBudget
+
+def verify_acquisition_monitor(model, plan, acquisition, source, boundaries, certificate, *, max_search_steps=None):
+    budget = RoleSearchBudget(max_search_steps)
+    with budget.scope():
+        budget.consume()
+        return _verify_monitor(model, plan, acquisition, source, boundaries, certificate, budget)

tgi/acquisition_projection.py

@@ -0,0 +1,70 @@
+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);valid=True
+            for u,v,_,_ in a['positions']:
+                budget.consume()
+                if u in mapping and mapping[u]!=v:valid=False;break
+                mapping[u]=v
+            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]
+            fibers={}
+            for u,v in sorted(mapping.items()):budget.consume();fibers.setdefault(v,[]).append(u)
+            outcomes.append(dict(direction=direction,terminal=terminal,count=node['count'],inverse_fibers=[dict(output=v,inputs=us) for v,us in sorted(fibers.items())],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_acquisition_projection(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='acquisition_projection_v1',threshold=OMEGA_CRIT,**_produce(snapshot(model),[dict(r) for r in measurements],list(left) if isinstance(left,list) else left,list(right) if isinstance(right,list) else right,query,budget))

tgi/acquisition_projection_check.py

@@ -0,0 +1,93 @@
+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):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):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_acquisition_projection(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']!='acquisition_projection_v1' or type(c['threshold']) is not int or c['threshold']!=OMEGA_CRIT:return False
+        m=snapshot(model);q=encode(query);measurements=[dict(r) for r in measurements];left=list(left) if isinstance(left,list) else left;right=list(right) if isinstance(right,list) else right
+        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])
+                fibers={}
+                for u,v in node['mapping']:budget.consume();fibers.setdefault(v,set()).add(u)
+                outcomes.append(dict(direction=sign,terminal=terminal,count=node['count'],inverse_fibers=[dict(output=v,inputs=sorted(us)) for v,us in sorted(fibers.items())],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