From e6c5d30a3b4e1d870af9a13078abc88166d770ad Mon Sep 17 00:00:00 2001 From: epi13 Date: Mon, 27 Jul 2026 22:44:50 -0800 Subject: [PATCH 01/13] Add RAVEL machine-native inference architecture (#29) * Add RAVEL machine-native inference case study * Add RAVEL execution capsule * Add RAVEL build targets * Add RAVEL development evidence * Add RAVEL readable contract --- CONTRACT.md | 42 +++++++++++++++++++++++++++++++ Makefile | 16 ++++++++++++ README.md | 69 +++++++++++++++++++++++++++++++++++++++++++++++++++ evidence.json | 41 ++++++++++++++++++++++++++++++ ravel.c | 69 +++++++++++++++++++++++++++++++++++++++++++++++++++ 5 files changed, 237 insertions(+) create mode 100644 CONTRACT.md create mode 100644 Makefile create mode 100644 README.md create mode 100644 evidence.json create mode 100644 ravel.c diff --git a/CONTRACT.md b/CONTRACT.md new file mode 100644 index 0000000..745a0c1 --- /dev/null +++ b/CONTRACT.md @@ -0,0 +1,42 @@ +# RAVEL 0.1 readable contract + +## Intended use + +RAVEL 0.1 is a research component for exact conditional dispatch over a generated store of quantized experts. It tests whether a machine-generated routing lattice can reduce expert evaluations on familiar inputs while preserving the result of a complete reference scan. + +## Input and reference behavior + +A query contains eight signed 8-bit values. The declared in-domain range is `[-64, 63]` in every dimension. + +For every expert, the reference computes squared Euclidean distance between the query and expert centroid. It selects the minimum distance, resolving equal distances in favor of the lower expert identifier. It executes the selected expert as an integer dot product plus bias. + +## Candidate authority + +The candidate retrieves 24 generated experts from one lattice cell. It may return without a complete scan only when the routed winner's distance is strictly lower than the precomputed minimum possible distance of every excluded expert. + +Equality is not accepted. Uncertain or out-of-domain requests must scan every excluded expert before returning. + +Candidate output must exactly match the reference for expert identity, distance, and execution score. + +## Invariants + +1. Routing uncertainty never counts as success. +2. Out-of-domain values force fallback. +3. Each expert is evaluated at most once per query. +4. Candidate work is bounded between 24 and 256 expert evaluations. +5. Tie behavior is deterministic and reference-equivalent. +6. The complete oracle remains available as rollback. + +## Development gates + +On the declared familiar workload: + +- zero output mismatches; +- at least 95% certified routes; and +- no more than 32 mean expert evaluations. + +The uniform control workload requires exactness but does not require acceleration. Refusing unjustified shortcuts is expected. + +## Claim boundary + +This experiment is not a trained foundation model, production inference server, proof of generalization, or formal MNCS/MNCDS claim. Formal status remains `UNKNOWN` until independent protected evaluation and lifecycle evidence exist. diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..f1cc2db --- /dev/null +++ b/Makefile @@ -0,0 +1,16 @@ +CC ?= cc +CFLAGS ?= -std=c11 -O3 -Wall -Wextra -Werror -pedantic + +.PHONY: test evidence clean + +test: ravel + ./ravel >/dev/null + +evidence: ravel + ./ravel | tee evidence.json + +ravel: ravel.c + $(CC) $(CFLAGS) $< -o $@ + +clean: + rm -f ravel evidence.json diff --git a/README.md b/README.md new file mode 100644 index 0000000..901e1a5 --- /dev/null +++ b/README.md @@ -0,0 +1,69 @@ +# RAVEL — Recursive Adaptive Vector Execution Lattice + +RAVEL is a machine-native research architecture that treats AI/ML inference as one combined problem of **routing, retrieval, compression, and bounded computation**. + +Its foundational claim is that a model, memory store, router, and compute scheduler should not be four separate systems. A stored unit should simultaneously be: + +- a compressed region of behavior; +- a retrieval target; +- an executable expert; +- a routing destination; and +- a measured unit of computational cost. + +The long-term system records successful inference traces, compiles repeated traces into compact executable kernels, places those kernels into a generated routing lattice, and retires kernels that become dominated on quality, cost, or coverage. Familiar requests collapse into cheap retrieval-plus-execution. Unfamiliar requests automatically spend more compute. + +## Epoch-1 execution capsule + +The first mechanism proof contains 256 generated quantized experts. A query is routed into one of 256 lattice cells. The cell retrieves 24 candidate experts and carries a mathematical lower bound for every excluded expert. + +The candidate returns early only when the best routed expert is **strictly closer than any excluded expert could possibly be**. Otherwise it scans the excluded experts and becomes the complete oracle. Ties and uncertainty therefore fall back rather than being promoted to success. + +```text +query + -> generated lattice cell + -> retrieve 24 compressed experts + -> execute candidates + -> exact lower-bound certificate + PASS: return + UNKNOWN: scan excluded experts +``` + +## Initial development result + +The checked-in capsule produced: + +| Workload | Queries | Mismatches | Certified rate | Mean experts | Evaluation reduction | +|---|---:|---:|---:|---:|---:| +| Familiar, near stored experts | 100,000 | 0 | 100.000% | 24.000 | 90.625% | +| Uniform control | 25,000 | 0 | 2.236% | 250.812 | 2.026% | + +The control result is intentional: unfamiliar traffic receives nearly full computation because the shortcut cannot be justified. + +## Run + +```bash +make test +make evidence +``` + +Requirements: a C11 compiler and Make. + +## MNCS boundary + +- **Human control plane:** this README, `CONTRACT.md`, exact fallback, benefit thresholds, and exclusions. +- **Machine execution plane:** generated expert vectors and routing lattice. +- **Evidence plane:** paired candidate/oracle workloads and exact mismatch counts. +- **Development-control plane:** fixed generator seed, frozen constants, and preregistered gates. +- **Operational-control plane:** the complete full-scan oracle remains the rollback implementation. + +The local experiment records a development `PASS`. Formal MNCS and MNCDS status remain `UNKNOWN` pending protected workloads, independent evaluation, cross-host reproduction, legitimate learned baselines, and lifecycle evidence. + +## Claim boundary + +RAVEL does not establish a solution to intelligence, generalization, training, or production inference. It demonstrates one foundational mechanism: exact conditional compute over a generated compressed expert lattice. + +## Origin + +The name, architecture, algorithm, repository setup, and initial implementation were created by **GPT-5.6 Thinking** in response to Alexander Collamore's challenge to design an AI/ML foundation that fully embraces Machine-Native Complexity. Alexander Collamore is the repository steward. + +A fuller standalone repository package includes the separated generator, API, tests, threat model, assurance case, and generated artifacts. \ No newline at end of file diff --git a/evidence.json b/evidence.json new file mode 100644 index 0000000..299f0d3 --- /dev/null +++ b/evidence.json @@ -0,0 +1,41 @@ +{ + "schema": "ravel-capsule-evidence/0.1", + "environment": { + "compiler": "cc 14.2.0", + "optimization": "-O3", + "captured_date": "2026-07-27", + "timings_are_observational": true + }, + "experts": 256, + "route_width": 24, + "workloads": { + "familiar": { + "queries": 100000, + "mismatches": 0, + "certified_rate": 1.0, + "mean_experts": 24.0, + "reduction": 0.90625, + "candidate_ns": 14380373, + "reference_ns": 86998955, + "checksum": "0000034300750035" + }, + "uniform": { + "queries": 25000, + "mismatches": 0, + "certified_rate": 0.02236, + "mean_experts": 250.81248, + "reduction": 0.02026375, + "candidate_ns": 26611235, + "reference_ns": 22155051, + "checksum": "00000025002106a7" + } + }, + "gates": { + "all_mismatches_equal_zero": true, + "familiar_certified_rate_at_least_0_95": true, + "familiar_mean_experts_at_most_32": true + }, + "development_result": "PASS", + "formal_mncs_status": "UNKNOWN", + "formal_mncds_status": "UNKNOWN" +} diff --git a/ravel.c b/ravel.c new file mode 100644 index 0000000..46385dd --- /dev/null +++ b/ravel.c @@ -0,0 +1,69 @@ +/* + * RAVEL execution capsule 0.1 + * Recursive Adaptive Vector Execution Lattice + * + * Human-maintained surface: contract, constants, exact fallback, evidence gates. + * Machine-owned surface: generated expert store and routing lattice in memory. + */ +#define _POSIX_C_SOURCE 200809L +#include +#include +#include +#include +#include +#include +#include + +#define E 256u +#define D 8u +#define K 24u +#define B 256u +#define LO (-64) +#define HI 63 + +typedef struct { int8_t x[D]; } Q; +typedef struct { int32_t y; uint32_t d; uint16_t e, n; uint8_t cert; } R; +typedef struct { uint64_t q, bad, cert, eval, ns_c, ns_r, sum; } M; + +static int8_t C[E][D], W[E][D]; +static int16_t Z[E]; +static uint16_t T[B][K]; +static uint32_t L[B]; +static uint64_t S = UINT64_C(0x524156454c9e3779); + +static uint32_t u32(void) { + S ^= S >> 12; S ^= S << 25; S ^= S >> 27; + return (uint32_t)((S * UINT64_C(2685821657736338717)) >> 32); +} +static uint64_t ns(void) { + struct timespec t; clock_gettime(CLOCK_MONOTONIC, &t); + return (uint64_t)t.tv_sec * UINT64_C(1000000000) + (uint64_t)t.tv_nsec; +} +static int8_t sat(int v) { return (int8_t)(v < LO ? LO : v > HI ? HI : v); } +static uint32_t sd(const Q *q, uint16_t e) { + uint32_t z=0; for (uint32_t i=0;ix[i]-C[e][i];z+=(uint32_t)(v*v);} return z; +} +static int32_t ex(const Q *q, uint16_t e) { + int32_t z=Z[e]; for(uint32_t i=0;ix[i]*W[e][i]; return z; +} +static int bt(uint32_t d,uint16_t e,uint32_t bd,uint16_t be){return dx[i]x[i]>HI)*ok=0;for(uint32_t i=0;i<4;i++){int v=((int)q->x[i]-LO)/32;if(v<0)v=0;if(v>3)v=3;b=(uint16_t)((b<<2)|(uint16_t)v);}return b;} +static uint32_t lb1(int c,int lo,int hi){return chi?(uint32_t)((c-hi)*(c-hi)):0u;} + +static void gen(void) { + for(uint32_t e=0;e>s)&3u,lo=(uint32_t)(LO+32*(int)v),hi=lo+31u;z+=lb1(C[e][i],(int)lo,(int)hi);}d[e]=z;id[e]=(uint16_t)e;} + for(uint32_t i=0;ins_c+=ns()-t;t=ns();R b=ref(q);m->ns_r+=ns()-t;m->q++;m->cert+=a.cert;m->eval+=a.n;m->sum^=((uint64_t)(uint32_t)a.y<<32)^((uint64_t)a.e<<16)^a.d;if(a.e!=b.e||a.d!=b.d||a.y!=b.y)m->bad++;assert(a.n<=E);} +static M familiar(uint32_t n){M m={0};for(uint32_t j=0;jcert/m->q,me=(double)m->eval/m->q,red=1.0-me/E;printf(" \"%s\":{\"queries\":%"PRIu64",\"mismatches\":%"PRIu64",\"certified_rate\":%.9f,\"mean_experts\":%.6f,\"reduction\":%.9f,\"candidate_ns\":%"PRIu64",\"reference_ns\":%"PRIu64",\"checksum\":\"%016"PRIx64"\"}%s\n",n,m->q,m->bad,cr,me,red,m->ns_c,m->ns_r,m->sum,c?",":"");} +int main(void){gen();Q z={{0}};R a=run(&z),b=ref(&z);assert(a.e==b.e&&a.d==b.d&&a.y==b.y);M f=familiar(100000u),u=uniform(25000u);double cr=(double)f.cert/f.q,me=(double)f.eval/f.q;int pass=!f.bad&&!u.bad&&cr>=.95&&me<=32.0;printf("{\n \"schema\":\"ravel-capsule-evidence/0.1\",\n \"experts\":256,\"route_width\":24,\n \"workloads\":{\n");pm("familiar",&f,1);pm("uniform",&u,0);printf(" },\n \"development_result\":\"%s\",\n \"formal_mncs_status\":\"UNKNOWN\",\n \"formal_mncds_status\":\"UNKNOWN\"\n}\n",pass?"PASS":"FAIL");return pass?0:1;} From 71ff8bae7054aeaacd5200a3d22942d106476460 Mon Sep 17 00:00:00 2001 From: epi13 Date: Tue, 28 Jul 2026 06:26:19 -0800 Subject: [PATCH 02/13] Develop RAVEL unified recursive architecture (#30) * Add RAVEL recursive training capsule * Add RAVEL-T readable training contract * Preregister RAVEL-T training protocol * Add deterministic RAVEL-T training evidence * Add RAVEL-T training threat model * Add RAVEL-T bounded assurance case * Add RAVEL recursive training build targets * Extend RAVEL into recursive training territory * Canonicalize RAVEL-T generated evidence bytes * Bind RAVEL-T assurance case to canonical evidence * Add root RAVEL training verification targets * Run RAVEL recursive training in CI * Document the RAVEL research architecture * Link RAVEL training research from documentation * Add RAVEL unified execution capsule * Add RAVEL unified core shard * Add RAVEL unified routing shard * Add RAVEL unified training shard * Add RAVEL unified evaluation shard * Add RAVEL unified evidence * Document RAVEL architectural blockers and boundary * Add RAVEL unified readable contract * Add RAVEL unified preregistration * Add RAVEL unified threat model * Add RAVEL unified assurance case * Add RAVEL unified build and evidence gates * Add root RAVEL unified validation target * Reproduce RAVEL unified evidence in CI * Document RAVEL unified architecture and results * Document RAVEL unified architecture * Preserve failed RAVEL unified evidence output * Upload RAVEL unified mismatch evidence on failure * Add RAVEL to documentation navigation * Separate RAVEL unified binary from shard directory * Remove out-of-tree link from strict RAVEL docs --- ARCHITECTURE_GAPS.md | 37 +++ Makefile | 35 ++- README.md | 115 +++++--- TRAINING_CONTRACT.md | 87 ++++++ UNIFIED_CONTRACT.md | 54 ++++ ravel_train.c | 483 ++++++++++++++++++++++++++++++++++ ravel_unified.c | 5 + ravel_unified/00_core.inc | 150 +++++++++++ ravel_unified/10_route.inc | 170 ++++++++++++ ravel_unified/20_train.inc | 159 +++++++++++ ravel_unified/30_eval.inc | 162 ++++++++++++ training-assurance-case.json | 42 +++ training-evidence.json | 18 ++ training-preregistration.json | 53 ++++ training-threat-model.json | 61 +++++ unified-assurance-case.json | 52 ++++ unified-evidence.json | 19 ++ unified-preregistration.json | 41 +++ unified-threat-model.json | 69 +++++ 19 files changed, 1772 insertions(+), 40 deletions(-) create mode 100644 ARCHITECTURE_GAPS.md create mode 100644 TRAINING_CONTRACT.md create mode 100644 UNIFIED_CONTRACT.md create mode 100644 ravel_train.c create mode 100644 ravel_unified.c create mode 100644 ravel_unified/00_core.inc create mode 100644 ravel_unified/10_route.inc create mode 100644 ravel_unified/20_train.inc create mode 100644 ravel_unified/30_eval.inc create mode 100644 training-assurance-case.json create mode 100644 training-evidence.json create mode 100644 training-preregistration.json create mode 100644 training-threat-model.json create mode 100644 unified-assurance-case.json create mode 100644 unified-evidence.json create mode 100644 unified-preregistration.json create mode 100644 unified-threat-model.json diff --git a/ARCHITECTURE_GAPS.md b/ARCHITECTURE_GAPS.md new file mode 100644 index 0000000..18c17b8 --- /dev/null +++ b/ARCHITECTURE_GAPS.md @@ -0,0 +1,37 @@ +# What prevented RAVEL from being a unified architecture + +RAVEL 0.1 unified exact routing, retrieval, compressed experts, and conditional inference. RAVEL-T 0.2 added recursive expert birth and training. Those versions were still components rather than an architecture because the learned unit did not also own representation, reconstruction, action-conditioned prediction, temporal memory, planning, continual adaptation, retirement, checkpoint identity, and rollback equivalence. + +RAVEL-U 0.3 closes that bounded architectural gap. One expert now simultaneously acts as: + +- a retrieval key; +- a compressed representation of a state region; +- a reconstruction program; +- a classifier; +- an action-conditioned next-state predictor; +- a node in learned temporal memory; +- a planning destination; +- a training and replay shard; +- a lineage-bearing lifecycle object; and +- a measured unit of computational cost. + +The same expert population builds the exact routing lattice, receives training assignments, identifies unresolved error, creates children, compiles its transition graph, supplies plans, adapts to semantic drift, and retires low-utility duplicate children. Successful checkpoint restoration must reproduce both model identity and evaluation behavior. + +## Intentionally external + +RAVEL is not made safer or more complete by allowing the recursive execution plane to rewrite everything. The following remain outside its authority: + +- raw modality adapters and data acquisition; +- intended-use and prohibited-use policy; +- evaluator, seeds, partitions, thresholds, and promotion decision; +- authorization for external effects; +- protected evidence custody; +- release signing and deployment; +- rollback approval; and +- formal MNCS or MNCDS status. + +These are control surfaces, not missing intelligence components. Moving them into the recursive model would remove the independent boundary needed to evaluate, contain, replace, or retire it. + +## Remaining scale gaps + +RAVEL-U is a deterministic synthetic mechanism proof. It does not yet establish learned tokenization, language or multimodal generation, stochastic world modeling, gradient-scale optimization, distributed execution, long-horizon credit assignment, causal identification, protected real-data generalization, adversarial robustness, or production safety. Those are the next experimental domains, not hidden claims of this capsule. diff --git a/Makefile b/Makefile index f1cc2db..ad1a3f1 100644 --- a/Makefile +++ b/Makefile @@ -1,7 +1,8 @@ CC ?= cc CFLAGS ?= -std=c11 -O3 -Wall -Wextra -Werror -pedantic +LDLIBS ?= -lm -.PHONY: test evidence clean +.PHONY: test evidence training-test training-evidence training-check unified-test unified-evidence unified-check all clean test: ravel ./ravel >/dev/null @@ -9,8 +10,38 @@ test: ravel evidence: ravel ./ravel | tee evidence.json +training-test: ravel_train + ./ravel_train >/dev/null + +training-evidence: ravel_train + ./ravel_train | tee training-evidence.json + +training-check: ravel_train + @tmp=$$(mktemp); \ + trap 'rm -f "$$tmp"' EXIT; \ + ./ravel_train > "$$tmp"; \ + diff -u training-evidence.json "$$tmp" + +unified-test: ravel_unified_bin + ./ravel_unified_bin >/dev/null + +unified-evidence: ravel_unified_bin + ./ravel_unified_bin | tee unified-evidence.json + +unified-check: ravel_unified_bin + ./ravel_unified_bin > unified-actual.json + diff -u unified-evidence.json unified-actual.json + +all: test training-check unified-check + ravel: ravel.c $(CC) $(CFLAGS) $< -o $@ +ravel_train: ravel_train.c + $(CC) $(CFLAGS) $< $(LDLIBS) -o $@ + +ravel_unified_bin: ravel_unified.c ravel_unified/00_core.inc ravel_unified/10_route.inc ravel_unified/20_train.inc ravel_unified/30_eval.inc + $(CC) $(CFLAGS) ravel_unified.c $(LDLIBS) -o $@ + clean: - rm -f ravel evidence.json + rm -f ravel ravel_train ravel_unified_bin evidence.json unified-actual.json ravel-unified-checkpoint.bin diff --git a/README.md b/README.md index 901e1a5..8e82155 100644 --- a/README.md +++ b/README.md @@ -1,69 +1,108 @@ # RAVEL — Recursive Adaptive Vector Execution Lattice -RAVEL is a machine-native research architecture that treats AI/ML inference as one combined problem of **routing, retrieval, compression, and bounded computation**. +RAVEL is a machine-native research architecture that treats AI/ML as one combined problem of routing, retrieval, compression, representation, training state, temporal memory, planning, lifecycle, and bounded computation. -Its foundational claim is that a model, memory store, router, and compute scheduler should not be four separate systems. A stored unit should simultaneously be: +Its foundational claim is that a model, memory store, router, trainer, world model, planner, and compute scheduler should not be separate systems. A stored expert should simultaneously be a retrieval key, compressed representation, executable predictor, training shard, transition-memory node, planning destination, lineage object, and measured unit of computation. -- a compressed region of behavior; -- a retrieval target; -- an executable expert; -- a routing destination; and -- a measured unit of computational cost. +Human readability is relocated into contracts, evaluator authority, evidence, regeneration, and rollback. The generated execution plane is expected to be replaced as a unit rather than routinely hand-maintained. -The long-term system records successful inference traces, compiles repeated traces into compact executable kernels, places those kernels into a generated routing lattice, and retires kernels that become dominated on quality, cost, or coverage. Familiar requests collapse into cheap retrieval-plus-execution. Unfamiliar requests automatically spend more compute. +## RAVEL 0.1 — exact conditional inference -## Epoch-1 execution capsule +The first capsule generates 256 quantized experts and retrieves 24 candidates per familiar query. A strict lower-bound certificate permits early return only when every excluded expert is provably unable to win. Otherwise execution becomes the complete oracle. -The first mechanism proof contains 256 generated quantized experts. A query is routed into one of 256 lattice cells. The cell retrieves 24 candidate experts and carries a mathematical lower bound for every excluded expert. +| Workload | Queries | Mismatches | Certified rate | Mean experts | Reduction | +|---|---:|---:|---:|---:|---:| +| Familiar | 100,000 | 0 | 100.000% | 24.000 | 90.625% | +| Uniform control | 25,000 | 0 | 2.236% | 250.812 | 2.026% | -The candidate returns early only when the best routed expert is **strictly closer than any excluded expert could possibly be**. Otherwise it scans the excluded experts and becomes the complete oracle. Ties and uncertainty therefore fall back rather than being promoted to success. +## RAVEL-T 0.2 — recursive training -```text -query - -> generated lattice cell - -> retrieve 24 compressed experts - -> execute candidates - -> exact lower-bound certificate - PASS: return - UNKNOWN: scan excluded experts -``` +The current experts build the exact router; routed assignments update the experts; unresolved error ranks overloaded shards; bounded splits compile children; child lineage rebuilds the next router. -## Initial development result +| Implementation | Holdout accuracy | Mean experts | Training evaluations | +|---|---:|---:|---:| +| RAVEL-T recursive 8→64 | 100.000% | 8.000 | 4,144,248 | +| Fixed eight-expert | 22.461% | 8.000 | 3,538,944 | +| Flat 64-expert | 100.000% | 64.000 | 87,031,808 | -The checked-in capsule produced: +## RAVEL-U 0.3 — unified architecture -| Workload | Queries | Mismatches | Certified rate | Mean experts | Evaluation reduction | -|---|---:|---:|---:|---:|---:| -| Familiar, near stored experts | 100,000 | 0 | 100.000% | 24.000 | 90.625% | -| Uniform control | 25,000 | 0 | 2.236% | 250.812 | 2.026% | +RAVEL-U closes the component gap. One expert population now owns: + +- retrieval and exact conditional compute; +- compressed state representation and reconstruction; +- label prediction; +- action-conditioned next-observation prediction; +- temporal-memory graph compilation; +- bounded planning over the learned graph; +- error-driven expert birth; +- replay-backed continual adaptation; +- low-utility child retirement; and +- checkpoint identity and behavioral rollback verification. + +The synthetic world contains 64 states, four actions, eight labels, and eight-dimensional observations. Semantic drift changes both observations and labels for 16 states. The frozen model is evaluated before adaptation, then RAVEL proposes 24 drift experts, retires eight low-utility duplicates, rebuilds the router and transition graph, and re-evaluates drift, retention, planning, and checkpoint behavior. + +### Unified development result -The control result is intentional: unfamiliar traffic receives nearly full computation because the shortcut cannot be justified. +| Measure | Result | +|---|---:| +| Base holdout accuracy | 96.826% | +| Static model on semantic drift | 71.899% | +| Adapted model on semantic drift | 100.000% | +| Original-task retention after adaptation | 96.704% | +| Adapted transition accuracy | 99.292% | +| Adapted planning target success | 505 / 512 | +| Routed-versus-complete mismatches | 0 | +| Mean routed experts | 8.000 | +| Adaptation births / retirements | 24 / 8 | +| Checkpoint identity and evaluation match | PASS | + +The expert is now simultaneously a key, representation, decoder, classifier, world-model fragment, transition node, replay shard, planning node, lineage object, and compute unit. See `ARCHITECTURE_GAPS.md` for what was missing and why raw modality adapters, use policy, protected evaluation, external effects, and promotion authority intentionally remain outside the recursive surface. ## Run ```bash make test +make training-check +make unified-check +``` + +To rewrite repository-visible development evidence: + +```bash make evidence +make training-evidence +make unified-evidence ``` -Requirements: a C11 compiler and Make. +Requirements: a C11 compiler, the C math library, and Make. + +## Files + +- `ravel.c`, `CONTRACT.md`, `evidence.json` — exact conditional inference; +- `ravel_train.c`, `TRAINING_CONTRACT.md`, `training-*.json` — recursive training; +- `ravel_unified.c` and `ravel_unified/*.inc` — generated unified execution shards; +- `ARCHITECTURE_GAPS.md` — architectural audit and intentional external boundary; +- `UNIFIED_CONTRACT.md` — unified readable authority and gates; +- `unified-preregistration.json` — frozen protocol; +- `unified-evidence.json` — deterministic observations; +- `unified-threat-model.json` — threats and residual UNKNOWNs; and +- `unified-assurance-case.json` — bounded non-promotion record. ## MNCS boundary -- **Human control plane:** this README, `CONTRACT.md`, exact fallback, benefit thresholds, and exclusions. -- **Machine execution plane:** generated expert vectors and routing lattice. -- **Evidence plane:** paired candidate/oracle workloads and exact mismatch counts. -- **Development-control plane:** fixed generator seed, frozen constants, and preregistered gates. -- **Operational-control plane:** the complete full-scan oracle remains the rollback implementation. +- **Human control plane:** intended use, event contract, external authority, limits, gates, and exclusions. +- **Machine execution plane:** expert keys, decoders, classifiers, next-state programs, router, transition graph, topology, replay assignments, and lineage. +- **Evidence plane:** exact-oracle agreement, accuracy, reconstruction, prediction, transition, planning, lifecycle, checkpoint, checksums, and limitations. +- **Development-control plane:** fixed seeds, partitions, birth and retirement budgets, immutable thresholds, and non-promotion fields. +- **Operational-control plane:** complete-scan fallback, checkpoint restoration, model identity, and replacement of the generated execution shards. -The local experiment records a development `PASS`. Formal MNCS and MNCDS status remain `UNKNOWN` pending protected workloads, independent evaluation, cross-host reproduction, legitimate learned baselines, and lifecycle evidence. +The repository-visible studies record development `PASS`. Formal MNCS and MNCDS status remain `UNKNOWN`; promotion is unauthorized pending independent protected real-data evaluation, adversarial continual-learning studies, learned modality adapters, cross-host reproduction, accelerator and distributed evidence, and operational release controls. ## Claim boundary -RAVEL does not establish a solution to intelligence, generalization, training, or production inference. It demonstrates one foundational mechanism: exact conditional compute over a generated compressed expert lattice. +RAVEL-U is a favorable deterministic mechanism proof. It does not establish general intelligence, foundation-model performance, language or multimodal generation, causal reasoning, real-data generalization, production safety, or formal conformance. ## Origin -The name, architecture, algorithm, repository setup, and initial implementation were created by **GPT-5.6 Thinking** in response to Alexander Collamore's challenge to design an AI/ML foundation that fully embraces Machine-Native Complexity. Alexander Collamore is the repository steward. - -A fuller standalone repository package includes the separated generator, API, tests, threat model, assurance case, and generated artifacts. \ No newline at end of file +The name, architecture, algorithms, and initial implementations were created by **GPT-5.6 Thinking** in response to Alexander Collamore's challenge to design an AI/ML foundation that fully embraces Machine-Native Complexity. Alexander Collamore is the repository steward. diff --git a/TRAINING_CONTRACT.md b/TRAINING_CONTRACT.md new file mode 100644 index 0000000..8232964 --- /dev/null +++ b/TRAINING_CONTRACT.md @@ -0,0 +1,87 @@ +# RAVEL-T 0.2 readable training contract + +## Intended use + +RAVEL-T 0.2 is a deterministic mechanism study for recursive expert formation. It tests whether one bounded structure can serve simultaneously as model parameters, retrieval memory, routing geometry, training state, and computational budget. + +It is not a general-purpose trainer or evidence that the method scales to neural foundation models. + +## Task and data boundary + +The development task is supervised classification over eight signed integer dimensions. A frozen synthetic teacher contains 64 separated latent regions and eight labels. Development and holdout samples use distinct fixed seeds. + +The teacher construction is repository-visible. The holdout is therefore untouched by the training procedure but is not independently protected evidence. + +## Recursive training behavior + +Training begins with eight experts selected from development data. Each training round must: + +1. build a routing lattice from the current expert centroids; +2. route every development sample through the same exact certificate and fallback authority used for inference; +3. update the selected expert's centroid and label statistics; +4. rank expert shards by unresolved classification error; +5. split bounded high-error shards into two child experts; +6. assign each child a deterministic lineage identity; and +7. rebuild the lattice before the next round. + +The resulting loop is recursive: current experts determine routing; routing determines training shards; shard errors determine child experts; child experts regenerate the router; the regenerated router changes the next training observations. + +## Machine-owned surface + +The implementation may machine-manage: + +- expert count between 8 and 64; +- expert centroids and labels; +- shard assignments; +- split order and child parameters; +- routing-lattice contents; +- exact-routing workload allocation; and +- lineage identities. + +These artifacts are expected to be regenerated rather than manually maintained. + +## Human authority surface + +The recursive procedure must not alter: + +- the development and holdout generators or seeds; +- the full-scan nearest-expert oracle; +- the exact route-certificate rule; +- the maximum of 64 experts; +- the maximum of eight births per growth round; +- tie-breaking behavior; +- development gates; +- formal-status fields; or +- the prohibition on automatic promotion. + +A routed result is accepted only when it exactly agrees with the full-scan expert identity. Uncertainty spends more computation. + +## Baselines + +The same development data and holdout are evaluated against: + +- a fixed eight-expert conventional nearest-centroid learner; and +- a flat 64-expert conventional learner initialized directly and refined by full scans. + +Training expert-evaluation counts include initialization and refinement work. + +## Preregistered development gates + +The recursive candidate passes this repository-visible development protocol only when all are true: + +- exactly 64 final experts and 56 successful child births; +- zero routed-versus-full-scan expert mismatches on holdout; +- holdout accuracy at least 0.95; +- holdout accuracy no more than 0.01 below the flat 64-expert baseline; +- holdout accuracy at least 0.20 above the fixed eight-expert baseline; and +- no more than 16 mean expert evaluations per holdout sample. + +## Rollback and failure behavior + +The full-scan implementation is the inference rollback. The fixed-topology learner is the training rollback. A failed gate produces development `FAIL`; it must not be rewritten as success by changing thresholds after observation. + +## Claim boundary + +A development `PASS` applies only to this deterministic synthetic mechanism study. It does not establish protected-holdout independence, real-data generalization, gradient-training compatibility, accelerator behavior, distributed training, continual-learning safety, resistance to data poisoning, production benefit, or formal MNCS/MNCDS conformance. + +Formal MNCS and MNCDS status remain `UNKNOWN`, and promotion remains unauthorized. diff --git a/UNIFIED_CONTRACT.md b/UNIFIED_CONTRACT.md new file mode 100644 index 0000000..9117891 --- /dev/null +++ b/UNIFIED_CONTRACT.md @@ -0,0 +1,54 @@ +# RAVEL-U 0.3 unified architecture contract + +## Intended use + +RAVEL-U is a bounded research architecture for testing whether one recursively managed expert population can provide exact retrieval, compressed representation, reconstruction, classification, action-conditioned prediction, temporal memory, planning, continual adaptation, lifecycle compression, and checkpoint rollback under one deterministic protocol. + +## Event contract + +Each event contains an eight-dimensional signed observation, one of four actions, one of eight labels, and the next observation. The declared value range is `[-64, 63]` in every dimension. + +## Expert contract + +Every active expert contains one retrieval key, one reconstruction vector, four action-conditioned next-observation vectors, a label distribution, usage and error statistics, generation metadata, and lineage identity. The compiled transition graph maps each expert and action to the expert nearest its predicted next observation. + +## Routing authority + +The generated lattice evaluates eight candidates. It may return early only when the selected distance is strictly lower than the mathematical lower bound for every excluded expert. Equality, malformed input, or insufficient separation requires the complete scan. Routed and complete scans must select the same expert. + +## Recursive development authority + +The mutable execution plane may update expert parameters, rank overloaded shards, create bounded child experts, rebuild routing and transition structures, replay retained events, and retire low-utility adaptation children. It may not change data seeds, partitions, topology limits, evaluator behavior, gates, formal-status fields, or promotion authority. + +## Required behavior + +The same learned expert store must support: + +1. exact retrieval relative to the full-scan oracle; +2. label prediction; +3. observation reconstruction; +4. action-conditioned next-observation prediction; +5. transition-graph compilation; +6. bounded graph planning; +7. semantic-drift adaptation with replay; +8. bounded expert birth and retirement; and +9. checkpoint restoration with matching identity and evaluation behavior. + +## Development gates + +- base holdout accuracy at least 0.95; +- adapted drift accuracy at least 0.95; +- adapted drift gain over the static model at least 0.20; +- original-task retention after adaptation at least 0.90; +- adapted transition accuracy at least 0.95; +- adapted planning target success at least 0.90; +- zero routed-versus-complete expert mismatches; and +- checkpoint digest and evaluation checksum equality. + +## External authority + +Modality adapters, data collection, use policy, protected evaluation, external effects, deployment, release signing, and formal conformance decisions remain outside the recursive model. + +## Claim boundary + +A development `PASS` establishes only that the frozen deterministic capsule passed this synthetic protocol. It does not establish foundation-model capability, real-data generalization, production safety, independent holdout custody, distributed training, accelerator performance, or formal MNCS/MNCDS conformance. diff --git a/ravel_train.c b/ravel_train.c new file mode 100644 index 0000000..2feb108 --- /dev/null +++ b/ravel_train.c @@ -0,0 +1,483 @@ +#define _POSIX_C_SOURCE 200809L +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define D 8u +#define CLASSES 8u +#define TEACHERS 64u +#define MAXE 64u +#define INIT_E 8u +#define ROUTE_K 8u +#define CELLS 256u +#define NTRAIN 32768u +#define NTEST 8192u +#define GROW_PER_ROUND 8u +#define FINAL_REFINE 5u +#define FLAT_REFINE 10u +#define FIXED_REFINE 10u +#define LO (-64) +#define HI 63 + +typedef struct { int8_t x[D]; uint8_t y; } Sample; +typedef struct { + double c[D]; + uint32_t labels[CLASSES]; + uint32_t count; + uint8_t label; + uint64_t lineage; +} Expert; +typedef struct { uint16_t id[ROUTE_K]; double excluded_lb; } Cell; +typedef struct { + uint64_t samples; + uint64_t correct; + uint64_t exact_mismatches; + uint64_t certified; + uint64_t expert_evaluations; + uint64_t checksum; +} Eval; +typedef struct { + uint64_t expert_evaluations; + uint64_t certified; + uint64_t samples; + uint64_t splits; + uint64_t lineage_digest; +} TrainMetric; + +static uint64_t rng_state = UINT64_C(0x524156454c54524e); +static int8_t teacher_c[TEACHERS][D]; +static uint8_t teacher_y[TEACHERS]; +static Sample train_set[NTRAIN]; +static Sample test_set[NTEST]; +static uint16_t assignment[NTRAIN]; + +static uint32_t rng_u32(void) { + rng_state ^= rng_state >> 12; + rng_state ^= rng_state << 25; + rng_state ^= rng_state >> 27; + return (uint32_t)((rng_state * UINT64_C(2685821657736338717)) >> 32); +} + +static uint64_t mix64(uint64_t x) { + x ^= x >> 30; x *= UINT64_C(0xbf58476d1ce4e5b9); + x ^= x >> 27; x *= UINT64_C(0x94d049bb133111eb); + return x ^ (x >> 31); +} + +static int8_t clamp_i8(int v) { + if (v < LO) return (int8_t)LO; + if (v > HI) return (int8_t)HI; + return (int8_t)v; +} + +static double dist_sample(const Sample *s, const Expert *e) { + double z = 0.0; + for (uint32_t d = 0; d < D; ++d) { + double q = (double)s->x[d] - e->c[d]; + z += q * q; + } + return z; +} + +static double dist_vec(const double a[D], const double b[D]) { + double z = 0.0; + for (uint32_t d = 0; d < D; ++d) { + double q = a[d] - b[d]; + z += q * q; + } + return z; +} + +static uint8_t majority(const uint32_t counts[CLASSES]) { + uint8_t best = 0; + for (uint8_t y = 1; y < CLASSES; ++y) { + if (counts[y] > counts[best]) best = y; + } + return best; +} + +static void make_teacher(void) { + for (uint32_t t = 0; t < TEACHERS; ++t) { + for (uint32_t d = 0; d < 6u; ++d) { + teacher_c[t][d] = (int8_t)(((t >> d) & 1u) ? 42 : -42); + } + teacher_c[t][6] = (int8_t)(-36 + 24 * (int)((t * 5u + (t >> 2)) & 3u)); + teacher_c[t][7] = (int8_t)(-36 + 24 * (int)((t * 3u + (t >> 1)) & 3u)); + teacher_y[t] = (uint8_t)(((t * 29u) ^ (t >> 1) ^ (t >> 3)) & 7u); + } +} + +static void make_dataset(Sample *out, uint32_t n, uint64_t seed) { + rng_state = seed; + for (uint32_t i = 0; i < n; ++i) { + uint32_t t = rng_u32() % TEACHERS; + out[i].y = teacher_y[t]; + for (uint32_t d = 0; d < D; ++d) { + int noise = (int)(rng_u32() % 11u) - 5; + out[i].x[d] = clamp_i8((int)teacher_c[t][d] + noise); + } + } +} + +static uint16_t cell_id(const Sample *s, int *in_domain) { + uint16_t b = 0; + *in_domain = 1; + for (uint32_t d = 0; d < D; ++d) { + if (s->x[d] < LO || s->x[d] > HI) *in_domain = 0; + } + for (uint32_t d = 0; d < 4u; ++d) { + int v = ((int)s->x[d] - LO) / 32; + if (v < 0) v = 0; + if (v > 3) v = 3; + b = (uint16_t)((b << 2) | (uint16_t)v); + } + return b; +} + +static double axis_lb(double c, double lo, double hi) { + if (c < lo) { double v = lo - c; return v * v; } + if (c > hi) { double v = c - hi; return v * v; } + return 0.0; +} + +static void build_lattice(const Expert e[MAXE], uint16_t n, Cell cells[CELLS]) { + for (uint32_t b = 0; b < CELLS; ++b) { + double d[MAXE]; + uint16_t id[MAXE]; + for (uint16_t j = 0; j < n; ++j) { + double z = 0.0; + for (uint32_t k = 0; k < 4u; ++k) { + uint32_t shift = 2u * (3u - k); + uint32_t v = (b >> shift) & 3u; + double lo = (double)(LO + 32 * (int)v); + double hi = lo + 31.0; + z += axis_lb(e[j].c[k], lo, hi); + } + d[j] = z; + id[j] = j; + } + uint16_t take = n < ROUTE_K ? n : ROUTE_K; + uint16_t need = n > ROUTE_K ? (uint16_t)(ROUTE_K + 1u) : n; + for (uint16_t i = 0; i < need; ++i) { + uint16_t m = i; + for (uint16_t j = (uint16_t)(i + 1u); j < n; ++j) { + if (d[j] < d[m] || (d[j] == d[m] && id[j] < id[m])) m = j; + } + double td = d[i]; d[i] = d[m]; d[m] = td; + uint16_t ti = id[i]; id[i] = id[m]; id[m] = ti; + } + for (uint16_t i = 0; i < ROUTE_K; ++i) cells[b].id[i] = UINT16_MAX; + for (uint16_t i = 0; i < take; ++i) cells[b].id[i] = id[i]; + cells[b].excluded_lb = n > ROUTE_K ? d[ROUTE_K] : DBL_MAX; + } +} + +static int better(double d, uint16_t id, double best_d, uint16_t best_id) { + return d < best_d || (d == best_d && id < best_id); +} + +static uint16_t full_nearest(const Sample *s, const Expert e[MAXE], uint16_t n, uint64_t *evals) { + double best_d = DBL_MAX; + uint16_t best = UINT16_MAX; + for (uint16_t j = 0; j < n; ++j) { + double d = dist_sample(s, &e[j]); + ++*evals; + if (better(d, j, best_d, best)) { best_d = d; best = j; } + } + return best; +} + +static uint16_t routed_nearest(const Sample *s, const Expert e[MAXE], uint16_t n, + const Cell cells[CELLS], uint64_t *evals, uint64_t *certified) { + int in_domain = 0; + uint16_t b = cell_id(s, &in_domain); + uint8_t seen[MAXE]; + memset(seen, 0, sizeof seen); + double best_d = DBL_MAX; + uint16_t best = UINT16_MAX; + uint16_t take = n < ROUTE_K ? n : ROUTE_K; + for (uint16_t i = 0; i < take; ++i) { + uint16_t j = cells[b].id[i]; + assert(j < n); + seen[j] = 1u; + double d = dist_sample(s, &e[j]); + ++*evals; + if (better(d, j, best_d, best)) { best_d = d; best = j; } + } + if (in_domain && best_d < cells[b].excluded_lb) { + ++*certified; + return best; + } + for (uint16_t j = 0; j < n; ++j) { + if (!seen[j]) { + double d = dist_sample(s, &e[j]); + ++*evals; + if (better(d, j, best_d, best)) { best_d = d; best = j; } + } + } + return best; +} + +static void farthest_init(Expert e[MAXE], uint16_t n, const Sample *data, uint32_t count, + uint64_t *evals) { + memset(e, 0, sizeof(Expert) * MAXE); + for (uint32_t d = 0; d < D; ++d) e[0].c[d] = (double)data[0].x[d]; + e[0].label = data[0].y; + e[0].lineage = mix64(UINT64_C(0x524156454c000001)); + for (uint16_t k = 1; k < n; ++k) { + double far = -1.0; + uint32_t far_i = 0u; + for (uint32_t i = 0; i < count; ++i) { + double nearest = DBL_MAX; + for (uint16_t j = 0; j < k; ++j) { + double z = 0.0; + for (uint32_t d = 0; d < D; ++d) { + double v = (double)data[i].x[d] - e[j].c[d]; + z += v * v; + } + ++*evals; + if (z < nearest) nearest = z; + } + if (nearest > far) { far = nearest; far_i = i; } + } + for (uint32_t d = 0; d < D; ++d) e[k].c[d] = (double)data[far_i].x[d]; + e[k].label = data[far_i].y; + e[k].lineage = mix64(e[0].lineage ^ (uint64_t)k); + } +} + +static void refine(Expert e[MAXE], uint16_t n, const Sample *data, uint32_t count, + uint32_t iterations, int routed, uint16_t *out_assignment, + TrainMetric *metric) { + Cell cells[CELLS]; + for (uint32_t it = 0; it < iterations; ++it) { + double sums[MAXE][D]; + uint32_t counts[MAXE]; + uint32_t labels[MAXE][CLASSES]; + memset(sums, 0, sizeof sums); + memset(counts, 0, sizeof counts); + memset(labels, 0, sizeof labels); + if (routed) build_lattice(e, n, cells); + for (uint32_t i = 0; i < count; ++i) { + uint16_t j; + if (routed) { + j = routed_nearest(&data[i], e, n, cells, + &metric->expert_evaluations, &metric->certified); + } else { + j = full_nearest(&data[i], e, n, &metric->expert_evaluations); + } + ++metric->samples; + if (out_assignment != NULL) out_assignment[i] = j; + ++counts[j]; + ++labels[j][data[i].y]; + for (uint32_t d = 0; d < D; ++d) { + double v = (double)data[i].x[d]; + sums[j][d] += v; + } + } + for (uint16_t j = 0; j < n; ++j) { + e[j].count = counts[j]; + memcpy(e[j].labels, labels[j], sizeof e[j].labels); + if (counts[j] > 0u) { + for (uint32_t d = 0; d < D; ++d) e[j].c[d] = sums[j][d] / (double)counts[j]; + e[j].label = majority(labels[j]); + } + } + } +} + +static double expert_score(const Expert *e) { + if (e->count < 2u) return -1.0; + uint32_t max_label = 0u; + for (uint32_t y = 0; y < CLASSES; ++y) if (e->labels[y] > max_label) max_label = e->labels[y]; + uint32_t errors = e->count - max_label; + return (double)errors * 1000000000.0 + (double)e->count; +} + +static int split_one(Expert e[MAXE], uint16_t parent, uint16_t child, + const Sample *data, uint32_t count, const uint16_t *a, + uint32_t round) { + uint32_t first = UINT32_MAX; + for (uint32_t i = 0; i < count; ++i) if (a[i] == parent) { first = i; break; } + if (first == UINT32_MAX) return 0; + uint32_t pa = first; + double far = -1.0; + for (uint32_t i = 0; i < count; ++i) if (a[i] == parent) { + double z = 0.0; + for (uint32_t d = 0; d < D; ++d) { + double v = (double)data[i].x[d] - (double)data[first].x[d]; + z += v * v; + } + if (z > far) { far = z; pa = i; } + } + uint32_t pb = pa; + far = -1.0; + for (uint32_t i = 0; i < count; ++i) if (a[i] == parent) { + double z = 0.0; + for (uint32_t d = 0; d < D; ++d) { + double v = (double)data[i].x[d] - (double)data[pa].x[d]; + z += v * v; + } + if (z > far) { far = z; pb = i; } + } + if (pa == pb) return 0; + double ca[D], cb[D]; + for (uint32_t d = 0; d < D; ++d) { ca[d] = (double)data[pa].x[d]; cb[d] = (double)data[pb].x[d]; } + uint32_t la[CLASSES], lb[CLASSES]; + uint32_t na = 0u, nb = 0u; + for (uint32_t it = 0; it < 8u; ++it) { + double sa[D] = {0}, sb[D] = {0}; + memset(la, 0, sizeof la); memset(lb, 0, sizeof lb); + na = 0u; nb = 0u; + for (uint32_t i = 0; i < count; ++i) if (a[i] == parent) { + double va[D]; + for (uint32_t d = 0; d < D; ++d) va[d] = (double)data[i].x[d]; + double da = dist_vec(va, ca), db = dist_vec(va, cb); + int side = da < db || (da == db && pa < pb) ? 0 : 1; + if (side == 0) { + ++na; ++la[data[i].y]; + for (uint32_t d = 0; d < D; ++d) sa[d] += va[d]; + } else { + ++nb; ++lb[data[i].y]; + for (uint32_t d = 0; d < D; ++d) sb[d] += va[d]; + } + } + if (na == 0u || nb == 0u) return 0; + for (uint32_t d = 0; d < D; ++d) { ca[d] = sa[d] / (double)na; cb[d] = sb[d] / (double)nb; } + } + uint64_t root = e[parent].lineage; + memset(&e[parent], 0, sizeof e[parent]); + memset(&e[child], 0, sizeof e[child]); + for (uint32_t d = 0; d < D; ++d) { e[parent].c[d] = ca[d]; e[child].c[d] = cb[d]; } + memcpy(e[parent].labels, la, sizeof la); memcpy(e[child].labels, lb, sizeof lb); + e[parent].count = na; e[child].count = nb; + e[parent].label = majority(la); e[child].label = majority(lb); + e[parent].lineage = mix64(root ^ ((uint64_t)round << 32) ^ UINT64_C(0xa5)); + e[child].lineage = mix64(root ^ ((uint64_t)round << 32) ^ UINT64_C(0x5a)); + return 1; +} + +static uint16_t train_recursive(Expert e[MAXE], TrainMetric *metric) { + uint64_t init_evals = 0u; + farthest_init(e, INIT_E, train_set, NTRAIN, &init_evals); + metric->expert_evaluations += init_evals; + uint16_t n = INIT_E; + uint32_t round = 0u; + while (n < MAXE) { + refine(e, n, train_set, NTRAIN, 1u, 1, assignment, metric); + uint16_t order[MAXE]; + for (uint16_t j = 0; j < n; ++j) order[j] = j; + for (uint16_t i = 0; i < n; ++i) { + uint16_t m = i; + for (uint16_t j = (uint16_t)(i + 1u); j < n; ++j) { + double sj = expert_score(&e[order[j]]), sm = expert_score(&e[order[m]]); + if (sj > sm || (sj == sm && order[j] < order[m])) m = j; + } + uint16_t t = order[i]; order[i] = order[m]; order[m] = t; + } + uint16_t target = (uint16_t)((MAXE - n) < GROW_PER_ROUND ? (MAXE - n) : GROW_PER_ROUND); + uint16_t made = 0u; + for (uint16_t i = 0; i < n && made < target; ++i) { + uint16_t parent = order[i]; + if (split_one(e, parent, (uint16_t)(n + made), train_set, NTRAIN, assignment, round)) { + ++made; ++metric->splits; + } + } + if (made == 0u) break; + n = (uint16_t)(n + made); + ++round; + } + refine(e, n, train_set, NTRAIN, FINAL_REFINE, 1, assignment, metric); + uint64_t dig = 0u; + for (uint16_t j = 0; j < n; ++j) dig ^= mix64(e[j].lineage ^ ((uint64_t)e[j].label << 56)); + metric->lineage_digest = dig; + return n; +} + +static void train_flat(Expert e[MAXE], uint16_t n, uint32_t iterations, TrainMetric *metric) { + uint64_t init_evals = 0u; + farthest_init(e, n, train_set, NTRAIN, &init_evals); + metric->expert_evaluations += init_evals; + refine(e, n, train_set, NTRAIN, iterations, 0, NULL, metric); +} + +static Eval evaluate(const Expert e[MAXE], uint16_t n, int routed) { + Eval out = {0}; + Cell cells[CELLS]; + if (routed) build_lattice(e, n, cells); + for (uint32_t i = 0; i < NTEST; ++i) { + uint64_t before = out.expert_evaluations; + uint16_t got; + if (routed) got = routed_nearest(&test_set[i], e, n, cells, + &out.expert_evaluations, &out.certified); + else got = full_nearest(&test_set[i], e, n, &out.expert_evaluations); + uint64_t ref_evals = 0u; + uint16_t oracle = full_nearest(&test_set[i], e, n, &ref_evals); + if (got != oracle) ++out.exact_mismatches; + if (e[got].label == test_set[i].y) ++out.correct; + ++out.samples; + out.checksum ^= mix64(((uint64_t)got << 48) ^ ((uint64_t)e[got].label << 40) ^ i); + assert(out.expert_evaluations - before >= (uint64_t)(n < ROUTE_K ? n : (routed ? ROUTE_K : n))); + } + return out; +} + +static void print_eval(const char *name, const Eval *e, uint16_t experts, int comma) { + double accuracy = (double)e->correct / (double)e->samples; + double cert = (double)e->certified / (double)e->samples; + double mean = (double)e->expert_evaluations / (double)e->samples; + printf(" \"%s\":{\"experts\":%u,\"samples\":%" PRIu64 ",\"accuracy\":%.9f," + "\"exact_mismatches\":%" PRIu64 ",\"certified_rate\":%.9f," + "\"mean_experts\":%.6f,\"checksum\":\"%016" PRIx64 "\"}%s\n", + name, experts, e->samples, accuracy, e->exact_mismatches, cert, mean, + e->checksum, comma ? "," : ""); +} + +int main(void) { + make_teacher(); + make_dataset(train_set, NTRAIN, UINT64_C(0x747261696e000001)); + make_dataset(test_set, NTEST, UINT64_C(0x686f6c646f757401)); + + Expert recursive[MAXE], fixed[MAXE], flat[MAXE]; + TrainMetric rt = {0}, ft = {0}, flt = {0}; + uint16_t rn = train_recursive(recursive, &rt); + train_flat(fixed, INIT_E, FIXED_REFINE, &ft); + train_flat(flat, MAXE, FLAT_REFINE, &flt); + + Eval re = evaluate(recursive, rn, 1); + Eval fe = evaluate(fixed, INIT_E, 0); + Eval fle = evaluate(flat, MAXE, 0); + + double racc = (double)re.correct / (double)re.samples; + double facc = (double)fe.correct / (double)fe.samples; + double flacc = (double)fle.correct / (double)fle.samples; + double rmean = (double)re.expert_evaluations / (double)re.samples; + int pass = rn == MAXE && re.exact_mismatches == 0u && racc >= 0.95 && + racc + 0.01 >= flacc && racc - facc >= 0.20 && rmean <= 16.0; + + printf("{\n \"schema\":\"ravel-training-evidence/0.2\",\n"); + printf(" \"dataset\":{\"train\":%u,\"holdout\":%u,\"dimensions\":%u," + "\"latent_regions\":%u,\"classes\":%u},\n", NTRAIN, NTEST, D, TEACHERS, CLASSES); + printf(" \"training\":{\n"); + printf(" \"recursive\":{\"final_experts\":%u,\"splits\":%" PRIu64 + ",\"samples_processed\":%" PRIu64 ",\"expert_evaluations\":%" PRIu64 + ",\"certified_routes\":%" PRIu64 ",\"lineage_digest\":\"%016" PRIx64 "\"},\n", + rn, rt.splits, rt.samples, rt.expert_evaluations, rt.certified, rt.lineage_digest); + printf(" \"fixed8\":{\"expert_evaluations\":%" PRIu64 "},\n", ft.expert_evaluations); + printf(" \"flat64\":{\"expert_evaluations\":%" PRIu64 "}\n", flt.expert_evaluations); + printf(" },\n \"holdout\":{\n"); + print_eval("recursive", &re, rn, 1); + print_eval("fixed8", &fe, INIT_E, 1); + print_eval("flat64", &fle, MAXE, 0); + printf(" },\n \"development_result\":\"%s\",\n", pass ? "PASS" : "FAIL"); + printf(" \"formal_mncs_status\":\"UNKNOWN\",\n"); + printf(" \"formal_mncds_status\":\"UNKNOWN\",\n"); + printf(" \"promotion_authorized\":false\n}\n"); + return pass ? 0 : 1; +} diff --git a/ravel_unified.c b/ravel_unified.c new file mode 100644 index 0000000..2c230a2 --- /dev/null +++ b/ravel_unified.c @@ -0,0 +1,5 @@ +/* Generated RAVEL-U 0.3 execution shards. Do not hand-edit the shards. */ +#include "ravel_unified/00_core.inc" +#include "ravel_unified/10_route.inc" +#include "ravel_unified/20_train.inc" +#include "ravel_unified/30_eval.inc" diff --git a/ravel_unified/00_core.inc b/ravel_unified/00_core.inc new file mode 100644 index 0000000..41d38e8 --- /dev/null +++ b/ravel_unified/00_core.inc @@ -0,0 +1,150 @@ +#define _POSIX_C_SOURCE 200809L +#include +#include +#include +#include +#include +#include +#include +#include + +#define D 8u +#define CLASSES 8u +#define STATES 64u +#define ACTIONS 4u +#define MAXE 96u +#define BASE_E 64u +#define INIT_E 8u +#define ROUTE_K 8u +#define CELLS 256u +#define NTRAIN 32768u +#define NHOLD 8192u +#define NADAPT 16384u +#define NREPLAY 8192u +#define ADAPT_BIRTHS 24u +#define ADAPT_TARGET 80u +#define GROW_PER_ROUND 8u +#define REFINE_FINAL 5u +#define REFINE_ADAPT 6u +#define LO (-64) +#define HI 63 +#define PLAN_CASES 512u +#define PLAN_LIMIT 32u + +/* One event supplies all learning surfaces: present, action, label, next observation. */ +typedef struct { + int8_t x[D]; + int8_t nx[D]; + uint8_t action; + uint8_t label; + uint8_t state; + uint8_t next_state; +} Event; + +typedef struct { + double key[D]; /* retrieval key + compressed present-state representation */ + double decode[D]; /* reconstruction program */ + double next[ACTIONS][D]; /* action-conditioned world-model program */ + uint32_t labels[CLASSES]; + uint32_t action_count[ACTIONS]; + uint32_t count; + uint32_t errors; + double reconstruction_sse; + double prediction_sse; + uint8_t label; + uint8_t active; + uint16_t generation; + uint64_t lineage; +} Expert; + +typedef struct { + uint16_t id[ROUTE_K]; + double excluded_lb; +} Cell; + +typedef struct { + Expert e[MAXE]; + uint16_t n; + uint16_t next_graph[MAXE][ACTIONS]; + uint64_t epoch; + uint64_t digest; +} Model; + +typedef struct { + uint64_t samples; + uint64_t correct; + uint64_t exact_mismatches; + uint64_t certified; + uint64_t expert_evaluations; + double reconstruction_sse; + double prediction_sse; + uint64_t transition_correct; + uint64_t checksum; +} Eval; + +typedef struct { + uint64_t samples; + uint64_t expert_evaluations; + uint64_t certified; + uint64_t births; + uint64_t retired; + uint64_t lineage_digest; +} TrainMetric; + +typedef struct { + uint64_t cases; + uint64_t solved; + uint64_t exact_goals; + uint64_t expansions; + uint64_t checksum; +} PlanMetric; + +static uint64_t rng_state = UINT64_C(0x524156454c553033); +static int8_t world_c[STATES][D]; +static uint8_t world_y[STATES]; +static uint8_t world_next[STATES][ACTIONS]; +static Event train_set[NTRAIN]; +static Event hold_set[NHOLD]; +static Event adapt_set[NADAPT]; +static Event replay_set[NREPLAY]; +static Event adapt_mix[NADAPT + NREPLAY]; +static uint16_t assignment[NTRAIN > (NADAPT + NREPLAY) ? NTRAIN : (NADAPT + NREPLAY)]; + +static uint32_t rng_u32(void) { + rng_state ^= rng_state >> 12; + rng_state ^= rng_state << 25; + rng_state ^= rng_state >> 27; + return (uint32_t)((rng_state * UINT64_C(2685821657736338717)) >> 32); +} + +static uint64_t mix64(uint64_t x) { + x ^= x >> 30; x *= UINT64_C(0xbf58476d1ce4e5b9); + x ^= x >> 27; x *= UINT64_C(0x94d049bb133111eb); + return x ^ (x >> 31); +} + +static int8_t clamp_i8(int v) { + if (v < LO) return (int8_t)LO; + if (v > HI) return (int8_t)HI; + return (int8_t)v; +} + +static uint8_t majority(const uint32_t counts[CLASSES]) { + uint8_t best = 0u; + for (uint8_t y = 1u; y < CLASSES; ++y) { + if (counts[y] > counts[best]) best = y; + } + return best; +} + +static void make_world(void) { + for (uint32_t s = 0; s < STATES; ++s) { + for (uint32_t d = 0; d < 6u; ++d) world_c[s][d] = (int8_t)(((s >> d) & 1u) ? 42 : -42); + world_c[s][6] = (int8_t)(-36 + 24 * (int)((s * 5u + (s >> 2)) & 3u)); + world_c[s][7] = (int8_t)(-36 + 24 * (int)((s * 3u + (s >> 1)) & 3u)); + world_y[s] = (uint8_t)(((s * 29u) ^ (s >> 1) ^ (s >> 3)) & 7u); + world_next[s][0] = (uint8_t)((s + 1u) & 63u); + world_next[s][1] = (uint8_t)((s + 63u) & 63u); + world_next[s][2] = (uint8_t)(s ^ 8u); + world_next[s][3] = (uint8_t)(s ^ 32u); + } diff --git a/ravel_unified/10_route.inc b/ravel_unified/10_route.inc new file mode 100644 index 0000000..dbe58f4 --- /dev/null +++ b/ravel_unified/10_route.inc @@ -0,0 +1,170 @@ +} + +static void observation(uint8_t state, int drift, int8_t out[D]) { + for (uint32_t d = 0; d < D; ++d) { + int shift = 0; + if (drift && state < 16u) { + if (d == 6u) shift = 18; + if (d == 7u) shift = -18; + } + out[d] = clamp_i8((int)world_c[state][d] + shift + (int)(rng_u32() % 11u) - 5); + } +} + +static void make_dataset(Event *out, uint32_t n, uint64_t seed, int drift) { + rng_state = seed; + for (uint32_t i = 0; i < n; ++i) { + uint8_t s = (uint8_t)(rng_u32() % STATES); + uint8_t a = (uint8_t)(rng_u32() % ACTIONS); + uint8_t ns = world_next[s][a]; + out[i].state = s; + out[i].next_state = ns; + out[i].action = a; + out[i].label = (uint8_t)(drift && s < 16u ? ((world_y[s] + 3u) & 7u) : world_y[s]); + observation(s, drift, out[i].x); + observation(ns, drift, out[i].nx); + } +} + +static double dist_x(const int8_t x[D], const Expert *e) { + double z = 0.0; + for (uint32_t d = 0; d < D; ++d) { + double v = (double)x[d] - e->key[d]; + z += v * v; + } + return z; +} + +static double dist_vec(const double a[D], const double b[D]) { + double z = 0.0; + for (uint32_t d = 0; d < D; ++d) { + double v = a[d] - b[d]; + z += v * v; + } + return z; +} + +static uint16_t cell_id(const int8_t x[D], int *in_domain) { + uint16_t b = 0u; + *in_domain = 1; + for (uint32_t d = 0; d < D; ++d) if (x[d] < LO || x[d] > HI) *in_domain = 0; + for (uint32_t d = 0; d < 4u; ++d) { + int v = ((int)x[d] - LO) / 32; + if (v < 0) v = 0; + if (v > 3) v = 3; + b = (uint16_t)((b << 2) | (uint16_t)v); + } + return b; +} + +static double axis_lb(double c, double lo, double hi) { + if (c < lo) { double v = lo - c; return v * v; } + if (c > hi) { double v = c - hi; return v * v; } + return 0.0; +} + +static int better(double d, uint16_t id, double bd, uint16_t bi) { + return d < bd || (d == bd && id < bi); +} + +static void build_lattice(const Model *m, Cell cells[CELLS]) { + for (uint32_t b = 0; b < CELLS; ++b) { + double d[MAXE]; + uint16_t id[MAXE]; + for (uint16_t j = 0; j < m->n; ++j) { + double z = 0.0; + for (uint32_t k = 0; k < 4u; ++k) { + uint32_t shift = 2u * (3u - k); + uint32_t v = (b >> shift) & 3u; + double lo = (double)(LO + 32 * (int)v); + z += axis_lb(m->e[j].key[k], lo, lo + 31.0); + } + d[j] = z; id[j] = j; + } + uint16_t take = m->n < ROUTE_K ? m->n : ROUTE_K; + uint16_t need = m->n > ROUTE_K ? (uint16_t)(ROUTE_K + 1u) : m->n; + for (uint16_t i = 0; i < need; ++i) { + uint16_t k = i; + for (uint16_t j = (uint16_t)(i + 1u); j < m->n; ++j) { + if (d[j] < d[k] || (d[j] == d[k] && id[j] < id[k])) k = j; + } + double td = d[i]; d[i] = d[k]; d[k] = td; + uint16_t ti = id[i]; id[i] = id[k]; id[k] = ti; + } + for (uint16_t i = 0; i < ROUTE_K; ++i) cells[b].id[i] = UINT16_MAX; + for (uint16_t i = 0; i < take; ++i) cells[b].id[i] = id[i]; + cells[b].excluded_lb = m->n > ROUTE_K ? d[ROUTE_K] : DBL_MAX; + } +} + +static uint16_t full_nearest(const int8_t x[D], const Model *m, uint64_t *evals) { + double bd = DBL_MAX; uint16_t bi = UINT16_MAX; + for (uint16_t j = 0; j < m->n; ++j) { + double d = dist_x(x, &m->e[j]); + ++*evals; + if (better(d, j, bd, bi)) { bd = d; bi = j; } + } + return bi; +} + +static uint16_t routed_nearest(const int8_t x[D], const Model *m, const Cell cells[CELLS], + uint64_t *evals, uint64_t *certified) { + int in_domain = 0; + uint16_t b = cell_id(x, &in_domain); + uint8_t seen[MAXE]; memset(seen, 0, sizeof seen); + double bd = DBL_MAX; uint16_t bi = UINT16_MAX; + uint16_t take = m->n < ROUTE_K ? m->n : ROUTE_K; + for (uint16_t i = 0; i < take; ++i) { + uint16_t j = cells[b].id[i]; assert(j < m->n); seen[j] = 1u; + double d = dist_x(x, &m->e[j]); ++*evals; + if (better(d, j, bd, bi)) { bd = d; bi = j; } + } + if (in_domain && bd < cells[b].excluded_lb) { ++*certified; return bi; } + for (uint16_t j = 0; j < m->n; ++j) if (!seen[j]) { + double d = dist_x(x, &m->e[j]); ++*evals; + if (better(d, j, bd, bi)) { bd = d; bi = j; } + } + return bi; +} + +static void seed_expert(Expert *e, const Event *ev, uint64_t lineage, uint16_t generation) { + memset(e, 0, sizeof *e); + for (uint32_t d = 0; d < D; ++d) { + e->key[d] = (double)ev->x[d]; + e->decode[d] = (double)ev->x[d]; + for (uint32_t a = 0; a < ACTIONS; ++a) e->next[a][d] = (double)ev->nx[d]; + } + e->label = ev->label; + e->lineage = lineage; + e->generation = generation; + e->active = 1u; +} + +static void farthest_init(Model *m, uint16_t n, const Event *data, uint32_t count, TrainMetric *tm) { + memset(m, 0, sizeof *m); + m->n = n; + seed_expert(&m->e[0], &data[0], mix64(UINT64_C(0x524156454c550001)), 0u); + for (uint16_t k = 1; k < n; ++k) { + double far = -1.0; uint32_t fi = 0u; + for (uint32_t i = 0; i < count; ++i) { + double near = DBL_MAX; + for (uint16_t j = 0; j < k; ++j) { + double d = dist_x(data[i].x, &m->e[j]); ++tm->expert_evaluations; + if (d < near) near = d; + } + if (near > far) { far = near; fi = i; } + } + seed_expert(&m->e[k], &data[fi], mix64(m->e[0].lineage ^ k), 0u); + } +} + +static void refine(Model *m, const Event *data, uint32_t count, uint32_t iterations, + int routed, uint16_t *out_assignment, TrainMetric *tm) { + Cell cells[CELLS]; + for (uint32_t it = 0; it < iterations; ++it) { + double key_sum[MAXE][D], decode_sum[MAXE][D], next_sum[MAXE][ACTIONS][D]; + uint32_t counts[MAXE], labels[MAXE][CLASSES], action_count[MAXE][ACTIONS]; + uint32_t errors[MAXE]; double rsse[MAXE], psse[MAXE]; + memset(key_sum, 0, sizeof key_sum); memset(decode_sum, 0, sizeof decode_sum); + memset(next_sum, 0, sizeof next_sum); memset(counts, 0, sizeof counts); + memset(labels, 0, sizeof labels); memset(action_count, 0, sizeof action_count); diff --git a/ravel_unified/20_train.inc b/ravel_unified/20_train.inc new file mode 100644 index 0000000..a7e8bdb --- /dev/null +++ b/ravel_unified/20_train.inc @@ -0,0 +1,159 @@ + memset(errors, 0, sizeof errors); memset(rsse, 0, sizeof rsse); memset(psse, 0, sizeof psse); + if (routed) build_lattice(m, cells); + for (uint32_t i = 0; i < count; ++i) { + uint16_t j = routed ? routed_nearest(data[i].x, m, cells, &tm->expert_evaluations, &tm->certified) + : full_nearest(data[i].x, m, &tm->expert_evaluations); + ++tm->samples; + if (out_assignment != NULL) out_assignment[i] = j; + ++counts[j]; ++labels[j][data[i].label]; ++action_count[j][data[i].action]; + if (m->e[j].label != data[i].label) ++errors[j]; + for (uint32_t d = 0; d < D; ++d) { + double x = (double)data[i].x[d], nx = (double)data[i].nx[d]; + key_sum[j][d] += x; decode_sum[j][d] += x; + next_sum[j][data[i].action][d] += nx; + double rv = x - m->e[j].decode[d]; rsse[j] += rv * rv; + double pv = nx - m->e[j].next[data[i].action][d]; psse[j] += pv * pv; + } + } + for (uint16_t j = 0; j < m->n; ++j) { + m->e[j].count = counts[j]; m->e[j].errors = errors[j]; + m->e[j].reconstruction_sse = rsse[j]; m->e[j].prediction_sse = psse[j]; + memcpy(m->e[j].labels, labels[j], sizeof m->e[j].labels); + memcpy(m->e[j].action_count, action_count[j], sizeof m->e[j].action_count); + if (counts[j] > 0u) { + for (uint32_t d = 0; d < D; ++d) { + m->e[j].key[d] = key_sum[j][d] / (double)counts[j]; + m->e[j].decode[d] = decode_sum[j][d] / (double)counts[j]; + } + m->e[j].label = majority(labels[j]); + for (uint32_t a = 0; a < ACTIONS; ++a) if (action_count[j][a] > 0u) { + for (uint32_t d = 0; d < D; ++d) m->e[j].next[a][d] = next_sum[j][a][d] / (double)action_count[j][a]; + } + } + } + } +} + +static double split_score(const Expert *e) { + if (e->count < 2u) return -1.0; + return (double)e->errors * 1e12 + e->prediction_sse * 1e3 + e->reconstruction_sse + (double)e->count; +} + +static int split_one(Model *m, uint16_t parent, uint16_t child, const Event *data, + uint32_t count, const uint16_t *a, uint32_t round) { + uint32_t first = UINT32_MAX; + for (uint32_t i = 0; i < count; ++i) if (a[i] == parent) { first = i; break; } + if (first == UINT32_MAX) return 0; + uint32_t pa = first, pb = first; double far = -1.0; + for (uint32_t i = 0; i < count; ++i) if (a[i] == parent) { + double z = 0.0; for (uint32_t d = 0; d < D; ++d) { double v = (double)data[i].x[d] - data[first].x[d]; z += v * v; } + if (z > far) { far = z; pa = i; } + } + far = -1.0; + for (uint32_t i = 0; i < count; ++i) if (a[i] == parent) { + double z = 0.0; for (uint32_t d = 0; d < D; ++d) { double v = (double)data[i].x[d] - data[pa].x[d]; z += v * v; } + if (z > far) { far = z; pb = i; } + } + if (pa == pb) return 0; + uint64_t root = m->e[parent].lineage; + seed_expert(&m->e[parent], &data[pa], mix64(root ^ ((uint64_t)round << 32) ^ UINT64_C(0xa5)), (uint16_t)(m->e[parent].generation + 1u)); + seed_expert(&m->e[child], &data[pb], mix64(root ^ ((uint64_t)round << 32) ^ UINT64_C(0x5a)), (uint16_t)(m->e[parent].generation + 1u)); + return 1; +} + +static void train_base(Model *m, TrainMetric *tm) { + farthest_init(m, INIT_E, train_set, NTRAIN, tm); + uint32_t round = 0u; + while (m->n < BASE_E) { + refine(m, train_set, NTRAIN, 1u, 1, assignment, tm); + uint16_t order[MAXE]; for (uint16_t j = 0; j < m->n; ++j) order[j] = j; + for (uint16_t i = 0; i < m->n; ++i) { + uint16_t k = i; + for (uint16_t j = (uint16_t)(i + 1u); j < m->n; ++j) { + double a = split_score(&m->e[order[j]]), b = split_score(&m->e[order[k]]); + if (a > b || (a == b && order[j] < order[k])) k = j; + } + uint16_t t = order[i]; order[i] = order[k]; order[k] = t; + } + uint16_t target = (uint16_t)((BASE_E - m->n) < GROW_PER_ROUND ? (BASE_E - m->n) : GROW_PER_ROUND); + uint16_t made = 0u; + for (uint16_t i = 0; i < m->n && made < target; ++i) { + if (split_one(m, order[i], (uint16_t)(m->n + made), train_set, NTRAIN, assignment, round)) { ++made; ++tm->births; } + } + if (made == 0u) break; + m->n = (uint16_t)(m->n + made); ++round; + } + refine(m, train_set, NTRAIN, REFINE_FINAL, 1, assignment, tm); + ++m->epoch; +} + +static void birth_drift_experts(Model *m, const Event *data, uint32_t count, TrainMetric *tm) { + Cell cells[CELLS]; build_lattice(m, cells); + double score[NADAPT]; + for (uint32_t i = 0; i < count; ++i) { + uint64_t evals = 0u, cert = 0u; + uint16_t j = routed_nearest(data[i].x, m, cells, &evals, &cert); + tm->expert_evaluations += evals; tm->certified += cert; ++tm->samples; + double p = 0.0; + for (uint32_t d = 0; d < D; ++d) { double v = (double)data[i].nx[d] - m->e[j].next[data[i].action][d]; p += v * v; } + score[i] = (m->e[j].label != data[i].label ? 1e12 : 0.0) + p; + } + for (uint16_t b = 0; b < ADAPT_BIRTHS && m->n < MAXE; ++b) { + uint32_t best = 0u; double bs = -1.0; + for (uint32_t i = 0; i < count; ++i) { + double separation = DBL_MAX; + for (uint16_t j = 0; j < m->n; ++j) { + double d = dist_x(data[i].x, &m->e[j]); + if (d < separation) separation = d; + } + double s = score[i] + separation * 1e6; + if (s > bs) { bs = s; best = i; } + } + seed_expert(&m->e[m->n], &data[best], mix64(UINT64_C(0x4452494654424952) ^ m->n ^ m->epoch), (uint16_t)(m->epoch + 1u)); + ++m->n; ++tm->births; score[best] = -DBL_MAX; + } +} + +static void remove_expert(Model *m, uint16_t victim) { + assert(victim < m->n); + uint16_t last = (uint16_t)(m->n - 1u); + if (victim != last) m->e[victim] = m->e[last]; + memset(&m->e[last], 0, sizeof m->e[last]); + --m->n; +} + +static void retire_to_target(Model *m, const Event *data, uint32_t count, TrainMetric *tm) { + while (m->n > ADAPT_TARGET) { + uint16_t victim = BASE_E; + for (uint16_t j = (uint16_t)(BASE_E + 1u); j < m->n; ++j) { + const Expert *a = &m->e[j], *b = &m->e[victim]; + double ua = (double)a->count * 1e9 - (double)a->errors * 1e12 - a->prediction_sse; + double ub = (double)b->count * 1e9 - (double)b->errors * 1e12 - b->prediction_sse; + if (ua < ub || (ua == ub && j > victim)) victim = j; + } + remove_expert(m, victim); + ++tm->retired; + refine(m, data, count, 1u, 1, assignment, tm); + } +} + +static void adapt_model(Model *m, TrainMetric *tm) { + for (uint32_t i = 0; i < NREPLAY; ++i) replay_set[i] = train_set[(i * 4u) % NTRAIN]; + memcpy(adapt_mix, adapt_set, sizeof adapt_set); + memcpy(adapt_mix + NADAPT, replay_set, sizeof replay_set); + birth_drift_experts(m, adapt_set, NADAPT, tm); + refine(m, adapt_mix, NADAPT + NREPLAY, REFINE_ADAPT, 1, assignment, tm); + retire_to_target(m, adapt_mix, NADAPT + NREPLAY, tm); + ++m->epoch; +} + +static uint16_t nearest_vec(const double v[D], const Model *m) { + double bd = DBL_MAX; uint16_t bi = UINT16_MAX; + for (uint16_t j = 0; j < m->n; ++j) { + double d = dist_vec(v, m->e[j].key); + if (better(d, j, bd, bi)) { bd = d; bi = j; } + } + return bi; +} + +static void compile_graph(Model *m) { diff --git a/ravel_unified/30_eval.inc b/ravel_unified/30_eval.inc new file mode 100644 index 0000000..35e728b --- /dev/null +++ b/ravel_unified/30_eval.inc @@ -0,0 +1,162 @@ + for (uint16_t j = 0; j < m->n; ++j) { + for (uint32_t a = 0; a < ACTIONS; ++a) m->next_graph[j][a] = nearest_vec(m->e[j].next[a], m); + } +} + +static uint64_t model_digest(const Model *m) { + uint64_t h = mix64(m->n ^ (m->epoch << 32)); + for (uint16_t j = 0; j < m->n; ++j) { + uint64_t q = m->e[j].lineage ^ ((uint64_t)m->e[j].label << 56) ^ m->e[j].count; + for (uint32_t d = 0; d < D; ++d) { + int64_t v = (int64_t)llround(m->e[j].key[d] * 1024.0); + q ^= mix64((uint64_t)v ^ ((uint64_t)d << 48)); + } + for (uint32_t a = 0; a < ACTIONS; ++a) q ^= mix64(((uint64_t)m->next_graph[j][a] << 32) ^ a); + h ^= mix64(q ^ j); + } + return h; +} + +static Eval evaluate(const Model *m, const Event *data, uint32_t count) { + Eval out = {0}; Cell cells[CELLS]; build_lattice(m, cells); + for (uint32_t i = 0; i < count; ++i) { + uint16_t got = routed_nearest(data[i].x, m, cells, &out.expert_evaluations, &out.certified); + uint64_t oe = 0u; uint16_t oracle = full_nearest(data[i].x, m, &oe); + if (got != oracle) ++out.exact_mismatches; + if (m->e[got].label == data[i].label) ++out.correct; + double pred[D]; + for (uint32_t d = 0; d < D; ++d) { + double rv = (double)data[i].x[d] - m->e[got].decode[d]; out.reconstruction_sse += rv * rv; + pred[d] = m->e[got].next[data[i].action][d]; + double pv = (double)data[i].nx[d] - pred[d]; out.prediction_sse += pv * pv; + } + uint16_t next_e = nearest_vec(pred, m); + uint64_t ne = 0u; uint16_t true_next_e = full_nearest(data[i].nx, m, &ne); + if (next_e == true_next_e) ++out.transition_correct; + ++out.samples; + out.checksum ^= mix64(((uint64_t)got << 48) ^ ((uint64_t)next_e << 32) ^ ((uint64_t)m->e[got].label << 24) ^ i); + } + return out; +} + +static int plan_actions(const Model *m, uint16_t start, uint16_t goal, uint8_t actions[PLAN_LIMIT], uint32_t *used, uint64_t *expansions) { + uint16_t queue[MAXE], parent[MAXE], parent_action[MAXE]; uint8_t seen[MAXE]; + memset(seen, 0, sizeof seen); for (uint16_t i = 0; i < MAXE; ++i) { parent[i] = UINT16_MAX; parent_action[i] = UINT16_MAX; } + uint16_t qh = 0u, qt = 0u; queue[qt++] = start; seen[start] = 1u; + while (qh < qt) { + uint16_t cur = queue[qh++]; ++*expansions; + if (cur == goal) break; + for (uint16_t a = 0; a < ACTIONS; ++a) { + uint16_t nx = m->next_graph[cur][a]; + if (!seen[nx]) { seen[nx] = 1u; parent[nx] = cur; parent_action[nx] = a; queue[qt++] = nx; } + } + } + if (!seen[goal]) return 0; + uint8_t rev[PLAN_LIMIT]; uint32_t n = 0u; uint16_t cur = goal; + while (cur != start && n < PLAN_LIMIT) { rev[n++] = (uint8_t)parent_action[cur]; cur = parent[cur]; } + if (cur != start) return 0; + for (uint32_t i = 0; i < n; ++i) actions[i] = rev[n - 1u - i]; + *used = n; return 1; +} + +static PlanMetric evaluate_planning(const Model *m, int drift) { + PlanMetric pm = {0}; rng_state = UINT64_C(0x504c414e484f4c44) ^ (uint64_t)drift; + Cell cells[CELLS]; build_lattice(m, cells); + for (uint32_t i = 0; i < PLAN_CASES; ++i) { + uint8_t s = (uint8_t)(rng_u32() % STATES), g = (uint8_t)(rng_u32() % STATES); + int8_t sx[D], gx[D]; observation(s, drift, sx); observation(g, drift, gx); + uint64_t ev = 0u, cert = 0u; + uint16_t se = routed_nearest(sx, m, cells, &ev, &cert); + uint16_t ge = routed_nearest(gx, m, cells, &ev, &cert); + uint8_t acts[PLAN_LIMIT]; uint32_t used = 0u; + ++pm.cases; + if (!plan_actions(m, se, ge, acts, &used, &pm.expansions)) continue; + ++pm.solved; + uint8_t cur = s; + for (uint32_t k = 0; k < used; ++k) cur = world_next[cur][acts[k]]; + int8_t fx[D]; for (uint32_t d = 0; d < D; ++d) { + int shift = (drift && cur < 16u) ? (d == 6u ? 18 : d == 7u ? -18 : 0) : 0; + fx[d] = clamp_i8((int)world_c[cur][d] + shift); + } + uint16_t fe = routed_nearest(fx, m, cells, &ev, &cert); + if (fe == ge) ++pm.exact_goals; + pm.checksum ^= mix64(((uint64_t)se << 48) ^ ((uint64_t)ge << 32) ^ ((uint64_t)fe << 16) ^ used ^ i); + } + return pm; +} + +static int checkpoint_roundtrip(const Model *m, Model *out) { + const char *path = "ravel-unified-checkpoint.bin"; + FILE *f = fopen(path, "wb"); if (f == NULL) return 0; + size_t wrote = fwrite(m, sizeof *m, 1u, f); int ok = fclose(f) == 0 && wrote == 1u; + if (!ok) { remove(path); return 0; } + f = fopen(path, "rb"); if (f == NULL) { remove(path); return 0; } + size_t read = fread(out, sizeof *out, 1u, f); ok = fclose(f) == 0 && read == 1u; + remove(path); return ok; +} + +static void print_eval(const char *name, const Eval *e, uint16_t experts, int comma) { + double acc = (double)e->correct / e->samples; + double cert = (double)e->certified / e->samples; + double mean = (double)e->expert_evaluations / e->samples; + double rrmse = sqrt(e->reconstruction_sse / (double)(e->samples * D)); + double prmse = sqrt(e->prediction_sse / (double)(e->samples * D)); + double tr = (double)e->transition_correct / e->samples; + printf(" \"%s\":{\"experts\":%u,\"samples\":%" PRIu64 ",\"accuracy\":%.9f,\"exact_mismatches\":%" PRIu64 ",\"certified_rate\":%.9f,\"mean_experts\":%.6f,\"reconstruction_rmse\":%.9f,\"next_prediction_rmse\":%.9f,\"transition_accuracy\":%.9f,\"checksum\":\"%016" PRIx64 "\"}%s\n", + name, experts, e->samples, acc, e->exact_mismatches, cert, mean, rrmse, prmse, tr, e->checksum, comma ? "," : ""); +} + +int main(void) { + make_world(); + make_dataset(train_set, NTRAIN, UINT64_C(0x747261696e550001), 0); + make_dataset(hold_set, NHOLD, UINT64_C(0x686f6c6455000001), 0); + make_dataset(adapt_set, NADAPT, UINT64_C(0x6164617074550001), 1); + + Model base; TrainMetric base_tm = {0}; train_base(&base, &base_tm); compile_graph(&base); base.digest = model_digest(&base); + Eval base_hold = evaluate(&base, hold_set, NHOLD); + Eval static_drift = evaluate(&base, adapt_set, NADAPT); + PlanMetric base_plan = evaluate_planning(&base, 0); + + Model adapted = base; TrainMetric adapt_tm = {0}; adapt_model(&adapted, &adapt_tm); compile_graph(&adapted); adapted.digest = model_digest(&adapted); + Eval adapted_drift = evaluate(&adapted, adapt_set, NADAPT); + Eval retained_hold = evaluate(&adapted, hold_set, NHOLD); + PlanMetric adapted_plan = evaluate_planning(&adapted, 1); + + Model restored; int checkpoint_ok = checkpoint_roundtrip(&adapted, &restored); + uint64_t restored_digest = checkpoint_ok ? model_digest(&restored) : 0u; + Eval restored_eval = checkpoint_ok ? evaluate(&restored, adapt_set, NADAPT) : (Eval){0}; + + double base_acc = (double)base_hold.correct / base_hold.samples; + double drift_static_acc = (double)static_drift.correct / static_drift.samples; + double drift_adapt_acc = (double)adapted_drift.correct / adapted_drift.samples; + double retain_acc = (double)retained_hold.correct / retained_hold.samples; + double transition = (double)adapted_drift.transition_correct / adapted_drift.samples; + double plan_success = (double)adapted_plan.exact_goals / adapted_plan.cases; + int pass = base.n == BASE_E && adapted.n == ADAPT_TARGET && + base_hold.exact_mismatches == 0u && adapted_drift.exact_mismatches == 0u && + base_acc >= 0.95 && drift_adapt_acc >= 0.95 && drift_adapt_acc >= drift_static_acc + 0.20 && + retain_acc >= 0.90 && transition >= 0.95 && plan_success >= 0.90 && + checkpoint_ok && restored_digest == adapted.digest && restored_eval.checksum == adapted_drift.checksum; + + printf("{\n \"schema\":\"ravel-unified-evidence/0.3\",\n"); + printf(" \"architecture\":{\"event_dimensions\":%u,\"classes\":%u,\"actions\":%u,\"world_states\":%u,\"route_width\":%u},\n", D, CLASSES, ACTIONS, STATES, ROUTE_K); + printf(" \"base_training\":{\"initial_experts\":%u,\"final_experts\":%u,\"births\":%" PRIu64 ",\"samples_processed\":%" PRIu64 ",\"expert_evaluations\":%" PRIu64 ",\"certified_routes\":%" PRIu64 ",\"model_digest\":\"%016" PRIx64 "\"},\n", + INIT_E, base.n, base_tm.births, base_tm.samples, base_tm.expert_evaluations, base_tm.certified, base.digest); + printf(" \"continual_adaptation\":{\"births\":%" PRIu64 ",\"retired\":%" PRIu64 ",\"final_experts\":%u,\"samples_processed\":%" PRIu64 ",\"expert_evaluations\":%" PRIu64 ",\"certified_routes\":%" PRIu64 ",\"model_digest\":\"%016" PRIx64 "\"},\n", + adapt_tm.births, adapt_tm.retired, adapted.n, adapt_tm.samples, adapt_tm.expert_evaluations, adapt_tm.certified, adapted.digest); + printf(" \"evaluation\":{\n"); + print_eval("base_holdout", &base_hold, base.n, 1); + print_eval("static_on_drift", &static_drift, base.n, 1); + print_eval("adapted_on_drift", &adapted_drift, adapted.n, 1); + print_eval("adapted_retention", &retained_hold, adapted.n, 0); + printf(" },\n"); + printf(" \"planning\":{\"base\":{\"cases\":%" PRIu64 ",\"solved\":%" PRIu64 ",\"exact_goals\":%" PRIu64 ",\"expansions\":%" PRIu64 ",\"checksum\":\"%016" PRIx64 "\"},\"adapted\":{\"cases\":%" PRIu64 ",\"solved\":%" PRIu64 ",\"exact_goals\":%" PRIu64 ",\"expansions\":%" PRIu64 ",\"checksum\":\"%016" PRIx64 "\"}},\n", + base_plan.cases, base_plan.solved, base_plan.exact_goals, base_plan.expansions, base_plan.checksum, + adapted_plan.cases, adapted_plan.solved, adapted_plan.exact_goals, adapted_plan.expansions, adapted_plan.checksum); + printf(" \"checkpoint\":{\"roundtrip\":%s,\"digest_match\":%s,\"evaluation_match\":%s},\n", + checkpoint_ok ? "true" : "false", restored_digest == adapted.digest ? "true" : "false", restored_eval.checksum == adapted_drift.checksum ? "true" : "false"); + printf(" \"gates\":{\"base_accuracy_at_least_0_95\":%s,\"adapted_drift_accuracy_at_least_0_95\":%s,\"drift_gain_at_least_0_20\":%s,\"retention_at_least_0_90\":%s,\"transition_accuracy_at_least_0_95\":%s,\"planning_success_at_least_0_90\":%s,\"exact_routing\":%s,\"checkpoint_reproducible\":%s},\n", + base_acc >= 0.95 ? "true" : "false", drift_adapt_acc >= 0.95 ? "true" : "false", drift_adapt_acc >= drift_static_acc + 0.20 ? "true" : "false", retain_acc >= 0.90 ? "true" : "false", transition >= 0.95 ? "true" : "false", plan_success >= 0.90 ? "true" : "false", (base_hold.exact_mismatches == 0u && adapted_drift.exact_mismatches == 0u) ? "true" : "false", (checkpoint_ok && restored_digest == adapted.digest && restored_eval.checksum == adapted_drift.checksum) ? "true" : "false"); + printf(" \"development_result\":\"%s\",\n \"formal_mncs_status\":\"UNKNOWN\",\n \"formal_mncds_status\":\"UNKNOWN\",\n \"promotion_authorized\":false\n}\n", pass ? "PASS" : "FAIL"); + return pass ? 0 : 1; +} diff --git a/training-assurance-case.json b/training-assurance-case.json new file mode 100644 index 0000000..8753563 --- /dev/null +++ b/training-assurance-case.json @@ -0,0 +1,42 @@ +{ + "schema_version": "0.2", + "assurance_case_id": "ravel.recursive-training.epoch-1.assurance.v1", + "claim": "The bounded RAVEL-T recursive trainer formed and routed a 64-expert classifier under the preregistered deterministic synthetic protocol.", + "development_result": "PASS", + "disposition": "REVIEW_REQUIRED", + "formal_mncs_status": "UNKNOWN", + "formal_mncds_status": "UNKNOWN", + "promotion_authorized": false, + "implementation": { + "source": "ravel_train.c", + "source_sha256": "90671ef2812c34eff6a8ce71a1cbf9e98d00d5943d0f3f0d275539eab9a42753", + "language": "C11" + }, + "evidence": { + "record": "training-evidence.json", + "record_sha256": "a3ba60ef239c1b61bcd66671ffeda29f30f5a55dfd3f858723f743e9899a0dec", + "deterministic_reproduction": true, + "routed_oracle_agreement": true, + "holdout_protected": false + }, + "observed_benefit": { + "recursive_holdout_accuracy": 1.0, + "flat64_holdout_accuracy": 1.0, + "fixed8_holdout_accuracy": 0.224609375, + "recursive_holdout_mean_experts": 8.0, + "flat64_holdout_mean_experts": 64.0, + "recursive_training_expert_evaluations": 4144248, + "flat64_training_expert_evaluations": 87031808, + "training_evaluation_reduction_vs_flat64": 0.9523823749588196 + }, + "promotion_blockers": [ + "independently protected real-data workloads", + "independent evaluator custody", + "non-synthetic learned baselines", + "data poisoning and continual-learning evaluation", + "expert merge and retirement protocol", + "cross-host reproduction", + "accelerator and distributed implementation", + "release, rollback, regeneration, and monitoring evidence" + ] +} diff --git a/training-evidence.json b/training-evidence.json new file mode 100644 index 0000000..5ee36d0 --- /dev/null +++ b/training-evidence.json @@ -0,0 +1,18 @@ +{ + "schema":"ravel-training-evidence/0.2", + "dataset":{"train":32768,"holdout":8192,"dimensions":8,"latent_regions":64,"classes":8}, + "training":{ + "recursive":{"final_experts":64,"splits":56,"samples_processed":393216,"expert_evaluations":4144248,"certified_routes":387898,"lineage_digest":"a03419ee3b58f5d7"}, + "fixed8":{"expert_evaluations":3538944}, + "flat64":{"expert_evaluations":87031808} + }, + "holdout":{ + "recursive":{"experts":64,"samples":8192,"accuracy":1.000000000,"exact_mismatches":0,"certified_rate":1.000000000,"mean_experts":8.000000,"checksum":"16c87a0b9a7f9617"}, + "fixed8":{"experts":8,"samples":8192,"accuracy":0.224609375,"exact_mismatches":0,"certified_rate":0.000000000,"mean_experts":8.000000,"checksum":"fbd74fc154768bb7"}, + "flat64":{"experts":64,"samples":8192,"accuracy":1.000000000,"exact_mismatches":0,"certified_rate":0.000000000,"mean_experts":64.000000,"checksum":"17f617329512a204"} + }, + "development_result":"PASS", + "formal_mncs_status":"UNKNOWN", + "formal_mncds_status":"UNKNOWN", + "promotion_authorized":false +} diff --git a/training-preregistration.json b/training-preregistration.json new file mode 100644 index 0000000..01ab9af --- /dev/null +++ b/training-preregistration.json @@ -0,0 +1,53 @@ +{ + "schema_version": "0.2", + "study_id": "ravel.recursive-training.epoch-1.v1", + "candidate_id": "ravel-t.recursive-expert-trainer.c11.v1", + "task": { + "type": "deterministic_synthetic_classification", + "dimensions": 8, + "classes": 8, + "latent_regions": 64, + "development_samples": 32768, + "holdout_samples": 8192, + "development_seed": "0x747261696e000001", + "holdout_seed": "0x686f6c646f757401" + }, + "candidate": { + "initial_experts": 8, + "maximum_experts": 64, + "births_per_round_max": 8, + "route_width": 8, + "final_refinement_rounds": 5, + "uncertain_route_behavior": "complete_full_scan", + "selection": "error_ranked_shard_split", + "lineage_identity": "deterministic_mix64" + }, + "baselines": [ + { + "id": "ravel.baseline.fixed8.nearest-centroid.v1", + "experts": 8, + "refinement_rounds": 10, + "routing": "full_scan" + }, + { + "id": "ravel.baseline.flat64.nearest-centroid.v1", + "experts": 64, + "refinement_rounds": 10, + "routing": "full_scan" + } + ], + "hard_gates": { + "final_experts": 64, + "successful_births": 56, + "holdout_exact_mismatches_max": 0, + "holdout_accuracy_min": 0.95, + "accuracy_deficit_vs_flat64_max": 0.01, + "accuracy_gain_vs_fixed8_min": 0.20, + "holdout_mean_experts_max": 16.0 + }, + "formal_status_if_passed": { + "mncs": "UNKNOWN", + "mncds": "UNKNOWN", + "promotion_authorized": false + } +} diff --git a/training-threat-model.json b/training-threat-model.json new file mode 100644 index 0000000..5c4a202 --- /dev/null +++ b/training-threat-model.json @@ -0,0 +1,61 @@ +{ + "schema_version": "0.1", + "threat_model_id": "ravel-t.training.threats.v1", + "assets": [ + "training and holdout separation", + "full-scan oracle semantics", + "route certificate", + "expert lineage", + "split budget", + "development thresholds", + "reported evidence" + ], + "threats": [ + { + "id": "RT1", + "threat": "recursive training rewrites its own evaluator or pass gates", + "mitigation": "evaluator, seeds, oracle, thresholds, and promotion fields are outside the mutable training surface", + "evidence": "TRAINING_CONTRACT.md and training-preregistration.json" + }, + { + "id": "RT2", + "threat": "approximate routing changes training assignments", + "mitigation": "every routed assignment uses an exact lower-bound certificate and otherwise completes a full scan", + "evidence": "zero holdout routed-versus-full-scan mismatches" + }, + { + "id": "RT3", + "threat": "unbounded expert birth consumes memory or compute", + "mitigation": "expert count is capped at 64 and each round may create at most eight children", + "evidence": "final expert and split counters" + }, + { + "id": "RT4", + "threat": "lineage or topology changes become irreproducible", + "mitigation": "fixed seeds, deterministic tie breaking, and a published lineage digest", + "evidence": "repeatable training-evidence.json" + }, + { + "id": "RT5", + "threat": "synthetic task construction leaks an easy solution into the claim", + "mitigation": "claim is limited to a mechanism proof and formal status remains UNKNOWN", + "evidence": "explicit claim boundary" + }, + { + "id": "RT6", + "threat": "malicious or drifting data causes unstable expert proliferation", + "mitigation": "not established in epoch 1; production and continual-training use are prohibited", + "evidence": "residual UNKNOWN" + } + ], + "residual_unknowns": [ + "real-world data generalization", + "protected evaluator custody", + "poisoning and backdoor resistance", + "catastrophic forgetting", + "expert retirement and merge safety", + "distributed and accelerator training", + "gradient-based parameter integration", + "cross-host reproduction" + ] +} diff --git a/unified-assurance-case.json b/unified-assurance-case.json new file mode 100644 index 0000000..28ad9d7 --- /dev/null +++ b/unified-assurance-case.json @@ -0,0 +1,52 @@ +{ + "schema_version": "0.3", + "assurance_case_id": "ravel.unified.synthetic.epoch-1.assurance.v1", + "claim": "The frozen RAVEL-U capsule passed a deterministic synthetic protocol in which one expert population performed exact retrieval, compression, reconstruction, classification, action-conditioned prediction, temporal-memory compilation, planning, continual adaptation, retirement, and checkpoint restoration.", + "development_result": "PASS", + "disposition": "REVIEW_REQUIRED", + "formal_mncs_status": "UNKNOWN", + "formal_mncds_status": "UNKNOWN", + "promotion_authorized": false, + "implementation": { + "entrypoint": "ravel_unified.c", + "generated_shards": [ + "ravel_unified/00_core.inc", + "ravel_unified/10_route.inc", + "ravel_unified/20_train.inc", + "ravel_unified/30_eval.inc" + ], + "concatenated_execution_sha256": "d6f2d0fd9165487087079a1b3e262c50c78479a9b266089d892d5bc6aeabc7f6", + "language": "C11" + }, + "evidence": { + "record": "unified-evidence.json", + "record_sha256": "6a12505a2d2a229e94391866b5e64064bee50c01389b29d839ee4fb412c06228", + "deterministic_reproduction": true, + "routed_oracle_agreement": true, + "checkpoint_behavioral_agreement": true, + "protected_holdout": false + }, + "observed_results": { + "base_holdout_accuracy": 0.968261719, + "static_drift_accuracy": 0.718994141, + "adapted_drift_accuracy": 1.0, + "post_adaptation_retention": 0.967041016, + "adapted_transition_accuracy": 0.992919922, + "adapted_planning_success": 0.986328125, + "adapted_mean_experts": 8.0, + "adaptation_births": 24, + "adaptation_retirements": 8 + }, + "promotion_blockers": [ + "independently protected real-data workloads", + "independent evaluator custody", + "learned modality adapters", + "language or multimodal generation evidence", + "stochastic and partially observed world models", + "poisoning and adversarial continual-learning evaluation", + "long-horizon planning and credit assignment", + "cross-host and cross-architecture reproduction", + "accelerator and distributed implementation", + "release signing, deployment, monitoring, and rollback evidence" + ] +} diff --git a/unified-evidence.json b/unified-evidence.json new file mode 100644 index 0000000..423d3f2 --- /dev/null +++ b/unified-evidence.json @@ -0,0 +1,19 @@ +{ + "schema":"ravel-unified-evidence/0.3", + "architecture":{"event_dimensions":8,"classes":8,"actions":4,"world_states":64,"route_width":8}, + "base_training":{"initial_experts":8,"final_experts":64,"births":56,"samples_processed":393216,"expert_evaluations":4851616,"certified_routes":359202,"model_digest":"4d4e9116810140b8"}, + "continual_adaptation":{"births":24,"retired":8,"final_experts":80,"samples_processed":360448,"expert_evaluations":2883584,"certified_routes":360448,"model_digest":"c2404c08943b3afd"}, + "evaluation":{ + "base_holdout":{"experts":64,"samples":8192,"accuracy":0.968261719,"exact_mismatches":0,"certified_rate":1.000000000,"mean_experts":8.000000,"reconstruction_rmse":4.899726995,"next_prediction_rmse":5.069874856,"transition_accuracy":0.956909180,"checksum":"c6c3a074be666611"}, + "static_on_drift":{"experts":64,"samples":16384,"accuracy":0.718994141,"exact_mismatches":0,"certified_rate":1.000000000,"mean_experts":8.000000,"reconstruction_rmse":6.627691159,"next_prediction_rmse":6.767901838,"transition_accuracy":0.960510254,"checksum":"52481ff252ecd16a"}, + "adapted_on_drift":{"experts":80,"samples":16384,"accuracy":1.000000000,"exact_mismatches":0,"certified_rate":1.000000000,"mean_experts":8.000000,"reconstruction_rmse":3.204095334,"next_prediction_rmse":3.276330631,"transition_accuracy":0.992919922,"checksum":"0caa892e0e5a6491"}, + "adapted_retention":{"experts":80,"samples":8192,"accuracy":0.967041016,"exact_mismatches":0,"certified_rate":1.000000000,"mean_experts":8.000000,"reconstruction_rmse":3.327176195,"next_prediction_rmse":3.662946981,"transition_accuracy":0.910278320,"checksum":"da7ff096a14faaab"} + }, + "planning":{"base":{"cases":512,"solved":512,"exact_goals":371,"expansions":16731,"checksum":"4d61c4f676aa6191"},"adapted":{"cases":512,"solved":512,"exact_goals":505,"expansions":17055,"checksum":"af3530ab3af661c4"}}, + "checkpoint":{"roundtrip":true,"digest_match":true,"evaluation_match":true}, + "gates":{"base_accuracy_at_least_0_95":true,"adapted_drift_accuracy_at_least_0_95":true,"drift_gain_at_least_0_20":true,"retention_at_least_0_90":true,"transition_accuracy_at_least_0_95":true,"planning_success_at_least_0_90":true,"exact_routing":true,"checkpoint_reproducible":true}, + "development_result":"PASS", + "formal_mncs_status":"UNKNOWN", + "formal_mncds_status":"UNKNOWN", + "promotion_authorized":false +} diff --git a/unified-preregistration.json b/unified-preregistration.json new file mode 100644 index 0000000..80d7082 --- /dev/null +++ b/unified-preregistration.json @@ -0,0 +1,41 @@ +{ + "schema_version": "0.3", + "study_id": "ravel.unified.synthetic.epoch-1.v1", + "candidate": "ravel-u.unified-expert-lattice.v0.3", + "frozen_inputs": { + "base_train_seed": "0x747261696e550001", + "base_holdout_seed": "0x686f6c6455000001", + "adaptation_seed": "0x6164617074550001", + "base_train_events": 32768, + "base_holdout_events": 8192, + "adaptation_events": 16384, + "replay_events": 8192, + "planning_cases": 512 + }, + "topology": { + "initial_experts": 8, + "base_experts": 64, + "adaptation_births": 24, + "adaptation_retirements": 8, + "final_experts": 80, + "maximum_experts": 96, + "route_width": 8 + }, + "hard_gates": { + "base_holdout_accuracy_min": 0.95, + "adapted_drift_accuracy_min": 0.95, + "adapted_gain_over_static_min": 0.20, + "post_adaptation_retention_min": 0.90, + "adapted_transition_accuracy_min": 0.95, + "adapted_planning_success_min": 0.90, + "routed_oracle_mismatches_max": 0, + "checkpoint_digest_match": true, + "checkpoint_evaluation_match": true + }, + "selection_rule": "No candidate selection occurs inside this epoch. The single frozen implementation receives PASS only when every hard gate passes.", + "formal_status_if_development_passes": { + "mncs": "UNKNOWN", + "mncds": "UNKNOWN", + "promotion_authorized": false + } +} diff --git a/unified-threat-model.json b/unified-threat-model.json new file mode 100644 index 0000000..f7a87e5 --- /dev/null +++ b/unified-threat-model.json @@ -0,0 +1,69 @@ +{ + "schema_version": "0.3", + "threat_model_id": "ravel.unified.synthetic.threats.v1", + "assets": [ + "exact routing equivalence", + "expert lineage and topology", + "replay retention", + "transition memory", + "planning graph", + "checkpoint identity", + "evaluation thresholds", + "formal status boundary" + ], + "threats": [ + { + "id": "U1", + "threat": "recursive topology growth silently changes evaluator or promotion rules", + "mitigation": "seeds, partitions, topology limits, gates, evaluator, and status fields are frozen outside the mutable model", + "evidence": "UNIFIED_CONTRACT.md and unified-preregistration.json" + }, + { + "id": "U2", + "threat": "approximate routing selects a different expert than the complete oracle", + "mitigation": "strict lower-bound certificate and complete fallback", + "evidence": "zero exact mismatches on every declared evaluation" + }, + { + "id": "U3", + "threat": "continual adaptation catastrophically forgets the original task", + "mitigation": "deterministic replay and a preregistered retention gate", + "evidence": "adapted_retention accuracy in unified-evidence.json" + }, + { + "id": "U4", + "threat": "unbounded expert birth converts every observation into memory", + "mitigation": "hard maximum, fixed adaptation birth budget, utility-ranked retirement, and final topology gate", + "evidence": "24 births, 8 retirements, and 80 final experts" + }, + { + "id": "U5", + "threat": "learned transition memory supports classification but not executable planning", + "mitigation": "compile action-conditioned predictions into a graph and execute bounded plans against the held-out synthetic world", + "evidence": "planning target success in unified-evidence.json" + }, + { + "id": "U6", + "threat": "checkpoint restoration substitutes a behaviorally different model", + "mitigation": "require both model digest equality and evaluation checksum equality", + "evidence": "checkpoint roundtrip gates" + }, + { + "id": "U7", + "threat": "favorable synthetic structure is promoted as general AI evidence", + "mitigation": "formal statuses remain UNKNOWN and promotion is unauthorized", + "evidence": "explicit claim boundary and assurance case" + } + ], + "residual_unknowns": [ + "real-data representation learning", + "language and multimodal generation", + "stochastic and partially observed environments", + "long-horizon credit assignment", + "causal generalization", + "data poisoning and adversarial continual learning", + "distributed and accelerator execution", + "protected holdout independence", + "production authorization and safety" + ] +} From 61835234dca37634aa17774b17be06da03597994 Mon Sep 17 00:00:00 2001 From: epi13 Date: Fri, 31 Jul 2026 20:41:30 -0800 Subject: [PATCH 03/13] feat(ravel): harden 0.4 evidence --- ARCHITECTURE_GAPS.md | 2 +- Makefile | 124 +- RAVEL_0_4_CONTRACT.md | 68 + RAVEL_0_4_RESULTS.md | 43 + RAVEL_0_4_SCOPE.md | 55 + README.md | 49 +- UNIFIED_CONTRACT.md | 8 +- ravel-0.4-assurance-case.json | 199 ++ ravel-0.4-limitations.md | 21 + ravel-0.4-negative-evidence.json | 241 ++ ravel-0.4-preregistration.json | 140 ++ ravel-0.4-raw-observations.json | 253 ++ ravel-0.4-runtime-observations.json | 22 + ravel-0.4-source-manifest-spec.json | 57 + ravel-0.4-source-manifest.json | 82 + ravel-0.4-threat-model.json | 74 + ravel-0.4-trial-evidence.json | 3605 +++++++++++++++++++++++++++ ravel_0_4.c | 2077 +++++++++++++++ ravel_unified.c | 5 +- ravel_unified/20_train.inc | 10 +- tools/ravel_0_4_evidence.py | 585 +++++ tools/ravel_source_digest.py | 228 ++ 22 files changed, 7931 insertions(+), 17 deletions(-) create mode 100644 RAVEL_0_4_CONTRACT.md create mode 100644 RAVEL_0_4_RESULTS.md create mode 100644 RAVEL_0_4_SCOPE.md create mode 100644 ravel-0.4-assurance-case.json create mode 100644 ravel-0.4-limitations.md create mode 100644 ravel-0.4-negative-evidence.json create mode 100644 ravel-0.4-preregistration.json create mode 100644 ravel-0.4-raw-observations.json create mode 100644 ravel-0.4-runtime-observations.json create mode 100644 ravel-0.4-source-manifest-spec.json create mode 100644 ravel-0.4-source-manifest.json create mode 100644 ravel-0.4-threat-model.json create mode 100644 ravel-0.4-trial-evidence.json create mode 100644 ravel_0_4.c create mode 100755 tools/ravel_0_4_evidence.py create mode 100755 tools/ravel_source_digest.py diff --git a/ARCHITECTURE_GAPS.md b/ARCHITECTURE_GAPS.md index 18c17b8..3e00930 100644 --- a/ARCHITECTURE_GAPS.md +++ b/ARCHITECTURE_GAPS.md @@ -15,7 +15,7 @@ RAVEL-U 0.3 closes that bounded architectural gap. One expert now simultaneously - a lineage-bearing lifecycle object; and - a measured unit of computational cost. -The same expert population builds the exact routing lattice, receives training assignments, identifies unresolved error, creates children, compiles its transition graph, supplies plans, adapts to semantic drift, and retires low-utility duplicate children. Successful checkpoint restoration must reproduce both model identity and evaluation behavior. +The same expert population builds the exact routing lattice, receives training assignments, identifies unresolved error, creates children, compiles its transition graph, supplies plans, adapts to semantic drift, and retires low-utility duplicate children. RAVEL 0.3 intended checkpoint restoration to reproduce both identity and behavior, but its digest and checksum were incomplete. RAVEL 0.4 supplies complete-field canonical identity, restored measurement comparison, and corruption tests. ## Intentionally external diff --git a/Makefile b/Makefile index ad1a3f1..edcdb09 100644 --- a/Makefile +++ b/Makefile @@ -1,20 +1,31 @@ CC ?= cc +SAN_CC ?= clang CFLAGS ?= -std=c11 -O3 -Wall -Wextra -Werror -pedantic LDLIBS ?= -lm -.PHONY: test evidence training-test training-evidence training-check unified-test unified-evidence unified-check all clean +.PHONY: test evidence training-test training-evidence training-check unified-test unified-evidence unified-check 0.4-evidence 0.4-check 0.4-manifest-negative-test 0.4-checkpoint-test 0.4-lineage-test 0.4-negative-test 0.4-compiler-matrix 0.4-sanitizers 0.4-runtime all clean test: ravel ./ravel >/dev/null evidence: ravel - ./ravel | tee evidence.json + @tmp=$$(mktemp); \ + trap 'rm -f "$$tmp"' EXIT; \ + if ./ravel > "$$tmp"; then \ + mv "$$tmp" evidence-actual.json; \ + else \ + cp "$$tmp" evidence-actual.json; \ + exit 1; \ + fi training-test: ravel_train ./ravel_train >/dev/null training-evidence: ravel_train - ./ravel_train | tee training-evidence.json + @tmp=$$(mktemp); \ + trap 'rm -f "$$tmp"' EXIT; \ + ./ravel_train > "$$tmp"; \ + mv "$$tmp" training-evidence.json training-check: ravel_train @tmp=$$(mktemp); \ @@ -26,13 +37,105 @@ unified-test: ravel_unified_bin ./ravel_unified_bin >/dev/null unified-evidence: ravel_unified_bin - ./ravel_unified_bin | tee unified-evidence.json + @tmp=$$(mktemp); \ + trap 'rm -f "$$tmp"' EXIT; \ + ./ravel_unified_bin > "$$tmp"; \ + mv "$$tmp" unified-evidence.json unified-check: ravel_unified_bin - ./ravel_unified_bin > unified-actual.json - diff -u unified-evidence.json unified-actual.json + @tmp=$$(mktemp); \ + trap 'rm -f "$$tmp"' EXIT; \ + if ./ravel_unified_bin > "$$tmp" && diff -u unified-evidence.json "$$tmp"; then \ + rm -f unified-actual.json; \ + else \ + cp "$$tmp" unified-actual.json; \ + exit 1; \ + fi + +0.4-evidence: ravel_0_4_bin + python3 tools/ravel_0_4_evidence.py generate --binary ./ravel_0_4_bin -all: test training-check unified-check +0.4-check: ravel_0_4_bin + python3 tools/ravel_0_4_evidence.py verify --binary ./ravel_0_4_bin --diagnostics-dir diagnostics + python3 tools/ravel_source_digest.py verify \ + --spec ravel-0.4-source-manifest-spec.json \ + --manifest ravel-0.4-source-manifest.json \ + --assurance ravel-0.4-assurance-case.json + +0.4-manifest-negative-test: + @tmp=$$(mktemp -d); \ + trap 'rm -rf "$$tmp"' EXIT; \ + cp -a . "$$tmp/ravel"; \ + cd "$$tmp/ravel"; \ + verify='python3 tools/ravel_source_digest.py verify --spec ravel-0.4-source-manifest-spec.json --manifest ravel-0.4-source-manifest.json --assurance ravel-0.4-assurance-case.json'; \ + $$verify >/dev/null; \ + cp RAVEL_0_4_CONTRACT.md contract.saved; \ + printf '\nmutation\n' >> RAVEL_0_4_CONTRACT.md; \ + if $$verify >/dev/null 2>&1; then exit 1; fi; \ + mv contract.saved RAVEL_0_4_CONTRACT.md; \ + cp ravel-0.4-source-manifest.json manifest.saved; \ + python3 -c 'import json; p="ravel-0.4-source-manifest.json"; r=json.load(open(p)); r["ordered_files"].pop(); json.dump(r,open(p,"w"))'; \ + if $$verify >/dev/null 2>&1; then exit 1; fi; \ + cp manifest.saved ravel-0.4-source-manifest.json; \ + python3 -c 'import json; p="ravel-0.4-source-manifest.json"; r=json.load(open(p)); r["ordered_files"][0],r["ordered_files"][1]=r["ordered_files"][1],r["ordered_files"][0]; json.dump(r,open(p,"w"))'; \ + if $$verify >/dev/null 2>&1; then exit 1; fi; \ + cp manifest.saved ravel-0.4-source-manifest.json; \ + mkdir -p ravel_0_4; \ + printf 'unexpected\n' > ravel_0_4/unexpected.inc; \ + if $$verify >/dev/null 2>&1; then exit 1; fi; \ + rm -rf ravel_0_4; \ + cp ravel-0.4-assurance-case.json assurance.saved; \ + python3 -c 'import json; p="ravel-0.4-assurance-case.json"; r=json.load(open(p)); r["implementation"]["source_digest"]="0"*64; json.dump(r,open(p,"w"))'; \ + if $$verify >/dev/null 2>&1; then exit 1; fi; \ + mv assurance.saved ravel-0.4-assurance-case.json + +0.4-checkpoint-test: ravel_0_4_bin + @tmp=$$(mktemp); \ + trap 'rm -f "$$tmp"' EXIT; \ + ./ravel_0_4_bin > "$$tmp"; \ + python3 -c 'import json,sys; r=json.load(open(sys.argv[1])); assert all(t["checkpoint_verification"]["complete_behavior_match"] and all(t["checkpoint_verification"]["mutations"].values()) for t in r["trials"])' "$$tmp" + +0.4-lineage-test: ravel_0_4_bin + @tmp=$$(mktemp); \ + trap 'rm -f "$$tmp"' EXIT; \ + ./ravel_0_4_bin > "$$tmp"; \ + python3 -c 'import json,sys; r=json.load(open(sys.argv[1])); assert all(all(t["lineage_invariants"].values()) for t in r["trials"])' "$$tmp" + +0.4-negative-test: ravel_0_4_bin + @tmp=$$(mktemp); \ + trap 'rm -f "$$tmp"' EXIT; \ + ./ravel_0_4_bin > "$$tmp"; \ + python3 -c 'import json,sys; r=json.load(open(sys.argv[1])); assert all(v["pass"] for v in r["negative_tests"].values())' "$$tmp" + +0.4-compiler-matrix: + @set -eu; \ + for compiler in gcc clang; do \ + if command -v "$$compiler" >/dev/null 2>&1; then \ + for optimization in 0 3; do \ + binary=$$(mktemp); output=$$(mktemp); \ + "$$compiler" -std=c11 "-O$$optimization" -Wall -Wextra -Werror -pedantic ravel_0_4.c -lm -o "$$binary"; \ + "$$binary" > "$$output"; \ + diff -u ravel-0.4-raw-observations.json "$$output"; \ + rm -f "$$binary" "$$output"; \ + done; \ + fi; \ + done + +0.4-sanitizers: + @set -eu; \ + command -v "$(SAN_CC)" >/dev/null 2>&1 || { echo "sanitizer compiler unavailable: $(SAN_CC)" >&2; exit 1; }; \ + binary=$$(mktemp); output=$$(mktemp); \ + trap 'rm -f "$$binary" "$$output"' EXIT; \ + $(SAN_CC) -std=c11 -O1 -g -Wall -Wextra -Werror -pedantic \ + -fsanitize=address,undefined -fno-omit-frame-pointer \ + ravel_0_4.c -lm -o "$$binary"; \ + ASAN_OPTIONS=detect_leaks=1 UBSAN_OPTIONS=halt_on_error=1 "$$binary" > "$$output"; \ + diff -u ravel-0.4-raw-observations.json "$$output" + +0.4-runtime: ravel_0_4_bin + python3 tools/ravel_0_4_evidence.py runtime --binary ./ravel_0_4_bin --runs 3 + +all: test training-check unified-check 0.4-check ravel: ravel.c $(CC) $(CFLAGS) $< -o $@ @@ -43,5 +146,10 @@ ravel_train: ravel_train.c ravel_unified_bin: ravel_unified.c ravel_unified/00_core.inc ravel_unified/10_route.inc ravel_unified/20_train.inc ravel_unified/30_eval.inc $(CC) $(CFLAGS) ravel_unified.c $(LDLIBS) -o $@ +ravel_0_4_bin: ravel_0_4.c + $(CC) $(CFLAGS) ravel_0_4.c $(LDLIBS) -o $@ + clean: - rm -f ravel ravel_train ravel_unified_bin evidence.json unified-actual.json ravel-unified-checkpoint.bin + rm -f ravel ravel_train ravel_unified_bin ravel_0_4_bin + rm -f evidence-actual.json unified-actual.json ravel-unified-checkpoint.bin ravel-0.4-checkpoint.bin + rm -rf diagnostics diff --git a/RAVEL_0_4_CONTRACT.md b/RAVEL_0_4_CONTRACT.md new file mode 100644 index 0000000..c88d393 --- /dev/null +++ b/RAVEL_0_4_CONTRACT.md @@ -0,0 +1,68 @@ +# RAVEL 0.4 evidence-hardening contract + +## Intended use + +RAVEL 0.4 evaluates the existing bounded recursive-expert mechanism under +deterministic synthetic drift. It is an assurance repair, not a foundation-model +or production architecture claim. + +## Dataset authority + +Every trial has six disjoint, seed-addressed inputs: + +1. base training observations; +2. base holdout observations; +3. drift adaptation training observations; +4. untouched drift holdout observations; +5. original-task retention holdout observations; and +6. planning cases. + +The drift holdout is never passed to expert birth selection, refinement, +retirement, threshold selection, topology selection, replay selection, or model +selection. The source and evaluator make those operations separate calls. + +## Exact routing + +Routing may return early only when the routed best distance is strictly lower +than the lower bound for every excluded expert. Equality, malformed data, and +out-of-domain observations cannot certify a shortcut. Valid uncertain +observations fall back to complete scan. Ties choose the lower expert identity. + +## Canonical checkpoint + +The checkpoint is not a C memory image. It contains: + +- an eight-byte magic identifier; +- a big-endian schema version and declared dimensions and topology limits; +- a big-endian payload length; +- a SHA-256 payload digest; and +- a canonical payload using explicit integer widths and signed Q20 fixed-point + values for retained real-valued fields. + +The payload covers expert count, epoch, active and lifecycle status, keys, +reconstruction vectors, action-conditioned prediction vectors, label and action +counts, selected labels, usage/error statistics, retained reconstruction and +prediction statistics, generation, lineage, compiled transition graph, and the +complete routing lattice. Restoration rejects unsupported dimensions or +versions, malformed fields, truncation, oversized payloads, reordered data, +unexpected trailing bytes, invalid graph/routing identities, and digest +mismatch. + +Restored behavior is compared over classification, reconstruction and +prediction totals, transition predictions, routing certification and +complete-oracle agreement, planning, model topology, lineage, and the complete +reported evaluation record. + +## Planning measurements + +Planning reports path found, exact world-state target reached, goal expert +reached, executed path length, calculable optimal path length, regret, graph +disconnection, transition-model error, and state aliasing separately. +Goal-expert equivalence is never named exact success. + +## Development disposition + +Each trial evaluates every preregistered hard gate. The global development +result is `PASS` only when all eight frozen trials pass. Failures remain evidence +and do not change formal status. Formal MNCS and MNCDS status remain `UNKNOWN`; +promotion remains unauthorized. diff --git a/RAVEL_0_4_RESULTS.md b/RAVEL_0_4_RESULTS.md new file mode 100644 index 0000000..200d8e3 --- /dev/null +++ b/RAVEL_0_4_RESULTS.md @@ -0,0 +1,43 @@ +# RAVEL 0.4 generated results + +This file is generated from canonical raw observations. It is not an independent attestation. + +## Frozen trial outcomes + +| Trial | Regime | Result | Failed gates | +|---|---|---:|---| +| trial-01-separated | separated_state | FAIL | adapted_gain_over_static | +| trial-02-overlap | partially_overlapping_observations | FAIL | adapted_gain_over_static | +| trial-03-noise | increased_observation_noise | FAIL | adapted_gain_over_static | +| trial-04-label | label_drift | FAIL | base_holdout_retention, adapted_reconstruction_improvement | +| trial-05-observation | observation_drift | FAIL | adapted_gain_over_static | +| trial-06-transition | transition_drift | FAIL | adapted_gain_over_static, retention_prediction | +| trial-07-combined | combined_observation_and_label_drift | FAIL | base_holdout_retention | +| trial-08-ambiguous | partially_observed_ambiguous | FAIL | exact_world_state_target_rate | + +## Candidate aggregates + +| Metric | Minimum | Median | Maximum | Mean | Population SD | +|---|---:|---:|---:|---:|---:| +| base_holdout_accuracy | 0.937500000 | 0.988281250 | 1.000000000 | 0.980957031 | 0.020710264 | +| adaptation_training_accuracy | 0.962890625 | 1.000000000 | 1.000000000 | 0.988037109 | 0.015729554 | +| static_model_drift_holdout_accuracy | 0.613281250 | 0.955078125 | 0.992187500 | 0.842285156 | 0.167865810 | +| adapted_model_drift_holdout_accuracy | 0.933593750 | 1.000000000 | 1.000000000 | 0.985351562 | 0.022333197 | +| base_holdout_retention | 0.671875000 | 1.000000000 | 1.000000000 | 0.904296875 | 0.135865080 | +| base_reconstruction_rmse | 3.249159843 | 4.779562945 | 9.256042033 | 5.290470095 | 1.792634061 | +| adapted_drift_reconstruction_rmse | 3.268650797 | 4.714815610 | 11.722196472 | 5.595161787 | 2.701052029 | +| base_prediction_rmse | 5.274702577 | 9.068426947 | 15.803773847 | 9.351916128 | 3.336964137 | +| adapted_drift_prediction_rmse | 5.210900214 | 7.561135692 | 15.132556407 | 9.089436322 | 3.791884802 | +| planning_exact_state_rate | 0.296875000 | 0.945312500 | 1.000000000 | 0.867187500 | 0.222210354 | +| planning_path_found_rate | 0.968750000 | 1.000000000 | 1.000000000 | 0.996093750 | 0.010334966 | +| expert_count | 68.000000000 | 68.000000000 | 68.000000000 | 68.000000000 | 0.000000000 | +| training_evaluations | 184288.000000000 | 198176.500000000 | 248728.000000000 | 201902.500000000 | 19212.060339797 | +| checkpoint_size_bytes | 39438.000000000 | 39438.000000000 | 39438.000000000 | 39438.000000000 | 0.000000000 | + +## Interpretation + +Development result: `FAIL`. Passing trials: 0; failing trials: 8. + +Baseline and ablation results are mixed. No superiority claim is made. Per-variant wall-clock observations remain `UNKNOWN` in canonical evidence; deterministic operation counts are compared instead. + +Formal MNCS status remains `UNKNOWN`. Formal MNCDS status remains `UNKNOWN`. Promotion is unauthorized. diff --git a/RAVEL_0_4_SCOPE.md b/RAVEL_0_4_SCOPE.md new file mode 100644 index 0000000..a29caf7 --- /dev/null +++ b/RAVEL_0_4_SCOPE.md @@ -0,0 +1,55 @@ +# RAVEL 0.4 evidence-hardening scope + +RAVEL 0.4 is a bounded repair release for the existing synthetic RAVEL-U +mechanism study. It does not add a new model class or broaden the intended use. + +## Repairs in scope + +- replace raw-C-struct checkpointing with a versioned canonical format; +- bind checkpoint identity to every retained behavioral and topology field; +- compare restored classification, reconstruction, prediction, transition, + routing, planning, topology, lineage, and reported evaluation measurements; +- correct sibling generation metadata and test repeated descendant splitting; +- separate drift adaptation training from untouched drift holdout evaluation; +- execute eight frozen deterministic trials covering eight synthetic regimes; +- report exact-state and expert-equivalence planning outcomes separately; +- add reconstruction and prediction gates; +- compare bounded baselines and ablations without a superiority claim; +- exercise malformed, adversarial, mutation, provenance, and nondeterminism + failure paths; and +- bind the assurance record to an ordered, machine-verified source manifest. + +## Historical audit + +RAVEL-U 0.3 adapted on `adapt_set` and then reported adapted performance on that +same array. Its `100%` adapted drift score was therefore an adaptation-training +observation, not an untouched drift-holdout result. RAVEL 0.4 retains the 0.3 +evidence as historical evidence and does not relabel that observation. + +The 0.3 checkpoint used `fwrite(sizeof(Model))` and omitted decoder and +action-conditioned prediction vectors from `model_digest()`. Its behavioral +checksum also omitted reconstruction and prediction measurements. The 0.4 +checkpoint and mutation campaign replace that assurance mechanism. + +The 0.3 entrypoint described split `.inc` files as generated, but neither the +repository nor the reviewed pull-request history contains a generator or +higher-level generation specification. RAVEL 0.4 therefore records those files +as maintained split C source. It does not invent a generator to support the old +description. + +The 0.3 assurance digest was incorrect. RAVEL 0.4 adds an ordered manifest and a +repository script that calculates and verifies implementation identity. The +historical 0.3 assurance record receives an explicit audit correction rather +than being silently replaced. + +## Evidence boundary + +All 0.4 evidence is repository-visible development evidence. It is not +independent protected evidence. Synthetic results do not establish real-data +generalization. Deterministic reproduction does not establish +cross-organizational reproduction. Exact routing equivalence does not establish +overall model correctness. Checkpoint reproducibility does not authorize a +production rollback. + +Formal MNCS status is `UNKNOWN`. Formal MNCDS status is `UNKNOWN`. Promotion is +unauthorized. diff --git a/README.md b/README.md index 8e82155..01e7d28 100644 --- a/README.md +++ b/README.md @@ -4,7 +4,7 @@ RAVEL is a machine-native research architecture that treats AI/ML as one combine Its foundational claim is that a model, memory store, router, trainer, world model, planner, and compute scheduler should not be separate systems. A stored expert should simultaneously be a retrieval key, compressed representation, executable predictor, training shard, transition-memory node, planning destination, lineage object, and measured unit of computation. -Human readability is relocated into contracts, evaluator authority, evidence, regeneration, and rollback. The generated execution plane is expected to be replaced as a unit rather than routinely hand-maintained. +Human readability is relocated into contracts, evaluator authority, evidence, provenance, and rollback. The 0.3 split C translation unit is maintained source: no reproducible higher-level generator was included in the repository or reviewed pull-request history. ## RAVEL 0.1 — exact conditional inference @@ -59,12 +59,45 @@ The synthetic world contains 64 states, four actions, eight labels, and eight-di The expert is now simultaneously a key, representation, decoder, classifier, world-model fragment, transition node, replay shard, planning node, lineage object, and compute unit. See `ARCHITECTURE_GAPS.md` for what was missing and why raw modality adapters, use policy, protected evaluation, external effects, and promotion authority intentionally remain outside the recursive surface. +The historical `100.000%` adapted drift value above was measured on the same +`adapt_set` used for adaptation. It is an adaptation-training observation, not +an untouched drift-holdout result. Likewise, the historical planning +`exact_goals` field measured goal-expert equivalence rather than exact +world-state equality. RAVEL 0.4 preserves these facts instead of relabeling the +0.3 evidence. + +## RAVEL 0.4 — evidence hardening + +RAVEL 0.4 repairs assurance rather than expanding the architecture. It adds: + +- disjoint base training, base holdout, drift adaptation training, untouched + drift holdout, original-task retention holdout, and planning inputs; +- eight frozen seeds covering separated, overlapping, noisy, label-drift, + observation-drift, transition-drift, combined, and ambiguous regimes; +- canonical big-endian Q20 checkpoints with a versioned header and SHA-256 + payload identity instead of raw C memory images; +- complete restored classification, reconstruction, prediction, transition, + routing, planning, topology, lineage, and reported-metric comparison; +- deliberate field, payload, truncation, append, schema, and substitution + checkpoint mutations; +- exact-state planning measurements distinct from goal-expert equivalence; +- reconstruction and next-observation prediction gates; +- five bounded baselines, five ablations, negative/adversarial tests, aggregate + variance, and preserved failures; and +- an ordered, script-generated source manifest and assurance digest. + +The frozen 0.4 experiment records development `FAIL`; no seeds, regimes, or +gates were removed to obtain a favorable result. See +`RAVEL_0_4_RESULTS.md` for generated per-trial failures and aggregates, and +`ravel-0.4-assurance-case.json` for the bounded assurance disposition. + ## Run ```bash make test make training-check make unified-check +make 0.4-check ``` To rewrite repository-visible development evidence: @@ -73,6 +106,7 @@ To rewrite repository-visible development evidence: make evidence make training-evidence make unified-evidence +make 0.4-evidence ``` Requirements: a C11 compiler, the C math library, and Make. @@ -81,13 +115,20 @@ Requirements: a C11 compiler, the C math library, and Make. - `ravel.c`, `CONTRACT.md`, `evidence.json` — exact conditional inference; - `ravel_train.c`, `TRAINING_CONTRACT.md`, `training-*.json` — recursive training; -- `ravel_unified.c` and `ravel_unified/*.inc` — generated unified execution shards; +- `ravel_unified.c` and `ravel_unified/*.inc` — maintained 0.3 split C source; - `ARCHITECTURE_GAPS.md` — architectural audit and intentional external boundary; - `UNIFIED_CONTRACT.md` — unified readable authority and gates; - `unified-preregistration.json` — frozen protocol; - `unified-evidence.json` — deterministic observations; - `unified-threat-model.json` — threats and residual UNKNOWNs; and -- `unified-assurance-case.json` — bounded non-promotion record. +- `unified-assurance-case.json` — historical bounded non-promotion record; +- `ravel_0_4.c` and `RAVEL_0_4_CONTRACT.md` — hardened maintained execution and + readable authority; +- `ravel-0.4-preregistration.json` — frozen seeds, regimes, partitions, and gates; +- `ravel-0.4-raw-observations.json`, `ravel-0.4-trial-evidence.json`, and + `ravel-0.4-negative-evidence.json` — executable raw and derived evidence; +- `ravel-0.4-source-manifest.json` — ordered implementation identity; and +- `ravel-0.4-assurance-case.json` — current bounded non-promotion record. ## MNCS boundary @@ -95,7 +136,7 @@ Requirements: a C11 compiler, the C math library, and Make. - **Machine execution plane:** expert keys, decoders, classifiers, next-state programs, router, transition graph, topology, replay assignments, and lineage. - **Evidence plane:** exact-oracle agreement, accuracy, reconstruction, prediction, transition, planning, lifecycle, checkpoint, checksums, and limitations. - **Development-control plane:** fixed seeds, partitions, birth and retirement budgets, immutable thresholds, and non-promotion fields. -- **Operational-control plane:** complete-scan fallback, checkpoint restoration, model identity, and replacement of the generated execution shards. +- **Operational-control plane:** complete-scan fallback, checkpoint restoration, model identity, and replacement of maintained execution source. The repository-visible studies record development `PASS`. Formal MNCS and MNCDS status remain `UNKNOWN`; promotion is unauthorized pending independent protected real-data evaluation, adversarial continual-learning studies, learned modality adapters, cross-host reproduction, accelerator and distributed evidence, and operational release controls. diff --git a/UNIFIED_CONTRACT.md b/UNIFIED_CONTRACT.md index 9117891..38db80d 100644 --- a/UNIFIED_CONTRACT.md +++ b/UNIFIED_CONTRACT.md @@ -1,5 +1,11 @@ # RAVEL-U 0.3 unified architecture contract +> Historical protocol note: RAVEL 0.3 evaluated adapted performance on its +> adaptation array, used a raw-struct checkpoint with incomplete identity, and +> measured planning goal-expert equivalence rather than exact state equality. +> RAVEL 0.4 preserves this contract as history and replaces those assurance +> mechanisms in `RAVEL_0_4_CONTRACT.md`. + ## Intended use RAVEL-U is a bounded research architecture for testing whether one recursively managed expert population can provide exact retrieval, compressed representation, reconstruction, classification, action-conditioned prediction, temporal memory, planning, continual adaptation, lifecycle compression, and checkpoint rollback under one deterministic protocol. @@ -14,7 +20,7 @@ Every active expert contains one retrieval key, one reconstruction vector, four ## Routing authority -The generated lattice evaluates eight candidates. It may return early only when the selected distance is strictly lower than the mathematical lower bound for every excluded expert. Equality, malformed input, or insufficient separation requires the complete scan. Routed and complete scans must select the same expert. +The maintained lattice evaluates eight candidates. It may return early only when the selected distance is strictly lower than the mathematical lower bound for every excluded expert. Equality, malformed input, or insufficient separation requires the complete scan. Routed and complete scans must select the same expert. ## Recursive development authority diff --git a/ravel-0.4-assurance-case.json b/ravel-0.4-assurance-case.json new file mode 100644 index 0000000..1cf31c9 --- /dev/null +++ b/ravel-0.4-assurance-case.json @@ -0,0 +1,199 @@ +{ + "schema": "ravel-assurance-case/0.4", + "assurance_case_id": "ravel.evidence-hardening.epoch-1.assurance.v1", + "claim": "The bounded RAVEL 0.4 harness produced deterministic development evidence with separated drift holdouts, canonical checkpoint verification, mutations, multiple regimes, baselines, ablations, and preserved failures.", + "development_result": "FAIL", + "disposition": "NON_PROMOTION_RESEARCH_FAILURES_PRESERVED", + "formal_mncs_status": "UNKNOWN", + "formal_mncds_status": "UNKNOWN", + "promotion_authorized": false, + "implementation": { + "entrypoint": "ravel_0_4.c", + "source_manifest": "ravel-0.4-source-manifest.json", + "source_manifest_sha256": "c3b590a93313c929ef667f7c41100eb51a130c5015b2b2b7789bb6bf2033d768", + "source_digest": "1a8b8f0fcbabf0ec2000c8bfd89a754a0c203cf0c2f1747c6e32fb862123937e", + "digest_algorithm": "sha256", + "digest_procedure": "For each file in declared order, hash uint32_be(path_utf8_length), path_utf8, uint64_be(file_length), and exact file bytes.", + "source_provenance": "human_maintained_c11_no_generator", + "generated_execution_shards": [], + "language": "C11" + }, + "evidence": { + "records": [ + { + "path": "ravel-0.4-raw-observations.json", + "bytes": 80943, + "sha256": "c7c71ad964b2cc06584a21185930eca5cb361112e4a9e1d9f6bc541b1d47f4e2" + }, + { + "path": "ravel-0.4-trial-evidence.json", + "bytes": 134551, + "sha256": "a5ffbfdbf2f46274413edf0644df2afa36df27da629c777bcf59b1f6e79066aa" + }, + { + "path": "ravel-0.4-negative-evidence.json", + "bytes": 7104, + "sha256": "12026b61cb81e86ccffccd1b69cc8853140eea2a3bf3f3be3f7e14e7dbd5b2b1" + } + ], + "deterministic_reproduction": true, + "drift_holdout_used_for_adaptation": false, + "checkpoint_complete_identity": true, + "checkpoint_complete_behavioral_agreement": true, + "checkpoint_mutation_campaign": true, + "protected_holdout": false, + "independent_custody": false + }, + "trial_summary": { + "declared": 8, + "passing": 0, + "failing": 8, + "pass_rule": "all_8_trials_pass" + }, + "failed_gates_by_trial": { + "trial-01-separated": [ + "adapted_gain_over_static" + ], + "trial-02-overlap": [ + "adapted_gain_over_static" + ], + "trial-03-noise": [ + "adapted_gain_over_static" + ], + "trial-04-label": [ + "base_holdout_retention", + "adapted_reconstruction_improvement" + ], + "trial-05-observation": [ + "adapted_gain_over_static" + ], + "trial-06-transition": [ + "adapted_gain_over_static", + "retention_prediction" + ], + "trial-07-combined": [ + "base_holdout_retention" + ], + "trial-08-ambiguous": [ + "exact_world_state_target_rate" + ] + }, + "observed_aggregates": { + "base_holdout_accuracy": { + "minimum": 0.9375, + "median": 0.98828125, + "maximum": 1.0, + "arithmetic_mean": 0.98095703125, + "population_standard_deviation": 0.020710263730906734 + }, + "adaptation_training_accuracy": { + "minimum": 0.962890625, + "median": 1.0, + "maximum": 1.0, + "arithmetic_mean": 0.988037109375, + "population_standard_deviation": 0.015729554363129505 + }, + "static_model_drift_holdout_accuracy": { + "minimum": 0.61328125, + "median": 0.955078125, + "maximum": 0.9921875, + "arithmetic_mean": 0.84228515625, + "population_standard_deviation": 0.16786581034443188 + }, + "adapted_model_drift_holdout_accuracy": { + "minimum": 0.93359375, + "median": 1.0, + "maximum": 1.0, + "arithmetic_mean": 0.9853515625, + "population_standard_deviation": 0.022333196535213422 + }, + "base_holdout_retention": { + "minimum": 0.671875, + "median": 1.0, + "maximum": 1.0, + "arithmetic_mean": 0.904296875, + "population_standard_deviation": 0.1358650803862397 + }, + "base_reconstruction_rmse": { + "minimum": 3.249159843, + "median": 4.779562945, + "maximum": 9.256042033, + "arithmetic_mean": 5.290470095125, + "population_standard_deviation": 1.7926340609447835 + }, + "adapted_drift_reconstruction_rmse": { + "minimum": 3.268650797, + "median": 4.7148156100000005, + "maximum": 11.722196472, + "arithmetic_mean": 5.595161787, + "population_standard_deviation": 2.7010520289568483 + }, + "base_prediction_rmse": { + "minimum": 5.274702577, + "median": 9.0684269465, + "maximum": 15.803773847, + "arithmetic_mean": 9.351916128375, + "population_standard_deviation": 3.3369641369339753 + }, + "adapted_drift_prediction_rmse": { + "minimum": 5.210900214, + "median": 7.5611356915000005, + "maximum": 15.132556407, + "arithmetic_mean": 9.0894363225, + "population_standard_deviation": 3.7918848016987137 + }, + "planning_exact_state_rate": { + "minimum": 0.296875, + "median": 0.9453125, + "maximum": 1.0, + "arithmetic_mean": 0.8671875, + "population_standard_deviation": 0.2222103539582483 + }, + "planning_path_found_rate": { + "minimum": 0.96875, + "median": 1.0, + "maximum": 1.0, + "arithmetic_mean": 0.99609375, + "population_standard_deviation": 0.010334966058846057 + }, + "expert_count": { + "minimum": 68.0, + "median": 68.0, + "maximum": 68.0, + "arithmetic_mean": 68.0, + "population_standard_deviation": 0.0 + }, + "training_evaluations": { + "minimum": 184288.0, + "median": 198176.5, + "maximum": 248728.0, + "arithmetic_mean": 201902.5, + "population_standard_deviation": 19212.06033979698 + }, + "checkpoint_size_bytes": { + "minimum": 39438.0, + "median": 39438.0, + "maximum": 39438.0, + "arithmetic_mean": 39438.0, + "population_standard_deviation": 0.0 + } + }, + "baseline_and_ablation_interpretation": "Results are mixed across the frozen regimes; no superiority claim is made.", + "historical_audit": { + "ravel_u_0_3_adapted_score": "The historical 100% adapted drift score reused adaptation data and was not an untouched drift-holdout result.", + "ravel_u_0_3_checkpoint": "The historical raw-struct checkpoint and weak digest are not accepted as RAVEL 0.4 assurance.", + "ravel_u_0_3_source_digest": "The historical unified assurance digest was incorrect; RAVEL 0.4 replaces implementation identity with the ordered manifest.", + "ravel_u_0_3_shard_provenance": "No generator was present in source or reviewed pull-request history; split sources are maintained, not claimed as generated." + }, + "limitations": [ + "development evidence is not independent protected evidence", + "synthetic success or failure is not real-data generalization", + "deterministic reproduction is not cross-organizational reproduction", + "exact routing equivalence is not overall model correctness", + "checkpoint reproducibility is not production rollback authorization", + "runtime observations are non-normative", + "formal MNCS status remains UNKNOWN", + "formal MNCDS status remains UNKNOWN", + "promotion remains unauthorized" + ] +} diff --git a/ravel-0.4-limitations.md b/ravel-0.4-limitations.md new file mode 100644 index 0000000..ae204a5 --- /dev/null +++ b/ravel-0.4-limitations.md @@ -0,0 +1,21 @@ +# RAVEL 0.4 limitations + +- The trials are synthetic, repository-visible, and not independently + protected. +- Eight deterministic regimes are broader than the 0.3 single world, but they + do not establish real-data or real-world generalization. +- Baselines and ablations are bounded implementations in the same C harness; + they are not claims against contemporary learned systems. +- Canonical checkpoint identity and behavioral reproduction do not provide + signing, authorization, deployment, monitoring, or production rollback. +- Exact routed-versus-complete expert agreement proves only the routing + equivalence property. +- Runtime measurements are observational and non-normative; deterministic + operation counts are the canonical compute comparison. +- Repository-local byte reproduction is not independent or + cross-organizational reproduction. +- No result creates protected custody, witnessing, governance approval, + certification, or promotion. +- Formal MNCS status remains `UNKNOWN`. +- Formal MNCDS status remains `UNKNOWN`. +- Promotion remains unauthorized. diff --git a/ravel-0.4-negative-evidence.json b/ravel-0.4-negative-evidence.json new file mode 100644 index 0000000..1f5a149 --- /dev/null +++ b/ravel-0.4-negative-evidence.json @@ -0,0 +1,241 @@ +{ + "schema": "ravel-negative-evidence/0.4", + "tests": { + "malformed_observation": { + "expected_disposition": "reject", + "observed": true, + "pass": true + }, + "out_of_domain_value": { + "expected_disposition": "fall_back", + "observed": true, + "pass": true + }, + "empty_expert_assignment": { + "expected_disposition": "reject", + "observed": true, + "pass": true + }, + "degenerate_expert_assignment": { + "expected_disposition": "reject", + "observed": true, + "pass": true + }, + "duplicate_expert": { + "expected_disposition": "reject", + "observed": true, + "pass": true + }, + "tied_distance": { + "expected_disposition": "preserve_non_promotion", + "observed": true, + "pass": true + }, + "routing_lower_bound_equality": { + "expected_disposition": "fall_back", + "observed": true, + "pass": true + }, + "maximum_expert_capacity": { + "expected_disposition": "preserve_non_promotion", + "observed": true, + "pass": true + }, + "birth_beyond_capacity": { + "expected_disposition": "reject", + "observed": true, + "pass": true + }, + "wrong_lifecycle_retirement": { + "expected_disposition": "reject", + "observed": true, + "pass": true + }, + "poisoned_adaptation_labels": { + "expected_disposition": "fail_a_gate", + "observed": true, + "pass": true + }, + "poisoned_transition_observations": { + "expected_disposition": "fail_a_gate", + "observed": true, + "pass": true + }, + "replay_removal": { + "expected_disposition": "fail_a_gate", + "observed": true, + "pass": true + }, + "catastrophic_forgetting_condition": { + "expected_disposition": "fail_a_gate", + "observed": true, + "pass": true + }, + "evidence_file_mutation": { + "expected_disposition": "reject", + "observed": true, + "pass": true + }, + "stale_assurance_digest": { + "expected_disposition": "reject", + "observed": true, + "pass": true + }, + "nondeterministic_output_detection": { + "expected_disposition": "reject", + "observed": true, + "pass": true, + "note": "two independent process executions were byte-identical" + } + }, + "checkpoint_mutation_campaign": { + "trial-01-separated": { + "expected_disposition": "reject_or_fail_equivalence", + "mutations": { + "retrieval_key_component": true, + "reconstruction_component": true, + "next_observation_component": true, + "label": true, + "label_count": true, + "lineage": true, + "transition_graph_edge": true, + "payload_byte": true, + "checkpoint_truncation": true, + "appended_unexpected_byte": true, + "incorrect_schema_version": true, + "checkpoint_substitution": true + }, + "pass": true + }, + "trial-02-overlap": { + "expected_disposition": "reject_or_fail_equivalence", + "mutations": { + "retrieval_key_component": true, + "reconstruction_component": true, + "next_observation_component": true, + "label": true, + "label_count": true, + "lineage": true, + "transition_graph_edge": true, + "payload_byte": true, + "checkpoint_truncation": true, + "appended_unexpected_byte": true, + "incorrect_schema_version": true, + "checkpoint_substitution": true + }, + "pass": true + }, + "trial-03-noise": { + "expected_disposition": "reject_or_fail_equivalence", + "mutations": { + "retrieval_key_component": true, + "reconstruction_component": true, + "next_observation_component": true, + "label": true, + "label_count": true, + "lineage": true, + "transition_graph_edge": true, + "payload_byte": true, + "checkpoint_truncation": true, + "appended_unexpected_byte": true, + "incorrect_schema_version": true, + "checkpoint_substitution": true + }, + "pass": true + }, + "trial-04-label": { + "expected_disposition": "reject_or_fail_equivalence", + "mutations": { + "retrieval_key_component": true, + "reconstruction_component": true, + "next_observation_component": true, + "label": true, + "label_count": true, + "lineage": true, + "transition_graph_edge": true, + "payload_byte": true, + "checkpoint_truncation": true, + "appended_unexpected_byte": true, + "incorrect_schema_version": true, + "checkpoint_substitution": true + }, + "pass": true + }, + "trial-05-observation": { + "expected_disposition": "reject_or_fail_equivalence", + "mutations": { + "retrieval_key_component": true, + "reconstruction_component": true, + "next_observation_component": true, + "label": true, + "label_count": true, + "lineage": true, + "transition_graph_edge": true, + "payload_byte": true, + "checkpoint_truncation": true, + "appended_unexpected_byte": true, + "incorrect_schema_version": true, + "checkpoint_substitution": true + }, + "pass": true + }, + "trial-06-transition": { + "expected_disposition": "reject_or_fail_equivalence", + "mutations": { + "retrieval_key_component": true, + "reconstruction_component": true, + "next_observation_component": true, + "label": true, + "label_count": true, + "lineage": true, + "transition_graph_edge": true, + "payload_byte": true, + "checkpoint_truncation": true, + "appended_unexpected_byte": true, + "incorrect_schema_version": true, + "checkpoint_substitution": true + }, + "pass": true + }, + "trial-07-combined": { + "expected_disposition": "reject_or_fail_equivalence", + "mutations": { + "retrieval_key_component": true, + "reconstruction_component": true, + "next_observation_component": true, + "label": true, + "label_count": true, + "lineage": true, + "transition_graph_edge": true, + "payload_byte": true, + "checkpoint_truncation": true, + "appended_unexpected_byte": true, + "incorrect_schema_version": true, + "checkpoint_substitution": true + }, + "pass": true + }, + "trial-08-ambiguous": { + "expected_disposition": "reject_or_fail_equivalence", + "mutations": { + "retrieval_key_component": true, + "reconstruction_component": true, + "next_observation_component": true, + "label": true, + "label_count": true, + "lineage": true, + "transition_graph_edge": true, + "payload_byte": true, + "checkpoint_truncation": true, + "appended_unexpected_byte": true, + "incorrect_schema_version": true, + "checkpoint_substitution": true + }, + "pass": true + } + }, + "all_negative_tests_pass": true, + "formal_mncs_status": "UNKNOWN", + "formal_mncds_status": "UNKNOWN", + "promotion_authorized": false +} diff --git a/ravel-0.4-preregistration.json b/ravel-0.4-preregistration.json new file mode 100644 index 0000000..e1c6c2c --- /dev/null +++ b/ravel-0.4-preregistration.json @@ -0,0 +1,140 @@ +{ + "schema": "ravel-preregistration/0.4", + "study_id": "ravel.evidence-hardening.epoch-1.v1", + "candidate_id": "ravel-u.evidence-hardened.c11.v0.4", + "frozen_before_final_evidence": true, + "trial_pass_rule": "all_hard_gates_per_trial", + "global_pass_rule": "all_8_trials_pass", + "datasets_per_trial": { + "base_training": 1024, + "base_holdout": 256, + "drift_adaptation_training": 512, + "drift_holdout": 256, + "original_task_retention_holdout": 256, + "planning_cases": 64 + }, + "dataset_prohibitions": { + "drift_holdout_may_be_used_for": [ + "post-freeze evaluation" + ], + "drift_holdout_may_not_be_used_for": [ + "expert birth selection", + "refinement", + "retirement", + "threshold selection", + "topology selection", + "replay selection", + "model selection" + ] + }, + "topology": { + "dimensions": 8, + "classes": 8, + "actions": 4, + "world_states": 64, + "initial_experts": 8, + "base_experts": 64, + "adaptation_births": 8, + "adaptation_retirements": 4, + "adapted_experts": 68, + "maximum_experts": 80, + "route_width": 8, + "routing_cells": 256 + }, + "trials": [ + { + "trial_id": "trial-01-separated", + "seed": "0x0401000000000001", + "regime": "separated_state" + }, + { + "trial_id": "trial-02-overlap", + "seed": "0x0402000000000002", + "regime": "partially_overlapping_observations" + }, + { + "trial_id": "trial-03-noise", + "seed": "0x0403000000000003", + "regime": "increased_observation_noise" + }, + { + "trial_id": "trial-04-label", + "seed": "0x0404000000000004", + "regime": "label_drift" + }, + { + "trial_id": "trial-05-observation", + "seed": "0x0405000000000005", + "regime": "observation_drift" + }, + { + "trial_id": "trial-06-transition", + "seed": "0x0406000000000006", + "regime": "transition_drift" + }, + { + "trial_id": "trial-07-combined", + "seed": "0x0407000000000007", + "regime": "combined_observation_and_label_drift" + }, + { + "trial_id": "trial-08-ambiguous", + "seed": "0x0408000000000008", + "regime": "partially_observed_ambiguous" + } + ], + "hard_gates": { + "base_holdout_accuracy_min": 0.75, + "adaptation_training_accuracy_min": 0.70, + "adapted_drift_holdout_accuracy_min": 0.70, + "adapted_gain_over_static_drift_holdout_min": 0.05, + "base_holdout_retention_min": 0.70, + "routed_complete_oracle_mismatches_max": 0, + "base_reconstruction_rmse_max": 18.0, + "adapted_drift_reconstruction_rmse_max": 18.0, + "adapted_drift_reconstruction_improvement_min": 0.25, + "retention_reconstruction_degradation_max": 4.0, + "base_prediction_rmse_max": 24.0, + "adapted_drift_prediction_rmse_max": 24.0, + "adapted_drift_prediction_improvement_min": 0.25, + "retention_prediction_degradation_max": 5.0, + "exact_world_state_target_rate_min": 0.60, + "path_found_rate_min": 0.70, + "checkpoint_identity_match": true, + "checkpoint_behavior_match": true, + "checkpoint_mutation_campaign_pass": true, + "lineage_and_topology_invariants_pass": true + }, + "baselines": [ + "fixed_8_expert", + "flat_64_expert_complete_scan", + "fixed_topology_64_expert_routed", + "nearest_centroid_16_no_recursive_births", + "no_adaptation_static" + ], + "ablations": [ + "ravel_without_replay", + "ravel_without_retirement", + "ravel_complete_scan_without_certification", + "ravel_fixed_topology_without_recursive_births", + "ravel_random_births" + ], + "comparison_metrics": [ + "accuracy", + "drift_holdout_accuracy", + "retention_accuracy", + "reconstruction_rmse", + "next_observation_prediction_rmse", + "planning_exact_state_rate", + "expert_evaluations", + "expert_count", + "training_evaluations", + "checkpoint_size_bytes", + "runtime_observation_non_normative" + ], + "formal_status_regardless_of_development_result": { + "mncs": "UNKNOWN", + "mncds": "UNKNOWN", + "promotion_authorized": false + } +} diff --git a/ravel-0.4-raw-observations.json b/ravel-0.4-raw-observations.json new file mode 100644 index 0000000..81ac5fb --- /dev/null +++ b/ravel-0.4-raw-observations.json @@ -0,0 +1,253 @@ +{ + "schema":"ravel-raw-observations/0.4", + "preregistration":"ravel-0.4-preregistration.json", + "checkpoint_format":{"magic":"RAVEL04\\u0000","schema_version":4,"byte_order":"big_endian","real_encoding":"signed_q20_int64","payload_digest":"sha256","maximum_bytes":65536}, + "trials":[ + { + "trial_id":"trial-01-separated","regime":"separated_state","seed":"0x0401000000000001", + "dataset_seeds":{"base_training":"0xfb9173fec332d474","base_holdout":"0xa2cb7273b415f00f","drift_adaptation_training":"0xd128a6be12aedae6","drift_holdout":"0xc8c3a44f89c5d6a7","original_task_retention_holdout":"0x7fac89bfda811927","planning_cases":"0x4dbc3dd2a99ef496"}, + "candidate":{"expert_count":68,"base_births":56,"adaptation_births":8,"adaptation_retirements":4,"training_evaluations":184288,"checkpoint_size_bytes":39438,"model_identity":"f749f4346b5f1a6fa55950a97192666e6649edead2d32477cbc20313b0c62c0c","behavior_identity":"d7bb0c9b9c43226b516a5c6e200831b8dc7f97650c4370532feca71cd41f68e8", + "base_holdout":{"samples":256,"rejected":0,"accuracy":0.937500000,"reconstruction_rmse":6.771654787,"next_observation_prediction_rmse":10.387196711,"transition_accuracy":0.914062500,"routing_certification_count":256,"complete_oracle_agreement":256,"routed_complete_mismatches":0,"expert_evaluations":2048,"classification_checksum":"621008a0accf4117","reconstruction_checksum":"bbc6d95bb03c71b3","prediction_checksum":"d0ebe4d1e7f20613","transition_checksum":"982b9a44cdccbcb7"}, + "adaptation_training":{"samples":512,"rejected":0,"accuracy":1.000000000,"reconstruction_rmse":3.009849648,"next_observation_prediction_rmse":2.568334400,"transition_accuracy":0.986328125,"routing_certification_count":512,"complete_oracle_agreement":512,"routed_complete_mismatches":0,"expert_evaluations":4096,"classification_checksum":"34bb91b25793446d","reconstruction_checksum":"2065f12be33264fb","prediction_checksum":"58c88a10857785a5","transition_checksum":"5a1d5dec583cd7c6"}, + "static_model_drift_holdout":{"samples":256,"rejected":0,"accuracy":0.953125000,"reconstruction_rmse":6.080038321,"next_observation_prediction_rmse":9.069805773,"transition_accuracy":0.933593750,"routing_certification_count":256,"complete_oracle_agreement":256,"routed_complete_mismatches":0,"expert_evaluations":2048,"classification_checksum":"bc4851585cd4847c","reconstruction_checksum":"a2e1dad23a64c827","prediction_checksum":"2088e68834483eaa","transition_checksum":"0881513aa1b2b983"}, + "adapted_model_drift_holdout":{"samples":256,"rejected":0,"accuracy":1.000000000,"reconstruction_rmse":3.268650797,"next_observation_prediction_rmse":5.534045939,"transition_accuracy":0.976562500,"routing_certification_count":256,"complete_oracle_agreement":256,"routed_complete_mismatches":0,"expert_evaluations":2048,"classification_checksum":"e8130132975e90e0","reconstruction_checksum":"4726339a3b30ffbd","prediction_checksum":"5b9408ccf32d2ba0","transition_checksum":"e47d08295bd4268e"}, + "base_holdout_retention":{"samples":256,"rejected":0,"accuracy":1.000000000,"reconstruction_rmse":3.224120775,"next_observation_prediction_rmse":3.792183638,"transition_accuracy":0.996093750,"routing_certification_count":256,"complete_oracle_agreement":256,"routed_complete_mismatches":0,"expert_evaluations":2048,"classification_checksum":"2467726ebb18c9ea","reconstruction_checksum":"b465510aae54fd34","prediction_checksum":"58aadbc1d6eac16c","transition_checksum":"fcfed22da80eb85d"}, + "planning":{"cases":64,"path_found":62,"exact_world_state_target_reached":59,"goal_expert_reached":59,"executed_path_length":261,"optimal_path_length":262,"path_length_regret":2,"graph_disconnection_failures":2,"transition_model_error_failures":3,"state_aliasing_failures":0,"expansions":1927,"checksum":"cc0f6efda781d157"}}, + "checkpoint_verification":{"roundtrip":true,"identity_match":true,"adaptation_training_evaluation_match":true,"drift_holdout_evaluation_match":true,"retention_evaluation_match":true,"planning_match":true,"complete_behavior_match":true,"mutations":{"retrieval_key_component":true,"reconstruction_component":true,"next_observation_component":true,"label":true,"label_count":true,"lineage":true,"transition_graph_edge":true,"payload_byte":true,"checkpoint_truncation":true,"appended_unexpected_byte":true,"incorrect_schema_version":true,"checkpoint_substitution":true}}, + "lineage_invariants":{"sibling_generation_equality":true,"parent_child_generation_increment":true,"lineage_uniqueness":true,"repeated_descendant_splitting":true,"no_accidental_lineage_reuse":true,"deterministic_topology_reproduction":true}, + "comparisons":{ + "ravel_0_4_candidate":{"expert_count":68,"training_evaluations":184288,"drift_holdout_accuracy":1.000000000,"retention_accuracy":1.000000000,"reconstruction_rmse":3.268650797,"prediction_rmse":5.534045939,"planning_exact_state_rate":0.921875000,"expert_evaluations":2048,"checkpoint_size_bytes":39438,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "fixed_8_expert":{"expert_count":8,"training_evaluations":61440,"drift_holdout_accuracy":0.199218750,"retention_accuracy":0.250000000,"reconstruction_rmse":28.565835338,"prediction_rmse":29.869555279,"planning_exact_state_rate":0.031250000,"expert_evaluations":2048,"checkpoint_size_bytes":10578,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "flat_64_expert_complete_scan":{"expert_count":64,"training_evaluations":2326528,"drift_holdout_accuracy":1.000000000,"retention_accuracy":1.000000000,"reconstruction_rmse":3.239324581,"prediction_rmse":7.670675312,"planning_exact_state_rate":0.953125000,"expert_evaluations":16384,"checkpoint_size_bytes":37514,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "fixed_topology_64_expert_routed":{"expert_count":64,"training_evaluations":2326528,"drift_holdout_accuracy":1.000000000,"retention_accuracy":1.000000000,"reconstruction_rmse":3.239324581,"prediction_rmse":7.670675312,"planning_exact_state_rate":0.953125000,"expert_evaluations":2048,"checkpoint_size_bytes":37514,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "nearest_centroid_16_no_recursive_births":{"expert_count":16,"training_evaluations":188416,"drift_holdout_accuracy":0.210937500,"retention_accuracy":0.265625000,"reconstruction_rmse":22.911277755,"prediction_rmse":24.245409824,"planning_exact_state_rate":0.156250000,"expert_evaluations":4096,"checkpoint_size_bytes":14426,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "no_adaptation_static":{"expert_count":64,"training_evaluations":131040,"drift_holdout_accuracy":0.953125000,"retention_accuracy":0.968750000,"reconstruction_rmse":6.080038321,"prediction_rmse":9.069805773,"planning_exact_state_rate":0.750000000,"expert_evaluations":2048,"checkpoint_size_bytes":37514,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "ravel_without_replay":{"expert_count":68,"training_evaluations":167904,"drift_holdout_accuracy":1.000000000,"retention_accuracy":1.000000000,"reconstruction_rmse":3.357316160,"prediction_rmse":6.825674031,"planning_exact_state_rate":1.000000000,"expert_evaluations":2048,"checkpoint_size_bytes":39438,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "ravel_without_retirement":{"expert_count":72,"training_evaluations":159712,"drift_holdout_accuracy":1.000000000,"retention_accuracy":1.000000000,"reconstruction_rmse":3.268070888,"prediction_rmse":8.886386680,"planning_exact_state_rate":0.906250000,"expert_evaluations":2048,"checkpoint_size_bytes":41362,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "ravel_complete_scan_without_certification":{"expert_count":68,"training_evaluations":380896,"drift_holdout_accuracy":1.000000000,"retention_accuracy":1.000000000,"reconstruction_rmse":3.268650797,"prediction_rmse":5.534045939,"planning_exact_state_rate":0.921875000,"expert_evaluations":17408,"checkpoint_size_bytes":39438,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "ravel_fixed_topology_without_recursive_births":{"expert_count":64,"training_evaluations":2351104,"drift_holdout_accuracy":1.000000000,"retention_accuracy":1.000000000,"reconstruction_rmse":3.276899436,"prediction_rmse":3.725665254,"planning_exact_state_rate":1.000000000,"expert_evaluations":2048,"checkpoint_size_bytes":37514,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "ravel_random_births":{"expert_count":68,"training_evaluations":185164,"drift_holdout_accuracy":0.968750000,"retention_accuracy":0.972656250,"reconstruction_rmse":5.095431803,"prediction_rmse":5.244062968,"planning_exact_state_rate":0.859375000,"expert_evaluations":2108,"checkpoint_size_bytes":39438,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}} + }, + "hard_gates":{"expected_topology":true,"base_holdout_accuracy":true,"adaptation_training_accuracy":true,"adapted_drift_holdout_accuracy":true,"adapted_gain_over_static":false,"base_holdout_retention":true,"exact_routing":true,"base_reconstruction_rmse":true,"adapted_reconstruction_rmse":true,"adapted_reconstruction_improvement":true,"retention_reconstruction":true,"base_prediction_rmse":true,"adapted_prediction_rmse":true,"adapted_prediction_improvement":true,"retention_prediction":true,"exact_world_state_target_rate":true,"path_found_rate":true,"checkpoint_identity":true,"checkpoint_behavior":true,"checkpoint_mutations":true,"lineage_and_topology":true}, + "trial_result":"FAIL" + }, + { + "trial_id":"trial-02-overlap","regime":"partially_overlapping_observations","seed":"0x0402000000000002", + "dataset_seeds":{"base_training":"0x359791d15caa8021","base_holdout":"0x347629147b455cc1","drift_adaptation_training":"0xc5b9901d9746e31d","drift_holdout":"0x9662c6f345517a30","original_task_retention_holdout":"0x8c6d375a4e72b2ee","planning_cases":"0xa469eb102cb94fff"}, + "candidate":{"expert_count":68,"base_births":56,"adaptation_births":8,"adaptation_retirements":4,"training_evaluations":248728,"checkpoint_size_bytes":39438,"model_identity":"77c5530ae17887619c8b9c67bf728d0c61274c7da26f8c20a73f547bc6225193","behavior_identity":"7b979ea1ffa888236dd1d5fd29766affdd216ef0b764f806b977deab3719f736", + "base_holdout":{"samples":256,"rejected":0,"accuracy":0.984375000,"reconstruction_rmse":4.682442178,"next_observation_prediction_rmse":7.749657182,"transition_accuracy":0.953125000,"routing_certification_count":250,"complete_oracle_agreement":256,"routed_complete_mismatches":0,"expert_evaluations":2384,"classification_checksum":"036a80c04271efd2","reconstruction_checksum":"5f21253cc71596e1","prediction_checksum":"1a1f7876f3cc397d","transition_checksum":"53181bb942dbcf59"}, + "adaptation_training":{"samples":512,"rejected":0,"accuracy":1.000000000,"reconstruction_rmse":4.136402676,"next_observation_prediction_rmse":3.456683979,"transition_accuracy":0.988281250,"routing_certification_count":512,"complete_oracle_agreement":512,"routed_complete_mismatches":0,"expert_evaluations":4096,"classification_checksum":"966484f3d827cb07","reconstruction_checksum":"2b6c05741e6cf15a","prediction_checksum":"64ca7b8c28a4c1df","transition_checksum":"5352b3c50b8ebd37"}, + "static_model_drift_holdout":{"samples":256,"rejected":0,"accuracy":0.968750000,"reconstruction_rmse":4.741379161,"next_observation_prediction_rmse":6.308541448,"transition_accuracy":0.976562500,"routing_certification_count":246,"complete_oracle_agreement":256,"routed_complete_mismatches":0,"expert_evaluations":2608,"classification_checksum":"b8abbf549864e6c4","reconstruction_checksum":"64d2a4a6a0da11ad","prediction_checksum":"1bde53784df95a76","transition_checksum":"f49f5057e7a746c0"}, + "adapted_model_drift_holdout":{"samples":256,"rejected":0,"accuracy":1.000000000,"reconstruction_rmse":4.459759700,"next_observation_prediction_rmse":5.210900214,"transition_accuracy":0.984375000,"routing_certification_count":256,"complete_oracle_agreement":256,"routed_complete_mismatches":0,"expert_evaluations":2048,"classification_checksum":"5240a759ab88cac2","reconstruction_checksum":"d9ad5b705868359f","prediction_checksum":"7534d917b59170f4","transition_checksum":"f62159f7a4deeebe"}, + "base_holdout_retention":{"samples":256,"rejected":0,"accuracy":1.000000000,"reconstruction_rmse":4.506023348,"next_observation_prediction_rmse":6.320249235,"transition_accuracy":0.960937500,"routing_certification_count":256,"complete_oracle_agreement":256,"routed_complete_mismatches":0,"expert_evaluations":2048,"classification_checksum":"9b4af0db28883f0a","reconstruction_checksum":"985b8fa03c17c5e2","prediction_checksum":"bcb25ada809a99dc","transition_checksum":"cd61076b01f84266"}, + "planning":{"cases":64,"path_found":64,"exact_world_state_target_reached":64,"goal_expert_reached":64,"executed_path_length":304,"optimal_path_length":304,"path_length_regret":0,"graph_disconnection_failures":0,"transition_model_error_failures":0,"state_aliasing_failures":0,"expansions":2175,"checksum":"351ce529139874a7"}}, + "checkpoint_verification":{"roundtrip":true,"identity_match":true,"adaptation_training_evaluation_match":true,"drift_holdout_evaluation_match":true,"retention_evaluation_match":true,"planning_match":true,"complete_behavior_match":true,"mutations":{"retrieval_key_component":true,"reconstruction_component":true,"next_observation_component":true,"label":true,"label_count":true,"lineage":true,"transition_graph_edge":true,"payload_byte":true,"checkpoint_truncation":true,"appended_unexpected_byte":true,"incorrect_schema_version":true,"checkpoint_substitution":true}}, + "lineage_invariants":{"sibling_generation_equality":true,"parent_child_generation_increment":true,"lineage_uniqueness":true,"repeated_descendant_splitting":true,"no_accidental_lineage_reuse":true,"deterministic_topology_reproduction":true}, + "comparisons":{ + "ravel_0_4_candidate":{"expert_count":68,"training_evaluations":248728,"drift_holdout_accuracy":1.000000000,"retention_accuracy":1.000000000,"reconstruction_rmse":4.459759700,"prediction_rmse":5.210900214,"planning_exact_state_rate":1.000000000,"expert_evaluations":2048,"checkpoint_size_bytes":39438,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "fixed_8_expert":{"expert_count":8,"training_evaluations":61440,"drift_holdout_accuracy":0.222656250,"retention_accuracy":0.195312500,"reconstruction_rmse":16.462897466,"prediction_rmse":17.871856266,"planning_exact_state_rate":0.046875000,"expert_evaluations":2048,"checkpoint_size_bytes":10578,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "flat_64_expert_complete_scan":{"expert_count":64,"training_evaluations":2326528,"drift_holdout_accuracy":1.000000000,"retention_accuracy":1.000000000,"reconstruction_rmse":4.448226133,"prediction_rmse":6.283162910,"planning_exact_state_rate":0.968750000,"expert_evaluations":16384,"checkpoint_size_bytes":37514,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "fixed_topology_64_expert_routed":{"expert_count":64,"training_evaluations":2326528,"drift_holdout_accuracy":1.000000000,"retention_accuracy":1.000000000,"reconstruction_rmse":4.448226133,"prediction_rmse":6.283162910,"planning_exact_state_rate":0.968750000,"expert_evaluations":2048,"checkpoint_size_bytes":37514,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "nearest_centroid_16_no_recursive_births":{"expert_count":16,"training_evaluations":188416,"drift_holdout_accuracy":0.214843750,"retention_accuracy":0.250000000,"reconstruction_rmse":11.975113520,"prediction_rmse":11.988090221,"planning_exact_state_rate":0.328125000,"expert_evaluations":4096,"checkpoint_size_bytes":14426,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "no_adaptation_static":{"expert_count":64,"training_evaluations":192824,"drift_holdout_accuracy":0.968750000,"retention_accuracy":0.964843750,"reconstruction_rmse":4.741379161,"prediction_rmse":6.308541448,"planning_exact_state_rate":0.812500000,"expert_evaluations":2608,"checkpoint_size_bytes":37514,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "ravel_without_replay":{"expert_count":68,"training_evaluations":231960,"drift_holdout_accuracy":1.000000000,"retention_accuracy":1.000000000,"reconstruction_rmse":4.540499400,"prediction_rmse":6.171878127,"planning_exact_state_rate":1.000000000,"expert_evaluations":2048,"checkpoint_size_bytes":39438,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "ravel_without_retirement":{"expert_count":72,"training_evaluations":224152,"drift_holdout_accuracy":1.000000000,"retention_accuracy":1.000000000,"reconstruction_rmse":4.463321940,"prediction_rmse":5.628626399,"planning_exact_state_rate":1.000000000,"expert_evaluations":2048,"checkpoint_size_bytes":41362,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "ravel_complete_scan_without_certification":{"expert_count":68,"training_evaluations":443800,"drift_holdout_accuracy":1.000000000,"retention_accuracy":1.000000000,"reconstruction_rmse":4.459759700,"prediction_rmse":5.210900214,"planning_exact_state_rate":1.000000000,"expert_evaluations":17408,"checkpoint_size_bytes":39438,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "ravel_fixed_topology_without_recursive_births":{"expert_count":64,"training_evaluations":2351104,"drift_holdout_accuracy":1.000000000,"retention_accuracy":1.000000000,"reconstruction_rmse":4.479194377,"prediction_rmse":5.202498190,"planning_exact_state_rate":1.000000000,"expert_evaluations":2048,"checkpoint_size_bytes":37514,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "ravel_random_births":{"expert_count":68,"training_evaluations":259742,"drift_holdout_accuracy":0.968750000,"retention_accuracy":0.964843750,"reconstruction_rmse":4.760327614,"prediction_rmse":5.964486250,"planning_exact_state_rate":0.796875000,"expert_evaluations":2528,"checkpoint_size_bytes":39438,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}} + }, + "hard_gates":{"expected_topology":true,"base_holdout_accuracy":true,"adaptation_training_accuracy":true,"adapted_drift_holdout_accuracy":true,"adapted_gain_over_static":false,"base_holdout_retention":true,"exact_routing":true,"base_reconstruction_rmse":true,"adapted_reconstruction_rmse":true,"adapted_reconstruction_improvement":true,"retention_reconstruction":true,"base_prediction_rmse":true,"adapted_prediction_rmse":true,"adapted_prediction_improvement":true,"retention_prediction":true,"exact_world_state_target_rate":true,"path_found_rate":true,"checkpoint_identity":true,"checkpoint_behavior":true,"checkpoint_mutations":true,"lineage_and_topology":true}, + "trial_result":"FAIL" + }, + { + "trial_id":"trial-03-noise","regime":"increased_observation_noise","seed":"0x0403000000000003", + "dataset_seeds":{"base_training":"0x31c899554a6b02bf","base_holdout":"0x30ab06786aecff1f","drift_adaptation_training":"0x5337eaaa31957ea0","drift_holdout":"0x849ccea305c2e858","original_task_retention_holdout":"0x1bcba0c16fd0b750","planning_cases":"0x2c6c4e52d917f858"}, + "candidate":{"expert_count":68,"base_births":56,"adaptation_births":8,"adaptation_retirements":4,"training_evaluations":191966,"checkpoint_size_bytes":39438,"model_identity":"094fa2315b914a3e8fe4b05403958769d77a80e84f9df17be05ceffbbf1b0e83","behavior_identity":"f39fad0c4a8340e4d0359aec9b2ac05d792afb7019028b6329058921c3c7be96", + "base_holdout":{"samples":256,"rejected":0,"accuracy":0.957031250,"reconstruction_rmse":9.256042033,"next_observation_prediction_rmse":12.015166216,"transition_accuracy":0.929687500,"routing_certification_count":254,"complete_oracle_agreement":256,"routed_complete_mismatches":0,"expert_evaluations":2160,"classification_checksum":"78ade4e3ed35bffa","reconstruction_checksum":"56a03e4fa9fd47e3","prediction_checksum":"0d2d7902d1277e1d","transition_checksum":"b1856bd2df36b1f5"}, + "adaptation_training":{"samples":512,"rejected":0,"accuracy":1.000000000,"reconstruction_rmse":10.681188351,"next_observation_prediction_rmse":8.970615587,"transition_accuracy":0.976562500,"routing_certification_count":511,"complete_oracle_agreement":512,"routed_complete_mismatches":0,"expert_evaluations":4156,"classification_checksum":"b3055f634bac50af","reconstruction_checksum":"b8c42536c2170e68","prediction_checksum":"478678748e759b6f","transition_checksum":"e2adee66e4283a9c"}, + "static_model_drift_holdout":{"samples":256,"rejected":0,"accuracy":0.957031250,"reconstruction_rmse":12.208403881,"next_observation_prediction_rmse":17.195498684,"transition_accuracy":0.890625000,"routing_certification_count":250,"complete_oracle_agreement":256,"routed_complete_mismatches":0,"expert_evaluations":2384,"classification_checksum":"c78ed10841903f15","reconstruction_checksum":"e017e54783b64e82","prediction_checksum":"eb07bd78ca758a86","transition_checksum":"a2f761de4e55be59"}, + "adapted_model_drift_holdout":{"samples":256,"rejected":0,"accuracy":1.000000000,"reconstruction_rmse":11.722196472,"next_observation_prediction_rmse":13.802821074,"transition_accuracy":0.972656250,"routing_certification_count":252,"complete_oracle_agreement":256,"routed_complete_mismatches":0,"expert_evaluations":2288,"classification_checksum":"1ed08bd42b12b5a9","reconstruction_checksum":"56bb01a6e0dd2d19","prediction_checksum":"2bc238dbe09141f1","transition_checksum":"1407053d804140a4"}, + "base_holdout_retention":{"samples":256,"rejected":0,"accuracy":1.000000000,"reconstruction_rmse":8.396915222,"next_observation_prediction_rmse":10.613961832,"transition_accuracy":0.976562500,"routing_certification_count":256,"complete_oracle_agreement":256,"routed_complete_mismatches":0,"expert_evaluations":2048,"classification_checksum":"cc9c9e18f84df52a","reconstruction_checksum":"7957a429e66aa981","prediction_checksum":"6d04a2d1c39cb8db","transition_checksum":"2cf05ac107da7dee"}, + "planning":{"cases":64,"path_found":64,"exact_world_state_target_reached":61,"goal_expert_reached":61,"executed_path_length":310,"optimal_path_length":311,"path_length_regret":0,"graph_disconnection_failures":0,"transition_model_error_failures":3,"state_aliasing_failures":0,"expansions":2292,"checksum":"3cc709ccf4c5fc5d"}}, + "checkpoint_verification":{"roundtrip":true,"identity_match":true,"adaptation_training_evaluation_match":true,"drift_holdout_evaluation_match":true,"retention_evaluation_match":true,"planning_match":true,"complete_behavior_match":true,"mutations":{"retrieval_key_component":true,"reconstruction_component":true,"next_observation_component":true,"label":true,"label_count":true,"lineage":true,"transition_graph_edge":true,"payload_byte":true,"checkpoint_truncation":true,"appended_unexpected_byte":true,"incorrect_schema_version":true,"checkpoint_substitution":true}}, + "lineage_invariants":{"sibling_generation_equality":true,"parent_child_generation_increment":true,"lineage_uniqueness":true,"repeated_descendant_splitting":true,"no_accidental_lineage_reuse":true,"deterministic_topology_reproduction":true}, + "comparisons":{ + "ravel_0_4_candidate":{"expert_count":68,"training_evaluations":191966,"drift_holdout_accuracy":1.000000000,"retention_accuracy":1.000000000,"reconstruction_rmse":11.722196472,"prediction_rmse":13.802821074,"planning_exact_state_rate":0.953125000,"expert_evaluations":2288,"checkpoint_size_bytes":39438,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "fixed_8_expert":{"expert_count":8,"training_evaluations":61440,"drift_holdout_accuracy":0.148437500,"retention_accuracy":0.156250000,"reconstruction_rmse":30.667927368,"prediction_rmse":33.419556245,"planning_exact_state_rate":0.031250000,"expert_evaluations":2048,"checkpoint_size_bytes":10578,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "flat_64_expert_complete_scan":{"expert_count":64,"training_evaluations":2326528,"drift_holdout_accuracy":1.000000000,"retention_accuracy":1.000000000,"reconstruction_rmse":11.498955243,"prediction_rmse":16.982378697,"planning_exact_state_rate":0.812500000,"expert_evaluations":16384,"checkpoint_size_bytes":37514,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "fixed_topology_64_expert_routed":{"expert_count":64,"training_evaluations":2326528,"drift_holdout_accuracy":1.000000000,"retention_accuracy":1.000000000,"reconstruction_rmse":11.498955243,"prediction_rmse":16.982378697,"planning_exact_state_rate":0.812500000,"expert_evaluations":2104,"checkpoint_size_bytes":37514,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "nearest_centroid_16_no_recursive_births":{"expert_count":16,"training_evaluations":188416,"drift_holdout_accuracy":0.285156250,"retention_accuracy":0.257812500,"reconstruction_rmse":25.316094113,"prediction_rmse":28.500359276,"planning_exact_state_rate":0.093750000,"expert_evaluations":4096,"checkpoint_size_bytes":14426,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "no_adaptation_static":{"expert_count":64,"training_evaluations":137528,"drift_holdout_accuracy":0.957031250,"retention_accuracy":0.957031250,"reconstruction_rmse":12.208403881,"prediction_rmse":17.195498684,"planning_exact_state_rate":0.578125000,"expert_evaluations":2384,"checkpoint_size_bytes":37514,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "ravel_without_replay":{"expert_count":68,"training_evaluations":175770,"drift_holdout_accuracy":1.000000000,"retention_accuracy":1.000000000,"reconstruction_rmse":12.117639144,"prediction_rmse":14.675433687,"planning_exact_state_rate":0.937500000,"expert_evaluations":2648,"checkpoint_size_bytes":39438,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "ravel_without_retirement":{"expert_count":72,"training_evaluations":167144,"drift_holdout_accuracy":1.000000000,"retention_accuracy":1.000000000,"reconstruction_rmse":11.715737213,"prediction_rmse":15.118959391,"planning_exact_state_rate":0.921875000,"expert_evaluations":2496,"checkpoint_size_bytes":41362,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "ravel_complete_scan_without_certification":{"expert_count":68,"training_evaluations":387742,"drift_holdout_accuracy":1.000000000,"retention_accuracy":1.000000000,"reconstruction_rmse":11.722196472,"prediction_rmse":13.802821074,"planning_exact_state_rate":0.953125000,"expert_evaluations":17408,"checkpoint_size_bytes":39438,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "ravel_fixed_topology_without_recursive_births":{"expert_count":64,"training_evaluations":2351160,"drift_holdout_accuracy":1.000000000,"retention_accuracy":1.000000000,"reconstruction_rmse":11.734432030,"prediction_rmse":13.131661923,"planning_exact_state_rate":1.000000000,"expert_evaluations":2272,"checkpoint_size_bytes":37514,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "ravel_random_births":{"expert_count":68,"training_evaluations":193719,"drift_holdout_accuracy":0.960937500,"retention_accuracy":0.960937500,"reconstruction_rmse":12.370829046,"prediction_rmse":14.167108782,"planning_exact_state_rate":0.609375000,"expert_evaluations":2708,"checkpoint_size_bytes":39438,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}} + }, + "hard_gates":{"expected_topology":true,"base_holdout_accuracy":true,"adaptation_training_accuracy":true,"adapted_drift_holdout_accuracy":true,"adapted_gain_over_static":false,"base_holdout_retention":true,"exact_routing":true,"base_reconstruction_rmse":true,"adapted_reconstruction_rmse":true,"adapted_reconstruction_improvement":true,"retention_reconstruction":true,"base_prediction_rmse":true,"adapted_prediction_rmse":true,"adapted_prediction_improvement":true,"retention_prediction":true,"exact_world_state_target_rate":true,"path_found_rate":true,"checkpoint_identity":true,"checkpoint_behavior":true,"checkpoint_mutations":true,"lineage_and_topology":true}, + "trial_result":"FAIL" + }, + { + "trial_id":"trial-04-label","regime":"label_drift","seed":"0x0404000000000004", + "dataset_seeds":{"base_training":"0xb119124bb25f62fd","base_holdout":"0xba974d75811c25b5","drift_adaptation_training":"0x08bb1d2ce7152f90","drift_holdout":"0x29b60e6074e6e6fe","original_task_retention_holdout":"0xa8a9a927d9b882fb","planning_cases":"0x3aa6b2bd4735ab34"}, + "candidate":{"expert_count":68,"base_births":56,"adaptation_births":8,"adaptation_retirements":4,"training_evaluations":184400,"checkpoint_size_bytes":39438,"model_identity":"7ac729eed49beb4abd7e89b3a47999db4f0ae5ae911356fbcfb387cf55d0c716","behavior_identity":"6448b04fcc6c2382081a5f9f427d110fbd4b346640095e5a3a117152061bcf12", + "base_holdout":{"samples":256,"rejected":0,"accuracy":1.000000000,"reconstruction_rmse":3.249159843,"next_observation_prediction_rmse":5.274702577,"transition_accuracy":0.992187500,"routing_certification_count":256,"complete_oracle_agreement":256,"routed_complete_mismatches":0,"expert_evaluations":2048,"classification_checksum":"ecc0702db2f2e0ee","reconstruction_checksum":"cc3772cbc44d2381","prediction_checksum":"410e74edf5b9d356","transition_checksum":"576182581fca82fc"}, + "adaptation_training":{"samples":512,"rejected":0,"accuracy":0.974609375,"reconstruction_rmse":2.999208801,"next_observation_prediction_rmse":2.576304245,"transition_accuracy":0.984375000,"routing_certification_count":512,"complete_oracle_agreement":512,"routed_complete_mismatches":0,"expert_evaluations":4096,"classification_checksum":"c76de4f4760f0a46","reconstruction_checksum":"1cafef0b0ccf035a","prediction_checksum":"ae58e537418e726c","transition_checksum":"296706d6eb355028"}, + "static_model_drift_holdout":{"samples":256,"rejected":0,"accuracy":0.632812500,"reconstruction_rmse":3.245941506,"next_observation_prediction_rmse":6.694133269,"transition_accuracy":0.988281250,"routing_certification_count":256,"complete_oracle_agreement":256,"routed_complete_mismatches":0,"expert_evaluations":2048,"classification_checksum":"d5abe6419bc92a60","reconstruction_checksum":"d78de092c59b9d1b","prediction_checksum":"da6fc180aa7abd76","transition_checksum":"eebd44338c6b40d8"}, + "adapted_model_drift_holdout":{"samples":256,"rejected":0,"accuracy":0.972656250,"reconstruction_rmse":3.284709157,"next_observation_prediction_rmse":5.929517197,"transition_accuracy":0.988281250,"routing_certification_count":256,"complete_oracle_agreement":256,"routed_complete_mismatches":0,"expert_evaluations":2048,"classification_checksum":"314f63b85b64e88f","reconstruction_checksum":"c8e18735756cb09a","prediction_checksum":"53b19e6217f535dc","transition_checksum":"7e9474adc2958e20"}, + "base_holdout_retention":{"samples":256,"rejected":0,"accuracy":0.671875000,"reconstruction_rmse":3.322548870,"next_observation_prediction_rmse":6.133100096,"transition_accuracy":0.980468750,"routing_certification_count":256,"complete_oracle_agreement":256,"routed_complete_mismatches":0,"expert_evaluations":2048,"classification_checksum":"ff2e7d89ac8af3be","reconstruction_checksum":"363d7216b8b76e93","prediction_checksum":"79af8c0e99f46229","transition_checksum":"7bf04bff940296f1"}, + "planning":{"cases":64,"path_found":64,"exact_world_state_target_reached":64,"goal_expert_reached":64,"executed_path_length":296,"optimal_path_length":296,"path_length_regret":0,"graph_disconnection_failures":0,"transition_model_error_failures":0,"state_aliasing_failures":0,"expansions":2153,"checksum":"bebe1a3ebe36d486"}}, + "checkpoint_verification":{"roundtrip":true,"identity_match":true,"adaptation_training_evaluation_match":true,"drift_holdout_evaluation_match":true,"retention_evaluation_match":true,"planning_match":true,"complete_behavior_match":true,"mutations":{"retrieval_key_component":true,"reconstruction_component":true,"next_observation_component":true,"label":true,"label_count":true,"lineage":true,"transition_graph_edge":true,"payload_byte":true,"checkpoint_truncation":true,"appended_unexpected_byte":true,"incorrect_schema_version":true,"checkpoint_substitution":true}}, + "lineage_invariants":{"sibling_generation_equality":true,"parent_child_generation_increment":true,"lineage_uniqueness":true,"repeated_descendant_splitting":true,"no_accidental_lineage_reuse":true,"deterministic_topology_reproduction":true}, + "comparisons":{ + "ravel_0_4_candidate":{"expert_count":68,"training_evaluations":184400,"drift_holdout_accuracy":0.972656250,"retention_accuracy":0.671875000,"reconstruction_rmse":3.284709157,"prediction_rmse":5.929517197,"planning_exact_state_rate":1.000000000,"expert_evaluations":2048,"checkpoint_size_bytes":39438,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "fixed_8_expert":{"expert_count":8,"training_evaluations":61440,"drift_holdout_accuracy":0.179687500,"retention_accuracy":0.214843750,"reconstruction_rmse":28.177461374,"prediction_rmse":29.442125356,"planning_exact_state_rate":0.031250000,"expert_evaluations":2048,"checkpoint_size_bytes":10578,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "flat_64_expert_complete_scan":{"expert_count":64,"training_evaluations":2326528,"drift_holdout_accuracy":0.632812500,"retention_accuracy":1.000000000,"reconstruction_rmse":3.245941506,"prediction_rmse":5.964526836,"planning_exact_state_rate":0.984375000,"expert_evaluations":16384,"checkpoint_size_bytes":37514,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "fixed_topology_64_expert_routed":{"expert_count":64,"training_evaluations":2326528,"drift_holdout_accuracy":0.632812500,"retention_accuracy":1.000000000,"reconstruction_rmse":3.245941506,"prediction_rmse":5.964526836,"planning_exact_state_rate":0.984375000,"expert_evaluations":2048,"checkpoint_size_bytes":37514,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "nearest_centroid_16_no_recursive_births":{"expert_count":16,"training_evaluations":188416,"drift_holdout_accuracy":0.207031250,"retention_accuracy":0.269531250,"reconstruction_rmse":23.766545085,"prediction_rmse":24.836108388,"planning_exact_state_rate":0.140625000,"expert_evaluations":4096,"checkpoint_size_bytes":14426,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "no_adaptation_static":{"expert_count":64,"training_evaluations":131152,"drift_holdout_accuracy":0.632812500,"retention_accuracy":1.000000000,"reconstruction_rmse":3.245941506,"prediction_rmse":6.694133269,"planning_exact_state_rate":0.984375000,"expert_evaluations":2048,"checkpoint_size_bytes":37514,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "ravel_without_replay":{"expert_count":68,"training_evaluations":168016,"drift_holdout_accuracy":1.000000000,"retention_accuracy":0.632812500,"reconstruction_rmse":3.353389407,"prediction_rmse":6.588012389,"planning_exact_state_rate":1.000000000,"expert_evaluations":2048,"checkpoint_size_bytes":39438,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "ravel_without_retirement":{"expert_count":72,"training_evaluations":159824,"drift_holdout_accuracy":0.972656250,"retention_accuracy":0.671875000,"reconstruction_rmse":3.287590917,"prediction_rmse":6.496733865,"planning_exact_state_rate":1.000000000,"expert_evaluations":2048,"checkpoint_size_bytes":41362,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "ravel_complete_scan_without_certification":{"expert_count":68,"training_evaluations":381008,"drift_holdout_accuracy":0.972656250,"retention_accuracy":0.671875000,"reconstruction_rmse":3.284709157,"prediction_rmse":5.929517197,"planning_exact_state_rate":1.000000000,"expert_evaluations":17408,"checkpoint_size_bytes":39438,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "ravel_fixed_topology_without_recursive_births":{"expert_count":64,"training_evaluations":2351104,"drift_holdout_accuracy":0.980468750,"retention_accuracy":0.664062500,"reconstruction_rmse":3.284108194,"prediction_rmse":5.306900561,"planning_exact_state_rate":1.000000000,"expert_evaluations":2048,"checkpoint_size_bytes":37514,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "ravel_random_births":{"expert_count":68,"training_evaluations":184400,"drift_holdout_accuracy":0.980468750,"retention_accuracy":0.664062500,"reconstruction_rmse":3.278805288,"prediction_rmse":7.104260996,"planning_exact_state_rate":1.000000000,"expert_evaluations":2048,"checkpoint_size_bytes":39438,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}} + }, + "hard_gates":{"expected_topology":true,"base_holdout_accuracy":true,"adaptation_training_accuracy":true,"adapted_drift_holdout_accuracy":true,"adapted_gain_over_static":true,"base_holdout_retention":false,"exact_routing":true,"base_reconstruction_rmse":true,"adapted_reconstruction_rmse":true,"adapted_reconstruction_improvement":false,"retention_reconstruction":true,"base_prediction_rmse":true,"adapted_prediction_rmse":true,"adapted_prediction_improvement":true,"retention_prediction":true,"exact_world_state_target_rate":true,"path_found_rate":true,"checkpoint_identity":true,"checkpoint_behavior":true,"checkpoint_mutations":true,"lineage_and_topology":true}, + "trial_result":"FAIL" + }, + { + "trial_id":"trial-05-observation","regime":"observation_drift","seed":"0x0405000000000005", + "dataset_seeds":{"base_training":"0x056696df8d3b6c3f","base_holdout":"0x82991be6b3c3b49b","drift_adaptation_training":"0xc88ff7795c17c309","drift_holdout":"0x6fae784d472487dd","original_task_retention_holdout":"0xbbca41d1303f0277","planning_cases":"0x0cd111aa847bd3dd"}, + "candidate":{"expert_count":68,"base_births":56,"adaptation_births":8,"adaptation_retirements":4,"training_evaluations":198795,"checkpoint_size_bytes":39438,"model_identity":"162084e398b93cbcf8bf7b298b91fe58b8da90d32f18e34d5800e0353a02f33e","behavior_identity":"66fb2612b268f816ecfb9a1a1d96f6d5b0d063b8f0f793308a3e03b523e0aef5", + "base_holdout":{"samples":256,"rejected":0,"accuracy":0.988281250,"reconstruction_rmse":4.088483070,"next_observation_prediction_rmse":5.745390367,"transition_accuracy":0.984375000,"routing_certification_count":256,"complete_oracle_agreement":256,"routed_complete_mismatches":0,"expert_evaluations":2048,"classification_checksum":"6590037caf973659","reconstruction_checksum":"44f1c43e7f352d40","prediction_checksum":"0808ea0a11572b7e","transition_checksum":"05d0df53a1426590"}, + "adaptation_training":{"samples":512,"rejected":0,"accuracy":1.000000000,"reconstruction_rmse":4.365044794,"next_observation_prediction_rmse":3.726372863,"transition_accuracy":0.996093750,"routing_certification_count":512,"complete_oracle_agreement":512,"routed_complete_mismatches":0,"expert_evaluations":4096,"classification_checksum":"0b8986fe5dc2780d","reconstruction_checksum":"741f88b7af72fb87","prediction_checksum":"49c4691e3cd7837e","transition_checksum":"5670ff85721a5aaf"}, + "static_model_drift_holdout":{"samples":256,"rejected":0,"accuracy":0.988281250,"reconstruction_rmse":7.214147712,"next_observation_prediction_rmse":8.980319577,"transition_accuracy":0.972656250,"routing_certification_count":256,"complete_oracle_agreement":256,"routed_complete_mismatches":0,"expert_evaluations":2048,"classification_checksum":"5e7a3d1c8098fd4f","reconstruction_checksum":"86885f60232e4e7f","prediction_checksum":"ccd62f1626f9e38e","transition_checksum":"3798f0b6a265b96c"}, + "adapted_model_drift_holdout":{"samples":256,"rejected":0,"accuracy":1.000000000,"reconstruction_rmse":4.969871520,"next_observation_prediction_rmse":5.908756185,"transition_accuracy":1.000000000,"routing_certification_count":256,"complete_oracle_agreement":256,"routed_complete_mismatches":0,"expert_evaluations":2048,"classification_checksum":"06889ba43eaa9f13","reconstruction_checksum":"56c4fda307558a43","prediction_checksum":"b7c2bf1328deb043","transition_checksum":"5ed594c48a1c64b3"}, + "base_holdout_retention":{"samples":256,"rejected":0,"accuracy":1.000000000,"reconstruction_rmse":4.742146477,"next_observation_prediction_rmse":10.344778044,"transition_accuracy":0.960937500,"routing_certification_count":256,"complete_oracle_agreement":256,"routed_complete_mismatches":0,"expert_evaluations":2048,"classification_checksum":"4257baa390b0702b","reconstruction_checksum":"bbb7556c367e13ae","prediction_checksum":"c0b400533f3d7afb","transition_checksum":"c823aed4d1a21197"}, + "planning":{"cases":64,"path_found":64,"exact_world_state_target_reached":64,"goal_expert_reached":64,"executed_path_length":277,"optimal_path_length":275,"path_length_regret":2,"graph_disconnection_failures":0,"transition_model_error_failures":0,"state_aliasing_failures":0,"expansions":1956,"checksum":"88023746529cc64c"}}, + "checkpoint_verification":{"roundtrip":true,"identity_match":true,"adaptation_training_evaluation_match":true,"drift_holdout_evaluation_match":true,"retention_evaluation_match":true,"planning_match":true,"complete_behavior_match":true,"mutations":{"retrieval_key_component":true,"reconstruction_component":true,"next_observation_component":true,"label":true,"label_count":true,"lineage":true,"transition_graph_edge":true,"payload_byte":true,"checkpoint_truncation":true,"appended_unexpected_byte":true,"incorrect_schema_version":true,"checkpoint_substitution":true}}, + "lineage_invariants":{"sibling_generation_equality":true,"parent_child_generation_increment":true,"lineage_uniqueness":true,"repeated_descendant_splitting":true,"no_accidental_lineage_reuse":true,"deterministic_topology_reproduction":true}, + "comparisons":{ + "ravel_0_4_candidate":{"expert_count":68,"training_evaluations":198795,"drift_holdout_accuracy":1.000000000,"retention_accuracy":1.000000000,"reconstruction_rmse":4.969871520,"prediction_rmse":5.908756185,"planning_exact_state_rate":1.000000000,"expert_evaluations":2048,"checkpoint_size_bytes":39438,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "fixed_8_expert":{"expert_count":8,"training_evaluations":61440,"drift_holdout_accuracy":0.195312500,"retention_accuracy":0.226562500,"reconstruction_rmse":28.588489902,"prediction_rmse":30.140919158,"planning_exact_state_rate":0.078125000,"expert_evaluations":2048,"checkpoint_size_bytes":10578,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "flat_64_expert_complete_scan":{"expert_count":64,"training_evaluations":2326528,"drift_holdout_accuracy":1.000000000,"retention_accuracy":1.000000000,"reconstruction_rmse":6.710329592,"prediction_rmse":9.665663175,"planning_exact_state_rate":0.984375000,"expert_evaluations":16384,"checkpoint_size_bytes":37514,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "fixed_topology_64_expert_routed":{"expert_count":64,"training_evaluations":2326528,"drift_holdout_accuracy":1.000000000,"retention_accuracy":1.000000000,"reconstruction_rmse":6.710329592,"prediction_rmse":9.665663175,"planning_exact_state_rate":0.984375000,"expert_evaluations":2048,"checkpoint_size_bytes":37514,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "nearest_centroid_16_no_recursive_births":{"expert_count":16,"training_evaluations":188416,"drift_holdout_accuracy":0.230468750,"retention_accuracy":0.289062500,"reconstruction_rmse":23.566883600,"prediction_rmse":25.375825862,"planning_exact_state_rate":0.171875000,"expert_evaluations":4096,"checkpoint_size_bytes":14426,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "no_adaptation_static":{"expert_count":64,"training_evaluations":133736,"drift_holdout_accuracy":0.988281250,"retention_accuracy":0.976562500,"reconstruction_rmse":7.214147712,"prediction_rmse":8.980319577,"planning_exact_state_rate":0.859375000,"expert_evaluations":2048,"checkpoint_size_bytes":37514,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "ravel_without_replay":{"expert_count":68,"training_evaluations":180125,"drift_holdout_accuracy":1.000000000,"retention_accuracy":1.000000000,"reconstruction_rmse":4.641846269,"prediction_rmse":5.858492042,"planning_exact_state_rate":1.000000000,"expert_evaluations":2048,"checkpoint_size_bytes":39438,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "ravel_without_retirement":{"expert_count":72,"training_evaluations":170344,"drift_holdout_accuracy":1.000000000,"retention_accuracy":1.000000000,"reconstruction_rmse":4.964079357,"prediction_rmse":6.628937969,"planning_exact_state_rate":0.968750000,"expert_evaluations":3328,"checkpoint_size_bytes":41362,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "ravel_complete_scan_without_certification":{"expert_count":68,"training_evaluations":387467,"drift_holdout_accuracy":1.000000000,"retention_accuracy":1.000000000,"reconstruction_rmse":4.969871520,"prediction_rmse":5.908756185,"planning_exact_state_rate":1.000000000,"expert_evaluations":17408,"checkpoint_size_bytes":39438,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "ravel_fixed_topology_without_recursive_births":{"expert_count":64,"training_evaluations":2351104,"drift_holdout_accuracy":1.000000000,"retention_accuracy":1.000000000,"reconstruction_rmse":4.968732508,"prediction_rmse":5.908756185,"planning_exact_state_rate":1.000000000,"expert_evaluations":2048,"checkpoint_size_bytes":37514,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "ravel_random_births":{"expert_count":68,"training_evaluations":186984,"drift_holdout_accuracy":1.000000000,"retention_accuracy":1.000000000,"reconstruction_rmse":4.872652007,"prediction_rmse":5.853272074,"planning_exact_state_rate":1.000000000,"expert_evaluations":2048,"checkpoint_size_bytes":39438,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}} + }, + "hard_gates":{"expected_topology":true,"base_holdout_accuracy":true,"adaptation_training_accuracy":true,"adapted_drift_holdout_accuracy":true,"adapted_gain_over_static":false,"base_holdout_retention":true,"exact_routing":true,"base_reconstruction_rmse":true,"adapted_reconstruction_rmse":true,"adapted_reconstruction_improvement":true,"retention_reconstruction":true,"base_prediction_rmse":true,"adapted_prediction_rmse":true,"adapted_prediction_improvement":true,"retention_prediction":true,"exact_world_state_target_rate":true,"path_found_rate":true,"checkpoint_identity":true,"checkpoint_behavior":true,"checkpoint_mutations":true,"lineage_and_topology":true}, + "trial_result":"FAIL" + }, + { + "trial_id":"trial-06-transition","regime":"transition_drift","seed":"0x0406000000000006", + "dataset_seeds":{"base_training":"0x926766a8f89b01fe","base_holdout":"0x4c841aa67ba9ccda","drift_adaptation_training":"0x29236cc144e74100","drift_holdout":"0x9468c22e35791397","original_task_retention_holdout":"0xdf904ec059d94431","planning_cases":"0x85212879e0609776"}, + "candidate":{"expert_count":68,"base_births":56,"adaptation_births":8,"adaptation_retirements":4,"training_evaluations":204431,"checkpoint_size_bytes":39438,"model_identity":"c9f3398d39810cbe2b0f70fffa52582204a29f0dd7c154d6fc38dd324c7f4572","behavior_identity":"218dcc8ecd66212dcb5a42746d5277935a8182edeab19b2d20c621f631ddd313", + "base_holdout":{"samples":256,"rejected":0,"accuracy":0.992187500,"reconstruction_rmse":4.014867992,"next_observation_prediction_rmse":10.752743838,"transition_accuracy":0.941406250,"routing_certification_count":256,"complete_oracle_agreement":256,"routed_complete_mismatches":0,"expert_evaluations":2048,"classification_checksum":"6e0106d9b5b350fa","reconstruction_checksum":"52629014d1060d6a","prediction_checksum":"917239c9f83390d4","transition_checksum":"4232633d53e59eec"}, + "adaptation_training":{"samples":512,"rejected":0,"accuracy":1.000000000,"reconstruction_rmse":3.005563520,"next_observation_prediction_rmse":6.928904267,"transition_accuracy":0.962890625,"routing_certification_count":512,"complete_oracle_agreement":512,"routed_complete_mismatches":0,"expert_evaluations":4096,"classification_checksum":"82b5e25d7ff724c7","reconstruction_checksum":"cc7762b3a56a7ab3","prediction_checksum":"22e9566a98d22fd6","transition_checksum":"feed63e7e75120b1"}, + "static_model_drift_holdout":{"samples":256,"rejected":0,"accuracy":0.992187500,"reconstruction_rmse":3.887227949,"next_observation_prediction_rmse":23.742634230,"transition_accuracy":0.761718750,"routing_certification_count":256,"complete_oracle_agreement":256,"routed_complete_mismatches":0,"expert_evaluations":2048,"classification_checksum":"27c8df540711e103","reconstruction_checksum":"03e7f1b90d5a0a2b","prediction_checksum":"6e1608d9bfceb46b","transition_checksum":"8a170a01d05f6d7d"}, + "adapted_model_drift_holdout":{"samples":256,"rejected":0,"accuracy":1.000000000,"reconstruction_rmse":3.325471662,"next_observation_prediction_rmse":12.004139378,"transition_accuracy":0.902343750,"routing_certification_count":256,"complete_oracle_agreement":256,"routed_complete_mismatches":0,"expert_evaluations":2048,"classification_checksum":"0a27b19971dc5cba","reconstruction_checksum":"d9e92709409fdc40","prediction_checksum":"2d33bc8b33b5cfea","transition_checksum":"1dfc28f7f966c6ea"}, + "base_holdout_retention":{"samples":256,"rejected":0,"accuracy":1.000000000,"reconstruction_rmse":3.353064513,"next_observation_prediction_rmse":18.338539315,"transition_accuracy":0.824218750,"routing_certification_count":256,"complete_oracle_agreement":256,"routed_complete_mismatches":0,"expert_evaluations":2048,"classification_checksum":"d031bf9b75dfd3d4","reconstruction_checksum":"4e30ac3dee1b39f7","prediction_checksum":"6868a7c76c4a9c8b","transition_checksum":"606edfed2c65db50"}, + "planning":{"cases":64,"path_found":64,"exact_world_state_target_reached":53,"goal_expert_reached":53,"executed_path_length":238,"optimal_path_length":234,"path_length_regret":8,"graph_disconnection_failures":0,"transition_model_error_failures":11,"state_aliasing_failures":0,"expansions":2180,"checksum":"f4634137350b92ba"}}, + "checkpoint_verification":{"roundtrip":true,"identity_match":true,"adaptation_training_evaluation_match":true,"drift_holdout_evaluation_match":true,"retention_evaluation_match":true,"planning_match":true,"complete_behavior_match":true,"mutations":{"retrieval_key_component":true,"reconstruction_component":true,"next_observation_component":true,"label":true,"label_count":true,"lineage":true,"transition_graph_edge":true,"payload_byte":true,"checkpoint_truncation":true,"appended_unexpected_byte":true,"incorrect_schema_version":true,"checkpoint_substitution":true}}, + "lineage_invariants":{"sibling_generation_equality":true,"parent_child_generation_increment":true,"lineage_uniqueness":true,"repeated_descendant_splitting":true,"no_accidental_lineage_reuse":true,"deterministic_topology_reproduction":true}, + "comparisons":{ + "ravel_0_4_candidate":{"expert_count":68,"training_evaluations":204431,"drift_holdout_accuracy":1.000000000,"retention_accuracy":1.000000000,"reconstruction_rmse":3.325471662,"prediction_rmse":12.004139378,"planning_exact_state_rate":0.828125000,"expert_evaluations":2048,"checkpoint_size_bytes":39438,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "fixed_8_expert":{"expert_count":8,"training_evaluations":61440,"drift_holdout_accuracy":0.234375000,"retention_accuracy":0.242187500,"reconstruction_rmse":28.776491142,"prediction_rmse":33.661330668,"planning_exact_state_rate":0.015625000,"expert_evaluations":2048,"checkpoint_size_bytes":10578,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "flat_64_expert_complete_scan":{"expert_count":64,"training_evaluations":2326528,"drift_holdout_accuracy":1.000000000,"retention_accuracy":1.000000000,"reconstruction_rmse":3.289496039,"prediction_rmse":23.603471108,"planning_exact_state_rate":0.578125000,"expert_evaluations":16384,"checkpoint_size_bytes":37514,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "fixed_topology_64_expert_routed":{"expert_count":64,"training_evaluations":2326528,"drift_holdout_accuracy":1.000000000,"retention_accuracy":1.000000000,"reconstruction_rmse":3.289496039,"prediction_rmse":23.603471108,"planning_exact_state_rate":0.578125000,"expert_evaluations":2048,"checkpoint_size_bytes":37514,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "nearest_centroid_16_no_recursive_births":{"expert_count":16,"training_evaluations":188416,"drift_holdout_accuracy":0.253906250,"retention_accuracy":0.238281250,"reconstruction_rmse":21.823954139,"prediction_rmse":29.618836762,"planning_exact_state_rate":0.078125000,"expert_evaluations":4096,"checkpoint_size_bytes":14426,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "no_adaptation_static":{"expert_count":64,"training_evaluations":128704,"drift_holdout_accuracy":0.992187500,"retention_accuracy":1.000000000,"reconstruction_rmse":3.887227949,"prediction_rmse":23.742634230,"planning_exact_state_rate":0.437500000,"expert_evaluations":2048,"checkpoint_size_bytes":37514,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "ravel_without_replay":{"expert_count":68,"training_evaluations":180427,"drift_holdout_accuracy":1.000000000,"retention_accuracy":1.000000000,"reconstruction_rmse":3.431959350,"prediction_rmse":9.730895929,"planning_exact_state_rate":0.859375000,"expert_evaluations":2048,"checkpoint_size_bytes":39438,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "ravel_without_retirement":{"expert_count":72,"training_evaluations":172480,"drift_holdout_accuracy":1.000000000,"retention_accuracy":1.000000000,"reconstruction_rmse":3.325329926,"prediction_rmse":12.949892046,"planning_exact_state_rate":0.812500000,"expert_evaluations":2496,"checkpoint_size_bytes":41362,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "ravel_complete_scan_without_certification":{"expert_count":68,"training_evaluations":385935,"drift_holdout_accuracy":1.000000000,"retention_accuracy":1.000000000,"reconstruction_rmse":3.325471662,"prediction_rmse":12.004139378,"planning_exact_state_rate":0.828125000,"expert_evaluations":17408,"checkpoint_size_bytes":39438,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "ravel_fixed_topology_without_recursive_births":{"expert_count":64,"training_evaluations":2351104,"drift_holdout_accuracy":1.000000000,"retention_accuracy":1.000000000,"reconstruction_rmse":3.325683177,"prediction_rmse":12.001830992,"planning_exact_state_rate":0.828125000,"expert_evaluations":2048,"checkpoint_size_bytes":37514,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "ravel_random_births":{"expert_count":68,"training_evaluations":181952,"drift_holdout_accuracy":1.000000000,"retention_accuracy":1.000000000,"reconstruction_rmse":3.323853271,"prediction_rmse":11.958909439,"planning_exact_state_rate":0.812500000,"expert_evaluations":2048,"checkpoint_size_bytes":39438,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}} + }, + "hard_gates":{"expected_topology":true,"base_holdout_accuracy":true,"adaptation_training_accuracy":true,"adapted_drift_holdout_accuracy":true,"adapted_gain_over_static":false,"base_holdout_retention":true,"exact_routing":true,"base_reconstruction_rmse":true,"adapted_reconstruction_rmse":true,"adapted_reconstruction_improvement":true,"retention_reconstruction":true,"base_prediction_rmse":true,"adapted_prediction_rmse":true,"adapted_prediction_improvement":true,"retention_prediction":false,"exact_world_state_target_rate":true,"path_found_rate":true,"checkpoint_identity":true,"checkpoint_behavior":true,"checkpoint_mutations":true,"lineage_and_topology":true}, + "trial_result":"FAIL" + }, + { + "trial_id":"trial-07-combined","regime":"combined_observation_and_label_drift","seed":"0x0407000000000007", + "dataset_seeds":{"base_training":"0xd37509ad6f4444a6","base_holdout":"0xc24118d60c43c1ea","drift_adaptation_training":"0x6ea6490add7501fc","drift_holdout":"0xa988d131a089eeee","original_task_retention_holdout":"0xc9bbd7c5753ce32e","planning_cases":"0xb148fd98c53e55d4"}, + "candidate":{"expert_count":68,"base_births":56,"adaptation_births":8,"adaptation_retirements":4,"training_evaluations":197558,"checkpoint_size_bytes":39438,"model_identity":"2ead11143532e496b9d9b5cbd2c4c5363effd8f0ae94b98c44d0e8fb9e0cbb0f","behavior_identity":"982a5bea0c5cc4cd65225ad89f69e948ae3aaf7f3b96775f272bfbb860c818e8", + "base_holdout":{"samples":256,"rejected":0,"accuracy":0.988281250,"reconstruction_rmse":4.876683712,"next_observation_prediction_rmse":7.086698289,"transition_accuracy":0.972656250,"routing_certification_count":255,"complete_oracle_agreement":256,"routed_complete_mismatches":0,"expert_evaluations":2104,"classification_checksum":"6cd7b6d1bd581f71","reconstruction_checksum":"3c79a743b378256a","prediction_checksum":"c9a65350c2f6a864","transition_checksum":"132d9ff47e9a3c34"}, + "adaptation_training":{"samples":512,"rejected":0,"accuracy":0.966796875,"reconstruction_rmse":6.512482533,"next_observation_prediction_rmse":5.470895116,"transition_accuracy":0.984375000,"routing_certification_count":512,"complete_oracle_agreement":512,"routed_complete_mismatches":0,"expert_evaluations":4096,"classification_checksum":"b44d4766a148c5a2","reconstruction_checksum":"ab2a825fe7ce2c66","prediction_checksum":"807dda64ed1d3e6e","transition_checksum":"170dff003fb8aef9"}, + "static_model_drift_holdout":{"samples":256,"rejected":0,"accuracy":0.632812500,"reconstruction_rmse":8.351477839,"next_observation_prediction_rmse":9.707866943,"transition_accuracy":0.968750000,"routing_certification_count":249,"complete_oracle_agreement":256,"routed_complete_mismatches":0,"expert_evaluations":2440,"classification_checksum":"8dd63826d89403eb","reconstruction_checksum":"8a4e616f0d0b57a1","prediction_checksum":"128ddd95639d580b","transition_checksum":"aadb36192c3461c4"}, + "adapted_model_drift_holdout":{"samples":256,"rejected":0,"accuracy":0.976562500,"reconstruction_rmse":6.954333254,"next_observation_prediction_rmse":9.192754186,"transition_accuracy":0.972656250,"routing_certification_count":256,"complete_oracle_agreement":256,"routed_complete_mismatches":0,"expert_evaluations":2048,"classification_checksum":"9826d9dd8b84f4ac","reconstruction_checksum":"2d462a2e5e5645d6","prediction_checksum":"997151b693eebed4","transition_checksum":"733cc1aaeea73a46"}, + "base_holdout_retention":{"samples":256,"rejected":0,"accuracy":0.687500000,"reconstruction_rmse":5.460581830,"next_observation_prediction_rmse":8.177056842,"transition_accuracy":0.953125000,"routing_certification_count":256,"complete_oracle_agreement":256,"routed_complete_mismatches":0,"expert_evaluations":2048,"classification_checksum":"9138ca83c6220659","reconstruction_checksum":"c17294b4edebb6c5","prediction_checksum":"485970e080858b11","transition_checksum":"e439dceab4f9949b"}, + "planning":{"cases":64,"path_found":64,"exact_world_state_target_reached":60,"goal_expert_reached":60,"executed_path_length":291,"optimal_path_length":290,"path_length_regret":1,"graph_disconnection_failures":0,"transition_model_error_failures":4,"state_aliasing_failures":0,"expansions":2157,"checksum":"3b7b0b37ec24a514"}}, + "checkpoint_verification":{"roundtrip":true,"identity_match":true,"adaptation_training_evaluation_match":true,"drift_holdout_evaluation_match":true,"retention_evaluation_match":true,"planning_match":true,"complete_behavior_match":true,"mutations":{"retrieval_key_component":true,"reconstruction_component":true,"next_observation_component":true,"label":true,"label_count":true,"lineage":true,"transition_graph_edge":true,"payload_byte":true,"checkpoint_truncation":true,"appended_unexpected_byte":true,"incorrect_schema_version":true,"checkpoint_substitution":true}}, + "lineage_invariants":{"sibling_generation_equality":true,"parent_child_generation_increment":true,"lineage_uniqueness":true,"repeated_descendant_splitting":true,"no_accidental_lineage_reuse":true,"deterministic_topology_reproduction":true}, + "comparisons":{ + "ravel_0_4_candidate":{"expert_count":68,"training_evaluations":197558,"drift_holdout_accuracy":0.976562500,"retention_accuracy":0.687500000,"reconstruction_rmse":6.954333254,"prediction_rmse":9.192754186,"planning_exact_state_rate":0.937500000,"expert_evaluations":2048,"checkpoint_size_bytes":39438,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "fixed_8_expert":{"expert_count":8,"training_evaluations":61440,"drift_holdout_accuracy":0.156250000,"retention_accuracy":0.160156250,"reconstruction_rmse":24.517232256,"prediction_rmse":26.045696477,"planning_exact_state_rate":0.046875000,"expert_evaluations":2048,"checkpoint_size_bytes":10578,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "flat_64_expert_complete_scan":{"expert_count":64,"training_evaluations":2326528,"drift_holdout_accuracy":0.648437500,"retention_accuracy":1.000000000,"reconstruction_rmse":8.060471065,"prediction_rmse":9.979726896,"planning_exact_state_rate":0.984375000,"expert_evaluations":16384,"checkpoint_size_bytes":37514,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "fixed_topology_64_expert_routed":{"expert_count":64,"training_evaluations":2326528,"drift_holdout_accuracy":0.648437500,"retention_accuracy":1.000000000,"reconstruction_rmse":8.060471065,"prediction_rmse":9.979726896,"planning_exact_state_rate":0.984375000,"expert_evaluations":2272,"checkpoint_size_bytes":37514,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "nearest_centroid_16_no_recursive_births":{"expert_count":16,"training_evaluations":188416,"drift_holdout_accuracy":0.203125000,"retention_accuracy":0.203125000,"reconstruction_rmse":20.580456353,"prediction_rmse":21.985895044,"planning_exact_state_rate":0.156250000,"expert_evaluations":4096,"checkpoint_size_bytes":14426,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "no_adaptation_static":{"expert_count":64,"training_evaluations":141600,"drift_holdout_accuracy":0.632812500,"retention_accuracy":0.972656250,"reconstruction_rmse":8.351477839,"prediction_rmse":9.707866943,"planning_exact_state_rate":0.859375000,"expert_evaluations":2440,"checkpoint_size_bytes":37514,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "ravel_without_replay":{"expert_count":68,"training_evaluations":181112,"drift_holdout_accuracy":1.000000000,"retention_accuracy":0.640625000,"reconstruction_rmse":6.954449813,"prediction_rmse":9.180787899,"planning_exact_state_rate":1.000000000,"expert_evaluations":2048,"checkpoint_size_bytes":39438,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "ravel_without_retirement":{"expert_count":72,"training_evaluations":172920,"drift_holdout_accuracy":0.968750000,"retention_accuracy":0.742187500,"reconstruction_rmse":6.949565093,"prediction_rmse":9.438350171,"planning_exact_state_rate":0.875000000,"expert_evaluations":2048,"checkpoint_size_bytes":41362,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "ravel_complete_scan_without_certification":{"expert_count":68,"training_evaluations":393142,"drift_holdout_accuracy":0.976562500,"retention_accuracy":0.687500000,"reconstruction_rmse":6.954333254,"prediction_rmse":9.192754186,"planning_exact_state_rate":0.937500000,"expert_evaluations":17408,"checkpoint_size_bytes":39438,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "ravel_fixed_topology_without_recursive_births":{"expert_count":64,"training_evaluations":2352336,"drift_holdout_accuracy":0.976562500,"retention_accuracy":0.648437500,"reconstruction_rmse":6.988528463,"prediction_rmse":8.334581379,"planning_exact_state_rate":1.000000000,"expert_evaluations":2048,"checkpoint_size_bytes":37514,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "ravel_random_births":{"expert_count":68,"training_evaluations":201047,"drift_holdout_accuracy":0.964843750,"retention_accuracy":0.664062500,"reconstruction_rmse":7.397027436,"prediction_rmse":8.943476831,"planning_exact_state_rate":0.984375000,"expert_evaluations":2288,"checkpoint_size_bytes":39438,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}} + }, + "hard_gates":{"expected_topology":true,"base_holdout_accuracy":true,"adaptation_training_accuracy":true,"adapted_drift_holdout_accuracy":true,"adapted_gain_over_static":true,"base_holdout_retention":false,"exact_routing":true,"base_reconstruction_rmse":true,"adapted_reconstruction_rmse":true,"adapted_reconstruction_improvement":true,"retention_reconstruction":true,"base_prediction_rmse":true,"adapted_prediction_rmse":true,"adapted_prediction_improvement":true,"retention_prediction":true,"exact_world_state_target_rate":true,"path_found_rate":true,"checkpoint_identity":true,"checkpoint_behavior":true,"checkpoint_mutations":true,"lineage_and_topology":true}, + "trial_result":"FAIL" + }, + { + "trial_id":"trial-08-ambiguous","regime":"partially_observed_ambiguous","seed":"0x0408000000000008", + "dataset_seeds":{"base_training":"0x28b00c8b3d322e56","base_holdout":"0xbc959ae447f27a9c","drift_adaptation_training":"0x924390d35b2a592a","drift_holdout":"0x5adc52056dbb377e","original_task_retention_holdout":"0x60e25d056ff28a31","planning_cases":"0xc54d048fd95f12d3"}, + "candidate":{"expert_count":68,"base_births":56,"adaptation_births":8,"adaptation_retirements":4,"training_evaluations":205054,"checkpoint_size_bytes":39438,"model_identity":"0fe9747959f4a56f4561610ae56325b3d017d91f4ff00638285d940ea592edf0","behavior_identity":"e1db12c2c8a9a2670f07e9c4855bf58d052389015398a1498e72b46faf4dee31", + "base_holdout":{"samples":256,"rejected":0,"accuracy":1.000000000,"reconstruction_rmse":5.384427146,"next_observation_prediction_rmse":15.803773847,"transition_accuracy":0.468750000,"routing_certification_count":239,"complete_oracle_agreement":256,"routed_complete_mismatches":0,"expert_evaluations":3000,"classification_checksum":"214882c78cb6f95f","reconstruction_checksum":"21c157eb8fc65f4b","prediction_checksum":"b74f4b2b443328bd","transition_checksum":"013fe1caa43a2a22"}, + "adaptation_training":{"samples":512,"rejected":0,"accuracy":0.962890625,"reconstruction_rmse":6.156287620,"next_observation_prediction_rmse":11.249369109,"transition_accuracy":0.703125000,"routing_certification_count":483,"complete_oracle_agreement":512,"routed_complete_mismatches":0,"expert_evaluations":5836,"classification_checksum":"598bf0425151ac04","reconstruction_checksum":"24dee8f9e51a0e7f","prediction_checksum":"bf5ab8b8072e170a","transition_checksum":"96f611bc4a11e759"}, + "static_model_drift_holdout":{"samples":256,"rejected":0,"accuracy":0.613281250,"reconstruction_rmse":8.173583379,"next_observation_prediction_rmse":21.228929994,"transition_accuracy":0.437500000,"routing_certification_count":220,"complete_oracle_agreement":256,"routed_complete_mismatches":0,"expert_evaluations":4064,"classification_checksum":"97aa80fedfc1b1fc","reconstruction_checksum":"3dffca1293f32450","prediction_checksum":"a9a774c6d104954d","transition_checksum":"66a66252979f2300"}, + "adapted_model_drift_holdout":{"samples":256,"rejected":0,"accuracy":0.933593750,"reconstruction_rmse":6.776301734,"next_observation_prediction_rmse":15.132556407,"transition_accuracy":0.562500000,"routing_certification_count":243,"complete_oracle_agreement":256,"routed_complete_mismatches":0,"expert_evaluations":2828,"classification_checksum":"95c6f5cbdc6a52a9","reconstruction_checksum":"8e0014fb3f210cca","prediction_checksum":"03e2c825a95c8c93","transition_checksum":"86e8adcd14afe9d4"}, + "base_holdout_retention":{"samples":256,"rejected":0,"accuracy":0.875000000,"reconstruction_rmse":5.952975229,"next_observation_prediction_rmse":17.637557343,"transition_accuracy":0.468750000,"routing_certification_count":242,"complete_oracle_agreement":256,"routed_complete_mismatches":0,"expert_evaluations":2888,"classification_checksum":"c3efaa00c7fc24e9","reconstruction_checksum":"d924edcafab4d00c","prediction_checksum":"11c05b3355ddcda8","transition_checksum":"8b4cf577b6a0e491"}, + "planning":{"cases":64,"path_found":64,"exact_world_state_target_reached":19,"goal_expert_reached":41,"executed_path_length":209,"optimal_path_length":208,"path_length_regret":5,"graph_disconnection_failures":0,"transition_model_error_failures":23,"state_aliasing_failures":22,"expansions":1655,"checksum":"e1a7ef0e8efb7ac9"}}, + "checkpoint_verification":{"roundtrip":true,"identity_match":true,"adaptation_training_evaluation_match":true,"drift_holdout_evaluation_match":true,"retention_evaluation_match":true,"planning_match":true,"complete_behavior_match":true,"mutations":{"retrieval_key_component":true,"reconstruction_component":true,"next_observation_component":true,"label":true,"label_count":true,"lineage":true,"transition_graph_edge":true,"payload_byte":true,"checkpoint_truncation":true,"appended_unexpected_byte":true,"incorrect_schema_version":true,"checkpoint_substitution":true}}, + "lineage_invariants":{"sibling_generation_equality":true,"parent_child_generation_increment":true,"lineage_uniqueness":true,"repeated_descendant_splitting":true,"no_accidental_lineage_reuse":true,"deterministic_topology_reproduction":true}, + "comparisons":{ + "ravel_0_4_candidate":{"expert_count":68,"training_evaluations":205054,"drift_holdout_accuracy":0.933593750,"retention_accuracy":0.875000000,"reconstruction_rmse":6.776301734,"prediction_rmse":15.132556407,"planning_exact_state_rate":0.296875000,"expert_evaluations":2828,"checkpoint_size_bytes":39438,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "fixed_8_expert":{"expert_count":8,"training_evaluations":61440,"drift_holdout_accuracy":0.203125000,"retention_accuracy":0.218750000,"reconstruction_rmse":18.973571631,"prediction_rmse":23.875998807,"planning_exact_state_rate":0.000000000,"expert_evaluations":2048,"checkpoint_size_bytes":10578,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "flat_64_expert_complete_scan":{"expert_count":64,"training_evaluations":2326528,"drift_holdout_accuracy":0.613281250,"retention_accuracy":1.000000000,"reconstruction_rmse":8.074792865,"prediction_rmse":20.861741043,"planning_exact_state_rate":0.078125000,"expert_evaluations":16384,"checkpoint_size_bytes":37514,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "fixed_topology_64_expert_routed":{"expert_count":64,"training_evaluations":2326528,"drift_holdout_accuracy":0.613281250,"retention_accuracy":1.000000000,"reconstruction_rmse":8.074792865,"prediction_rmse":20.861741043,"planning_exact_state_rate":0.078125000,"expert_evaluations":3672,"checkpoint_size_bytes":37514,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "nearest_centroid_16_no_recursive_births":{"expert_count":16,"training_evaluations":188416,"drift_holdout_accuracy":0.378906250,"retention_accuracy":0.542968750,"reconstruction_rmse":13.662055881,"prediction_rmse":22.389715333,"planning_exact_state_rate":0.031250000,"expert_evaluations":4096,"checkpoint_size_bytes":14426,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "no_adaptation_static":{"expert_count":64,"training_evaluations":126824,"drift_holdout_accuracy":0.613281250,"retention_accuracy":1.000000000,"reconstruction_rmse":8.173583379,"prediction_rmse":21.228929994,"planning_exact_state_rate":0.140625000,"expert_evaluations":4064,"checkpoint_size_bytes":37514,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "ravel_without_replay":{"expert_count":68,"training_evaluations":180238,"drift_holdout_accuracy":0.992187500,"retention_accuracy":0.683593750,"reconstruction_rmse":6.741988830,"prediction_rmse":14.419368162,"planning_exact_state_rate":0.312500000,"expert_evaluations":2768,"checkpoint_size_bytes":39438,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "ravel_without_retirement":{"expert_count":72,"training_evaluations":171256,"drift_holdout_accuracy":0.941406250,"retention_accuracy":0.871093750,"reconstruction_rmse":6.763869572,"prediction_rmse":15.078832884,"planning_exact_state_rate":0.265625000,"expert_evaluations":2880,"checkpoint_size_bytes":41362,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "ravel_complete_scan_without_certification":{"expert_count":68,"training_evaluations":390270,"drift_holdout_accuracy":0.933593750,"retention_accuracy":0.875000000,"reconstruction_rmse":6.776301734,"prediction_rmse":15.132556407,"planning_exact_state_rate":0.296875000,"expert_evaluations":17408,"checkpoint_size_bytes":39438,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "ravel_fixed_topology_without_recursive_births":{"expert_count":64,"training_evaluations":2354240,"drift_holdout_accuracy":0.980468750,"retention_accuracy":0.824218750,"reconstruction_rmse":6.687297570,"prediction_rmse":16.153250890,"planning_exact_state_rate":0.250000000,"expert_evaluations":2048,"checkpoint_size_bytes":37514,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}}, + "ravel_random_births":{"expert_count":68,"training_evaluations":216387,"drift_holdout_accuracy":0.937500000,"retention_accuracy":0.804687500,"reconstruction_rmse":6.807537642,"prediction_rmse":15.611341361,"planning_exact_state_rate":0.328125000,"expert_evaluations":3008,"checkpoint_size_bytes":39438,"runtime_observation_non_normative":{"status":"UNKNOWN","reason":"excluded_from_canonical_deterministic_evidence"}} + }, + "hard_gates":{"expected_topology":true,"base_holdout_accuracy":true,"adaptation_training_accuracy":true,"adapted_drift_holdout_accuracy":true,"adapted_gain_over_static":true,"base_holdout_retention":true,"exact_routing":true,"base_reconstruction_rmse":true,"adapted_reconstruction_rmse":true,"adapted_reconstruction_improvement":true,"retention_reconstruction":true,"base_prediction_rmse":true,"adapted_prediction_rmse":true,"adapted_prediction_improvement":true,"retention_prediction":true,"exact_world_state_target_rate":false,"path_found_rate":true,"checkpoint_identity":true,"checkpoint_behavior":true,"checkpoint_mutations":true,"lineage_and_topology":true}, + "trial_result":"FAIL" + } + ], + "negative_tests":{ + "malformed_observation":{"expected_disposition":"reject","observed":true,"pass":true}, + "out_of_domain_value":{"expected_disposition":"fall_back","observed":true,"pass":true}, + "empty_expert_assignment":{"expected_disposition":"reject","observed":true,"pass":true}, + "degenerate_expert_assignment":{"expected_disposition":"reject","observed":true,"pass":true}, + "duplicate_expert":{"expected_disposition":"reject","observed":true,"pass":true}, + "tied_distance":{"expected_disposition":"preserve_non_promotion","observed":true,"pass":true}, + "routing_lower_bound_equality":{"expected_disposition":"fall_back","observed":true,"pass":true}, + "maximum_expert_capacity":{"expected_disposition":"preserve_non_promotion","observed":true,"pass":true}, + "birth_beyond_capacity":{"expected_disposition":"reject","observed":true,"pass":true}, + "wrong_lifecycle_retirement":{"expected_disposition":"reject","observed":true,"pass":true}, + "poisoned_adaptation_labels":{"expected_disposition":"fail_a_gate","observed":true,"pass":true}, + "poisoned_transition_observations":{"expected_disposition":"fail_a_gate","observed":true,"pass":true}, + "replay_removal":{"expected_disposition":"fail_a_gate","observed":true,"pass":true}, + "catastrophic_forgetting_condition":{"expected_disposition":"fail_a_gate","observed":true,"pass":true} + }, + "trial_summary":{"declared":8,"passing":0,"failing":8,"pass_rule":"all_8_trials_pass"}, + "execution_integrity":"PASS", + "development_result":"FAIL", + "formal_mncs_status":"UNKNOWN", + "formal_mncds_status":"UNKNOWN", + "promotion_authorized":false +} diff --git a/ravel-0.4-runtime-observations.json b/ravel-0.4-runtime-observations.json new file mode 100644 index 0000000..6a44044 --- /dev/null +++ b/ravel-0.4-runtime-observations.json @@ -0,0 +1,22 @@ +{ + "schema": "ravel-runtime-observations/0.4", + "normative": false, + "scope": "whole_harness_only_not_per_variant", + "platform": "Linux-7.1.3-200.fc44.x86_64-x86_64-with-glibc2.43", + "python": "3.14.6", + "runs": 3, + "elapsed_nanoseconds": [ + 2590902368, + 2538623357, + 2547854960 + ], + "minimum_nanoseconds": 2538623357, + "median_nanoseconds": 2547854960, + "maximum_nanoseconds": 2590902368, + "arithmetic_mean_nanoseconds": 2559126895.0, + "output_sha256": "c7c71ad964b2cc06584a21185930eca5cb361112e4a9e1d9f6bc541b1d47f4e2", + "limitations": [ + "wall-clock observations are host-specific and non-normative", + "per-variant runtime remains UNKNOWN; canonical evidence compares operation counts" + ] +} diff --git a/ravel-0.4-source-manifest-spec.json b/ravel-0.4-source-manifest-spec.json new file mode 100644 index 0000000..a2e4bc4 --- /dev/null +++ b/ravel-0.4-source-manifest-spec.json @@ -0,0 +1,57 @@ +{ + "schema": "ravel-source-manifest-spec/0.4", + "digest_algorithm": "sha256", + "digest_procedure": "For each file in declared order, hash uint32_be(path_utf8_length), path_utf8, uint64_be(file_length), and exact file bytes.", + "entrypoint": "ravel_0_4.c", + "generated_execution_shards": [], + "source_provenance": "human_maintained_c11_no_generator", + "ordered_files": [ + { + "role": "entrypoint", + "path": "ravel_0_4.c" + }, + { + "role": "contract", + "path": "RAVEL_0_4_CONTRACT.md" + }, + { + "role": "scope", + "path": "RAVEL_0_4_SCOPE.md" + }, + { + "role": "preregistration", + "path": "ravel-0.4-preregistration.json" + }, + { + "role": "manifest_specification", + "path": "ravel-0.4-source-manifest-spec.json" + }, + { + "role": "threat_model", + "path": "ravel-0.4-threat-model.json" + }, + { + "role": "limitations", + "path": "ravel-0.4-limitations.md" + }, + { + "role": "evaluator_and_evidence_generator", + "path": "tools/ravel_0_4_evidence.py" + }, + { + "role": "source_digest_utility", + "path": "tools/ravel_source_digest.py" + } + ], + "evidence_schema_versions": [ + "ravel-raw-observations/0.4", + "ravel-trial-evidence/0.4", + "ravel-negative-evidence/0.4", + "ravel-assurance-case/0.4" + ], + "execution_shard_discovery_globs": [ + "ravel_0_4/*.inc", + "ravel_0_4/*.c", + "ravel_0_4/*.h" + ] +} diff --git a/ravel-0.4-source-manifest.json b/ravel-0.4-source-manifest.json new file mode 100644 index 0000000..bc37cb3 --- /dev/null +++ b/ravel-0.4-source-manifest.json @@ -0,0 +1,82 @@ +{ + "schema": "ravel-source-manifest/0.4", + "entrypoint": "ravel_0_4.c", + "generated_execution_shards": [], + "generator_source": null, + "source_provenance": "human_maintained_c11_no_generator", + "evidence_schema_versions": [ + "ravel-raw-observations/0.4", + "ravel-trial-evidence/0.4", + "ravel-negative-evidence/0.4", + "ravel-assurance-case/0.4" + ], + "digest_algorithm": "sha256", + "digest_procedure": "For each file in declared order, hash uint32_be(path_utf8_length), path_utf8, uint64_be(file_length), and exact file bytes.", + "ordered_files": [ + { + "order": 0, + "role": "entrypoint", + "path": "ravel_0_4.c", + "bytes": 91563, + "sha256": "5243022245bce97b2e3be6dd46e397d33445c25469b8ce9a364c6a104e757cd4" + }, + { + "order": 1, + "role": "contract", + "path": "RAVEL_0_4_CONTRACT.md", + "bytes": 2857, + "sha256": "e6a2d6ec9eb6c73521e575c608994f8a0da3f911611613e51b5515fd3197048d" + }, + { + "order": 2, + "role": "scope", + "path": "RAVEL_0_4_SCOPE.md", + "bytes": 2825, + "sha256": "5912d94993d4c7b120cfdc376a794beeaae374646016c1279b1697a58bc39a68" + }, + { + "order": 3, + "role": "preregistration", + "path": "ravel-0.4-preregistration.json", + "bytes": 4046, + "sha256": "d2e5e268392d0b341cfee96401d9da9bde36e8df8b69501512d54ee1bd373c8f" + }, + { + "order": 4, + "role": "manifest_specification", + "path": "ravel-0.4-source-manifest-spec.json", + "bytes": 1448, + "sha256": "d8548832deb03a35cd2f91e7f60c39408cf818734f74cb1f33fd516d514b9102" + }, + { + "order": 5, + "role": "threat_model", + "path": "ravel-0.4-threat-model.json", + "bytes": 3497, + "sha256": "fca61fadad5c8d7feb16a0eebe5b9e09a78e048ae057ee389d0d88d7b2b2007e" + }, + { + "order": 6, + "role": "limitations", + "path": "ravel-0.4-limitations.md", + "bytes": 1072, + "sha256": "92c75aebd78fbdf0eea3ccc6c16b3c3d03ba23b35dc356c4bb831cc5a7d8466b" + }, + { + "order": 7, + "role": "evaluator_and_evidence_generator", + "path": "tools/ravel_0_4_evidence.py", + "bytes": 23566, + "sha256": "c6fdef88d32a0496bbab60def535f5fce13563f9aff6c4b954e7af92875731b5" + }, + { + "order": 8, + "role": "source_digest_utility", + "path": "tools/ravel_source_digest.py", + "bytes": 8590, + "sha256": "3b161bb5baab1ea2a2413770a051f457347c4381ee4f92ef4ba9560d7601bb74" + } + ], + "source_digest": "1a8b8f0fcbabf0ec2000c8bfd89a754a0c203cf0c2f1747c6e32fb862123937e", + "unexpected_execution_shards": [] +} diff --git a/ravel-0.4-threat-model.json b/ravel-0.4-threat-model.json new file mode 100644 index 0000000..62f5a1e --- /dev/null +++ b/ravel-0.4-threat-model.json @@ -0,0 +1,74 @@ +{ + "schema": "ravel-threat-model/0.4", + "threat_model_id": "ravel.evidence-hardening.threats.v1", + "assets": [ + "adaptation and drift-holdout separation", + "canonical checkpoint identity", + "behavioral restoration measurements", + "expert lineage and topology", + "exact routing fallback", + "planning claim precision", + "ordered implementation provenance", + "deterministic raw and derived evidence", + "formal UNKNOWN and non-promotion boundary" + ], + "threats": [ + { + "id": "R04-T1", + "threat": "drift evaluation data influences adaptation or topology", + "mitigation": "separate seed-addressed arrays and call boundaries; drift holdout is passed only to post-adaptation evaluation", + "residual_status": "repository visibility prevents protected independence" + }, + { + "id": "R04-T2", + "threat": "checkpoint substitution or corruption preserves a weak identity", + "mitigation": "canonical full-field payload, SHA-256 payload identity, strict parser, full restored measurement comparison, and deliberate mutations", + "residual_status": "no signing, authorization, protected custody, or operational rollback" + }, + { + "id": "R04-T3", + "threat": "split metadata misstates sibling or descendant generation", + "mitigation": "capture original generation before reseeding and test sibling, descendant, uniqueness, reuse, and deterministic topology invariants", + "residual_status": "lineage identity is deterministic development metadata, not an external attestation" + }, + { + "id": "R04-T4", + "threat": "expert-equivalence is reported as exact planning success", + "mitigation": "separate exact world state, goal expert, path, regret, disconnection, transition error, and aliasing measurements", + "residual_status": "bounded synthetic planning is not real-world planning evidence" + }, + { + "id": "R04-T5", + "threat": "assurance digest is stale, incomplete, reordered, or omits source", + "mitigation": "machine-generated ordered manifest with per-file hashes, framed aggregate digest, shard discovery, and independent verification", + "residual_status": "repository-local verification is not protected or independent custody" + }, + { + "id": "R04-T6", + "threat": "favorable seed or regime selection hides failures", + "mitigation": "eight frozen seeds and regimes, all-trials pass rule, per-trial failures, variance, and no seed removal", + "residual_status": "the bounded matrix is not representative of arbitrary environments" + }, + { + "id": "R04-T7", + "threat": "poisoning, replay removal, malformed data, or capacity boundaries fail silently", + "mitigation": "negative tests with declared reject, fallback, fail-gate, UNKNOWN, or non-promotion dispositions", + "residual_status": "the attacks are bounded fixtures, not a complete adversarial evaluation" + } + ], + "residual_unknowns": [ + "independently protected evaluation", + "real-data and real-world generalization", + "cross-organizational reproduction", + "language or multimodal capability", + "causal or long-horizon reasoning", + "production safety and authorization", + "release signing and monitored rollback", + "distributed and accelerator behavior", + "formal MNCS conformance", + "formal MNCDS conformance" + ], + "formal_mncs_status": "UNKNOWN", + "formal_mncds_status": "UNKNOWN", + "promotion_authorized": false +} diff --git a/ravel-0.4-trial-evidence.json b/ravel-0.4-trial-evidence.json new file mode 100644 index 0000000..dd61145 --- /dev/null +++ b/ravel-0.4-trial-evidence.json @@ -0,0 +1,3605 @@ +{ + "schema": "ravel-trial-evidence/0.4", + "study_id": "ravel.evidence-hardening.epoch-1.v1", + "preregistration": "ravel-0.4-preregistration.json", + "trial_pass_rule": "all_hard_gates_per_trial", + "global_pass_rule": "all_8_trials_pass", + "trials": [ + { + "trial_id": "trial-01-separated", + "regime": "separated_state", + "seed": "0x0401000000000001", + "dataset_seeds": { + "base_training": "0xfb9173fec332d474", + "base_holdout": "0xa2cb7273b415f00f", + "drift_adaptation_training": "0xd128a6be12aedae6", + "drift_holdout": "0xc8c3a44f89c5d6a7", + "original_task_retention_holdout": "0x7fac89bfda811927", + "planning_cases": "0x4dbc3dd2a99ef496" + }, + "candidate": { + "expert_count": 68, + "base_births": 56, + "adaptation_births": 8, + "adaptation_retirements": 4, + "training_evaluations": 184288, + "checkpoint_size_bytes": 39438, + "model_identity": "f749f4346b5f1a6fa55950a97192666e6649edead2d32477cbc20313b0c62c0c", + "behavior_identity": "d7bb0c9b9c43226b516a5c6e200831b8dc7f97650c4370532feca71cd41f68e8", + "base_holdout": { + "samples": 256, + "rejected": 0, + "accuracy": 0.9375, + "reconstruction_rmse": 6.771654787, + "next_observation_prediction_rmse": 10.387196711, + "transition_accuracy": 0.9140625, + "routing_certification_count": 256, + "complete_oracle_agreement": 256, + "routed_complete_mismatches": 0, + "expert_evaluations": 2048, + "classification_checksum": "621008a0accf4117", + "reconstruction_checksum": "bbc6d95bb03c71b3", + "prediction_checksum": "d0ebe4d1e7f20613", + "transition_checksum": "982b9a44cdccbcb7" + }, + "adaptation_training": { + "samples": 512, + "rejected": 0, + "accuracy": 1.0, + "reconstruction_rmse": 3.009849648, + "next_observation_prediction_rmse": 2.5683344, + "transition_accuracy": 0.986328125, + "routing_certification_count": 512, + "complete_oracle_agreement": 512, + "routed_complete_mismatches": 0, + "expert_evaluations": 4096, + "classification_checksum": "34bb91b25793446d", + "reconstruction_checksum": "2065f12be33264fb", + "prediction_checksum": "58c88a10857785a5", + "transition_checksum": "5a1d5dec583cd7c6" + }, + "static_model_drift_holdout": { + "samples": 256, + "rejected": 0, + "accuracy": 0.953125, + "reconstruction_rmse": 6.080038321, + "next_observation_prediction_rmse": 9.069805773, + "transition_accuracy": 0.93359375, + "routing_certification_count": 256, + "complete_oracle_agreement": 256, + "routed_complete_mismatches": 0, + "expert_evaluations": 2048, + "classification_checksum": "bc4851585cd4847c", + "reconstruction_checksum": "a2e1dad23a64c827", + "prediction_checksum": "2088e68834483eaa", + "transition_checksum": "0881513aa1b2b983" + }, + "adapted_model_drift_holdout": { + "samples": 256, + "rejected": 0, + "accuracy": 1.0, + "reconstruction_rmse": 3.268650797, + "next_observation_prediction_rmse": 5.534045939, + "transition_accuracy": 0.9765625, + "routing_certification_count": 256, + "complete_oracle_agreement": 256, + "routed_complete_mismatches": 0, + "expert_evaluations": 2048, + "classification_checksum": "e8130132975e90e0", + "reconstruction_checksum": "4726339a3b30ffbd", + "prediction_checksum": "5b9408ccf32d2ba0", + "transition_checksum": "e47d08295bd4268e" + }, + "base_holdout_retention": { + "samples": 256, + "rejected": 0, + "accuracy": 1.0, + "reconstruction_rmse": 3.224120775, + "next_observation_prediction_rmse": 3.792183638, + "transition_accuracy": 0.99609375, + "routing_certification_count": 256, + "complete_oracle_agreement": 256, + "routed_complete_mismatches": 0, + "expert_evaluations": 2048, + "classification_checksum": "2467726ebb18c9ea", + "reconstruction_checksum": "b465510aae54fd34", + "prediction_checksum": "58aadbc1d6eac16c", + "transition_checksum": "fcfed22da80eb85d" + }, + "planning": { + "cases": 64, + "path_found": 62, + "exact_world_state_target_reached": 59, + "goal_expert_reached": 59, + "executed_path_length": 261, + "optimal_path_length": 262, + "path_length_regret": 2, + "graph_disconnection_failures": 2, + "transition_model_error_failures": 3, + "state_aliasing_failures": 0, + "expansions": 1927, + "checksum": "cc0f6efda781d157" + } + }, + "checkpoint_verification": { + "roundtrip": true, + "identity_match": true, + "adaptation_training_evaluation_match": true, + "drift_holdout_evaluation_match": true, + "retention_evaluation_match": true, + "planning_match": true, + "complete_behavior_match": true, + "mutations": { + "retrieval_key_component": true, + "reconstruction_component": true, + "next_observation_component": true, + "label": true, + "label_count": true, + "lineage": true, + "transition_graph_edge": true, + "payload_byte": true, + "checkpoint_truncation": true, + "appended_unexpected_byte": true, + "incorrect_schema_version": true, + "checkpoint_substitution": true + } + }, + "lineage_invariants": { + "sibling_generation_equality": true, + "parent_child_generation_increment": true, + "lineage_uniqueness": true, + "repeated_descendant_splitting": true, + "no_accidental_lineage_reuse": true, + "deterministic_topology_reproduction": true + }, + "comparisons": { + "ravel_0_4_candidate": { + "expert_count": 68, + "training_evaluations": 184288, + "drift_holdout_accuracy": 1.0, + "retention_accuracy": 1.0, + "reconstruction_rmse": 3.268650797, + "prediction_rmse": 5.534045939, + "planning_exact_state_rate": 0.921875, + "expert_evaluations": 2048, + "checkpoint_size_bytes": 39438, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "fixed_8_expert": { + "expert_count": 8, + "training_evaluations": 61440, + "drift_holdout_accuracy": 0.19921875, + "retention_accuracy": 0.25, + "reconstruction_rmse": 28.565835338, + "prediction_rmse": 29.869555279, + "planning_exact_state_rate": 0.03125, + "expert_evaluations": 2048, + "checkpoint_size_bytes": 10578, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "flat_64_expert_complete_scan": { + "expert_count": 64, + "training_evaluations": 2326528, + "drift_holdout_accuracy": 1.0, + "retention_accuracy": 1.0, + "reconstruction_rmse": 3.239324581, + "prediction_rmse": 7.670675312, + "planning_exact_state_rate": 0.953125, + "expert_evaluations": 16384, + "checkpoint_size_bytes": 37514, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "fixed_topology_64_expert_routed": { + "expert_count": 64, + "training_evaluations": 2326528, + "drift_holdout_accuracy": 1.0, + "retention_accuracy": 1.0, + "reconstruction_rmse": 3.239324581, + "prediction_rmse": 7.670675312, + "planning_exact_state_rate": 0.953125, + "expert_evaluations": 2048, + "checkpoint_size_bytes": 37514, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "nearest_centroid_16_no_recursive_births": { + "expert_count": 16, + "training_evaluations": 188416, + "drift_holdout_accuracy": 0.2109375, + "retention_accuracy": 0.265625, + "reconstruction_rmse": 22.911277755, + "prediction_rmse": 24.245409824, + "planning_exact_state_rate": 0.15625, + "expert_evaluations": 4096, + "checkpoint_size_bytes": 14426, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "no_adaptation_static": { + "expert_count": 64, + "training_evaluations": 131040, + "drift_holdout_accuracy": 0.953125, + "retention_accuracy": 0.96875, + "reconstruction_rmse": 6.080038321, + "prediction_rmse": 9.069805773, + "planning_exact_state_rate": 0.75, + "expert_evaluations": 2048, + "checkpoint_size_bytes": 37514, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "ravel_without_replay": { + "expert_count": 68, + "training_evaluations": 167904, + "drift_holdout_accuracy": 1.0, + "retention_accuracy": 1.0, + "reconstruction_rmse": 3.35731616, + "prediction_rmse": 6.825674031, + "planning_exact_state_rate": 1.0, + "expert_evaluations": 2048, + "checkpoint_size_bytes": 39438, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "ravel_without_retirement": { + "expert_count": 72, + "training_evaluations": 159712, + "drift_holdout_accuracy": 1.0, + "retention_accuracy": 1.0, + "reconstruction_rmse": 3.268070888, + "prediction_rmse": 8.88638668, + "planning_exact_state_rate": 0.90625, + "expert_evaluations": 2048, + "checkpoint_size_bytes": 41362, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "ravel_complete_scan_without_certification": { + "expert_count": 68, + "training_evaluations": 380896, + "drift_holdout_accuracy": 1.0, + "retention_accuracy": 1.0, + "reconstruction_rmse": 3.268650797, + "prediction_rmse": 5.534045939, + "planning_exact_state_rate": 0.921875, + "expert_evaluations": 17408, + "checkpoint_size_bytes": 39438, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "ravel_fixed_topology_without_recursive_births": { + "expert_count": 64, + "training_evaluations": 2351104, + "drift_holdout_accuracy": 1.0, + "retention_accuracy": 1.0, + "reconstruction_rmse": 3.276899436, + "prediction_rmse": 3.725665254, + "planning_exact_state_rate": 1.0, + "expert_evaluations": 2048, + "checkpoint_size_bytes": 37514, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "ravel_random_births": { + "expert_count": 68, + "training_evaluations": 185164, + "drift_holdout_accuracy": 0.96875, + "retention_accuracy": 0.97265625, + "reconstruction_rmse": 5.095431803, + "prediction_rmse": 5.244062968, + "planning_exact_state_rate": 0.859375, + "expert_evaluations": 2108, + "checkpoint_size_bytes": 39438, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + } + }, + "hard_gates": { + "expected_topology": true, + "base_holdout_accuracy": true, + "adaptation_training_accuracy": true, + "adapted_drift_holdout_accuracy": true, + "adapted_gain_over_static": false, + "base_holdout_retention": true, + "exact_routing": true, + "base_reconstruction_rmse": true, + "adapted_reconstruction_rmse": true, + "adapted_reconstruction_improvement": true, + "retention_reconstruction": true, + "base_prediction_rmse": true, + "adapted_prediction_rmse": true, + "adapted_prediction_improvement": true, + "retention_prediction": true, + "exact_world_state_target_rate": true, + "path_found_rate": true, + "checkpoint_identity": true, + "checkpoint_behavior": true, + "checkpoint_mutations": true, + "lineage_and_topology": true + }, + "trial_result": "FAIL" + }, + { + "trial_id": "trial-02-overlap", + "regime": "partially_overlapping_observations", + "seed": "0x0402000000000002", + "dataset_seeds": { + "base_training": "0x359791d15caa8021", + "base_holdout": "0x347629147b455cc1", + "drift_adaptation_training": "0xc5b9901d9746e31d", + "drift_holdout": "0x9662c6f345517a30", + "original_task_retention_holdout": "0x8c6d375a4e72b2ee", + "planning_cases": "0xa469eb102cb94fff" + }, + "candidate": { + "expert_count": 68, + "base_births": 56, + "adaptation_births": 8, + "adaptation_retirements": 4, + "training_evaluations": 248728, + "checkpoint_size_bytes": 39438, + "model_identity": "77c5530ae17887619c8b9c67bf728d0c61274c7da26f8c20a73f547bc6225193", + "behavior_identity": "7b979ea1ffa888236dd1d5fd29766affdd216ef0b764f806b977deab3719f736", + "base_holdout": { + "samples": 256, + "rejected": 0, + "accuracy": 0.984375, + "reconstruction_rmse": 4.682442178, + "next_observation_prediction_rmse": 7.749657182, + "transition_accuracy": 0.953125, + "routing_certification_count": 250, + "complete_oracle_agreement": 256, + "routed_complete_mismatches": 0, + "expert_evaluations": 2384, + "classification_checksum": "036a80c04271efd2", + "reconstruction_checksum": "5f21253cc71596e1", + "prediction_checksum": "1a1f7876f3cc397d", + "transition_checksum": "53181bb942dbcf59" + }, + "adaptation_training": { + "samples": 512, + "rejected": 0, + "accuracy": 1.0, + "reconstruction_rmse": 4.136402676, + "next_observation_prediction_rmse": 3.456683979, + "transition_accuracy": 0.98828125, + "routing_certification_count": 512, + "complete_oracle_agreement": 512, + "routed_complete_mismatches": 0, + "expert_evaluations": 4096, + "classification_checksum": "966484f3d827cb07", + "reconstruction_checksum": "2b6c05741e6cf15a", + "prediction_checksum": "64ca7b8c28a4c1df", + "transition_checksum": "5352b3c50b8ebd37" + }, + "static_model_drift_holdout": { + "samples": 256, + "rejected": 0, + "accuracy": 0.96875, + "reconstruction_rmse": 4.741379161, + "next_observation_prediction_rmse": 6.308541448, + "transition_accuracy": 0.9765625, + "routing_certification_count": 246, + "complete_oracle_agreement": 256, + "routed_complete_mismatches": 0, + "expert_evaluations": 2608, + "classification_checksum": "b8abbf549864e6c4", + "reconstruction_checksum": "64d2a4a6a0da11ad", + "prediction_checksum": "1bde53784df95a76", + "transition_checksum": "f49f5057e7a746c0" + }, + "adapted_model_drift_holdout": { + "samples": 256, + "rejected": 0, + "accuracy": 1.0, + "reconstruction_rmse": 4.4597597, + "next_observation_prediction_rmse": 5.210900214, + "transition_accuracy": 0.984375, + "routing_certification_count": 256, + "complete_oracle_agreement": 256, + "routed_complete_mismatches": 0, + "expert_evaluations": 2048, + "classification_checksum": "5240a759ab88cac2", + "reconstruction_checksum": "d9ad5b705868359f", + "prediction_checksum": "7534d917b59170f4", + "transition_checksum": "f62159f7a4deeebe" + }, + "base_holdout_retention": { + "samples": 256, + "rejected": 0, + "accuracy": 1.0, + "reconstruction_rmse": 4.506023348, + "next_observation_prediction_rmse": 6.320249235, + "transition_accuracy": 0.9609375, + "routing_certification_count": 256, + "complete_oracle_agreement": 256, + "routed_complete_mismatches": 0, + "expert_evaluations": 2048, + "classification_checksum": "9b4af0db28883f0a", + "reconstruction_checksum": "985b8fa03c17c5e2", + "prediction_checksum": "bcb25ada809a99dc", + "transition_checksum": "cd61076b01f84266" + }, + "planning": { + "cases": 64, + "path_found": 64, + "exact_world_state_target_reached": 64, + "goal_expert_reached": 64, + "executed_path_length": 304, + "optimal_path_length": 304, + "path_length_regret": 0, + "graph_disconnection_failures": 0, + "transition_model_error_failures": 0, + "state_aliasing_failures": 0, + "expansions": 2175, + "checksum": "351ce529139874a7" + } + }, + "checkpoint_verification": { + "roundtrip": true, + "identity_match": true, + "adaptation_training_evaluation_match": true, + "drift_holdout_evaluation_match": true, + "retention_evaluation_match": true, + "planning_match": true, + "complete_behavior_match": true, + "mutations": { + "retrieval_key_component": true, + "reconstruction_component": true, + "next_observation_component": true, + "label": true, + "label_count": true, + "lineage": true, + "transition_graph_edge": true, + "payload_byte": true, + "checkpoint_truncation": true, + "appended_unexpected_byte": true, + "incorrect_schema_version": true, + "checkpoint_substitution": true + } + }, + "lineage_invariants": { + "sibling_generation_equality": true, + "parent_child_generation_increment": true, + "lineage_uniqueness": true, + "repeated_descendant_splitting": true, + "no_accidental_lineage_reuse": true, + "deterministic_topology_reproduction": true + }, + "comparisons": { + "ravel_0_4_candidate": { + "expert_count": 68, + "training_evaluations": 248728, + "drift_holdout_accuracy": 1.0, + "retention_accuracy": 1.0, + "reconstruction_rmse": 4.4597597, + "prediction_rmse": 5.210900214, + "planning_exact_state_rate": 1.0, + "expert_evaluations": 2048, + "checkpoint_size_bytes": 39438, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "fixed_8_expert": { + "expert_count": 8, + "training_evaluations": 61440, + "drift_holdout_accuracy": 0.22265625, + "retention_accuracy": 0.1953125, + "reconstruction_rmse": 16.462897466, + "prediction_rmse": 17.871856266, + "planning_exact_state_rate": 0.046875, + "expert_evaluations": 2048, + "checkpoint_size_bytes": 10578, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "flat_64_expert_complete_scan": { + "expert_count": 64, + "training_evaluations": 2326528, + "drift_holdout_accuracy": 1.0, + "retention_accuracy": 1.0, + "reconstruction_rmse": 4.448226133, + "prediction_rmse": 6.28316291, + "planning_exact_state_rate": 0.96875, + "expert_evaluations": 16384, + "checkpoint_size_bytes": 37514, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "fixed_topology_64_expert_routed": { + "expert_count": 64, + "training_evaluations": 2326528, + "drift_holdout_accuracy": 1.0, + "retention_accuracy": 1.0, + "reconstruction_rmse": 4.448226133, + "prediction_rmse": 6.28316291, + "planning_exact_state_rate": 0.96875, + "expert_evaluations": 2048, + "checkpoint_size_bytes": 37514, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "nearest_centroid_16_no_recursive_births": { + "expert_count": 16, + "training_evaluations": 188416, + "drift_holdout_accuracy": 0.21484375, + "retention_accuracy": 0.25, + "reconstruction_rmse": 11.97511352, + "prediction_rmse": 11.988090221, + "planning_exact_state_rate": 0.328125, + "expert_evaluations": 4096, + "checkpoint_size_bytes": 14426, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "no_adaptation_static": { + "expert_count": 64, + "training_evaluations": 192824, + "drift_holdout_accuracy": 0.96875, + "retention_accuracy": 0.96484375, + "reconstruction_rmse": 4.741379161, + "prediction_rmse": 6.308541448, + "planning_exact_state_rate": 0.8125, + "expert_evaluations": 2608, + "checkpoint_size_bytes": 37514, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "ravel_without_replay": { + "expert_count": 68, + "training_evaluations": 231960, + "drift_holdout_accuracy": 1.0, + "retention_accuracy": 1.0, + "reconstruction_rmse": 4.5404994, + "prediction_rmse": 6.171878127, + "planning_exact_state_rate": 1.0, + "expert_evaluations": 2048, + "checkpoint_size_bytes": 39438, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "ravel_without_retirement": { + "expert_count": 72, + "training_evaluations": 224152, + "drift_holdout_accuracy": 1.0, + "retention_accuracy": 1.0, + "reconstruction_rmse": 4.46332194, + "prediction_rmse": 5.628626399, + "planning_exact_state_rate": 1.0, + "expert_evaluations": 2048, + "checkpoint_size_bytes": 41362, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "ravel_complete_scan_without_certification": { + "expert_count": 68, + "training_evaluations": 443800, + "drift_holdout_accuracy": 1.0, + "retention_accuracy": 1.0, + "reconstruction_rmse": 4.4597597, + "prediction_rmse": 5.210900214, + "planning_exact_state_rate": 1.0, + "expert_evaluations": 17408, + "checkpoint_size_bytes": 39438, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "ravel_fixed_topology_without_recursive_births": { + "expert_count": 64, + "training_evaluations": 2351104, + "drift_holdout_accuracy": 1.0, + "retention_accuracy": 1.0, + "reconstruction_rmse": 4.479194377, + "prediction_rmse": 5.20249819, + "planning_exact_state_rate": 1.0, + "expert_evaluations": 2048, + "checkpoint_size_bytes": 37514, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "ravel_random_births": { + "expert_count": 68, + "training_evaluations": 259742, + "drift_holdout_accuracy": 0.96875, + "retention_accuracy": 0.96484375, + "reconstruction_rmse": 4.760327614, + "prediction_rmse": 5.96448625, + "planning_exact_state_rate": 0.796875, + "expert_evaluations": 2528, + "checkpoint_size_bytes": 39438, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + } + }, + "hard_gates": { + "expected_topology": true, + "base_holdout_accuracy": true, + "adaptation_training_accuracy": true, + "adapted_drift_holdout_accuracy": true, + "adapted_gain_over_static": false, + "base_holdout_retention": true, + "exact_routing": true, + "base_reconstruction_rmse": true, + "adapted_reconstruction_rmse": true, + "adapted_reconstruction_improvement": true, + "retention_reconstruction": true, + "base_prediction_rmse": true, + "adapted_prediction_rmse": true, + "adapted_prediction_improvement": true, + "retention_prediction": true, + "exact_world_state_target_rate": true, + "path_found_rate": true, + "checkpoint_identity": true, + "checkpoint_behavior": true, + "checkpoint_mutations": true, + "lineage_and_topology": true + }, + "trial_result": "FAIL" + }, + { + "trial_id": "trial-03-noise", + "regime": "increased_observation_noise", + "seed": "0x0403000000000003", + "dataset_seeds": { + "base_training": "0x31c899554a6b02bf", + "base_holdout": "0x30ab06786aecff1f", + "drift_adaptation_training": "0x5337eaaa31957ea0", + "drift_holdout": "0x849ccea305c2e858", + "original_task_retention_holdout": "0x1bcba0c16fd0b750", + "planning_cases": "0x2c6c4e52d917f858" + }, + "candidate": { + "expert_count": 68, + "base_births": 56, + "adaptation_births": 8, + "adaptation_retirements": 4, + "training_evaluations": 191966, + "checkpoint_size_bytes": 39438, + "model_identity": "094fa2315b914a3e8fe4b05403958769d77a80e84f9df17be05ceffbbf1b0e83", + "behavior_identity": "f39fad0c4a8340e4d0359aec9b2ac05d792afb7019028b6329058921c3c7be96", + "base_holdout": { + "samples": 256, + "rejected": 0, + "accuracy": 0.95703125, + "reconstruction_rmse": 9.256042033, + "next_observation_prediction_rmse": 12.015166216, + "transition_accuracy": 0.9296875, + "routing_certification_count": 254, + "complete_oracle_agreement": 256, + "routed_complete_mismatches": 0, + "expert_evaluations": 2160, + "classification_checksum": "78ade4e3ed35bffa", + "reconstruction_checksum": "56a03e4fa9fd47e3", + "prediction_checksum": "0d2d7902d1277e1d", + "transition_checksum": "b1856bd2df36b1f5" + }, + "adaptation_training": { + "samples": 512, + "rejected": 0, + "accuracy": 1.0, + "reconstruction_rmse": 10.681188351, + "next_observation_prediction_rmse": 8.970615587, + "transition_accuracy": 0.9765625, + "routing_certification_count": 511, + "complete_oracle_agreement": 512, + "routed_complete_mismatches": 0, + "expert_evaluations": 4156, + "classification_checksum": "b3055f634bac50af", + "reconstruction_checksum": "b8c42536c2170e68", + "prediction_checksum": "478678748e759b6f", + "transition_checksum": "e2adee66e4283a9c" + }, + "static_model_drift_holdout": { + "samples": 256, + "rejected": 0, + "accuracy": 0.95703125, + "reconstruction_rmse": 12.208403881, + "next_observation_prediction_rmse": 17.195498684, + "transition_accuracy": 0.890625, + "routing_certification_count": 250, + "complete_oracle_agreement": 256, + "routed_complete_mismatches": 0, + "expert_evaluations": 2384, + "classification_checksum": "c78ed10841903f15", + "reconstruction_checksum": "e017e54783b64e82", + "prediction_checksum": "eb07bd78ca758a86", + "transition_checksum": "a2f761de4e55be59" + }, + "adapted_model_drift_holdout": { + "samples": 256, + "rejected": 0, + "accuracy": 1.0, + "reconstruction_rmse": 11.722196472, + "next_observation_prediction_rmse": 13.802821074, + "transition_accuracy": 0.97265625, + "routing_certification_count": 252, + "complete_oracle_agreement": 256, + "routed_complete_mismatches": 0, + "expert_evaluations": 2288, + "classification_checksum": "1ed08bd42b12b5a9", + "reconstruction_checksum": "56bb01a6e0dd2d19", + "prediction_checksum": "2bc238dbe09141f1", + "transition_checksum": "1407053d804140a4" + }, + "base_holdout_retention": { + "samples": 256, + "rejected": 0, + "accuracy": 1.0, + "reconstruction_rmse": 8.396915222, + "next_observation_prediction_rmse": 10.613961832, + "transition_accuracy": 0.9765625, + "routing_certification_count": 256, + "complete_oracle_agreement": 256, + "routed_complete_mismatches": 0, + "expert_evaluations": 2048, + "classification_checksum": "cc9c9e18f84df52a", + "reconstruction_checksum": "7957a429e66aa981", + "prediction_checksum": "6d04a2d1c39cb8db", + "transition_checksum": "2cf05ac107da7dee" + }, + "planning": { + "cases": 64, + "path_found": 64, + "exact_world_state_target_reached": 61, + "goal_expert_reached": 61, + "executed_path_length": 310, + "optimal_path_length": 311, + "path_length_regret": 0, + "graph_disconnection_failures": 0, + "transition_model_error_failures": 3, + "state_aliasing_failures": 0, + "expansions": 2292, + "checksum": "3cc709ccf4c5fc5d" + } + }, + "checkpoint_verification": { + "roundtrip": true, + "identity_match": true, + "adaptation_training_evaluation_match": true, + "drift_holdout_evaluation_match": true, + "retention_evaluation_match": true, + "planning_match": true, + "complete_behavior_match": true, + "mutations": { + "retrieval_key_component": true, + "reconstruction_component": true, + "next_observation_component": true, + "label": true, + "label_count": true, + "lineage": true, + "transition_graph_edge": true, + "payload_byte": true, + "checkpoint_truncation": true, + "appended_unexpected_byte": true, + "incorrect_schema_version": true, + "checkpoint_substitution": true + } + }, + "lineage_invariants": { + "sibling_generation_equality": true, + "parent_child_generation_increment": true, + "lineage_uniqueness": true, + "repeated_descendant_splitting": true, + "no_accidental_lineage_reuse": true, + "deterministic_topology_reproduction": true + }, + "comparisons": { + "ravel_0_4_candidate": { + "expert_count": 68, + "training_evaluations": 191966, + "drift_holdout_accuracy": 1.0, + "retention_accuracy": 1.0, + "reconstruction_rmse": 11.722196472, + "prediction_rmse": 13.802821074, + "planning_exact_state_rate": 0.953125, + "expert_evaluations": 2288, + "checkpoint_size_bytes": 39438, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "fixed_8_expert": { + "expert_count": 8, + "training_evaluations": 61440, + "drift_holdout_accuracy": 0.1484375, + "retention_accuracy": 0.15625, + "reconstruction_rmse": 30.667927368, + "prediction_rmse": 33.419556245, + "planning_exact_state_rate": 0.03125, + "expert_evaluations": 2048, + "checkpoint_size_bytes": 10578, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "flat_64_expert_complete_scan": { + "expert_count": 64, + "training_evaluations": 2326528, + "drift_holdout_accuracy": 1.0, + "retention_accuracy": 1.0, + "reconstruction_rmse": 11.498955243, + "prediction_rmse": 16.982378697, + "planning_exact_state_rate": 0.8125, + "expert_evaluations": 16384, + "checkpoint_size_bytes": 37514, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "fixed_topology_64_expert_routed": { + "expert_count": 64, + "training_evaluations": 2326528, + "drift_holdout_accuracy": 1.0, + "retention_accuracy": 1.0, + "reconstruction_rmse": 11.498955243, + "prediction_rmse": 16.982378697, + "planning_exact_state_rate": 0.8125, + "expert_evaluations": 2104, + "checkpoint_size_bytes": 37514, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "nearest_centroid_16_no_recursive_births": { + "expert_count": 16, + "training_evaluations": 188416, + "drift_holdout_accuracy": 0.28515625, + "retention_accuracy": 0.2578125, + "reconstruction_rmse": 25.316094113, + "prediction_rmse": 28.500359276, + "planning_exact_state_rate": 0.09375, + "expert_evaluations": 4096, + "checkpoint_size_bytes": 14426, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "no_adaptation_static": { + "expert_count": 64, + "training_evaluations": 137528, + "drift_holdout_accuracy": 0.95703125, + "retention_accuracy": 0.95703125, + "reconstruction_rmse": 12.208403881, + "prediction_rmse": 17.195498684, + "planning_exact_state_rate": 0.578125, + "expert_evaluations": 2384, + "checkpoint_size_bytes": 37514, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "ravel_without_replay": { + "expert_count": 68, + "training_evaluations": 175770, + "drift_holdout_accuracy": 1.0, + "retention_accuracy": 1.0, + "reconstruction_rmse": 12.117639144, + "prediction_rmse": 14.675433687, + "planning_exact_state_rate": 0.9375, + "expert_evaluations": 2648, + "checkpoint_size_bytes": 39438, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "ravel_without_retirement": { + "expert_count": 72, + "training_evaluations": 167144, + "drift_holdout_accuracy": 1.0, + "retention_accuracy": 1.0, + "reconstruction_rmse": 11.715737213, + "prediction_rmse": 15.118959391, + "planning_exact_state_rate": 0.921875, + "expert_evaluations": 2496, + "checkpoint_size_bytes": 41362, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "ravel_complete_scan_without_certification": { + "expert_count": 68, + "training_evaluations": 387742, + "drift_holdout_accuracy": 1.0, + "retention_accuracy": 1.0, + "reconstruction_rmse": 11.722196472, + "prediction_rmse": 13.802821074, + "planning_exact_state_rate": 0.953125, + "expert_evaluations": 17408, + "checkpoint_size_bytes": 39438, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "ravel_fixed_topology_without_recursive_births": { + "expert_count": 64, + "training_evaluations": 2351160, + "drift_holdout_accuracy": 1.0, + "retention_accuracy": 1.0, + "reconstruction_rmse": 11.73443203, + "prediction_rmse": 13.131661923, + "planning_exact_state_rate": 1.0, + "expert_evaluations": 2272, + "checkpoint_size_bytes": 37514, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "ravel_random_births": { + "expert_count": 68, + "training_evaluations": 193719, + "drift_holdout_accuracy": 0.9609375, + "retention_accuracy": 0.9609375, + "reconstruction_rmse": 12.370829046, + "prediction_rmse": 14.167108782, + "planning_exact_state_rate": 0.609375, + "expert_evaluations": 2708, + "checkpoint_size_bytes": 39438, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + } + }, + "hard_gates": { + "expected_topology": true, + "base_holdout_accuracy": true, + "adaptation_training_accuracy": true, + "adapted_drift_holdout_accuracy": true, + "adapted_gain_over_static": false, + "base_holdout_retention": true, + "exact_routing": true, + "base_reconstruction_rmse": true, + "adapted_reconstruction_rmse": true, + "adapted_reconstruction_improvement": true, + "retention_reconstruction": true, + "base_prediction_rmse": true, + "adapted_prediction_rmse": true, + "adapted_prediction_improvement": true, + "retention_prediction": true, + "exact_world_state_target_rate": true, + "path_found_rate": true, + "checkpoint_identity": true, + "checkpoint_behavior": true, + "checkpoint_mutations": true, + "lineage_and_topology": true + }, + "trial_result": "FAIL" + }, + { + "trial_id": "trial-04-label", + "regime": "label_drift", + "seed": "0x0404000000000004", + "dataset_seeds": { + "base_training": "0xb119124bb25f62fd", + "base_holdout": "0xba974d75811c25b5", + "drift_adaptation_training": "0x08bb1d2ce7152f90", + "drift_holdout": "0x29b60e6074e6e6fe", + "original_task_retention_holdout": "0xa8a9a927d9b882fb", + "planning_cases": "0x3aa6b2bd4735ab34" + }, + "candidate": { + "expert_count": 68, + "base_births": 56, + "adaptation_births": 8, + "adaptation_retirements": 4, + "training_evaluations": 184400, + "checkpoint_size_bytes": 39438, + "model_identity": "7ac729eed49beb4abd7e89b3a47999db4f0ae5ae911356fbcfb387cf55d0c716", + "behavior_identity": "6448b04fcc6c2382081a5f9f427d110fbd4b346640095e5a3a117152061bcf12", + "base_holdout": { + "samples": 256, + "rejected": 0, + "accuracy": 1.0, + "reconstruction_rmse": 3.249159843, + "next_observation_prediction_rmse": 5.274702577, + "transition_accuracy": 0.9921875, + "routing_certification_count": 256, + "complete_oracle_agreement": 256, + "routed_complete_mismatches": 0, + "expert_evaluations": 2048, + "classification_checksum": "ecc0702db2f2e0ee", + "reconstruction_checksum": "cc3772cbc44d2381", + "prediction_checksum": "410e74edf5b9d356", + "transition_checksum": "576182581fca82fc" + }, + "adaptation_training": { + "samples": 512, + "rejected": 0, + "accuracy": 0.974609375, + "reconstruction_rmse": 2.999208801, + "next_observation_prediction_rmse": 2.576304245, + "transition_accuracy": 0.984375, + "routing_certification_count": 512, + "complete_oracle_agreement": 512, + "routed_complete_mismatches": 0, + "expert_evaluations": 4096, + "classification_checksum": "c76de4f4760f0a46", + "reconstruction_checksum": "1cafef0b0ccf035a", + "prediction_checksum": "ae58e537418e726c", + "transition_checksum": "296706d6eb355028" + }, + "static_model_drift_holdout": { + "samples": 256, + "rejected": 0, + "accuracy": 0.6328125, + "reconstruction_rmse": 3.245941506, + "next_observation_prediction_rmse": 6.694133269, + "transition_accuracy": 0.98828125, + "routing_certification_count": 256, + "complete_oracle_agreement": 256, + "routed_complete_mismatches": 0, + "expert_evaluations": 2048, + "classification_checksum": "d5abe6419bc92a60", + "reconstruction_checksum": "d78de092c59b9d1b", + "prediction_checksum": "da6fc180aa7abd76", + "transition_checksum": "eebd44338c6b40d8" + }, + "adapted_model_drift_holdout": { + "samples": 256, + "rejected": 0, + "accuracy": 0.97265625, + "reconstruction_rmse": 3.284709157, + "next_observation_prediction_rmse": 5.929517197, + "transition_accuracy": 0.98828125, + "routing_certification_count": 256, + "complete_oracle_agreement": 256, + "routed_complete_mismatches": 0, + "expert_evaluations": 2048, + "classification_checksum": "314f63b85b64e88f", + "reconstruction_checksum": "c8e18735756cb09a", + "prediction_checksum": "53b19e6217f535dc", + "transition_checksum": "7e9474adc2958e20" + }, + "base_holdout_retention": { + "samples": 256, + "rejected": 0, + "accuracy": 0.671875, + "reconstruction_rmse": 3.32254887, + "next_observation_prediction_rmse": 6.133100096, + "transition_accuracy": 0.98046875, + "routing_certification_count": 256, + "complete_oracle_agreement": 256, + "routed_complete_mismatches": 0, + "expert_evaluations": 2048, + "classification_checksum": "ff2e7d89ac8af3be", + "reconstruction_checksum": "363d7216b8b76e93", + "prediction_checksum": "79af8c0e99f46229", + "transition_checksum": "7bf04bff940296f1" + }, + "planning": { + "cases": 64, + "path_found": 64, + "exact_world_state_target_reached": 64, + "goal_expert_reached": 64, + "executed_path_length": 296, + "optimal_path_length": 296, + "path_length_regret": 0, + "graph_disconnection_failures": 0, + "transition_model_error_failures": 0, + "state_aliasing_failures": 0, + "expansions": 2153, + "checksum": "bebe1a3ebe36d486" + } + }, + "checkpoint_verification": { + "roundtrip": true, + "identity_match": true, + "adaptation_training_evaluation_match": true, + "drift_holdout_evaluation_match": true, + "retention_evaluation_match": true, + "planning_match": true, + "complete_behavior_match": true, + "mutations": { + "retrieval_key_component": true, + "reconstruction_component": true, + "next_observation_component": true, + "label": true, + "label_count": true, + "lineage": true, + "transition_graph_edge": true, + "payload_byte": true, + "checkpoint_truncation": true, + "appended_unexpected_byte": true, + "incorrect_schema_version": true, + "checkpoint_substitution": true + } + }, + "lineage_invariants": { + "sibling_generation_equality": true, + "parent_child_generation_increment": true, + "lineage_uniqueness": true, + "repeated_descendant_splitting": true, + "no_accidental_lineage_reuse": true, + "deterministic_topology_reproduction": true + }, + "comparisons": { + "ravel_0_4_candidate": { + "expert_count": 68, + "training_evaluations": 184400, + "drift_holdout_accuracy": 0.97265625, + "retention_accuracy": 0.671875, + "reconstruction_rmse": 3.284709157, + "prediction_rmse": 5.929517197, + "planning_exact_state_rate": 1.0, + "expert_evaluations": 2048, + "checkpoint_size_bytes": 39438, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "fixed_8_expert": { + "expert_count": 8, + "training_evaluations": 61440, + "drift_holdout_accuracy": 0.1796875, + "retention_accuracy": 0.21484375, + "reconstruction_rmse": 28.177461374, + "prediction_rmse": 29.442125356, + "planning_exact_state_rate": 0.03125, + "expert_evaluations": 2048, + "checkpoint_size_bytes": 10578, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "flat_64_expert_complete_scan": { + "expert_count": 64, + "training_evaluations": 2326528, + "drift_holdout_accuracy": 0.6328125, + "retention_accuracy": 1.0, + "reconstruction_rmse": 3.245941506, + "prediction_rmse": 5.964526836, + "planning_exact_state_rate": 0.984375, + "expert_evaluations": 16384, + "checkpoint_size_bytes": 37514, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "fixed_topology_64_expert_routed": { + "expert_count": 64, + "training_evaluations": 2326528, + "drift_holdout_accuracy": 0.6328125, + "retention_accuracy": 1.0, + "reconstruction_rmse": 3.245941506, + "prediction_rmse": 5.964526836, + "planning_exact_state_rate": 0.984375, + "expert_evaluations": 2048, + "checkpoint_size_bytes": 37514, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "nearest_centroid_16_no_recursive_births": { + "expert_count": 16, + "training_evaluations": 188416, + "drift_holdout_accuracy": 0.20703125, + "retention_accuracy": 0.26953125, + "reconstruction_rmse": 23.766545085, + "prediction_rmse": 24.836108388, + "planning_exact_state_rate": 0.140625, + "expert_evaluations": 4096, + "checkpoint_size_bytes": 14426, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "no_adaptation_static": { + "expert_count": 64, + "training_evaluations": 131152, + "drift_holdout_accuracy": 0.6328125, + "retention_accuracy": 1.0, + "reconstruction_rmse": 3.245941506, + "prediction_rmse": 6.694133269, + "planning_exact_state_rate": 0.984375, + "expert_evaluations": 2048, + "checkpoint_size_bytes": 37514, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "ravel_without_replay": { + "expert_count": 68, + "training_evaluations": 168016, + "drift_holdout_accuracy": 1.0, + "retention_accuracy": 0.6328125, + "reconstruction_rmse": 3.353389407, + "prediction_rmse": 6.588012389, + "planning_exact_state_rate": 1.0, + "expert_evaluations": 2048, + "checkpoint_size_bytes": 39438, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "ravel_without_retirement": { + "expert_count": 72, + "training_evaluations": 159824, + "drift_holdout_accuracy": 0.97265625, + "retention_accuracy": 0.671875, + "reconstruction_rmse": 3.287590917, + "prediction_rmse": 6.496733865, + "planning_exact_state_rate": 1.0, + "expert_evaluations": 2048, + "checkpoint_size_bytes": 41362, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "ravel_complete_scan_without_certification": { + "expert_count": 68, + "training_evaluations": 381008, + "drift_holdout_accuracy": 0.97265625, + "retention_accuracy": 0.671875, + "reconstruction_rmse": 3.284709157, + "prediction_rmse": 5.929517197, + "planning_exact_state_rate": 1.0, + "expert_evaluations": 17408, + "checkpoint_size_bytes": 39438, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "ravel_fixed_topology_without_recursive_births": { + "expert_count": 64, + "training_evaluations": 2351104, + "drift_holdout_accuracy": 0.98046875, + "retention_accuracy": 0.6640625, + "reconstruction_rmse": 3.284108194, + "prediction_rmse": 5.306900561, + "planning_exact_state_rate": 1.0, + "expert_evaluations": 2048, + "checkpoint_size_bytes": 37514, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "ravel_random_births": { + "expert_count": 68, + "training_evaluations": 184400, + "drift_holdout_accuracy": 0.98046875, + "retention_accuracy": 0.6640625, + "reconstruction_rmse": 3.278805288, + "prediction_rmse": 7.104260996, + "planning_exact_state_rate": 1.0, + "expert_evaluations": 2048, + "checkpoint_size_bytes": 39438, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + } + }, + "hard_gates": { + "expected_topology": true, + "base_holdout_accuracy": true, + "adaptation_training_accuracy": true, + "adapted_drift_holdout_accuracy": true, + "adapted_gain_over_static": true, + "base_holdout_retention": false, + "exact_routing": true, + "base_reconstruction_rmse": true, + "adapted_reconstruction_rmse": true, + "adapted_reconstruction_improvement": false, + "retention_reconstruction": true, + "base_prediction_rmse": true, + "adapted_prediction_rmse": true, + "adapted_prediction_improvement": true, + "retention_prediction": true, + "exact_world_state_target_rate": true, + "path_found_rate": true, + "checkpoint_identity": true, + "checkpoint_behavior": true, + "checkpoint_mutations": true, + "lineage_and_topology": true + }, + "trial_result": "FAIL" + }, + { + "trial_id": "trial-05-observation", + "regime": "observation_drift", + "seed": "0x0405000000000005", + "dataset_seeds": { + "base_training": "0x056696df8d3b6c3f", + "base_holdout": "0x82991be6b3c3b49b", + "drift_adaptation_training": "0xc88ff7795c17c309", + "drift_holdout": "0x6fae784d472487dd", + "original_task_retention_holdout": "0xbbca41d1303f0277", + "planning_cases": "0x0cd111aa847bd3dd" + }, + "candidate": { + "expert_count": 68, + "base_births": 56, + "adaptation_births": 8, + "adaptation_retirements": 4, + "training_evaluations": 198795, + "checkpoint_size_bytes": 39438, + "model_identity": "162084e398b93cbcf8bf7b298b91fe58b8da90d32f18e34d5800e0353a02f33e", + "behavior_identity": "66fb2612b268f816ecfb9a1a1d96f6d5b0d063b8f0f793308a3e03b523e0aef5", + "base_holdout": { + "samples": 256, + "rejected": 0, + "accuracy": 0.98828125, + "reconstruction_rmse": 4.08848307, + "next_observation_prediction_rmse": 5.745390367, + "transition_accuracy": 0.984375, + "routing_certification_count": 256, + "complete_oracle_agreement": 256, + "routed_complete_mismatches": 0, + "expert_evaluations": 2048, + "classification_checksum": "6590037caf973659", + "reconstruction_checksum": "44f1c43e7f352d40", + "prediction_checksum": "0808ea0a11572b7e", + "transition_checksum": "05d0df53a1426590" + }, + "adaptation_training": { + "samples": 512, + "rejected": 0, + "accuracy": 1.0, + "reconstruction_rmse": 4.365044794, + "next_observation_prediction_rmse": 3.726372863, + "transition_accuracy": 0.99609375, + "routing_certification_count": 512, + "complete_oracle_agreement": 512, + "routed_complete_mismatches": 0, + "expert_evaluations": 4096, + "classification_checksum": "0b8986fe5dc2780d", + "reconstruction_checksum": "741f88b7af72fb87", + "prediction_checksum": "49c4691e3cd7837e", + "transition_checksum": "5670ff85721a5aaf" + }, + "static_model_drift_holdout": { + "samples": 256, + "rejected": 0, + "accuracy": 0.98828125, + "reconstruction_rmse": 7.214147712, + "next_observation_prediction_rmse": 8.980319577, + "transition_accuracy": 0.97265625, + "routing_certification_count": 256, + "complete_oracle_agreement": 256, + "routed_complete_mismatches": 0, + "expert_evaluations": 2048, + "classification_checksum": "5e7a3d1c8098fd4f", + "reconstruction_checksum": "86885f60232e4e7f", + "prediction_checksum": "ccd62f1626f9e38e", + "transition_checksum": "3798f0b6a265b96c" + }, + "adapted_model_drift_holdout": { + "samples": 256, + "rejected": 0, + "accuracy": 1.0, + "reconstruction_rmse": 4.96987152, + "next_observation_prediction_rmse": 5.908756185, + "transition_accuracy": 1.0, + "routing_certification_count": 256, + "complete_oracle_agreement": 256, + "routed_complete_mismatches": 0, + "expert_evaluations": 2048, + "classification_checksum": "06889ba43eaa9f13", + "reconstruction_checksum": "56c4fda307558a43", + "prediction_checksum": "b7c2bf1328deb043", + "transition_checksum": "5ed594c48a1c64b3" + }, + "base_holdout_retention": { + "samples": 256, + "rejected": 0, + "accuracy": 1.0, + "reconstruction_rmse": 4.742146477, + "next_observation_prediction_rmse": 10.344778044, + "transition_accuracy": 0.9609375, + "routing_certification_count": 256, + "complete_oracle_agreement": 256, + "routed_complete_mismatches": 0, + "expert_evaluations": 2048, + "classification_checksum": "4257baa390b0702b", + "reconstruction_checksum": "bbb7556c367e13ae", + "prediction_checksum": "c0b400533f3d7afb", + "transition_checksum": "c823aed4d1a21197" + }, + "planning": { + "cases": 64, + "path_found": 64, + "exact_world_state_target_reached": 64, + "goal_expert_reached": 64, + "executed_path_length": 277, + "optimal_path_length": 275, + "path_length_regret": 2, + "graph_disconnection_failures": 0, + "transition_model_error_failures": 0, + "state_aliasing_failures": 0, + "expansions": 1956, + "checksum": "88023746529cc64c" + } + }, + "checkpoint_verification": { + "roundtrip": true, + "identity_match": true, + "adaptation_training_evaluation_match": true, + "drift_holdout_evaluation_match": true, + "retention_evaluation_match": true, + "planning_match": true, + "complete_behavior_match": true, + "mutations": { + "retrieval_key_component": true, + "reconstruction_component": true, + "next_observation_component": true, + "label": true, + "label_count": true, + "lineage": true, + "transition_graph_edge": true, + "payload_byte": true, + "checkpoint_truncation": true, + "appended_unexpected_byte": true, + "incorrect_schema_version": true, + "checkpoint_substitution": true + } + }, + "lineage_invariants": { + "sibling_generation_equality": true, + "parent_child_generation_increment": true, + "lineage_uniqueness": true, + "repeated_descendant_splitting": true, + "no_accidental_lineage_reuse": true, + "deterministic_topology_reproduction": true + }, + "comparisons": { + "ravel_0_4_candidate": { + "expert_count": 68, + "training_evaluations": 198795, + "drift_holdout_accuracy": 1.0, + "retention_accuracy": 1.0, + "reconstruction_rmse": 4.96987152, + "prediction_rmse": 5.908756185, + "planning_exact_state_rate": 1.0, + "expert_evaluations": 2048, + "checkpoint_size_bytes": 39438, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "fixed_8_expert": { + "expert_count": 8, + "training_evaluations": 61440, + "drift_holdout_accuracy": 0.1953125, + "retention_accuracy": 0.2265625, + "reconstruction_rmse": 28.588489902, + "prediction_rmse": 30.140919158, + "planning_exact_state_rate": 0.078125, + "expert_evaluations": 2048, + "checkpoint_size_bytes": 10578, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "flat_64_expert_complete_scan": { + "expert_count": 64, + "training_evaluations": 2326528, + "drift_holdout_accuracy": 1.0, + "retention_accuracy": 1.0, + "reconstruction_rmse": 6.710329592, + "prediction_rmse": 9.665663175, + "planning_exact_state_rate": 0.984375, + "expert_evaluations": 16384, + "checkpoint_size_bytes": 37514, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "fixed_topology_64_expert_routed": { + "expert_count": 64, + "training_evaluations": 2326528, + "drift_holdout_accuracy": 1.0, + "retention_accuracy": 1.0, + "reconstruction_rmse": 6.710329592, + "prediction_rmse": 9.665663175, + "planning_exact_state_rate": 0.984375, + "expert_evaluations": 2048, + "checkpoint_size_bytes": 37514, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "nearest_centroid_16_no_recursive_births": { + "expert_count": 16, + "training_evaluations": 188416, + "drift_holdout_accuracy": 0.23046875, + "retention_accuracy": 0.2890625, + "reconstruction_rmse": 23.5668836, + "prediction_rmse": 25.375825862, + "planning_exact_state_rate": 0.171875, + "expert_evaluations": 4096, + "checkpoint_size_bytes": 14426, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "no_adaptation_static": { + "expert_count": 64, + "training_evaluations": 133736, + "drift_holdout_accuracy": 0.98828125, + "retention_accuracy": 0.9765625, + "reconstruction_rmse": 7.214147712, + "prediction_rmse": 8.980319577, + "planning_exact_state_rate": 0.859375, + "expert_evaluations": 2048, + "checkpoint_size_bytes": 37514, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "ravel_without_replay": { + "expert_count": 68, + "training_evaluations": 180125, + "drift_holdout_accuracy": 1.0, + "retention_accuracy": 1.0, + "reconstruction_rmse": 4.641846269, + "prediction_rmse": 5.858492042, + "planning_exact_state_rate": 1.0, + "expert_evaluations": 2048, + "checkpoint_size_bytes": 39438, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "ravel_without_retirement": { + "expert_count": 72, + "training_evaluations": 170344, + "drift_holdout_accuracy": 1.0, + "retention_accuracy": 1.0, + "reconstruction_rmse": 4.964079357, + "prediction_rmse": 6.628937969, + "planning_exact_state_rate": 0.96875, + "expert_evaluations": 3328, + "checkpoint_size_bytes": 41362, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "ravel_complete_scan_without_certification": { + "expert_count": 68, + "training_evaluations": 387467, + "drift_holdout_accuracy": 1.0, + "retention_accuracy": 1.0, + "reconstruction_rmse": 4.96987152, + "prediction_rmse": 5.908756185, + "planning_exact_state_rate": 1.0, + "expert_evaluations": 17408, + "checkpoint_size_bytes": 39438, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "ravel_fixed_topology_without_recursive_births": { + "expert_count": 64, + "training_evaluations": 2351104, + "drift_holdout_accuracy": 1.0, + "retention_accuracy": 1.0, + "reconstruction_rmse": 4.968732508, + "prediction_rmse": 5.908756185, + "planning_exact_state_rate": 1.0, + "expert_evaluations": 2048, + "checkpoint_size_bytes": 37514, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "ravel_random_births": { + "expert_count": 68, + "training_evaluations": 186984, + "drift_holdout_accuracy": 1.0, + "retention_accuracy": 1.0, + "reconstruction_rmse": 4.872652007, + "prediction_rmse": 5.853272074, + "planning_exact_state_rate": 1.0, + "expert_evaluations": 2048, + "checkpoint_size_bytes": 39438, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + } + }, + "hard_gates": { + "expected_topology": true, + "base_holdout_accuracy": true, + "adaptation_training_accuracy": true, + "adapted_drift_holdout_accuracy": true, + "adapted_gain_over_static": false, + "base_holdout_retention": true, + "exact_routing": true, + "base_reconstruction_rmse": true, + "adapted_reconstruction_rmse": true, + "adapted_reconstruction_improvement": true, + "retention_reconstruction": true, + "base_prediction_rmse": true, + "adapted_prediction_rmse": true, + "adapted_prediction_improvement": true, + "retention_prediction": true, + "exact_world_state_target_rate": true, + "path_found_rate": true, + "checkpoint_identity": true, + "checkpoint_behavior": true, + "checkpoint_mutations": true, + "lineage_and_topology": true + }, + "trial_result": "FAIL" + }, + { + "trial_id": "trial-06-transition", + "regime": "transition_drift", + "seed": "0x0406000000000006", + "dataset_seeds": { + "base_training": "0x926766a8f89b01fe", + "base_holdout": "0x4c841aa67ba9ccda", + "drift_adaptation_training": "0x29236cc144e74100", + "drift_holdout": "0x9468c22e35791397", + "original_task_retention_holdout": "0xdf904ec059d94431", + "planning_cases": "0x85212879e0609776" + }, + "candidate": { + "expert_count": 68, + "base_births": 56, + "adaptation_births": 8, + "adaptation_retirements": 4, + "training_evaluations": 204431, + "checkpoint_size_bytes": 39438, + "model_identity": "c9f3398d39810cbe2b0f70fffa52582204a29f0dd7c154d6fc38dd324c7f4572", + "behavior_identity": "218dcc8ecd66212dcb5a42746d5277935a8182edeab19b2d20c621f631ddd313", + "base_holdout": { + "samples": 256, + "rejected": 0, + "accuracy": 0.9921875, + "reconstruction_rmse": 4.014867992, + "next_observation_prediction_rmse": 10.752743838, + "transition_accuracy": 0.94140625, + "routing_certification_count": 256, + "complete_oracle_agreement": 256, + "routed_complete_mismatches": 0, + "expert_evaluations": 2048, + "classification_checksum": "6e0106d9b5b350fa", + "reconstruction_checksum": "52629014d1060d6a", + "prediction_checksum": "917239c9f83390d4", + "transition_checksum": "4232633d53e59eec" + }, + "adaptation_training": { + "samples": 512, + "rejected": 0, + "accuracy": 1.0, + "reconstruction_rmse": 3.00556352, + "next_observation_prediction_rmse": 6.928904267, + "transition_accuracy": 0.962890625, + "routing_certification_count": 512, + "complete_oracle_agreement": 512, + "routed_complete_mismatches": 0, + "expert_evaluations": 4096, + "classification_checksum": "82b5e25d7ff724c7", + "reconstruction_checksum": "cc7762b3a56a7ab3", + "prediction_checksum": "22e9566a98d22fd6", + "transition_checksum": "feed63e7e75120b1" + }, + "static_model_drift_holdout": { + "samples": 256, + "rejected": 0, + "accuracy": 0.9921875, + "reconstruction_rmse": 3.887227949, + "next_observation_prediction_rmse": 23.74263423, + "transition_accuracy": 0.76171875, + "routing_certification_count": 256, + "complete_oracle_agreement": 256, + "routed_complete_mismatches": 0, + "expert_evaluations": 2048, + "classification_checksum": "27c8df540711e103", + "reconstruction_checksum": "03e7f1b90d5a0a2b", + "prediction_checksum": "6e1608d9bfceb46b", + "transition_checksum": "8a170a01d05f6d7d" + }, + "adapted_model_drift_holdout": { + "samples": 256, + "rejected": 0, + "accuracy": 1.0, + "reconstruction_rmse": 3.325471662, + "next_observation_prediction_rmse": 12.004139378, + "transition_accuracy": 0.90234375, + "routing_certification_count": 256, + "complete_oracle_agreement": 256, + "routed_complete_mismatches": 0, + "expert_evaluations": 2048, + "classification_checksum": "0a27b19971dc5cba", + "reconstruction_checksum": "d9e92709409fdc40", + "prediction_checksum": "2d33bc8b33b5cfea", + "transition_checksum": "1dfc28f7f966c6ea" + }, + "base_holdout_retention": { + "samples": 256, + "rejected": 0, + "accuracy": 1.0, + "reconstruction_rmse": 3.353064513, + "next_observation_prediction_rmse": 18.338539315, + "transition_accuracy": 0.82421875, + "routing_certification_count": 256, + "complete_oracle_agreement": 256, + "routed_complete_mismatches": 0, + "expert_evaluations": 2048, + "classification_checksum": "d031bf9b75dfd3d4", + "reconstruction_checksum": "4e30ac3dee1b39f7", + "prediction_checksum": "6868a7c76c4a9c8b", + "transition_checksum": "606edfed2c65db50" + }, + "planning": { + "cases": 64, + "path_found": 64, + "exact_world_state_target_reached": 53, + "goal_expert_reached": 53, + "executed_path_length": 238, + "optimal_path_length": 234, + "path_length_regret": 8, + "graph_disconnection_failures": 0, + "transition_model_error_failures": 11, + "state_aliasing_failures": 0, + "expansions": 2180, + "checksum": "f4634137350b92ba" + } + }, + "checkpoint_verification": { + "roundtrip": true, + "identity_match": true, + "adaptation_training_evaluation_match": true, + "drift_holdout_evaluation_match": true, + "retention_evaluation_match": true, + "planning_match": true, + "complete_behavior_match": true, + "mutations": { + "retrieval_key_component": true, + "reconstruction_component": true, + "next_observation_component": true, + "label": true, + "label_count": true, + "lineage": true, + "transition_graph_edge": true, + "payload_byte": true, + "checkpoint_truncation": true, + "appended_unexpected_byte": true, + "incorrect_schema_version": true, + "checkpoint_substitution": true + } + }, + "lineage_invariants": { + "sibling_generation_equality": true, + "parent_child_generation_increment": true, + "lineage_uniqueness": true, + "repeated_descendant_splitting": true, + "no_accidental_lineage_reuse": true, + "deterministic_topology_reproduction": true + }, + "comparisons": { + "ravel_0_4_candidate": { + "expert_count": 68, + "training_evaluations": 204431, + "drift_holdout_accuracy": 1.0, + "retention_accuracy": 1.0, + "reconstruction_rmse": 3.325471662, + "prediction_rmse": 12.004139378, + "planning_exact_state_rate": 0.828125, + "expert_evaluations": 2048, + "checkpoint_size_bytes": 39438, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "fixed_8_expert": { + "expert_count": 8, + "training_evaluations": 61440, + "drift_holdout_accuracy": 0.234375, + "retention_accuracy": 0.2421875, + "reconstruction_rmse": 28.776491142, + "prediction_rmse": 33.661330668, + "planning_exact_state_rate": 0.015625, + "expert_evaluations": 2048, + "checkpoint_size_bytes": 10578, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "flat_64_expert_complete_scan": { + "expert_count": 64, + "training_evaluations": 2326528, + "drift_holdout_accuracy": 1.0, + "retention_accuracy": 1.0, + "reconstruction_rmse": 3.289496039, + "prediction_rmse": 23.603471108, + "planning_exact_state_rate": 0.578125, + "expert_evaluations": 16384, + "checkpoint_size_bytes": 37514, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "fixed_topology_64_expert_routed": { + "expert_count": 64, + "training_evaluations": 2326528, + "drift_holdout_accuracy": 1.0, + "retention_accuracy": 1.0, + "reconstruction_rmse": 3.289496039, + "prediction_rmse": 23.603471108, + "planning_exact_state_rate": 0.578125, + "expert_evaluations": 2048, + "checkpoint_size_bytes": 37514, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "nearest_centroid_16_no_recursive_births": { + "expert_count": 16, + "training_evaluations": 188416, + "drift_holdout_accuracy": 0.25390625, + "retention_accuracy": 0.23828125, + "reconstruction_rmse": 21.823954139, + "prediction_rmse": 29.618836762, + "planning_exact_state_rate": 0.078125, + "expert_evaluations": 4096, + "checkpoint_size_bytes": 14426, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "no_adaptation_static": { + "expert_count": 64, + "training_evaluations": 128704, + "drift_holdout_accuracy": 0.9921875, + "retention_accuracy": 1.0, + "reconstruction_rmse": 3.887227949, + "prediction_rmse": 23.74263423, + "planning_exact_state_rate": 0.4375, + "expert_evaluations": 2048, + "checkpoint_size_bytes": 37514, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "ravel_without_replay": { + "expert_count": 68, + "training_evaluations": 180427, + "drift_holdout_accuracy": 1.0, + "retention_accuracy": 1.0, + "reconstruction_rmse": 3.43195935, + "prediction_rmse": 9.730895929, + "planning_exact_state_rate": 0.859375, + "expert_evaluations": 2048, + "checkpoint_size_bytes": 39438, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "ravel_without_retirement": { + "expert_count": 72, + "training_evaluations": 172480, + "drift_holdout_accuracy": 1.0, + "retention_accuracy": 1.0, + "reconstruction_rmse": 3.325329926, + "prediction_rmse": 12.949892046, + "planning_exact_state_rate": 0.8125, + "expert_evaluations": 2496, + "checkpoint_size_bytes": 41362, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "ravel_complete_scan_without_certification": { + "expert_count": 68, + "training_evaluations": 385935, + "drift_holdout_accuracy": 1.0, + "retention_accuracy": 1.0, + "reconstruction_rmse": 3.325471662, + "prediction_rmse": 12.004139378, + "planning_exact_state_rate": 0.828125, + "expert_evaluations": 17408, + "checkpoint_size_bytes": 39438, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "ravel_fixed_topology_without_recursive_births": { + "expert_count": 64, + "training_evaluations": 2351104, + "drift_holdout_accuracy": 1.0, + "retention_accuracy": 1.0, + "reconstruction_rmse": 3.325683177, + "prediction_rmse": 12.001830992, + "planning_exact_state_rate": 0.828125, + "expert_evaluations": 2048, + "checkpoint_size_bytes": 37514, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "ravel_random_births": { + "expert_count": 68, + "training_evaluations": 181952, + "drift_holdout_accuracy": 1.0, + "retention_accuracy": 1.0, + "reconstruction_rmse": 3.323853271, + "prediction_rmse": 11.958909439, + "planning_exact_state_rate": 0.8125, + "expert_evaluations": 2048, + "checkpoint_size_bytes": 39438, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + } + }, + "hard_gates": { + "expected_topology": true, + "base_holdout_accuracy": true, + "adaptation_training_accuracy": true, + "adapted_drift_holdout_accuracy": true, + "adapted_gain_over_static": false, + "base_holdout_retention": true, + "exact_routing": true, + "base_reconstruction_rmse": true, + "adapted_reconstruction_rmse": true, + "adapted_reconstruction_improvement": true, + "retention_reconstruction": true, + "base_prediction_rmse": true, + "adapted_prediction_rmse": true, + "adapted_prediction_improvement": true, + "retention_prediction": false, + "exact_world_state_target_rate": true, + "path_found_rate": true, + "checkpoint_identity": true, + "checkpoint_behavior": true, + "checkpoint_mutations": true, + "lineage_and_topology": true + }, + "trial_result": "FAIL" + }, + { + "trial_id": "trial-07-combined", + "regime": "combined_observation_and_label_drift", + "seed": "0x0407000000000007", + "dataset_seeds": { + "base_training": "0xd37509ad6f4444a6", + "base_holdout": "0xc24118d60c43c1ea", + "drift_adaptation_training": "0x6ea6490add7501fc", + "drift_holdout": "0xa988d131a089eeee", + "original_task_retention_holdout": "0xc9bbd7c5753ce32e", + "planning_cases": "0xb148fd98c53e55d4" + }, + "candidate": { + "expert_count": 68, + "base_births": 56, + "adaptation_births": 8, + "adaptation_retirements": 4, + "training_evaluations": 197558, + "checkpoint_size_bytes": 39438, + "model_identity": "2ead11143532e496b9d9b5cbd2c4c5363effd8f0ae94b98c44d0e8fb9e0cbb0f", + "behavior_identity": "982a5bea0c5cc4cd65225ad89f69e948ae3aaf7f3b96775f272bfbb860c818e8", + "base_holdout": { + "samples": 256, + "rejected": 0, + "accuracy": 0.98828125, + "reconstruction_rmse": 4.876683712, + "next_observation_prediction_rmse": 7.086698289, + "transition_accuracy": 0.97265625, + "routing_certification_count": 255, + "complete_oracle_agreement": 256, + "routed_complete_mismatches": 0, + "expert_evaluations": 2104, + "classification_checksum": "6cd7b6d1bd581f71", + "reconstruction_checksum": "3c79a743b378256a", + "prediction_checksum": "c9a65350c2f6a864", + "transition_checksum": "132d9ff47e9a3c34" + }, + "adaptation_training": { + "samples": 512, + "rejected": 0, + "accuracy": 0.966796875, + "reconstruction_rmse": 6.512482533, + "next_observation_prediction_rmse": 5.470895116, + "transition_accuracy": 0.984375, + "routing_certification_count": 512, + "complete_oracle_agreement": 512, + "routed_complete_mismatches": 0, + "expert_evaluations": 4096, + "classification_checksum": "b44d4766a148c5a2", + "reconstruction_checksum": "ab2a825fe7ce2c66", + "prediction_checksum": "807dda64ed1d3e6e", + "transition_checksum": "170dff003fb8aef9" + }, + "static_model_drift_holdout": { + "samples": 256, + "rejected": 0, + "accuracy": 0.6328125, + "reconstruction_rmse": 8.351477839, + "next_observation_prediction_rmse": 9.707866943, + "transition_accuracy": 0.96875, + "routing_certification_count": 249, + "complete_oracle_agreement": 256, + "routed_complete_mismatches": 0, + "expert_evaluations": 2440, + "classification_checksum": "8dd63826d89403eb", + "reconstruction_checksum": "8a4e616f0d0b57a1", + "prediction_checksum": "128ddd95639d580b", + "transition_checksum": "aadb36192c3461c4" + }, + "adapted_model_drift_holdout": { + "samples": 256, + "rejected": 0, + "accuracy": 0.9765625, + "reconstruction_rmse": 6.954333254, + "next_observation_prediction_rmse": 9.192754186, + "transition_accuracy": 0.97265625, + "routing_certification_count": 256, + "complete_oracle_agreement": 256, + "routed_complete_mismatches": 0, + "expert_evaluations": 2048, + "classification_checksum": "9826d9dd8b84f4ac", + "reconstruction_checksum": "2d462a2e5e5645d6", + "prediction_checksum": "997151b693eebed4", + "transition_checksum": "733cc1aaeea73a46" + }, + "base_holdout_retention": { + "samples": 256, + "rejected": 0, + "accuracy": 0.6875, + "reconstruction_rmse": 5.46058183, + "next_observation_prediction_rmse": 8.177056842, + "transition_accuracy": 0.953125, + "routing_certification_count": 256, + "complete_oracle_agreement": 256, + "routed_complete_mismatches": 0, + "expert_evaluations": 2048, + "classification_checksum": "9138ca83c6220659", + "reconstruction_checksum": "c17294b4edebb6c5", + "prediction_checksum": "485970e080858b11", + "transition_checksum": "e439dceab4f9949b" + }, + "planning": { + "cases": 64, + "path_found": 64, + "exact_world_state_target_reached": 60, + "goal_expert_reached": 60, + "executed_path_length": 291, + "optimal_path_length": 290, + "path_length_regret": 1, + "graph_disconnection_failures": 0, + "transition_model_error_failures": 4, + "state_aliasing_failures": 0, + "expansions": 2157, + "checksum": "3b7b0b37ec24a514" + } + }, + "checkpoint_verification": { + "roundtrip": true, + "identity_match": true, + "adaptation_training_evaluation_match": true, + "drift_holdout_evaluation_match": true, + "retention_evaluation_match": true, + "planning_match": true, + "complete_behavior_match": true, + "mutations": { + "retrieval_key_component": true, + "reconstruction_component": true, + "next_observation_component": true, + "label": true, + "label_count": true, + "lineage": true, + "transition_graph_edge": true, + "payload_byte": true, + "checkpoint_truncation": true, + "appended_unexpected_byte": true, + "incorrect_schema_version": true, + "checkpoint_substitution": true + } + }, + "lineage_invariants": { + "sibling_generation_equality": true, + "parent_child_generation_increment": true, + "lineage_uniqueness": true, + "repeated_descendant_splitting": true, + "no_accidental_lineage_reuse": true, + "deterministic_topology_reproduction": true + }, + "comparisons": { + "ravel_0_4_candidate": { + "expert_count": 68, + "training_evaluations": 197558, + "drift_holdout_accuracy": 0.9765625, + "retention_accuracy": 0.6875, + "reconstruction_rmse": 6.954333254, + "prediction_rmse": 9.192754186, + "planning_exact_state_rate": 0.9375, + "expert_evaluations": 2048, + "checkpoint_size_bytes": 39438, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "fixed_8_expert": { + "expert_count": 8, + "training_evaluations": 61440, + "drift_holdout_accuracy": 0.15625, + "retention_accuracy": 0.16015625, + "reconstruction_rmse": 24.517232256, + "prediction_rmse": 26.045696477, + "planning_exact_state_rate": 0.046875, + "expert_evaluations": 2048, + "checkpoint_size_bytes": 10578, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "flat_64_expert_complete_scan": { + "expert_count": 64, + "training_evaluations": 2326528, + "drift_holdout_accuracy": 0.6484375, + "retention_accuracy": 1.0, + "reconstruction_rmse": 8.060471065, + "prediction_rmse": 9.979726896, + "planning_exact_state_rate": 0.984375, + "expert_evaluations": 16384, + "checkpoint_size_bytes": 37514, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "fixed_topology_64_expert_routed": { + "expert_count": 64, + "training_evaluations": 2326528, + "drift_holdout_accuracy": 0.6484375, + "retention_accuracy": 1.0, + "reconstruction_rmse": 8.060471065, + "prediction_rmse": 9.979726896, + "planning_exact_state_rate": 0.984375, + "expert_evaluations": 2272, + "checkpoint_size_bytes": 37514, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "nearest_centroid_16_no_recursive_births": { + "expert_count": 16, + "training_evaluations": 188416, + "drift_holdout_accuracy": 0.203125, + "retention_accuracy": 0.203125, + "reconstruction_rmse": 20.580456353, + "prediction_rmse": 21.985895044, + "planning_exact_state_rate": 0.15625, + "expert_evaluations": 4096, + "checkpoint_size_bytes": 14426, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "no_adaptation_static": { + "expert_count": 64, + "training_evaluations": 141600, + "drift_holdout_accuracy": 0.6328125, + "retention_accuracy": 0.97265625, + "reconstruction_rmse": 8.351477839, + "prediction_rmse": 9.707866943, + "planning_exact_state_rate": 0.859375, + "expert_evaluations": 2440, + "checkpoint_size_bytes": 37514, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "ravel_without_replay": { + "expert_count": 68, + "training_evaluations": 181112, + "drift_holdout_accuracy": 1.0, + "retention_accuracy": 0.640625, + "reconstruction_rmse": 6.954449813, + "prediction_rmse": 9.180787899, + "planning_exact_state_rate": 1.0, + "expert_evaluations": 2048, + "checkpoint_size_bytes": 39438, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "ravel_without_retirement": { + "expert_count": 72, + "training_evaluations": 172920, + "drift_holdout_accuracy": 0.96875, + "retention_accuracy": 0.7421875, + "reconstruction_rmse": 6.949565093, + "prediction_rmse": 9.438350171, + "planning_exact_state_rate": 0.875, + "expert_evaluations": 2048, + "checkpoint_size_bytes": 41362, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "ravel_complete_scan_without_certification": { + "expert_count": 68, + "training_evaluations": 393142, + "drift_holdout_accuracy": 0.9765625, + "retention_accuracy": 0.6875, + "reconstruction_rmse": 6.954333254, + "prediction_rmse": 9.192754186, + "planning_exact_state_rate": 0.9375, + "expert_evaluations": 17408, + "checkpoint_size_bytes": 39438, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "ravel_fixed_topology_without_recursive_births": { + "expert_count": 64, + "training_evaluations": 2352336, + "drift_holdout_accuracy": 0.9765625, + "retention_accuracy": 0.6484375, + "reconstruction_rmse": 6.988528463, + "prediction_rmse": 8.334581379, + "planning_exact_state_rate": 1.0, + "expert_evaluations": 2048, + "checkpoint_size_bytes": 37514, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "ravel_random_births": { + "expert_count": 68, + "training_evaluations": 201047, + "drift_holdout_accuracy": 0.96484375, + "retention_accuracy": 0.6640625, + "reconstruction_rmse": 7.397027436, + "prediction_rmse": 8.943476831, + "planning_exact_state_rate": 0.984375, + "expert_evaluations": 2288, + "checkpoint_size_bytes": 39438, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + } + }, + "hard_gates": { + "expected_topology": true, + "base_holdout_accuracy": true, + "adaptation_training_accuracy": true, + "adapted_drift_holdout_accuracy": true, + "adapted_gain_over_static": true, + "base_holdout_retention": false, + "exact_routing": true, + "base_reconstruction_rmse": true, + "adapted_reconstruction_rmse": true, + "adapted_reconstruction_improvement": true, + "retention_reconstruction": true, + "base_prediction_rmse": true, + "adapted_prediction_rmse": true, + "adapted_prediction_improvement": true, + "retention_prediction": true, + "exact_world_state_target_rate": true, + "path_found_rate": true, + "checkpoint_identity": true, + "checkpoint_behavior": true, + "checkpoint_mutations": true, + "lineage_and_topology": true + }, + "trial_result": "FAIL" + }, + { + "trial_id": "trial-08-ambiguous", + "regime": "partially_observed_ambiguous", + "seed": "0x0408000000000008", + "dataset_seeds": { + "base_training": "0x28b00c8b3d322e56", + "base_holdout": "0xbc959ae447f27a9c", + "drift_adaptation_training": "0x924390d35b2a592a", + "drift_holdout": "0x5adc52056dbb377e", + "original_task_retention_holdout": "0x60e25d056ff28a31", + "planning_cases": "0xc54d048fd95f12d3" + }, + "candidate": { + "expert_count": 68, + "base_births": 56, + "adaptation_births": 8, + "adaptation_retirements": 4, + "training_evaluations": 205054, + "checkpoint_size_bytes": 39438, + "model_identity": "0fe9747959f4a56f4561610ae56325b3d017d91f4ff00638285d940ea592edf0", + "behavior_identity": "e1db12c2c8a9a2670f07e9c4855bf58d052389015398a1498e72b46faf4dee31", + "base_holdout": { + "samples": 256, + "rejected": 0, + "accuracy": 1.0, + "reconstruction_rmse": 5.384427146, + "next_observation_prediction_rmse": 15.803773847, + "transition_accuracy": 0.46875, + "routing_certification_count": 239, + "complete_oracle_agreement": 256, + "routed_complete_mismatches": 0, + "expert_evaluations": 3000, + "classification_checksum": "214882c78cb6f95f", + "reconstruction_checksum": "21c157eb8fc65f4b", + "prediction_checksum": "b74f4b2b443328bd", + "transition_checksum": "013fe1caa43a2a22" + }, + "adaptation_training": { + "samples": 512, + "rejected": 0, + "accuracy": 0.962890625, + "reconstruction_rmse": 6.15628762, + "next_observation_prediction_rmse": 11.249369109, + "transition_accuracy": 0.703125, + "routing_certification_count": 483, + "complete_oracle_agreement": 512, + "routed_complete_mismatches": 0, + "expert_evaluations": 5836, + "classification_checksum": "598bf0425151ac04", + "reconstruction_checksum": "24dee8f9e51a0e7f", + "prediction_checksum": "bf5ab8b8072e170a", + "transition_checksum": "96f611bc4a11e759" + }, + "static_model_drift_holdout": { + "samples": 256, + "rejected": 0, + "accuracy": 0.61328125, + "reconstruction_rmse": 8.173583379, + "next_observation_prediction_rmse": 21.228929994, + "transition_accuracy": 0.4375, + "routing_certification_count": 220, + "complete_oracle_agreement": 256, + "routed_complete_mismatches": 0, + "expert_evaluations": 4064, + "classification_checksum": "97aa80fedfc1b1fc", + "reconstruction_checksum": "3dffca1293f32450", + "prediction_checksum": "a9a774c6d104954d", + "transition_checksum": "66a66252979f2300" + }, + "adapted_model_drift_holdout": { + "samples": 256, + "rejected": 0, + "accuracy": 0.93359375, + "reconstruction_rmse": 6.776301734, + "next_observation_prediction_rmse": 15.132556407, + "transition_accuracy": 0.5625, + "routing_certification_count": 243, + "complete_oracle_agreement": 256, + "routed_complete_mismatches": 0, + "expert_evaluations": 2828, + "classification_checksum": "95c6f5cbdc6a52a9", + "reconstruction_checksum": "8e0014fb3f210cca", + "prediction_checksum": "03e2c825a95c8c93", + "transition_checksum": "86e8adcd14afe9d4" + }, + "base_holdout_retention": { + "samples": 256, + "rejected": 0, + "accuracy": 0.875, + "reconstruction_rmse": 5.952975229, + "next_observation_prediction_rmse": 17.637557343, + "transition_accuracy": 0.46875, + "routing_certification_count": 242, + "complete_oracle_agreement": 256, + "routed_complete_mismatches": 0, + "expert_evaluations": 2888, + "classification_checksum": "c3efaa00c7fc24e9", + "reconstruction_checksum": "d924edcafab4d00c", + "prediction_checksum": "11c05b3355ddcda8", + "transition_checksum": "8b4cf577b6a0e491" + }, + "planning": { + "cases": 64, + "path_found": 64, + "exact_world_state_target_reached": 19, + "goal_expert_reached": 41, + "executed_path_length": 209, + "optimal_path_length": 208, + "path_length_regret": 5, + "graph_disconnection_failures": 0, + "transition_model_error_failures": 23, + "state_aliasing_failures": 22, + "expansions": 1655, + "checksum": "e1a7ef0e8efb7ac9" + } + }, + "checkpoint_verification": { + "roundtrip": true, + "identity_match": true, + "adaptation_training_evaluation_match": true, + "drift_holdout_evaluation_match": true, + "retention_evaluation_match": true, + "planning_match": true, + "complete_behavior_match": true, + "mutations": { + "retrieval_key_component": true, + "reconstruction_component": true, + "next_observation_component": true, + "label": true, + "label_count": true, + "lineage": true, + "transition_graph_edge": true, + "payload_byte": true, + "checkpoint_truncation": true, + "appended_unexpected_byte": true, + "incorrect_schema_version": true, + "checkpoint_substitution": true + } + }, + "lineage_invariants": { + "sibling_generation_equality": true, + "parent_child_generation_increment": true, + "lineage_uniqueness": true, + "repeated_descendant_splitting": true, + "no_accidental_lineage_reuse": true, + "deterministic_topology_reproduction": true + }, + "comparisons": { + "ravel_0_4_candidate": { + "expert_count": 68, + "training_evaluations": 205054, + "drift_holdout_accuracy": 0.93359375, + "retention_accuracy": 0.875, + "reconstruction_rmse": 6.776301734, + "prediction_rmse": 15.132556407, + "planning_exact_state_rate": 0.296875, + "expert_evaluations": 2828, + "checkpoint_size_bytes": 39438, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "fixed_8_expert": { + "expert_count": 8, + "training_evaluations": 61440, + "drift_holdout_accuracy": 0.203125, + "retention_accuracy": 0.21875, + "reconstruction_rmse": 18.973571631, + "prediction_rmse": 23.875998807, + "planning_exact_state_rate": 0.0, + "expert_evaluations": 2048, + "checkpoint_size_bytes": 10578, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "flat_64_expert_complete_scan": { + "expert_count": 64, + "training_evaluations": 2326528, + "drift_holdout_accuracy": 0.61328125, + "retention_accuracy": 1.0, + "reconstruction_rmse": 8.074792865, + "prediction_rmse": 20.861741043, + "planning_exact_state_rate": 0.078125, + "expert_evaluations": 16384, + "checkpoint_size_bytes": 37514, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "fixed_topology_64_expert_routed": { + "expert_count": 64, + "training_evaluations": 2326528, + "drift_holdout_accuracy": 0.61328125, + "retention_accuracy": 1.0, + "reconstruction_rmse": 8.074792865, + "prediction_rmse": 20.861741043, + "planning_exact_state_rate": 0.078125, + "expert_evaluations": 3672, + "checkpoint_size_bytes": 37514, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "nearest_centroid_16_no_recursive_births": { + "expert_count": 16, + "training_evaluations": 188416, + "drift_holdout_accuracy": 0.37890625, + "retention_accuracy": 0.54296875, + "reconstruction_rmse": 13.662055881, + "prediction_rmse": 22.389715333, + "planning_exact_state_rate": 0.03125, + "expert_evaluations": 4096, + "checkpoint_size_bytes": 14426, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "no_adaptation_static": { + "expert_count": 64, + "training_evaluations": 126824, + "drift_holdout_accuracy": 0.61328125, + "retention_accuracy": 1.0, + "reconstruction_rmse": 8.173583379, + "prediction_rmse": 21.228929994, + "planning_exact_state_rate": 0.140625, + "expert_evaluations": 4064, + "checkpoint_size_bytes": 37514, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "ravel_without_replay": { + "expert_count": 68, + "training_evaluations": 180238, + "drift_holdout_accuracy": 0.9921875, + "retention_accuracy": 0.68359375, + "reconstruction_rmse": 6.74198883, + "prediction_rmse": 14.419368162, + "planning_exact_state_rate": 0.3125, + "expert_evaluations": 2768, + "checkpoint_size_bytes": 39438, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "ravel_without_retirement": { + "expert_count": 72, + "training_evaluations": 171256, + "drift_holdout_accuracy": 0.94140625, + "retention_accuracy": 0.87109375, + "reconstruction_rmse": 6.763869572, + "prediction_rmse": 15.078832884, + "planning_exact_state_rate": 0.265625, + "expert_evaluations": 2880, + "checkpoint_size_bytes": 41362, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "ravel_complete_scan_without_certification": { + "expert_count": 68, + "training_evaluations": 390270, + "drift_holdout_accuracy": 0.93359375, + "retention_accuracy": 0.875, + "reconstruction_rmse": 6.776301734, + "prediction_rmse": 15.132556407, + "planning_exact_state_rate": 0.296875, + "expert_evaluations": 17408, + "checkpoint_size_bytes": 39438, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "ravel_fixed_topology_without_recursive_births": { + "expert_count": 64, + "training_evaluations": 2354240, + "drift_holdout_accuracy": 0.98046875, + "retention_accuracy": 0.82421875, + "reconstruction_rmse": 6.68729757, + "prediction_rmse": 16.15325089, + "planning_exact_state_rate": 0.25, + "expert_evaluations": 2048, + "checkpoint_size_bytes": 37514, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + }, + "ravel_random_births": { + "expert_count": 68, + "training_evaluations": 216387, + "drift_holdout_accuracy": 0.9375, + "retention_accuracy": 0.8046875, + "reconstruction_rmse": 6.807537642, + "prediction_rmse": 15.611341361, + "planning_exact_state_rate": 0.328125, + "expert_evaluations": 3008, + "checkpoint_size_bytes": 39438, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "excluded_from_canonical_deterministic_evidence" + } + } + }, + "hard_gates": { + "expected_topology": true, + "base_holdout_accuracy": true, + "adaptation_training_accuracy": true, + "adapted_drift_holdout_accuracy": true, + "adapted_gain_over_static": true, + "base_holdout_retention": true, + "exact_routing": true, + "base_reconstruction_rmse": true, + "adapted_reconstruction_rmse": true, + "adapted_reconstruction_improvement": true, + "retention_reconstruction": true, + "base_prediction_rmse": true, + "adapted_prediction_rmse": true, + "adapted_prediction_improvement": true, + "retention_prediction": true, + "exact_world_state_target_rate": false, + "path_found_rate": true, + "checkpoint_identity": true, + "checkpoint_behavior": true, + "checkpoint_mutations": true, + "lineage_and_topology": true + }, + "trial_result": "FAIL" + } + ], + "candidate_aggregates": { + "base_holdout_accuracy": { + "minimum": 0.9375, + "median": 0.98828125, + "maximum": 1.0, + "arithmetic_mean": 0.98095703125, + "population_standard_deviation": 0.020710263730906734 + }, + "adaptation_training_accuracy": { + "minimum": 0.962890625, + "median": 1.0, + "maximum": 1.0, + "arithmetic_mean": 0.988037109375, + "population_standard_deviation": 0.015729554363129505 + }, + "static_model_drift_holdout_accuracy": { + "minimum": 0.61328125, + "median": 0.955078125, + "maximum": 0.9921875, + "arithmetic_mean": 0.84228515625, + "population_standard_deviation": 0.16786581034443188 + }, + "adapted_model_drift_holdout_accuracy": { + "minimum": 0.93359375, + "median": 1.0, + "maximum": 1.0, + "arithmetic_mean": 0.9853515625, + "population_standard_deviation": 0.022333196535213422 + }, + "base_holdout_retention": { + "minimum": 0.671875, + "median": 1.0, + "maximum": 1.0, + "arithmetic_mean": 0.904296875, + "population_standard_deviation": 0.1358650803862397 + }, + "base_reconstruction_rmse": { + "minimum": 3.249159843, + "median": 4.779562945, + "maximum": 9.256042033, + "arithmetic_mean": 5.290470095125, + "population_standard_deviation": 1.7926340609447835 + }, + "adapted_drift_reconstruction_rmse": { + "minimum": 3.268650797, + "median": 4.7148156100000005, + "maximum": 11.722196472, + "arithmetic_mean": 5.595161787, + "population_standard_deviation": 2.7010520289568483 + }, + "base_prediction_rmse": { + "minimum": 5.274702577, + "median": 9.0684269465, + "maximum": 15.803773847, + "arithmetic_mean": 9.351916128375, + "population_standard_deviation": 3.3369641369339753 + }, + "adapted_drift_prediction_rmse": { + "minimum": 5.210900214, + "median": 7.5611356915000005, + "maximum": 15.132556407, + "arithmetic_mean": 9.0894363225, + "population_standard_deviation": 3.7918848016987137 + }, + "planning_exact_state_rate": { + "minimum": 0.296875, + "median": 0.9453125, + "maximum": 1.0, + "arithmetic_mean": 0.8671875, + "population_standard_deviation": 0.2222103539582483 + }, + "planning_path_found_rate": { + "minimum": 0.96875, + "median": 1.0, + "maximum": 1.0, + "arithmetic_mean": 0.99609375, + "population_standard_deviation": 0.010334966058846057 + }, + "expert_count": { + "minimum": 68.0, + "median": 68.0, + "maximum": 68.0, + "arithmetic_mean": 68.0, + "population_standard_deviation": 0.0 + }, + "training_evaluations": { + "minimum": 184288.0, + "median": 198176.5, + "maximum": 248728.0, + "arithmetic_mean": 201902.5, + "population_standard_deviation": 19212.06033979698 + }, + "checkpoint_size_bytes": { + "minimum": 39438.0, + "median": 39438.0, + "maximum": 39438.0, + "arithmetic_mean": 39438.0, + "population_standard_deviation": 0.0 + } + }, + "comparison_aggregates": { + "ravel_0_4_candidate": { + "drift_holdout_accuracy": { + "minimum": 0.93359375, + "median": 1.0, + "maximum": 1.0, + "arithmetic_mean": 0.9853515625, + "population_standard_deviation": 0.022333196535213422 + }, + "retention_accuracy": { + "minimum": 0.671875, + "median": 1.0, + "maximum": 1.0, + "arithmetic_mean": 0.904296875, + "population_standard_deviation": 0.1358650803862397 + }, + "reconstruction_rmse": { + "minimum": 3.268650797, + "median": 4.7148156100000005, + "maximum": 11.722196472, + "arithmetic_mean": 5.595161787, + "population_standard_deviation": 2.7010520289568483 + }, + "prediction_rmse": { + "minimum": 5.210900214, + "median": 7.5611356915000005, + "maximum": 15.132556407, + "arithmetic_mean": 9.0894363225, + "population_standard_deviation": 3.7918848016987137 + }, + "planning_exact_state_rate": { + "minimum": 0.296875, + "median": 0.9453125, + "maximum": 1.0, + "arithmetic_mean": 0.8671875, + "population_standard_deviation": 0.2222103539582483 + }, + "expert_evaluations": { + "minimum": 2048.0, + "median": 2048.0, + "maximum": 2828.0, + "arithmetic_mean": 2175.5, + "population_standard_deviation": 258.83150890106094 + }, + "expert_count": { + "minimum": 68.0, + "median": 68.0, + "maximum": 68.0, + "arithmetic_mean": 68.0, + "population_standard_deviation": 0.0 + }, + "training_evaluations": { + "minimum": 184288.0, + "median": 198176.5, + "maximum": 248728.0, + "arithmetic_mean": 201902.5, + "population_standard_deviation": 19212.06033979698 + }, + "checkpoint_size_bytes": { + "minimum": 39438.0, + "median": 39438.0, + "maximum": 39438.0, + "arithmetic_mean": 39438.0, + "population_standard_deviation": 0.0 + }, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "per-variant wall-clock timing excluded from canonical deterministic evidence" + } + }, + "fixed_8_expert": { + "drift_holdout_accuracy": { + "minimum": 0.1484375, + "median": 0.197265625, + "maximum": 0.234375, + "arithmetic_mean": 0.1923828125, + "population_standard_deviation": 0.02794743754151208 + }, + "retention_accuracy": { + "minimum": 0.15625, + "median": 0.216796875, + "maximum": 0.25, + "arithmetic_mean": 0.2080078125, + "population_standard_deviation": 0.03272577359397664 + }, + "reconstruction_rmse": { + "minimum": 16.462897466, + "median": 28.371648356, + "maximum": 30.667927368, + "arithmetic_mean": 25.591238309625, + "population_standard_deviation": 4.856857388778953 + }, + "prediction_rmse": { + "minimum": 17.871856266, + "median": 29.6558403175, + "maximum": 33.661330668, + "arithmetic_mean": 28.040879782, + "population_standard_deviation": 4.93676724301605 + }, + "planning_exact_state_rate": { + "minimum": 0.0, + "median": 0.03125, + "maximum": 0.078125, + "arithmetic_mean": 0.03515625, + "population_standard_deviation": 0.02174907954230477 + }, + "expert_evaluations": { + "minimum": 2048.0, + "median": 2048.0, + "maximum": 2048.0, + "arithmetic_mean": 2048.0, + "population_standard_deviation": 0.0 + }, + "expert_count": { + "minimum": 8.0, + "median": 8.0, + "maximum": 8.0, + "arithmetic_mean": 8.0, + "population_standard_deviation": 0.0 + }, + "training_evaluations": { + "minimum": 61440.0, + "median": 61440.0, + "maximum": 61440.0, + "arithmetic_mean": 61440.0, + "population_standard_deviation": 0.0 + }, + "checkpoint_size_bytes": { + "minimum": 10578.0, + "median": 10578.0, + "maximum": 10578.0, + "arithmetic_mean": 10578.0, + "population_standard_deviation": 0.0 + }, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "per-variant wall-clock timing excluded from canonical deterministic evidence" + } + }, + "flat_64_expert_complete_scan": { + "drift_holdout_accuracy": { + "minimum": 0.61328125, + "median": 1.0, + "maximum": 1.0, + "arithmetic_mean": 0.86181640625, + "population_standard_deviation": 0.17861151926413585 + }, + "retention_accuracy": { + "minimum": 1.0, + "median": 1.0, + "maximum": 1.0, + "arithmetic_mean": 1.0, + "population_standard_deviation": 0.0 + }, + "reconstruction_rmse": { + "minimum": 3.239324581, + "median": 5.5792778625, + "maximum": 11.498955243, + "arithmetic_mean": 6.0709421279999995, + "population_standard_deviation": 2.8331546433765546 + }, + "prediction_rmse": { + "minimum": 5.964526836, + "median": 9.8226950355, + "maximum": 23.603471108, + "arithmetic_mean": 12.626418247125, + "population_standard_deviation": 6.444365190744533 + }, + "planning_exact_state_rate": { + "minimum": 0.078125, + "median": 0.9609375, + "maximum": 0.984375, + "arithmetic_mean": 0.79296875, + "population_standard_deviation": 0.30083197624203367 + }, + "expert_evaluations": { + "minimum": 16384.0, + "median": 16384.0, + "maximum": 16384.0, + "arithmetic_mean": 16384.0, + "population_standard_deviation": 0.0 + }, + "expert_count": { + "minimum": 64.0, + "median": 64.0, + "maximum": 64.0, + "arithmetic_mean": 64.0, + "population_standard_deviation": 0.0 + }, + "training_evaluations": { + "minimum": 2326528.0, + "median": 2326528.0, + "maximum": 2326528.0, + "arithmetic_mean": 2326528.0, + "population_standard_deviation": 0.0 + }, + "checkpoint_size_bytes": { + "minimum": 37514.0, + "median": 37514.0, + "maximum": 37514.0, + "arithmetic_mean": 37514.0, + "population_standard_deviation": 0.0 + }, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "per-variant wall-clock timing excluded from canonical deterministic evidence" + } + }, + "fixed_topology_64_expert_routed": { + "drift_holdout_accuracy": { + "minimum": 0.61328125, + "median": 1.0, + "maximum": 1.0, + "arithmetic_mean": 0.86181640625, + "population_standard_deviation": 0.17861151926413585 + }, + "retention_accuracy": { + "minimum": 1.0, + "median": 1.0, + "maximum": 1.0, + "arithmetic_mean": 1.0, + "population_standard_deviation": 0.0 + }, + "reconstruction_rmse": { + "minimum": 3.239324581, + "median": 5.5792778625, + "maximum": 11.498955243, + "arithmetic_mean": 6.0709421279999995, + "population_standard_deviation": 2.8331546433765546 + }, + "prediction_rmse": { + "minimum": 5.964526836, + "median": 9.8226950355, + "maximum": 23.603471108, + "arithmetic_mean": 12.626418247125, + "population_standard_deviation": 6.444365190744533 + }, + "planning_exact_state_rate": { + "minimum": 0.078125, + "median": 0.9609375, + "maximum": 0.984375, + "arithmetic_mean": 0.79296875, + "population_standard_deviation": 0.30083197624203367 + }, + "expert_evaluations": { + "minimum": 2048.0, + "median": 2048.0, + "maximum": 3672.0, + "arithmetic_mean": 2286.0, + "population_standard_deviation": 528.8591494906749 + }, + "expert_count": { + "minimum": 64.0, + "median": 64.0, + "maximum": 64.0, + "arithmetic_mean": 64.0, + "population_standard_deviation": 0.0 + }, + "training_evaluations": { + "minimum": 2326528.0, + "median": 2326528.0, + "maximum": 2326528.0, + "arithmetic_mean": 2326528.0, + "population_standard_deviation": 0.0 + }, + "checkpoint_size_bytes": { + "minimum": 37514.0, + "median": 37514.0, + "maximum": 37514.0, + "arithmetic_mean": 37514.0, + "population_standard_deviation": 0.0 + }, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "per-variant wall-clock timing excluded from canonical deterministic evidence" + } + }, + "nearest_centroid_16_no_recursive_births": { + "drift_holdout_accuracy": { + "minimum": 0.203125, + "median": 0.22265625, + "maximum": 0.37890625, + "arithmetic_mean": 0.248046875, + "population_standard_deviation": 0.055928988528423255 + }, + "retention_accuracy": { + "minimum": 0.203125, + "median": 0.26171875, + "maximum": 0.54296875, + "arithmetic_mean": 0.28955078125, + "population_standard_deviation": 0.09865577354956519 + }, + "reconstruction_rmse": { + "minimum": 11.97511352, + "median": 22.367615947, + "maximum": 25.316094113, + "arithmetic_mean": 20.45029755575, + "population_standard_deviation": 4.6132397661509135 + }, + "prediction_rmse": { + "minimum": 11.988090221, + "median": 24.540759106, + "maximum": 29.618836762, + "arithmetic_mean": 23.61753008875, + "population_standard_deviation": 5.052748093230206 + }, + "planning_exact_state_rate": { + "minimum": 0.03125, + "median": 0.1484375, + "maximum": 0.328125, + "arithmetic_mean": 0.14453125, + "population_standard_deviation": 0.08258740043697646 + }, + "expert_evaluations": { + "minimum": 4096.0, + "median": 4096.0, + "maximum": 4096.0, + "arithmetic_mean": 4096.0, + "population_standard_deviation": 0.0 + }, + "expert_count": { + "minimum": 16.0, + "median": 16.0, + "maximum": 16.0, + "arithmetic_mean": 16.0, + "population_standard_deviation": 0.0 + }, + "training_evaluations": { + "minimum": 188416.0, + "median": 188416.0, + "maximum": 188416.0, + "arithmetic_mean": 188416.0, + "population_standard_deviation": 0.0 + }, + "checkpoint_size_bytes": { + "minimum": 14426.0, + "median": 14426.0, + "maximum": 14426.0, + "arithmetic_mean": 14426.0, + "population_standard_deviation": 0.0 + }, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "per-variant wall-clock timing excluded from canonical deterministic evidence" + } + }, + "no_adaptation_static": { + "drift_holdout_accuracy": { + "minimum": 0.61328125, + "median": 0.955078125, + "maximum": 0.9921875, + "arithmetic_mean": 0.84228515625, + "population_standard_deviation": 0.16786581034443188 + }, + "retention_accuracy": { + "minimum": 0.95703125, + "median": 0.974609375, + "maximum": 1.0, + "arithmetic_mean": 0.97998046875, + "population_standard_deviation": 0.016392002276947773 + }, + "reconstruction_rmse": { + "minimum": 3.245941506, + "median": 6.6470930164999995, + "maximum": 12.208403881, + "arithmetic_mean": 6.7377749685, + "population_standard_deviation": 2.72848463878845 + }, + "prediction_rmse": { + "minimum": 6.308541448, + "median": 9.388836358, + "maximum": 23.74263423, + "arithmetic_mean": 12.86596623975, + "population_standard_deviation": 6.398827412838275 + }, + "planning_exact_state_rate": { + "minimum": 0.140625, + "median": 0.78125, + "maximum": 0.984375, + "arithmetic_mean": 0.677734375, + "population_standard_deviation": 0.2596921888678679 + }, + "expert_evaluations": { + "minimum": 2048.0, + "median": 2216.0, + "maximum": 4064.0, + "arithmetic_mean": 2461.0, + "population_standard_deviation": 640.2991488359172 + }, + "expert_count": { + "minimum": 64.0, + "median": 64.0, + "maximum": 64.0, + "arithmetic_mean": 64.0, + "population_standard_deviation": 0.0 + }, + "training_evaluations": { + "minimum": 126824.0, + "median": 132444.0, + "maximum": 192824.0, + "arithmetic_mean": 140426.0, + "population_standard_deviation": 20299.651918198007 + }, + "checkpoint_size_bytes": { + "minimum": 37514.0, + "median": 37514.0, + "maximum": 37514.0, + "arithmetic_mean": 37514.0, + "population_standard_deviation": 0.0 + }, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "per-variant wall-clock timing excluded from canonical deterministic evidence" + } + }, + "ravel_without_replay": { + "drift_holdout_accuracy": { + "minimum": 0.9921875, + "median": 1.0, + "maximum": 1.0, + "arithmetic_mean": 0.9990234375, + "population_standard_deviation": 0.0025837415147115144 + }, + "retention_accuracy": { + "minimum": 0.6328125, + "median": 1.0, + "maximum": 1.0, + "arithmetic_mean": 0.86962890625, + "population_standard_deviation": 0.1688627360964158 + }, + "reconstruction_rmse": { + "minimum": 3.353389407, + "median": 4.5911728345, + "maximum": 12.117639144, + "arithmetic_mean": 5.642386046625, + "population_standard_deviation": 2.793336054256016 + }, + "prediction_rmse": { + "minimum": 5.858492042, + "median": 8.003230965, + "maximum": 14.675433687, + "arithmetic_mean": 9.18131778325, + "population_standard_deviation": 3.359626208001222 + }, + "planning_exact_state_rate": { + "minimum": 0.3125, + "median": 1.0, + "maximum": 1.0, + "arithmetic_mean": 0.888671875, + "population_standard_deviation": 0.2228189509716563 + }, + "expert_evaluations": { + "minimum": 2048.0, + "median": 2048.0, + "maximum": 2768.0, + "arithmetic_mean": 2213.0, + "population_standard_deviation": 287.35866091002026 + }, + "expert_count": { + "minimum": 68.0, + "median": 68.0, + "maximum": 68.0, + "arithmetic_mean": 68.0, + "population_standard_deviation": 0.0 + }, + "training_evaluations": { + "minimum": 167904.0, + "median": 180181.5, + "maximum": 231960.0, + "arithmetic_mean": 183194.0, + "population_standard_deviation": 19129.63024342081 + }, + "checkpoint_size_bytes": { + "minimum": 39438.0, + "median": 39438.0, + "maximum": 39438.0, + "arithmetic_mean": 39438.0, + "population_standard_deviation": 0.0 + }, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "per-variant wall-clock timing excluded from canonical deterministic evidence" + } + }, + "ravel_without_retirement": { + "drift_holdout_accuracy": { + "minimum": 0.94140625, + "median": 1.0, + "maximum": 1.0, + "arithmetic_mean": 0.9853515625, + "population_standard_deviation": 0.020739024005464162 + }, + "retention_accuracy": { + "minimum": 0.671875, + "median": 1.0, + "maximum": 1.0, + "arithmetic_mean": 0.91064453125, + "population_standard_deviation": 0.12593397263350678 + }, + "reconstruction_rmse": { + "minimum": 3.268070888, + "median": 4.7137006485, + "maximum": 11.715737213, + "arithmetic_mean": 5.59219561325, + "population_standard_deviation": 2.697993650013105 + }, + "prediction_rmse": { + "minimum": 5.628626399, + "median": 9.162368425499999, + "maximum": 15.118959391, + "arithmetic_mean": 10.028339925625, + "population_standard_deviation": 3.6227605449468716 + }, + "planning_exact_state_rate": { + "minimum": 0.265625, + "median": 0.9140625, + "maximum": 1.0, + "arithmetic_mean": 0.84375, + "population_standard_deviation": 0.2265625 + }, + "expert_evaluations": { + "minimum": 2048.0, + "median": 2272.0, + "maximum": 3328.0, + "arithmetic_mean": 2424.0, + "population_standard_deviation": 447.3566809605061 + }, + "expert_count": { + "minimum": 72.0, + "median": 72.0, + "maximum": 72.0, + "arithmetic_mean": 72.0, + "population_standard_deviation": 0.0 + }, + "training_evaluations": { + "minimum": 159712.0, + "median": 170800.0, + "maximum": 224152.0, + "arithmetic_mean": 174729.0, + "population_standard_deviation": 19324.385190737634 + }, + "checkpoint_size_bytes": { + "minimum": 41362.0, + "median": 41362.0, + "maximum": 41362.0, + "arithmetic_mean": 41362.0, + "population_standard_deviation": 0.0 + }, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "per-variant wall-clock timing excluded from canonical deterministic evidence" + } + }, + "ravel_complete_scan_without_certification": { + "drift_holdout_accuracy": { + "minimum": 0.93359375, + "median": 1.0, + "maximum": 1.0, + "arithmetic_mean": 0.9853515625, + "population_standard_deviation": 0.022333196535213422 + }, + "retention_accuracy": { + "minimum": 0.671875, + "median": 1.0, + "maximum": 1.0, + "arithmetic_mean": 0.904296875, + "population_standard_deviation": 0.1358650803862397 + }, + "reconstruction_rmse": { + "minimum": 3.268650797, + "median": 4.7148156100000005, + "maximum": 11.722196472, + "arithmetic_mean": 5.595161787, + "population_standard_deviation": 2.7010520289568483 + }, + "prediction_rmse": { + "minimum": 5.210900214, + "median": 7.5611356915000005, + "maximum": 15.132556407, + "arithmetic_mean": 9.0894363225, + "population_standard_deviation": 3.7918848016987137 + }, + "planning_exact_state_rate": { + "minimum": 0.296875, + "median": 0.9453125, + "maximum": 1.0, + "arithmetic_mean": 0.8671875, + "population_standard_deviation": 0.2222103539582483 + }, + "expert_evaluations": { + "minimum": 17408.0, + "median": 17408.0, + "maximum": 17408.0, + "arithmetic_mean": 17408.0, + "population_standard_deviation": 0.0 + }, + "expert_count": { + "minimum": 68.0, + "median": 68.0, + "maximum": 68.0, + "arithmetic_mean": 68.0, + "population_standard_deviation": 0.0 + }, + "training_evaluations": { + "minimum": 380896.0, + "median": 387604.5, + "maximum": 443800.0, + "arithmetic_mean": 393782.5, + "population_standard_deviation": 19305.77754196914 + }, + "checkpoint_size_bytes": { + "minimum": 39438.0, + "median": 39438.0, + "maximum": 39438.0, + "arithmetic_mean": 39438.0, + "population_standard_deviation": 0.0 + }, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "per-variant wall-clock timing excluded from canonical deterministic evidence" + } + }, + "ravel_fixed_topology_without_recursive_births": { + "drift_holdout_accuracy": { + "minimum": 0.9765625, + "median": 1.0, + "maximum": 1.0, + "arithmetic_mean": 0.9921875, + "population_standard_deviation": 0.01014873520059889 + }, + "retention_accuracy": { + "minimum": 0.6484375, + "median": 1.0, + "maximum": 1.0, + "arithmetic_mean": 0.89208984375, + "population_standard_deviation": 0.14756033875539998 + }, + "reconstruction_rmse": { + "minimum": 3.276899436, + "median": 4.7239634425000006, + "maximum": 11.73443203, + "arithmetic_mean": 5.593109469375, + "population_standard_deviation": 2.7001961915669406 + }, + "prediction_rmse": { + "minimum": 3.725665254, + "median": 7.1216687819999995, + "maximum": 16.15325089, + "arithmetic_mean": 8.72064317175, + "population_standard_deviation": 4.220537239010188 + }, + "planning_exact_state_rate": { + "minimum": 0.25, + "median": 1.0, + "maximum": 1.0, + "arithmetic_mean": 0.884765625, + "population_standard_deviation": 0.24642679596887263 + }, + "expert_evaluations": { + "minimum": 2048.0, + "median": 2048.0, + "maximum": 2272.0, + "arithmetic_mean": 2076.0, + "population_standard_deviation": 74.08103670980854 + }, + "expert_count": { + "minimum": 64.0, + "median": 64.0, + "maximum": 64.0, + "arithmetic_mean": 64.0, + "population_standard_deviation": 0.0 + }, + "training_evaluations": { + "minimum": 2351104.0, + "median": 2351104.0, + "maximum": 2354240.0, + "arithmetic_mean": 2351657.0, + "population_standard_deviation": 1055.2833742649411 + }, + "checkpoint_size_bytes": { + "minimum": 37514.0, + "median": 37514.0, + "maximum": 37514.0, + "arithmetic_mean": 37514.0, + "population_standard_deviation": 0.0 + }, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "per-variant wall-clock timing excluded from canonical deterministic evidence" + } + }, + "ravel_random_births": { + "drift_holdout_accuracy": { + "minimum": 0.9375, + "median": 0.96875, + "maximum": 1.0, + "arithmetic_mean": 0.97265625, + "population_standard_deviation": 0.01943334838098867 + }, + "retention_accuracy": { + "minimum": 0.6640625, + "median": 0.962890625, + "maximum": 1.0, + "arithmetic_mean": 0.87890625, + "population_standard_deviation": 0.13695570983014227 + }, + "reconstruction_rmse": { + "minimum": 3.278805288, + "median": 4.984041905, + "maximum": 12.370829046, + "arithmetic_mean": 5.988308013375001, + "population_standard_deviation": 2.769990490368177 + }, + "prediction_rmse": { + "minimum": 5.244062968, + "median": 8.0238689135, + "maximum": 15.611341361, + "arithmetic_mean": 9.355864837624999, + "population_standard_deviation": 3.7909629244858127 + }, + "planning_exact_state_rate": { + "minimum": 0.328125, + "median": 0.8359375, + "maximum": 1.0, + "arithmetic_mean": 0.798828125, + "population_standard_deviation": 0.21699034160443495 + }, + "expert_evaluations": { + "minimum": 2048.0, + "median": 2198.0, + "maximum": 3008.0, + "arithmetic_mean": 2348.0, + "population_standard_deviation": 340.73450074801644 + }, + "expert_count": { + "minimum": 68.0, + "median": 68.0, + "maximum": 68.0, + "arithmetic_mean": 68.0, + "population_standard_deviation": 0.0 + }, + "training_evaluations": { + "minimum": 181952.0, + "median": 190351.5, + "maximum": 259742.0, + "arithmetic_mean": 201174.375, + "population_standard_deviation": 24560.557062786156 + }, + "checkpoint_size_bytes": { + "minimum": 39438.0, + "median": 39438.0, + "maximum": 39438.0, + "arithmetic_mean": 39438.0, + "population_standard_deviation": 0.0 + }, + "runtime_observation_non_normative": { + "status": "UNKNOWN", + "reason": "per-variant wall-clock timing excluded from canonical deterministic evidence" + } + } + }, + "candidate_mean_drift_accuracy_delta_vs_comparisons": { + "fixed_8_expert": 0.79296875, + "flat_64_expert_complete_scan": 0.12353515625, + "fixed_topology_64_expert_routed": 0.12353515625, + "nearest_centroid_16_no_recursive_births": 0.7373046875, + "no_adaptation_static": 0.14306640625, + "ravel_without_replay": -0.013671875, + "ravel_without_retirement": 0.0, + "ravel_complete_scan_without_certification": 0.0, + "ravel_fixed_topology_without_recursive_births": -0.0068359375, + "ravel_random_births": 0.0126953125 + }, + "comparison_interpretation": "mixed_do_not_infer_superiority", + "trial_summary": { + "declared": 8, + "passing": 0, + "failing": 8, + "pass_rule": "all_8_trials_pass" + }, + "development_result": "FAIL", + "formal_mncs_status": "UNKNOWN", + "formal_mncds_status": "UNKNOWN", + "promotion_authorized": false +} diff --git a/ravel_0_4.c b/ravel_0_4.c new file mode 100644 index 0000000..76fc443 --- /dev/null +++ b/ravel_0_4.c @@ -0,0 +1,2077 @@ +/* + * RAVEL 0.4 -- bounded evidence-hardening experiment. + * + * This is maintained C11 source. No source generator is claimed. + */ +#define _POSIX_C_SOURCE 200809L +#include +#include +#include +#include +#include +#include +#include +#include + +#define D 8u +#define CLASSES 8u +#define ACTIONS 4u +#define STATES 64u +#define MAXE 80u +#define BASE_E 64u +#define INIT_E 8u +#define ADAPT_BIRTHS 8u +#define ADAPTED_E 68u +#define ROUTE_K 8u +#define CELLS 256u +#define BASE_TRAIN_N 1024u +#define BASE_HOLD_N 256u +#define ADAPT_TRAIN_N 512u +#define DRIFT_HOLD_N 256u +#define RETENTION_N 256u +#define REPLAY_N 256u +#define PLAN_N 64u +#define PLAN_LIMIT 32u +#define TRIALS 8u +#define LO (-64) +#define HI 63 +#define Q20_SCALE 1048576.0 +#define CHECKPOINT_SCHEMA 4u +#define CHECKPOINT_HEADER 64u +#define CHECKPOINT_MAX 65536u +#define INVALID_EXPERT UINT16_MAX + +typedef struct { + int16_t x[D]; + int16_t nx[D]; + uint8_t action; + uint8_t label; + uint8_t state; + uint8_t next_state; +} Event; + +typedef struct { + double key[D]; + double decode[D]; + double next[ACTIONS][D]; + uint32_t labels[CLASSES]; + uint32_t action_count[ACTIONS]; + uint32_t count; + uint32_t errors; + double reconstruction_sse; + double prediction_sse; + uint8_t label; + uint8_t active; + uint8_t lifecycle; + uint16_t generation; + uint64_t lineage; +} Expert; + +typedef struct { + uint16_t id[ROUTE_K]; + double excluded_lb; +} Cell; + +typedef struct { + Expert e[MAXE]; + Cell routing[CELLS]; + uint16_t next_graph[MAXE][ACTIONS]; + uint16_t n; + uint64_t epoch; + uint8_t identity[32]; +} Model; + +typedef struct { + uint64_t samples; + uint64_t rejected; + uint64_t correct; + uint64_t exact_mismatches; + uint64_t certified; + uint64_t expert_evaluations; + double reconstruction_sse; + double prediction_sse; + uint64_t transition_correct; + uint64_t classification_checksum; + uint64_t reconstruction_checksum; + uint64_t prediction_checksum; + uint64_t transition_checksum; +} Eval; + +typedef struct { + uint64_t samples; + uint64_t expert_evaluations; + uint64_t certified; + uint64_t births; + uint64_t retired; +} TrainMetric; + +typedef struct { + uint64_t cases; + uint64_t path_found; + uint64_t exact_state_targets; + uint64_t goal_expert_targets; + uint64_t executed_path_length; + uint64_t optimal_path_length; + uint64_t path_length_regret; + uint64_t graph_disconnection_failures; + uint64_t transition_model_failures; + uint64_t state_aliasing_failures; + uint64_t expansions; + uint64_t checksum; +} PlanMetric; + +typedef struct { + int16_t center[STATES][D]; + uint8_t label[STATES]; + uint8_t base_next[STATES][ACTIONS]; + uint8_t drift_next[STATES][ACTIONS]; +} World; + +typedef struct { + const char *trial_id; + const char *regime; + uint64_t seed; + int amplitude; + int base_noise; + int drift_noise; + uint8_t label_drift; + uint8_t observation_drift; + uint8_t transition_drift; + uint8_t ambiguous; +} TrialSpec; + +typedef struct { + uint64_t expert_evaluations; + uint8_t use_replay; + uint8_t use_retirement; + uint8_t routed; + uint8_t recursive_births; + uint8_t random_births; +} VariantConfig; + +typedef struct { + uint8_t data[CHECKPOINT_MAX]; + size_t len; + int ok; +} ByteBuffer; + +typedef struct { + const uint8_t *data; + size_t len; + size_t pos; + int ok; +} ByteReader; + +typedef struct { + uint32_t h[8]; + uint64_t bits; + uint8_t block[64]; + size_t used; +} Sha256; + +static const TrialSpec trial_specs[TRIALS] = { + {"trial-01-separated", "separated_state", UINT64_C(0x0401000000000001), 42, 5, 5, 0, 0, 0, 0}, + {"trial-02-overlap", "partially_overlapping_observations", UINT64_C(0x0402000000000002), 22, 7, 7, 0, 0, 0, 0}, + {"trial-03-noise", "increased_observation_noise", UINT64_C(0x0403000000000003), 42, 13, 19, 0, 0, 0, 0}, + {"trial-04-label", "label_drift", UINT64_C(0x0404000000000004), 42, 5, 5, 1, 0, 0, 0}, + {"trial-05-observation", "observation_drift", UINT64_C(0x0405000000000005), 42, 5, 7, 0, 1, 0, 0}, + {"trial-06-transition", "transition_drift", UINT64_C(0x0406000000000006), 42, 5, 5, 0, 0, 1, 0}, + {"trial-07-combined", "combined_observation_and_label_drift", UINT64_C(0x0407000000000007), 34, 7, 11, 1, 1, 0, 0}, + {"trial-08-ambiguous", "partially_observed_ambiguous", UINT64_C(0x0408000000000008), 30, 9, 11, 1, 1, 1, 1} +}; + +static uint64_t rng_state; + +static uint32_t rng_u32(void) { + rng_state ^= rng_state >> 12; + rng_state ^= rng_state << 25; + rng_state ^= rng_state >> 27; + return (uint32_t)((rng_state * UINT64_C(2685821657736338717)) >> 32); +} + +static uint64_t mix64(uint64_t x) { + x ^= x >> 30; + x *= UINT64_C(0xbf58476d1ce4e5b9); + x ^= x >> 27; + x *= UINT64_C(0x94d049bb133111eb); + return x ^ (x >> 31); +} + +static int16_t clamp_domain(int v) { + if (v < LO) return (int16_t)LO; + if (v > HI) return (int16_t)HI; + return (int16_t)v; +} + +static int64_t q20(double v) { + return (int64_t)llround(v * Q20_SCALE); +} + +static double from_q20(int64_t v) { + return (double)v / Q20_SCALE; +} + +static uint32_t rotr32(uint32_t x, uint32_t n) { + return (x >> n) | (x << (32u - n)); +} + +static void sha256_transform(Sha256 *s, const uint8_t block[64]) { + static const uint32_t k[64] = { + UINT32_C(0x428a2f98), UINT32_C(0x71374491), UINT32_C(0xb5c0fbcf), UINT32_C(0xe9b5dba5), + UINT32_C(0x3956c25b), UINT32_C(0x59f111f1), UINT32_C(0x923f82a4), UINT32_C(0xab1c5ed5), + UINT32_C(0xd807aa98), UINT32_C(0x12835b01), UINT32_C(0x243185be), UINT32_C(0x550c7dc3), + UINT32_C(0x72be5d74), UINT32_C(0x80deb1fe), UINT32_C(0x9bdc06a7), UINT32_C(0xc19bf174), + UINT32_C(0xe49b69c1), UINT32_C(0xefbe4786), UINT32_C(0x0fc19dc6), UINT32_C(0x240ca1cc), + UINT32_C(0x2de92c6f), UINT32_C(0x4a7484aa), UINT32_C(0x5cb0a9dc), UINT32_C(0x76f988da), + UINT32_C(0x983e5152), UINT32_C(0xa831c66d), UINT32_C(0xb00327c8), UINT32_C(0xbf597fc7), + UINT32_C(0xc6e00bf3), UINT32_C(0xd5a79147), UINT32_C(0x06ca6351), UINT32_C(0x14292967), + UINT32_C(0x27b70a85), UINT32_C(0x2e1b2138), UINT32_C(0x4d2c6dfc), UINT32_C(0x53380d13), + UINT32_C(0x650a7354), UINT32_C(0x766a0abb), UINT32_C(0x81c2c92e), UINT32_C(0x92722c85), + UINT32_C(0xa2bfe8a1), UINT32_C(0xa81a664b), UINT32_C(0xc24b8b70), UINT32_C(0xc76c51a3), + UINT32_C(0xd192e819), UINT32_C(0xd6990624), UINT32_C(0xf40e3585), UINT32_C(0x106aa070), + UINT32_C(0x19a4c116), UINT32_C(0x1e376c08), UINT32_C(0x2748774c), UINT32_C(0x34b0bcb5), + UINT32_C(0x391c0cb3), UINT32_C(0x4ed8aa4a), UINT32_C(0x5b9cca4f), UINT32_C(0x682e6ff3), + UINT32_C(0x748f82ee), UINT32_C(0x78a5636f), UINT32_C(0x84c87814), UINT32_C(0x8cc70208), + UINT32_C(0x90befffa), UINT32_C(0xa4506ceb), UINT32_C(0xbef9a3f7), UINT32_C(0xc67178f2) + }; + uint32_t w[64]; + for (uint32_t i = 0; i < 16u; ++i) { + w[i] = ((uint32_t)block[i * 4u] << 24) | ((uint32_t)block[i * 4u + 1u] << 16) | + ((uint32_t)block[i * 4u + 2u] << 8) | (uint32_t)block[i * 4u + 3u]; + } + for (uint32_t i = 16u; i < 64u; ++i) { + uint32_t a = w[i - 15u], b = w[i - 2u]; + uint32_t s0 = rotr32(a, 7u) ^ rotr32(a, 18u) ^ (a >> 3); + uint32_t s1 = rotr32(b, 17u) ^ rotr32(b, 19u) ^ (b >> 10); + w[i] = w[i - 16u] + s0 + w[i - 7u] + s1; + } + uint32_t a = s->h[0], b = s->h[1], c = s->h[2], d = s->h[3]; + uint32_t e = s->h[4], f = s->h[5], g = s->h[6], h = s->h[7]; + for (uint32_t i = 0; i < 64u; ++i) { + uint32_t s1 = rotr32(e, 6u) ^ rotr32(e, 11u) ^ rotr32(e, 25u); + uint32_t ch = (e & f) ^ ((~e) & g); + uint32_t t1 = h + s1 + ch + k[i] + w[i]; + uint32_t s0 = rotr32(a, 2u) ^ rotr32(a, 13u) ^ rotr32(a, 22u); + uint32_t maj = (a & b) ^ (a & c) ^ (b & c); + uint32_t t2 = s0 + maj; + h = g; g = f; f = e; e = d + t1; + d = c; c = b; b = a; a = t1 + t2; + } + s->h[0] += a; s->h[1] += b; s->h[2] += c; s->h[3] += d; + s->h[4] += e; s->h[5] += f; s->h[6] += g; s->h[7] += h; +} + +static void sha256_init(Sha256 *s) { + static const uint32_t initial[8] = { + UINT32_C(0x6a09e667), UINT32_C(0xbb67ae85), UINT32_C(0x3c6ef372), UINT32_C(0xa54ff53a), + UINT32_C(0x510e527f), UINT32_C(0x9b05688c), UINT32_C(0x1f83d9ab), UINT32_C(0x5be0cd19) + }; + memcpy(s->h, initial, sizeof initial); + s->bits = 0u; + s->used = 0u; +} + +static void sha256_update(Sha256 *s, const uint8_t *data, size_t n) { + for (size_t i = 0; i < n; ++i) { + s->block[s->used++] = data[i]; + if (s->used == 64u) { + sha256_transform(s, s->block); + s->bits += 512u; + s->used = 0u; + } + } +} + +static void sha256_final(Sha256 *s, uint8_t out[32]) { + s->bits += (uint64_t)s->used * 8u; + s->block[s->used++] = 0x80u; + if (s->used > 56u) { + while (s->used < 64u) s->block[s->used++] = 0u; + sha256_transform(s, s->block); + s->used = 0u; + } + while (s->used < 56u) s->block[s->used++] = 0u; + for (uint32_t i = 0; i < 8u; ++i) s->block[63u - i] = (uint8_t)(s->bits >> (i * 8u)); + sha256_transform(s, s->block); + for (uint32_t i = 0; i < 8u; ++i) { + out[i * 4u] = (uint8_t)(s->h[i] >> 24); + out[i * 4u + 1u] = (uint8_t)(s->h[i] >> 16); + out[i * 4u + 2u] = (uint8_t)(s->h[i] >> 8); + out[i * 4u + 3u] = (uint8_t)s->h[i]; + } +} + +static void sha256_bytes(const uint8_t *data, size_t n, uint8_t out[32]) { + Sha256 s; + sha256_init(&s); + sha256_update(&s, data, n); + sha256_final(&s, out); +} + +static int event_valid(const Event *ev) { + if (ev == NULL || ev->action >= ACTIONS || ev->label >= CLASSES || + ev->state >= STATES || ev->next_state >= STATES) return 0; + for (uint32_t d = 0; d < D; ++d) { + if (ev->x[d] < LO || ev->x[d] > HI || ev->nx[d] < LO || ev->nx[d] > HI) return 0; + } + return 1; +} + +static void make_world(World *w, const TrialSpec *spec) { + memset(w, 0, sizeof *w); + for (uint32_t s = 0; s < STATES; ++s) { + uint32_t visible = spec->ambiguous ? s / 2u : s; + for (uint32_t d = 0; d < 6u; ++d) { + w->center[s][d] = (int16_t)(((visible >> d) & 1u) ? spec->amplitude : -spec->amplitude); + } + w->center[s][6] = (int16_t)(-30 + 20 * (int)((visible * 5u + (visible >> 2)) & 3u)); + w->center[s][7] = (int16_t)(-30 + 20 * (int)((visible * 3u + (visible >> 1)) & 3u)); + w->label[s] = (uint8_t)(((visible * 29u) ^ (visible >> 1) ^ (visible >> 3)) & 7u); + w->base_next[s][0] = (uint8_t)((s + 1u) & 63u); + w->base_next[s][1] = (uint8_t)((s + 63u) & 63u); + w->base_next[s][2] = (uint8_t)(s ^ 8u); + w->base_next[s][3] = (uint8_t)(s ^ 32u); + for (uint32_t a = 0; a < ACTIONS; ++a) w->drift_next[s][a] = w->base_next[s][a]; + if (spec->transition_drift && s < 24u) { + w->drift_next[s][0] = (uint8_t)(s ^ 16u); + w->drift_next[s][2] = (uint8_t)((s + 2u) & 63u); + } + } +} + +static void make_observation(const World *w, const TrialSpec *spec, uint8_t state, + int drift, int noise, int16_t out[D]) { + for (uint32_t d = 0; d < D; ++d) { + int shift = 0; + if (drift && spec->observation_drift && state < 24u) { + if (d == 6u) shift = 16; + if (d == 7u) shift = -16; + } + int jitter = noise == 0 ? 0 : (int)(rng_u32() % (uint32_t)(2 * noise + 1)) - noise; + out[d] = clamp_domain((int)w->center[state][d] + shift + jitter); + } +} + +static void make_dataset(const World *w, const TrialSpec *spec, Event *out, uint32_t n, + uint64_t seed, int drift) { + rng_state = seed; + int noise = drift ? spec->drift_noise : spec->base_noise; + for (uint32_t i = 0; i < n; ++i) { + uint8_t s = (uint8_t)(rng_u32() % STATES); + uint8_t a = (uint8_t)(rng_u32() % ACTIONS); + const uint8_t (*next)[ACTIONS] = drift ? w->drift_next : w->base_next; + uint8_t ns = next[s][a]; + out[i].state = s; + out[i].next_state = ns; + out[i].action = a; + out[i].label = (uint8_t)(drift && spec->label_drift && s < 24u + ? ((w->label[s] + 3u) & 7u) : w->label[s]); + make_observation(w, spec, s, drift, noise, out[i].x); + make_observation(w, spec, ns, drift, noise, out[i].nx); + } +} + +static double dist_x(const int16_t x[D], const Expert *e) { + double total = 0.0; + for (uint32_t d = 0; d < D; ++d) { + double delta = (double)x[d] - e->key[d]; + total += delta * delta; + } + return total; +} + +static double dist_vec(const double a[D], const double b[D]) { + double total = 0.0; + for (uint32_t d = 0; d < D; ++d) { + double delta = a[d] - b[d]; + total += delta * delta; + } + return total; +} + +static int better(double d, uint16_t id, double best_d, uint16_t best_id) { + return d < best_d || (d == best_d && id < best_id); +} + +static uint8_t majority(const uint32_t counts[CLASSES]) { + uint8_t best = 0u; + for (uint8_t y = 1u; y < CLASSES; ++y) if (counts[y] > counts[best]) best = y; + return best; +} + +static uint16_t cell_id(const int16_t x[D], int *in_domain) { + uint16_t cell = 0u; + *in_domain = 1; + for (uint32_t d = 0; d < D; ++d) if (x[d] < LO || x[d] > HI) *in_domain = 0; + for (uint32_t d = 0; d < 4u; ++d) { + int v = ((int)x[d] - LO) / 32; + if (v < 0) v = 0; + if (v > 3) v = 3; + cell = (uint16_t)((cell << 2) | (uint16_t)v); + } + return cell; +} + +static double axis_lb(double c, double lo, double hi) { + if (c < lo) { double v = lo - c; return v * v; } + if (c > hi) { double v = c - hi; return v * v; } + return 0.0; +} + +static void build_lattice(Model *m) { + for (uint32_t b = 0; b < CELLS; ++b) { + double distances[MAXE]; + uint16_t ids[MAXE]; + for (uint16_t j = 0; j < m->n; ++j) { + double lower = 0.0; + for (uint32_t d = 0; d < 4u; ++d) { + uint32_t shift = 2u * (3u - d); + uint32_t v = (b >> shift) & 3u; + double lo = (double)(LO + 32 * (int)v); + lower += axis_lb(m->e[j].key[d], lo, lo + 31.0); + } + distances[j] = lower; + ids[j] = j; + } + uint16_t take = m->n < ROUTE_K ? m->n : ROUTE_K; + uint16_t need = m->n > ROUTE_K ? (uint16_t)(ROUTE_K + 1u) : m->n; + for (uint16_t i = 0; i < need; ++i) { + uint16_t best = i; + for (uint16_t j = (uint16_t)(i + 1u); j < m->n; ++j) { + if (better(distances[j], ids[j], distances[best], ids[best])) best = j; + } + double td = distances[i]; distances[i] = distances[best]; distances[best] = td; + uint16_t ti = ids[i]; ids[i] = ids[best]; ids[best] = ti; + } + for (uint16_t i = 0; i < ROUTE_K; ++i) m->routing[b].id[i] = INVALID_EXPERT; + for (uint16_t i = 0; i < take; ++i) m->routing[b].id[i] = ids[i]; + m->routing[b].excluded_lb = m->n > ROUTE_K ? distances[ROUTE_K] : DBL_MAX; + } +} + +static uint16_t full_nearest(const int16_t x[D], const Model *m, uint64_t *evaluations) { + if (m->n == 0u) return INVALID_EXPERT; + double best_d = DBL_MAX; + uint16_t best = INVALID_EXPERT; + for (uint16_t j = 0; j < m->n; ++j) { + double d = dist_x(x, &m->e[j]); + ++*evaluations; + if (better(d, j, best_d, best)) { best_d = d; best = j; } + } + return best; +} + +static uint16_t routed_nearest(const int16_t x[D], const Model *m, uint64_t *evaluations, + uint64_t *certified) { + if (m->n == 0u) return INVALID_EXPERT; + int in_domain = 0; + uint16_t cell = cell_id(x, &in_domain); + uint8_t seen[MAXE] = {0}; + double best_d = DBL_MAX; + uint16_t best = INVALID_EXPERT; + uint16_t take = m->n < ROUTE_K ? m->n : ROUTE_K; + for (uint16_t i = 0; i < take; ++i) { + uint16_t j = m->routing[cell].id[i]; + if (j >= m->n) return INVALID_EXPERT; + seen[j] = 1u; + double d = dist_x(x, &m->e[j]); + ++*evaluations; + if (better(d, j, best_d, best)) { best_d = d; best = j; } + } + if (in_domain && best_d < m->routing[cell].excluded_lb) { + ++*certified; + return best; + } + for (uint16_t j = 0; j < m->n; ++j) if (!seen[j]) { + double d = dist_x(x, &m->e[j]); + ++*evaluations; + if (better(d, j, best_d, best)) { best_d = d; best = j; } + } + return best; +} + +static void seed_expert(Expert *e, const Event *ev, uint64_t lineage, uint16_t generation, + uint8_t lifecycle) { + memset(e, 0, sizeof *e); + for (uint32_t d = 0; d < D; ++d) { + e->key[d] = (double)ev->x[d]; + e->decode[d] = (double)ev->x[d]; + for (uint32_t a = 0; a < ACTIONS; ++a) e->next[a][d] = (double)ev->nx[d]; + } + e->label = ev->label; + e->active = 1u; + e->lifecycle = lifecycle; + e->generation = generation; + e->lineage = lineage; +} + +static void init_farthest(Model *m, uint16_t n, const Event *data, uint32_t count, + TrainMetric *tm) { + memset(m, 0, sizeof *m); + m->n = n; + seed_expert(&m->e[0], &data[0], mix64(UINT64_C(0x524156454c040001)), 0u, 0u); + for (uint16_t k = 1; k < n; ++k) { + double farthest = -1.0; + uint32_t far_i = 0u; + for (uint32_t i = 0; i < count; ++i) { + double nearest = DBL_MAX; + for (uint16_t j = 0; j < k; ++j) { + double d = dist_x(data[i].x, &m->e[j]); + ++tm->expert_evaluations; + if (d < nearest) nearest = d; + } + if (nearest > farthest) { farthest = nearest; far_i = i; } + } + seed_expert(&m->e[k], &data[far_i], mix64(m->e[0].lineage ^ k), 0u, 0u); + } + build_lattice(m); +} + +static void refine(Model *m, const Event *data, uint32_t count, uint32_t iterations, + int routed, uint16_t *assignments, TrainMetric *tm) { + for (uint32_t iteration = 0; iteration < iterations; ++iteration) { + double key_sum[MAXE][D] = {{0}}; + double decode_sum[MAXE][D] = {{0}}; + double next_sum[MAXE][ACTIONS][D] = {{{0}}}; + uint32_t counts[MAXE] = {0}; + uint32_t labels[MAXE][CLASSES] = {{0}}; + uint32_t action_count[MAXE][ACTIONS] = {{0}}; + uint32_t errors[MAXE] = {0}; + double reconstruction_sse[MAXE] = {0}; + double prediction_sse[MAXE] = {0}; + build_lattice(m); + for (uint32_t i = 0; i < count; ++i) { + if (!event_valid(&data[i])) continue; + uint16_t j = routed + ? routed_nearest(data[i].x, m, &tm->expert_evaluations, &tm->certified) + : full_nearest(data[i].x, m, &tm->expert_evaluations); + if (j == INVALID_EXPERT) continue; + ++tm->samples; + if (assignments != NULL) assignments[i] = j; + ++counts[j]; + ++labels[j][data[i].label]; + ++action_count[j][data[i].action]; + if (m->e[j].label != data[i].label) ++errors[j]; + for (uint32_t d = 0; d < D; ++d) { + double x = (double)data[i].x[d], nx = (double)data[i].nx[d]; + key_sum[j][d] += x; + decode_sum[j][d] += x; + next_sum[j][data[i].action][d] += nx; + double rv = x - m->e[j].decode[d]; + double pv = nx - m->e[j].next[data[i].action][d]; + reconstruction_sse[j] += rv * rv; + prediction_sse[j] += pv * pv; + } + } + for (uint16_t j = 0; j < m->n; ++j) { + m->e[j].count = counts[j]; + m->e[j].errors = errors[j]; + m->e[j].reconstruction_sse = reconstruction_sse[j]; + m->e[j].prediction_sse = prediction_sse[j]; + memcpy(m->e[j].labels, labels[j], sizeof labels[j]); + memcpy(m->e[j].action_count, action_count[j], sizeof action_count[j]); + if (counts[j] == 0u) continue; + for (uint32_t d = 0; d < D; ++d) { + m->e[j].key[d] = key_sum[j][d] / (double)counts[j]; + m->e[j].decode[d] = decode_sum[j][d] / (double)counts[j]; + } + m->e[j].label = majority(labels[j]); + for (uint32_t a = 0; a < ACTIONS; ++a) if (action_count[j][a] != 0u) { + for (uint32_t d = 0; d < D; ++d) { + m->e[j].next[a][d] = next_sum[j][a][d] / (double)action_count[j][a]; + } + } + } + } + build_lattice(m); +} + +static double split_score(const Expert *e) { + if (e->count < 2u) return -1.0; + return (double)e->errors * 1e12 + e->prediction_sse * 1e3 + + e->reconstruction_sse + (double)e->count; +} + +static int split_one(Model *m, uint16_t parent, uint16_t child, const Event *data, + uint32_t count, const uint16_t *assignments, uint32_t round) { + if (parent >= m->n || child >= MAXE || assignments == NULL) return 0; + uint32_t first = UINT32_MAX; + for (uint32_t i = 0; i < count; ++i) if (assignments[i] == parent) { first = i; break; } + if (first == UINT32_MAX) return 0; + uint32_t a = first, b = first; + double farthest = -1.0; + for (uint32_t i = 0; i < count; ++i) if (assignments[i] == parent) { + double d = 0.0; + for (uint32_t k = 0; k < D; ++k) { + double delta = (double)data[i].x[k] - data[first].x[k]; + d += delta * delta; + } + if (d > farthest) { farthest = d; a = i; } + } + farthest = -1.0; + for (uint32_t i = 0; i < count; ++i) if (assignments[i] == parent) { + double d = 0.0; + for (uint32_t k = 0; k < D; ++k) { + double delta = (double)data[i].x[k] - data[a].x[k]; + d += delta * delta; + } + if (d > farthest) { farthest = d; b = i; } + } + if (a == b) return 0; + uint64_t original_lineage = m->e[parent].lineage; + uint16_t original_generation = m->e[parent].generation; + uint8_t lifecycle = m->e[parent].lifecycle; + uint16_t child_generation = (uint16_t)(original_generation + 1u); + seed_expert(&m->e[parent], &data[a], + mix64(original_lineage ^ ((uint64_t)round << 32) ^ UINT64_C(0xa5)), + child_generation, lifecycle); + seed_expert(&m->e[child], &data[b], + mix64(original_lineage ^ ((uint64_t)round << 32) ^ UINT64_C(0x5a)), + child_generation, lifecycle); + return m->e[parent].lineage != m->e[child].lineage; +} + +static void train_recursive(Model *m, const Event *data, uint32_t count, TrainMetric *tm) { + uint16_t assignments[BASE_TRAIN_N]; + init_farthest(m, INIT_E, data, count, tm); + uint32_t round = 0u; + while (m->n < BASE_E) { + refine(m, data, count, 1u, 1, assignments, tm); + uint16_t order[MAXE]; + for (uint16_t j = 0; j < m->n; ++j) order[j] = j; + for (uint16_t i = 0; i < m->n; ++i) { + uint16_t best = i; + for (uint16_t j = (uint16_t)(i + 1u); j < m->n; ++j) { + double x = split_score(&m->e[order[j]]); + double y = split_score(&m->e[order[best]]); + if (x > y || (x == y && order[j] < order[best])) best = j; + } + uint16_t tmp = order[i]; order[i] = order[best]; order[best] = tmp; + } + uint16_t target = (uint16_t)((BASE_E - m->n) < 8u ? (BASE_E - m->n) : 8u); + uint16_t made = 0u; + uint16_t old_n = m->n; + for (uint16_t i = 0; i < old_n && made < target; ++i) { + if (split_one(m, order[i], (uint16_t)(old_n + made), data, count, + assignments, round)) { + ++made; + ++tm->births; + } + } + if (made == 0u) break; + m->n = (uint16_t)(old_n + made); + ++round; + } + refine(m, data, count, 3u, 1, NULL, tm); + ++m->epoch; +} + +static int add_adaptation_experts(Model *m, const Event *data, uint32_t count, + int random_births, TrainMetric *tm) { + if (m->n > MAXE || ADAPT_BIRTHS > MAXE - m->n) return 0; + double score[ADAPT_TRAIN_N]; + uint8_t selected[ADAPT_TRAIN_N] = {0}; + build_lattice(m); + for (uint32_t i = 0; i < count; ++i) { + if (!event_valid(&data[i])) return 0; + uint64_t evaluations = 0u, certified = 0u; + uint16_t j = routed_nearest(data[i].x, m, &evaluations, &certified); + if (j == INVALID_EXPERT) return 0; + tm->expert_evaluations += evaluations; + tm->certified += certified; + ++tm->samples; + double prediction = 0.0; + for (uint32_t d = 0; d < D; ++d) { + double delta = (double)data[i].nx[d] - m->e[j].next[data[i].action][d]; + prediction += delta * delta; + } + score[i] = (m->e[j].label != data[i].label ? 1e12 : 0.0) + prediction; + } + for (uint16_t birth = 0; birth < ADAPT_BIRTHS; ++birth) { + uint32_t best = UINT32_MAX; + double best_score = -DBL_MAX; + if (random_births) { + uint32_t start = (uint32_t)(mix64(m->epoch ^ birth) % count); + for (uint32_t k = 0; k < count; ++k) { + uint32_t i = (start + k) % count; + if (!selected[i]) { best = i; break; } + } + } else { + for (uint32_t i = 0; i < count; ++i) if (!selected[i]) { + double separation = DBL_MAX; + for (uint16_t j = 0; j < m->n; ++j) { + double d = dist_x(data[i].x, &m->e[j]); + if (d < separation) separation = d; + } + double candidate = score[i] + separation * 1e6; + if (candidate > best_score || + (candidate == best_score && (best == UINT32_MAX || i < best))) { + best_score = candidate; + best = i; + } + } + } + if (best == UINT32_MAX) return 0; + selected[best] = 1u; + uint16_t id = m->n; + seed_expert(&m->e[id], &data[best], + mix64(UINT64_C(0x4144415054424952) ^ m->epoch ^ id ^ best), + (uint16_t)(m->epoch + 1u), 1u); + ++m->n; + ++tm->births; + } + build_lattice(m); + return 1; +} + +static int duplicate_experts(const Model *m) { + for (uint16_t i = 0; i < m->n; ++i) { + for (uint16_t j = (uint16_t)(i + 1u); j < m->n; ++j) { + if (m->e[i].lineage == m->e[j].lineage) return 1; + int same = m->e[i].label == m->e[j].label; + for (uint32_t d = 0; d < D && same; ++d) { + if (q20(m->e[i].key[d]) != q20(m->e[j].key[d])) same = 0; + } + if (same) return 1; + } + } + return 0; +} + +static int remove_expert(Model *m, uint16_t victim, int adaptation_only) { + if (victim >= m->n) return 0; + if (adaptation_only && m->e[victim].lifecycle != 1u) return 0; + uint16_t last = (uint16_t)(m->n - 1u); + if (victim != last) m->e[victim] = m->e[last]; + memset(&m->e[last], 0, sizeof m->e[last]); + --m->n; + return 1; +} + +static int retire_adaptation_to(Model *m, uint16_t target, const Event *data, + uint32_t count, TrainMetric *tm) { + while (m->n > target) { + uint16_t victim = INVALID_EXPERT; + double lowest = DBL_MAX; + for (uint16_t j = 0; j < m->n; ++j) if (m->e[j].lifecycle == 1u) { + double utility = (double)m->e[j].count * 1e9 - + (double)m->e[j].errors * 1e12 - m->e[j].prediction_sse; + if (victim == INVALID_EXPERT || utility < lowest || + (utility == lowest && j > victim)) { + victim = j; + lowest = utility; + } + } + if (victim == INVALID_EXPERT || !remove_expert(m, victim, 1)) return 0; + ++tm->retired; + refine(m, data, count, 1u, 1, NULL, tm); + } + return 1; +} + +static int adapt_model(Model *m, const Event *base_train, const Event *adapt_train, + const VariantConfig *config, TrainMetric *tm) { + Event mix[ADAPT_TRAIN_N + REPLAY_N]; + uint32_t mix_n = ADAPT_TRAIN_N; + memcpy(mix, adapt_train, sizeof(Event) * ADAPT_TRAIN_N); + if (config->use_replay) { + for (uint32_t i = 0; i < REPLAY_N; ++i) { + mix[ADAPT_TRAIN_N + i] = base_train[(i * 4u) % BASE_TRAIN_N]; + } + mix_n += REPLAY_N; + } + if (config->recursive_births && + !add_adaptation_experts(m, adapt_train, ADAPT_TRAIN_N, config->random_births, tm)) { + return 0; + } + refine(m, mix, mix_n, 4u, config->routed, NULL, tm); + if (config->use_retirement && m->n > ADAPTED_E && + !retire_adaptation_to(m, ADAPTED_E, mix, mix_n, tm)) return 0; + ++m->epoch; + return 1; +} + +static uint16_t nearest_vector(const double vector[D], const Model *m) { + double best_d = DBL_MAX; + uint16_t best = INVALID_EXPERT; + for (uint16_t j = 0; j < m->n; ++j) { + double d = dist_vec(vector, m->e[j].key); + if (better(d, j, best_d, best)) { best_d = d; best = j; } + } + return best; +} + +static void compile_graph(Model *m) { + for (uint16_t j = 0; j < m->n; ++j) { + for (uint32_t action = 0; action < ACTIONS; ++action) { + m->next_graph[j][action] = nearest_vector(m->e[j].next[action], m); + } + } + for (uint16_t j = m->n; j < MAXE; ++j) { + for (uint32_t action = 0; action < ACTIONS; ++action) { + m->next_graph[j][action] = INVALID_EXPERT; + } + } +} + +static void canonicalize_model(Model *m) { + for (uint16_t j = 0; j < m->n; ++j) { + for (uint32_t d = 0; d < D; ++d) { + m->e[j].key[d] = from_q20(q20(m->e[j].key[d])); + m->e[j].decode[d] = from_q20(q20(m->e[j].decode[d])); + for (uint32_t a = 0; a < ACTIONS; ++a) { + m->e[j].next[a][d] = from_q20(q20(m->e[j].next[a][d])); + } + } + m->e[j].reconstruction_sse = from_q20(q20(m->e[j].reconstruction_sse)); + m->e[j].prediction_sse = from_q20(q20(m->e[j].prediction_sse)); + } + build_lattice(m); + for (uint32_t b = 0; b < CELLS; ++b) { + if (m->routing[b].excluded_lb != DBL_MAX) { + m->routing[b].excluded_lb = from_q20(q20(m->routing[b].excluded_lb)); + } + } + compile_graph(m); +} + +static Eval evaluate(const Model *m, const Event *data, uint32_t count, int routed) { + Eval out = {0}; + for (uint32_t i = 0; i < count; ++i) { + if (!event_valid(&data[i])) { ++out.rejected; continue; } + uint16_t got = routed + ? routed_nearest(data[i].x, m, &out.expert_evaluations, &out.certified) + : full_nearest(data[i].x, m, &out.expert_evaluations); + uint64_t oracle_evaluations = 0u; + uint16_t oracle = full_nearest(data[i].x, m, &oracle_evaluations); + if (got == INVALID_EXPERT || oracle == INVALID_EXPERT) { ++out.rejected; continue; } + if (got != oracle) ++out.exact_mismatches; + if (m->e[got].label == data[i].label) ++out.correct; + double predicted[D]; + int64_t reconstruction_quantized = 0; + int64_t prediction_quantized = 0; + for (uint32_t d = 0; d < D; ++d) { + double rv = (double)data[i].x[d] - m->e[got].decode[d]; + double pv = (double)data[i].nx[d] - m->e[got].next[data[i].action][d]; + out.reconstruction_sse += rv * rv; + out.prediction_sse += pv * pv; + reconstruction_quantized += q20(rv * rv); + prediction_quantized += q20(pv * pv); + predicted[d] = m->e[got].next[data[i].action][d]; + } + uint16_t predicted_next = nearest_vector(predicted, m); + uint64_t next_evaluations = 0u; + uint16_t observed_next = full_nearest(data[i].nx, m, &next_evaluations); + if (predicted_next == observed_next) ++out.transition_correct; + ++out.samples; + out.classification_checksum ^= mix64(((uint64_t)got << 48) ^ + ((uint64_t)m->e[got].label << 32) ^ i); + out.reconstruction_checksum ^= mix64((uint64_t)reconstruction_quantized ^ i); + out.prediction_checksum ^= mix64((uint64_t)prediction_quantized ^ ((uint64_t)i << 16)); + out.transition_checksum ^= mix64(((uint64_t)predicted_next << 32) ^ observed_next ^ i); + } + return out; +} + +static int plan_actions(const Model *m, uint16_t start, uint16_t goal, + uint8_t actions[PLAN_LIMIT], uint32_t *used, uint64_t *expansions) { + if (start >= m->n || goal >= m->n) return 0; + uint16_t queue[MAXE], parent[MAXE], parent_action[MAXE]; + uint8_t seen[MAXE] = {0}; + for (uint16_t i = 0; i < MAXE; ++i) { + parent[i] = INVALID_EXPERT; + parent_action[i] = INVALID_EXPERT; + } + uint16_t head = 0u, tail = 0u; + queue[tail++] = start; + seen[start] = 1u; + while (head < tail) { + uint16_t current = queue[head++]; + ++*expansions; + if (current == goal) break; + for (uint16_t action = 0; action < ACTIONS; ++action) { + uint16_t next = m->next_graph[current][action]; + if (next >= m->n) return 0; + if (!seen[next]) { + seen[next] = 1u; + parent[next] = current; + parent_action[next] = action; + queue[tail++] = next; + } + } + } + if (!seen[goal]) return 0; + uint8_t reverse[PLAN_LIMIT]; + uint32_t n = 0u; + uint16_t current = goal; + while (current != start && n < PLAN_LIMIT) { + reverse[n++] = (uint8_t)parent_action[current]; + current = parent[current]; + } + if (current != start) return 0; + for (uint32_t i = 0; i < n; ++i) actions[i] = reverse[n - i - 1u]; + *used = n; + return 1; +} + +static uint32_t optimal_world_path(const uint8_t transitions[STATES][ACTIONS], + uint8_t start, uint8_t goal) { + uint8_t queue[STATES], seen[STATES] = {0}; + uint16_t distance[STATES] = {0}; + uint16_t head = 0u, tail = 0u; + queue[tail++] = start; + seen[start] = 1u; + while (head < tail) { + uint8_t current = queue[head++]; + if (current == goal) return distance[current]; + for (uint32_t action = 0; action < ACTIONS; ++action) { + uint8_t next = transitions[current][action]; + if (!seen[next]) { + seen[next] = 1u; + distance[next] = (uint16_t)(distance[current] + 1u); + queue[tail++] = next; + } + } + } + return UINT32_MAX; +} + +static PlanMetric evaluate_planning(const Model *m, const World *world, + const TrialSpec *spec, uint64_t seed, int drift) { + PlanMetric out = {0}; + rng_state = seed; + const uint8_t (*transitions)[ACTIONS] = drift ? world->drift_next : world->base_next; + for (uint32_t i = 0; i < PLAN_N; ++i) { + uint8_t start_state = (uint8_t)(rng_u32() % STATES); + uint8_t goal_state = (uint8_t)(rng_u32() % STATES); + int16_t start_observation[D], goal_observation[D]; + make_observation(world, spec, start_state, drift, 0, start_observation); + make_observation(world, spec, goal_state, drift, 0, goal_observation); + uint64_t evaluations = 0u, certified = 0u; + uint16_t start_expert = routed_nearest(start_observation, m, &evaluations, &certified); + uint16_t goal_expert = routed_nearest(goal_observation, m, &evaluations, &certified); + uint8_t actions[PLAN_LIMIT]; + uint32_t used = 0u; + ++out.cases; + uint32_t optimal = optimal_world_path(transitions, start_state, goal_state); + if (optimal != UINT32_MAX) out.optimal_path_length += optimal; + if (!plan_actions(m, start_expert, goal_expert, actions, &used, &out.expansions)) { + ++out.graph_disconnection_failures; + continue; + } + ++out.path_found; + out.executed_path_length += used; + uint8_t current = start_state; + for (uint32_t step = 0; step < used; ++step) current = transitions[current][actions[step]]; + int16_t final_observation[D]; + make_observation(world, spec, current, drift, 0, final_observation); + uint16_t final_expert = routed_nearest(final_observation, m, &evaluations, &certified); + int exact = current == goal_state; + int expert_goal = final_expert == goal_expert; + if (exact) { + ++out.exact_state_targets; + if (optimal != UINT32_MAX && used >= optimal) out.path_length_regret += used - optimal; + } + if (expert_goal) ++out.goal_expert_targets; + if (!exact && expert_goal) ++out.state_aliasing_failures; + if (!exact && !expert_goal) ++out.transition_model_failures; + out.checksum ^= mix64(((uint64_t)start_state << 56) ^ ((uint64_t)goal_state << 48) ^ + ((uint64_t)current << 40) ^ ((uint64_t)start_expert << 24) ^ + ((uint64_t)goal_expert << 8) ^ used ^ i); + } + return out; +} + +static void bb_bytes(ByteBuffer *b, const uint8_t *data, size_t n) { + if (!b->ok || n > CHECKPOINT_MAX - b->len) { b->ok = 0; return; } + memcpy(b->data + b->len, data, n); + b->len += n; +} + +static void bb_u8(ByteBuffer *b, uint8_t v) { + bb_bytes(b, &v, 1u); +} + +static void bb_u16(ByteBuffer *b, uint16_t v) { + uint8_t bytes[2] = {(uint8_t)(v >> 8), (uint8_t)v}; + bb_bytes(b, bytes, sizeof bytes); +} + +static void bb_u32(ByteBuffer *b, uint32_t v) { + uint8_t bytes[4] = { + (uint8_t)(v >> 24), (uint8_t)(v >> 16), (uint8_t)(v >> 8), (uint8_t)v + }; + bb_bytes(b, bytes, sizeof bytes); +} + +static void bb_u64(ByteBuffer *b, uint64_t v) { + uint8_t bytes[8]; + for (uint32_t i = 0; i < 8u; ++i) bytes[7u - i] = (uint8_t)(v >> (i * 8u)); + bb_bytes(b, bytes, sizeof bytes); +} + +static void bb_i64(ByteBuffer *b, int64_t v) { + bb_u64(b, (uint64_t)v); +} + +static void br_bytes(ByteReader *r, uint8_t *out, size_t n) { + if (!r->ok || n > r->len - r->pos) { r->ok = 0; return; } + memcpy(out, r->data + r->pos, n); + r->pos += n; +} + +static uint8_t br_u8(ByteReader *r) { + uint8_t out = 0u; + br_bytes(r, &out, 1u); + return out; +} + +static uint16_t br_u16(ByteReader *r) { + uint8_t bytes[2] = {0}; + br_bytes(r, bytes, sizeof bytes); + return (uint16_t)(((uint16_t)bytes[0] << 8) | bytes[1]); +} + +static uint32_t br_u32(ByteReader *r) { + uint8_t bytes[4] = {0}; + br_bytes(r, bytes, sizeof bytes); + return ((uint32_t)bytes[0] << 24) | ((uint32_t)bytes[1] << 16) | + ((uint32_t)bytes[2] << 8) | bytes[3]; +} + +static uint64_t br_u64(ByteReader *r) { + uint8_t bytes[8] = {0}; + br_bytes(r, bytes, sizeof bytes); + uint64_t out = 0u; + for (uint32_t i = 0; i < 8u; ++i) out = (out << 8) | bytes[i]; + return out; +} + +static int64_t br_i64(ByteReader *r) { + return (int64_t)br_u64(r); +} + +static int serialize_checkpoint(const Model *m, ByteBuffer *checkpoint) { + static const uint8_t magic[8] = {'R', 'A', 'V', 'E', 'L', '0', '4', 0}; + if (m == NULL || m->n == 0u || m->n > MAXE) return 0; + ByteBuffer payload = {{0}, 0u, 1}; + bb_u16(&payload, m->n); + bb_u64(&payload, m->epoch); + for (uint16_t j = 0; j < m->n; ++j) { + const Expert *e = &m->e[j]; + bb_u16(&payload, j); + bb_u8(&payload, e->active); + bb_u8(&payload, e->lifecycle); + bb_u16(&payload, e->generation); + bb_u8(&payload, e->label); + bb_u64(&payload, e->lineage); + for (uint32_t d = 0; d < D; ++d) bb_i64(&payload, q20(e->key[d])); + for (uint32_t d = 0; d < D; ++d) bb_i64(&payload, q20(e->decode[d])); + for (uint32_t a = 0; a < ACTIONS; ++a) { + for (uint32_t d = 0; d < D; ++d) bb_i64(&payload, q20(e->next[a][d])); + } + for (uint32_t y = 0; y < CLASSES; ++y) bb_u32(&payload, e->labels[y]); + for (uint32_t a = 0; a < ACTIONS; ++a) bb_u32(&payload, e->action_count[a]); + bb_u32(&payload, e->count); + bb_u32(&payload, e->errors); + bb_i64(&payload, q20(e->reconstruction_sse)); + bb_i64(&payload, q20(e->prediction_sse)); + } + for (uint16_t j = 0; j < m->n; ++j) { + bb_u16(&payload, j); + for (uint32_t a = 0; a < ACTIONS; ++a) bb_u16(&payload, m->next_graph[j][a]); + } + for (uint16_t cell = 0; cell < CELLS; ++cell) { + bb_u16(&payload, cell); + for (uint32_t i = 0; i < ROUTE_K; ++i) bb_u16(&payload, m->routing[cell].id[i]); + int64_t lower = m->routing[cell].excluded_lb == DBL_MAX + ? INT64_MAX : q20(m->routing[cell].excluded_lb); + bb_i64(&payload, lower); + } + if (!payload.ok || payload.len > UINT32_MAX) return 0; + uint8_t digest[32]; + sha256_bytes(payload.data, payload.len, digest); + *checkpoint = (ByteBuffer){{0}, 0u, 1}; + bb_bytes(checkpoint, magic, sizeof magic); + bb_u16(checkpoint, CHECKPOINT_SCHEMA); + bb_u16(checkpoint, D); + bb_u16(checkpoint, CLASSES); + bb_u16(checkpoint, ACTIONS); + bb_u16(checkpoint, STATES); + bb_u16(checkpoint, MAXE); + bb_u16(checkpoint, ROUTE_K); + bb_u16(checkpoint, CELLS); + bb_u32(checkpoint, UINT32_C(0x01020304)); + bb_u32(checkpoint, (uint32_t)payload.len); + bb_bytes(checkpoint, digest, sizeof digest); + if (checkpoint->len != CHECKPOINT_HEADER) return 0; + bb_bytes(checkpoint, payload.data, payload.len); + return checkpoint->ok; +} + +static int deserialize_checkpoint(const uint8_t *bytes, size_t size, Model *out) { + static const uint8_t magic[8] = {'R', 'A', 'V', 'E', 'L', '0', '4', 0}; + if (bytes == NULL || out == NULL || size < CHECKPOINT_HEADER || size > CHECKPOINT_MAX) return 0; + ByteReader header = {bytes, size, 0u, 1}; + uint8_t got_magic[8], expected_digest[32], actual_digest[32]; + br_bytes(&header, got_magic, sizeof got_magic); + uint16_t schema = br_u16(&header); + uint16_t dimensions = br_u16(&header); + uint16_t classes = br_u16(&header); + uint16_t actions = br_u16(&header); + uint16_t states = br_u16(&header); + uint16_t maximum = br_u16(&header); + uint16_t route_width = br_u16(&header); + uint16_t cells = br_u16(&header); + uint32_t byte_order = br_u32(&header); + uint32_t payload_length = br_u32(&header); + br_bytes(&header, expected_digest, sizeof expected_digest); + if (!header.ok || header.pos != CHECKPOINT_HEADER || + memcmp(got_magic, magic, sizeof magic) != 0 || + schema != CHECKPOINT_SCHEMA || dimensions != D || classes != CLASSES || + actions != ACTIONS || states != STATES || maximum != MAXE || + route_width != ROUTE_K || cells != CELLS || + byte_order != UINT32_C(0x01020304) || + payload_length > CHECKPOINT_MAX - CHECKPOINT_HEADER || + size != CHECKPOINT_HEADER + (size_t)payload_length) return 0; + sha256_bytes(bytes + CHECKPOINT_HEADER, payload_length, actual_digest); + if (memcmp(expected_digest, actual_digest, sizeof expected_digest) != 0) return 0; + ByteReader payload = { + bytes + CHECKPOINT_HEADER, payload_length, 0u, 1 + }; + Model model; + memset(&model, 0, sizeof model); + model.n = br_u16(&payload); + model.epoch = br_u64(&payload); + if (!payload.ok || model.n == 0u || model.n > MAXE) return 0; + for (uint16_t j = 0; j < model.n; ++j) { + Expert *e = &model.e[j]; + if (br_u16(&payload) != j) return 0; + e->active = br_u8(&payload); + e->lifecycle = br_u8(&payload); + e->generation = br_u16(&payload); + e->label = br_u8(&payload); + e->lineage = br_u64(&payload); + for (uint32_t d = 0; d < D; ++d) e->key[d] = from_q20(br_i64(&payload)); + for (uint32_t d = 0; d < D; ++d) e->decode[d] = from_q20(br_i64(&payload)); + for (uint32_t a = 0; a < ACTIONS; ++a) { + for (uint32_t d = 0; d < D; ++d) e->next[a][d] = from_q20(br_i64(&payload)); + } + for (uint32_t y = 0; y < CLASSES; ++y) e->labels[y] = br_u32(&payload); + for (uint32_t a = 0; a < ACTIONS; ++a) e->action_count[a] = br_u32(&payload); + e->count = br_u32(&payload); + e->errors = br_u32(&payload); + e->reconstruction_sse = from_q20(br_i64(&payload)); + e->prediction_sse = from_q20(br_i64(&payload)); + if (!payload.ok || e->active != 1u || e->lifecycle > 1u || + e->label >= CLASSES || e->lineage == 0u || e->errors > e->count) return 0; + } + for (uint16_t j = 0; j < model.n; ++j) { + if (br_u16(&payload) != j) return 0; + for (uint32_t a = 0; a < ACTIONS; ++a) { + model.next_graph[j][a] = br_u16(&payload); + if (model.next_graph[j][a] >= model.n) return 0; + } + } + uint16_t take = model.n < ROUTE_K ? model.n : ROUTE_K; + for (uint16_t cell = 0; cell < CELLS; ++cell) { + if (br_u16(&payload) != cell) return 0; + for (uint16_t i = 0; i < ROUTE_K; ++i) { + uint16_t id = br_u16(&payload); + model.routing[cell].id[i] = id; + if ((i < take && id >= model.n) || (i >= take && id != INVALID_EXPERT)) return 0; + for (uint16_t k = 0; k < i; ++k) if (model.routing[cell].id[k] == id) return 0; + } + int64_t lower = br_i64(&payload); + model.routing[cell].excluded_lb = lower == INT64_MAX ? DBL_MAX : from_q20(lower); + if (model.n > ROUTE_K && lower == INT64_MAX) return 0; + if (model.n <= ROUTE_K && lower != INT64_MAX) return 0; + } + if (!payload.ok || payload.pos != payload.len) return 0; + memcpy(model.identity, expected_digest, sizeof model.identity); + *out = model; + return 1; +} + +static int checkpoint_file_roundtrip(Model *model, Model *restored, size_t *checkpoint_size) { + const char *path = "ravel-0.4-checkpoint.bin"; + ByteBuffer checkpoint; + if (!serialize_checkpoint(model, &checkpoint)) return 0; + memcpy(model->identity, checkpoint.data + 32u, sizeof model->identity); + FILE *file = fopen(path, "wb"); + if (file == NULL) return 0; + size_t wrote = fwrite(checkpoint.data, 1u, checkpoint.len, file); + int ok = wrote == checkpoint.len && fclose(file) == 0; + if (!ok) { remove(path); return 0; } + file = fopen(path, "rb"); + if (file == NULL) { remove(path); return 0; } + uint8_t bytes[CHECKPOINT_MAX + 1u]; + size_t read = fread(bytes, 1u, sizeof bytes, file); + int read_ok = !ferror(file) && fclose(file) == 0; + remove(path); + if (!read_ok || read > CHECKPOINT_MAX || + !deserialize_checkpoint(bytes, read, restored)) return 0; + *checkpoint_size = checkpoint.len; + return 1; +} + +static int eval_equal(const Eval *a, const Eval *b) { + return a->samples == b->samples && a->rejected == b->rejected && + a->correct == b->correct && a->exact_mismatches == b->exact_mismatches && + a->certified == b->certified && + a->expert_evaluations == b->expert_evaluations && + a->reconstruction_sse == b->reconstruction_sse && + a->prediction_sse == b->prediction_sse && + a->transition_correct == b->transition_correct && + a->classification_checksum == b->classification_checksum && + a->reconstruction_checksum == b->reconstruction_checksum && + a->prediction_checksum == b->prediction_checksum && + a->transition_checksum == b->transition_checksum; +} + +static int plan_equal(const PlanMetric *a, const PlanMetric *b) { + return memcmp(a, b, sizeof *a) == 0; +} + +static void behavior_digest(const Model *m, const Eval *evaluation, + const PlanMetric *planning, uint8_t out[32]) { + ByteBuffer b = {{0}, 0u, 1}; + bb_bytes(&b, m->identity, sizeof m->identity); + bb_u64(&b, evaluation->samples); + bb_u64(&b, evaluation->rejected); + bb_u64(&b, evaluation->correct); + bb_u64(&b, evaluation->exact_mismatches); + bb_u64(&b, evaluation->certified); + bb_u64(&b, evaluation->expert_evaluations); + bb_i64(&b, q20(evaluation->reconstruction_sse)); + bb_i64(&b, q20(evaluation->prediction_sse)); + bb_u64(&b, evaluation->transition_correct); + bb_u64(&b, evaluation->classification_checksum); + bb_u64(&b, evaluation->reconstruction_checksum); + bb_u64(&b, evaluation->prediction_checksum); + bb_u64(&b, evaluation->transition_checksum); + bb_u64(&b, planning->cases); + bb_u64(&b, planning->path_found); + bb_u64(&b, planning->exact_state_targets); + bb_u64(&b, planning->goal_expert_targets); + bb_u64(&b, planning->executed_path_length); + bb_u64(&b, planning->optimal_path_length); + bb_u64(&b, planning->path_length_regret); + bb_u64(&b, planning->graph_disconnection_failures); + bb_u64(&b, planning->transition_model_failures); + bb_u64(&b, planning->state_aliasing_failures); + bb_u64(&b, planning->expansions); + bb_u64(&b, planning->checksum); + sha256_bytes(b.data, b.len, out); +} + +static int checkpoint_equivalent(const Model *expected, const Model *restored, + const Eval *expected_eval, const Eval *restored_eval, + const PlanMetric *expected_plan, + const PlanMetric *restored_plan) { + uint8_t expected_behavior[32], restored_behavior[32]; + behavior_digest(expected, expected_eval, expected_plan, expected_behavior); + behavior_digest(restored, restored_eval, restored_plan, restored_behavior); + return memcmp(expected->identity, restored->identity, 32u) == 0 && + eval_equal(expected_eval, restored_eval) && + plan_equal(expected_plan, restored_plan) && + memcmp(expected_behavior, restored_behavior, 32u) == 0; +} + +static int valid_model_mutation_detected(const Model *original, const Model *mutated) { + ByteBuffer checkpoint; + Model restored; + if (!serialize_checkpoint(mutated, &checkpoint) || + !deserialize_checkpoint(checkpoint.data, checkpoint.len, &restored)) return 0; + return memcmp(original->identity, restored.identity, sizeof original->identity) != 0; +} + +typedef struct { + int retrieval_key; + int reconstruction; + int next_observation; + int label; + int label_count; + int lineage; + int transition_graph; + int payload_byte; + int truncation; + int appended_byte; + int schema_version; + int checkpoint_substitution; +} MutationResult; + +static MutationResult checkpoint_mutations(const Model *original) { + MutationResult result = {0}; + Model mutated = *original; + mutated.e[0].key[0] += from_q20(1); + result.retrieval_key = valid_model_mutation_detected(original, &mutated); + mutated = *original; + mutated.e[0].decode[0] += from_q20(1); + result.reconstruction = valid_model_mutation_detected(original, &mutated); + mutated = *original; + mutated.e[0].next[0][0] += from_q20(1); + result.next_observation = valid_model_mutation_detected(original, &mutated); + mutated = *original; + mutated.e[0].label = (uint8_t)((mutated.e[0].label + 1u) % CLASSES); + result.label = valid_model_mutation_detected(original, &mutated); + mutated = *original; + ++mutated.e[0].labels[0]; + result.label_count = valid_model_mutation_detected(original, &mutated); + mutated = *original; + mutated.e[0].lineage ^= UINT64_C(0x1); + result.lineage = valid_model_mutation_detected(original, &mutated); + mutated = *original; + mutated.next_graph[0][0] = (uint16_t)((mutated.next_graph[0][0] + 1u) % mutated.n); + result.transition_graph = valid_model_mutation_detected(original, &mutated); + + ByteBuffer checkpoint; + if (serialize_checkpoint(original, &checkpoint)) { + ByteBuffer corrupt = checkpoint; + corrupt.data[CHECKPOINT_HEADER + 3u] ^= 0x01u; + Model restored; + result.payload_byte = !deserialize_checkpoint(corrupt.data, corrupt.len, &restored); + result.truncation = !deserialize_checkpoint(checkpoint.data, checkpoint.len - 1u, &restored); + corrupt = checkpoint; + corrupt.data[corrupt.len++] = 0u; + result.appended_byte = !deserialize_checkpoint(corrupt.data, corrupt.len, &restored); + corrupt = checkpoint; + corrupt.data[8] = 0u; + corrupt.data[9] = (uint8_t)(CHECKPOINT_SCHEMA + 1u); + result.schema_version = !deserialize_checkpoint(corrupt.data, corrupt.len, &restored); + mutated = *original; + mutated.epoch += 1u; + ByteBuffer substitute; + if (serialize_checkpoint(&mutated, &substitute) && + deserialize_checkpoint(substitute.data, substitute.len, &restored)) { + result.checkpoint_substitution = + memcmp(original->identity, restored.identity, sizeof original->identity) != 0; + } + } + return result; +} + +static int mutation_result_pass(const MutationResult *m) { + return m->retrieval_key && m->reconstruction && m->next_observation && + m->label && m->label_count && m->lineage && m->transition_graph && + m->payload_byte && m->truncation && m->appended_byte && + m->schema_version && m->checkpoint_substitution; +} + +typedef struct { + int sibling_generation_equality; + int parent_child_increment; + int lineage_uniqueness; + int repeated_descendant_increment; + int no_lineage_reuse; + int deterministic_topology; +} LineageResult; + +static LineageResult lineage_invariants(const Event *data) { + LineageResult result = {0}; + Model model; + memset(&model, 0, sizeof model); + model.n = 1u; + seed_expert(&model.e[0], &data[0], mix64(UINT64_C(0x1122334455667788)), 4u, 0u); + uint16_t assignments[BASE_TRAIN_N]; + for (uint32_t i = 0; i < BASE_TRAIN_N; ++i) assignments[i] = 0u; + uint16_t original_generation = model.e[0].generation; + int first_split = split_one(&model, 0u, 1u, data, BASE_TRAIN_N, assignments, 17u); + if (first_split) { + model.n = 2u; + result.sibling_generation_equality = + model.e[0].generation == model.e[1].generation; + result.parent_child_increment = + model.e[0].generation == (uint16_t)(original_generation + 1u); + result.lineage_uniqueness = model.e[0].lineage != model.e[1].lineage; + for (uint32_t i = 0; i < BASE_TRAIN_N; ++i) assignments[i] = 1u; + uint16_t descendant_generation = model.e[1].generation; + if (split_one(&model, 1u, 2u, data, BASE_TRAIN_N, assignments, 18u)) { + model.n = 3u; + result.repeated_descendant_increment = + model.e[1].generation == (uint16_t)(descendant_generation + 1u) && + model.e[2].generation == model.e[1].generation; + result.no_lineage_reuse = 1; + for (uint16_t i = 0; i < model.n; ++i) { + for (uint16_t j = (uint16_t)(i + 1u); j < model.n; ++j) { + if (model.e[i].lineage == model.e[j].lineage) result.no_lineage_reuse = 0; + } + } + } + } + Model first, second; + TrainMetric first_tm = {0}, second_tm = {0}; + train_recursive(&first, data, BASE_TRAIN_N, &first_tm); + train_recursive(&second, data, BASE_TRAIN_N, &second_tm); + canonicalize_model(&first); + canonicalize_model(&second); + ByteBuffer first_checkpoint, second_checkpoint; + if (serialize_checkpoint(&first, &first_checkpoint) && + serialize_checkpoint(&second, &second_checkpoint)) { + result.deterministic_topology = + first_checkpoint.len == second_checkpoint.len && + memcmp(first_checkpoint.data, second_checkpoint.data, first_checkpoint.len) == 0; + } + return result; +} + +static int lineage_result_pass(const LineageResult *r) { + return r->sibling_generation_equality && r->parent_child_increment && + r->lineage_uniqueness && r->repeated_descendant_increment && + r->no_lineage_reuse && r->deterministic_topology; +} + +typedef struct { + int malformed_observation_rejected; + int out_of_domain_fallback; + int empty_assignment_rejected; + int degenerate_assignment_rejected; + int duplicate_expert_rejected; + int tied_distance_lower_id; + int lower_bound_equality_fallback; + int maximum_capacity_preserved; + int birth_beyond_capacity_rejected; + int wrong_lifecycle_retirement_rejected; + int poisoned_labels_fail_gate; + int poisoned_transitions_fail_gate; + int replay_removal_fail_gate; + int catastrophic_forgetting_fail_gate; +} NegativeResult; + +static double eval_accuracy(const Eval *e) { + return e->samples == 0u ? 0.0 : (double)e->correct / (double)e->samples; +} + +static double reconstruction_rmse(const Eval *e) { + return e->samples == 0u ? DBL_MAX : sqrt(e->reconstruction_sse / (double)(e->samples * D)); +} + +static double prediction_rmse(const Eval *e) { + return e->samples == 0u ? DBL_MAX : sqrt(e->prediction_sse / (double)(e->samples * D)); +} + +static NegativeResult run_negative_tests(const Model *base, const Event *base_train, + const Event *retention, const Event *adapt_train, + const Event *drift_hold) { + NegativeResult result = {0}; + Event malformed = adapt_train[0]; + malformed.action = ACTIONS; + result.malformed_observation_rejected = !event_valid(&malformed); + + int16_t out_of_domain[D] = {100, 0, 0, 0, 0, 0, 0, 0}; + uint64_t evaluations = 0u, certified = 0u; + uint16_t fallback = routed_nearest(out_of_domain, base, &evaluations, &certified); + result.out_of_domain_fallback = + fallback != INVALID_EXPERT && certified == 0u && evaluations == base->n; + + Model empty; + memset(&empty, 0, sizeof empty); + evaluations = 0u; + result.empty_assignment_rejected = + full_nearest(base_train[0].x, &empty, &evaluations) == INVALID_EXPERT; + + Model degenerate; + memset(°enerate, 0, sizeof degenerate); + degenerate.n = 1u; + seed_expert(°enerate.e[0], &base_train[0], mix64(1u), 0u, 0u); + Event identical[2] = {base_train[0], base_train[0]}; + uint16_t assignments[2] = {0u, 0u}; + result.degenerate_assignment_rejected = + !split_one(°enerate, 0u, 1u, identical, 2u, assignments, 0u); + + Model duplicate = *base; + duplicate.e[1] = duplicate.e[0]; + result.duplicate_expert_rejected = duplicate_experts(&duplicate); + + Model tie; + memset(&tie, 0, sizeof tie); + tie.n = 2u; + seed_expert(&tie.e[0], &base_train[0], mix64(2u), 0u, 0u); + tie.e[1] = tie.e[0]; + tie.e[1].lineage = mix64(3u); + evaluations = 0u; + result.tied_distance_lower_id = + full_nearest(base_train[0].x, &tie, &evaluations) == 0u; + + Model equality = *base; + int in_domain = 0; + uint16_t cell = cell_id(base_train[0].x, &in_domain); + double routed_best = DBL_MAX; + for (uint16_t i = 0; i < ROUTE_K; ++i) { + uint16_t candidate = equality.routing[cell].id[i]; + double distance = dist_x(base_train[0].x, &equality.e[candidate]); + if (distance < routed_best) routed_best = distance; + } + equality.routing[cell].excluded_lb = routed_best; + evaluations = 0u; certified = 0u; + (void)routed_nearest(base_train[0].x, &equality, &evaluations, &certified); + result.lower_bound_equality_fallback = + in_domain && certified == 0u && evaluations == equality.n; + + Model capacity = *base; + while (capacity.n < MAXE) { + seed_expert(&capacity.e[capacity.n], &adapt_train[capacity.n % ADAPT_TRAIN_N], + mix64(UINT64_C(0x4341504143495459) ^ capacity.n), 1u, 1u); + ++capacity.n; + } + result.maximum_capacity_preserved = capacity.n == MAXE; + TrainMetric capacity_tm = {0}; + result.birth_beyond_capacity_rejected = + !add_adaptation_experts(&capacity, adapt_train, ADAPT_TRAIN_N, 0, &capacity_tm) && + capacity.n == MAXE; + + Model lifecycle = *base; + result.wrong_lifecycle_retirement_rejected = !remove_expert(&lifecycle, 0u, 1); + + Event poisoned_labels[ADAPT_TRAIN_N]; + Event poisoned_transitions[ADAPT_TRAIN_N]; + for (uint32_t i = 0; i < ADAPT_TRAIN_N; ++i) { + poisoned_labels[i] = base_train[i % BASE_TRAIN_N]; + poisoned_labels[i].label = (uint8_t)((poisoned_labels[i].label + 1u) % CLASSES); + poisoned_transitions[i] = adapt_train[i]; + for (uint32_t d = 0; d < D; ++d) { + poisoned_transitions[i].nx[d] = + clamp_domain(-(int)poisoned_transitions[i].nx[d]); + } + } + VariantConfig no_replay = {0u, 0u, 0u, 1u, 0u, 0u}; + Model label_model = *base; + TrainMetric label_tm = {0}; + int label_adapted = adapt_model(&label_model, base_train, poisoned_labels, &no_replay, &label_tm); + canonicalize_model(&label_model); + Eval label_retention = evaluate(&label_model, retention, RETENTION_N, 1); + result.poisoned_labels_fail_gate = + label_adapted && eval_accuracy(&label_retention) < 0.70; + result.replay_removal_fail_gate = result.poisoned_labels_fail_gate; + result.catastrophic_forgetting_fail_gate = result.poisoned_labels_fail_gate; + + Model transition_model = *base; + TrainMetric transition_tm = {0}; + int transition_adapted = + adapt_model(&transition_model, base_train, poisoned_transitions, &no_replay, &transition_tm); + canonicalize_model(&transition_model); + Eval transition_eval = evaluate(&transition_model, drift_hold, DRIFT_HOLD_N, 1); + result.poisoned_transitions_fail_gate = + transition_adapted && prediction_rmse(&transition_eval) > 24.0; + return result; +} + +static int negative_result_pass(const NegativeResult *r) { + return r->malformed_observation_rejected && r->out_of_domain_fallback && + r->empty_assignment_rejected && r->degenerate_assignment_rejected && + r->duplicate_expert_rejected && r->tied_distance_lower_id && + r->lower_bound_equality_fallback && r->maximum_capacity_preserved && + r->birth_beyond_capacity_rejected && + r->wrong_lifecycle_retirement_rejected && + r->poisoned_labels_fail_gate && r->poisoned_transitions_fail_gate && + r->replay_removal_fail_gate && r->catastrophic_forgetting_fail_gate; +} + +static void digest_hex(const uint8_t digest[32], char out[65]) { + static const char hex[] = "0123456789abcdef"; + for (uint32_t i = 0; i < 32u; ++i) { + out[i * 2u] = hex[digest[i] >> 4]; + out[i * 2u + 1u] = hex[digest[i] & 15u]; + } + out[64] = '\0'; +} + +static void train_flat(Model *m, uint16_t experts, const Event *base_train, + TrainMetric *tm, int routed) { + init_farthest(m, experts, base_train, BASE_TRAIN_N, tm); + refine(m, base_train, BASE_TRAIN_N, 4u, routed, NULL, tm); + ++m->epoch; + canonicalize_model(m); +} + +static size_t model_checkpoint_size(Model *m) { + ByteBuffer checkpoint; + if (!serialize_checkpoint(m, &checkpoint)) return 0u; + memcpy(m->identity, checkpoint.data + 32u, sizeof m->identity); + return checkpoint.len; +} + +static void print_eval_json(const Eval *e) { + printf("{\"samples\":%" PRIu64 ",\"rejected\":%" PRIu64 + ",\"accuracy\":%.9f,\"reconstruction_rmse\":%.9f" + ",\"next_observation_prediction_rmse\":%.9f" + ",\"transition_accuracy\":%.9f,\"routing_certification_count\":%" PRIu64 + ",\"complete_oracle_agreement\":%" PRIu64 + ",\"routed_complete_mismatches\":%" PRIu64 + ",\"expert_evaluations\":%" PRIu64 + ",\"classification_checksum\":\"%016" PRIx64 "\"" + ",\"reconstruction_checksum\":\"%016" PRIx64 "\"" + ",\"prediction_checksum\":\"%016" PRIx64 "\"" + ",\"transition_checksum\":\"%016" PRIx64 "\"}", + e->samples, e->rejected, eval_accuracy(e), reconstruction_rmse(e), + prediction_rmse(e), + e->samples == 0u ? 0.0 : (double)e->transition_correct / (double)e->samples, + e->certified, e->samples - e->exact_mismatches, e->exact_mismatches, + e->expert_evaluations, e->classification_checksum, + e->reconstruction_checksum, e->prediction_checksum, e->transition_checksum); +} + +static void print_plan_json(const PlanMetric *p) { + printf("{\"cases\":%" PRIu64 ",\"path_found\":%" PRIu64 + ",\"exact_world_state_target_reached\":%" PRIu64 + ",\"goal_expert_reached\":%" PRIu64 + ",\"executed_path_length\":%" PRIu64 + ",\"optimal_path_length\":%" PRIu64 + ",\"path_length_regret\":%" PRIu64 + ",\"graph_disconnection_failures\":%" PRIu64 + ",\"transition_model_error_failures\":%" PRIu64 + ",\"state_aliasing_failures\":%" PRIu64 + ",\"expansions\":%" PRIu64 ",\"checksum\":\"%016" PRIx64 "\"}", + p->cases, p->path_found, p->exact_state_targets, p->goal_expert_targets, + p->executed_path_length, p->optimal_path_length, p->path_length_regret, + p->graph_disconnection_failures, p->transition_model_failures, + p->state_aliasing_failures, p->expansions, p->checksum); +} + +static void print_variant_json(const char *name, Model *m, const Eval *drift, + const Eval *retention, const PlanMetric *planning, + uint64_t training_evaluations, int comma) { + size_t checkpoint_size = model_checkpoint_size(m); + printf(" \"%s\":{\"expert_count\":%u,\"training_evaluations\":%" PRIu64 + ",\"drift_holdout_accuracy\":%.9f,\"retention_accuracy\":%.9f" + ",\"reconstruction_rmse\":%.9f,\"prediction_rmse\":%.9f" + ",\"planning_exact_state_rate\":%.9f" + ",\"expert_evaluations\":%" PRIu64 ",\"checkpoint_size_bytes\":%zu" + ",\"runtime_observation_non_normative\":{\"status\":\"UNKNOWN\"," + "\"reason\":\"excluded_from_canonical_deterministic_evidence\"}}%s\n", + name, m->n, training_evaluations, eval_accuracy(drift), eval_accuracy(retention), + reconstruction_rmse(drift), prediction_rmse(drift), + planning->cases == 0u ? 0.0 : + (double)planning->exact_state_targets / (double)planning->cases, + drift->expert_evaluations, checkpoint_size, comma ? "," : ""); +} + +static void print_mutations_json(const MutationResult *m) { + printf("{\"retrieval_key_component\":%s,\"reconstruction_component\":%s," + "\"next_observation_component\":%s,\"label\":%s,\"label_count\":%s," + "\"lineage\":%s,\"transition_graph_edge\":%s,\"payload_byte\":%s," + "\"checkpoint_truncation\":%s,\"appended_unexpected_byte\":%s," + "\"incorrect_schema_version\":%s,\"checkpoint_substitution\":%s}", + m->retrieval_key ? "true" : "false", + m->reconstruction ? "true" : "false", + m->next_observation ? "true" : "false", + m->label ? "true" : "false", + m->label_count ? "true" : "false", + m->lineage ? "true" : "false", + m->transition_graph ? "true" : "false", + m->payload_byte ? "true" : "false", + m->truncation ? "true" : "false", + m->appended_byte ? "true" : "false", + m->schema_version ? "true" : "false", + m->checkpoint_substitution ? "true" : "false"); +} + +static void print_lineage_json(const LineageResult *r) { + printf("{\"sibling_generation_equality\":%s,\"parent_child_generation_increment\":%s," + "\"lineage_uniqueness\":%s,\"repeated_descendant_splitting\":%s," + "\"no_accidental_lineage_reuse\":%s,\"deterministic_topology_reproduction\":%s}", + r->sibling_generation_equality ? "true" : "false", + r->parent_child_increment ? "true" : "false", + r->lineage_uniqueness ? "true" : "false", + r->repeated_descendant_increment ? "true" : "false", + r->no_lineage_reuse ? "true" : "false", + r->deterministic_topology ? "true" : "false"); +} + +static void print_negative_case(const char *id, const char *expected, int observed, int comma) { + printf(" \"%s\":{\"expected_disposition\":\"%s\",\"observed\":%s,\"pass\":%s}%s\n", + id, expected, observed ? "true" : "false", observed ? "true" : "false", + comma ? "," : ""); +} + +int main(void) { + int all_trials_pass = 1; + int execution_integrity = 1; + uint32_t passing_trials = 0u, failing_trials = 0u; + NegativeResult negative = {0}; + LineageResult lineage = {0}; + int have_global_tests = 0; + + printf("{\n \"schema\":\"ravel-raw-observations/0.4\",\n"); + printf(" \"preregistration\":\"ravel-0.4-preregistration.json\",\n"); + printf(" \"checkpoint_format\":{\"magic\":\"RAVEL04\\\\u0000\",\"schema_version\":%u," + "\"byte_order\":\"big_endian\",\"real_encoding\":\"signed_q20_int64\"," + "\"payload_digest\":\"sha256\",\"maximum_bytes\":%u},\n", + CHECKPOINT_SCHEMA, CHECKPOINT_MAX); + printf(" \"trials\":[\n"); + + for (uint32_t trial = 0; trial < TRIALS; ++trial) { + const TrialSpec *spec = &trial_specs[trial]; + World world; + Event base_train[BASE_TRAIN_N], base_hold[BASE_HOLD_N]; + Event adapt_train[ADAPT_TRAIN_N], drift_hold[DRIFT_HOLD_N]; + Event retention[RETENTION_N]; + make_world(&world, spec); + uint64_t base_train_seed = mix64(spec->seed ^ UINT64_C(0x4241534554524149)); + uint64_t base_hold_seed = mix64(spec->seed ^ UINT64_C(0x42415345484f4c44)); + uint64_t adapt_train_seed = mix64(spec->seed ^ UINT64_C(0x414441505454524e)); + uint64_t drift_hold_seed = mix64(spec->seed ^ UINT64_C(0x4452494654484f4c)); + uint64_t retention_seed = mix64(spec->seed ^ UINT64_C(0x524554454e54494f)); + uint64_t planning_seed = mix64(spec->seed ^ UINT64_C(0x504c414e43415345)); + make_dataset(&world, spec, base_train, BASE_TRAIN_N, base_train_seed, 0); + make_dataset(&world, spec, base_hold, BASE_HOLD_N, base_hold_seed, 0); + make_dataset(&world, spec, adapt_train, ADAPT_TRAIN_N, adapt_train_seed, 1); + make_dataset(&world, spec, drift_hold, DRIFT_HOLD_N, drift_hold_seed, 1); + make_dataset(&world, spec, retention, RETENTION_N, retention_seed, 0); + + Model base; + TrainMetric base_tm = {0}; + train_recursive(&base, base_train, BASE_TRAIN_N, &base_tm); + canonicalize_model(&base); + (void)model_checkpoint_size(&base); + Eval base_hold_eval = evaluate(&base, base_hold, BASE_HOLD_N, 1); + Eval static_drift_eval = evaluate(&base, drift_hold, DRIFT_HOLD_N, 1); + + Model adapted = base; + TrainMetric adapt_tm = {0}; + VariantConfig candidate_config = {0u, 1u, 1u, 1u, 1u, 0u}; + int adaptation_ok = + adapt_model(&adapted, base_train, adapt_train, &candidate_config, &adapt_tm); + canonicalize_model(&adapted); + Model restored; + size_t checkpoint_size = 0u; + int checkpoint_ok = + adaptation_ok && checkpoint_file_roundtrip(&adapted, &restored, &checkpoint_size); + Eval adaptation_training_eval = evaluate(&adapted, adapt_train, ADAPT_TRAIN_N, 1); + Eval adapted_drift_eval = evaluate(&adapted, drift_hold, DRIFT_HOLD_N, 1); + Eval retention_eval = evaluate(&adapted, retention, RETENTION_N, 1); + PlanMetric adapted_plan = + evaluate_planning(&adapted, &world, spec, planning_seed, 1); + Eval restored_adaptation_training = checkpoint_ok + ? evaluate(&restored, adapt_train, ADAPT_TRAIN_N, 1) : (Eval){0}; + Eval restored_drift = checkpoint_ok + ? evaluate(&restored, drift_hold, DRIFT_HOLD_N, 1) : (Eval){0}; + Eval restored_retention = checkpoint_ok + ? evaluate(&restored, retention, RETENTION_N, 1) : (Eval){0}; + PlanMetric restored_plan = checkpoint_ok + ? evaluate_planning(&restored, &world, spec, planning_seed, 1) : (PlanMetric){0}; + int checkpoint_identity = + checkpoint_ok && memcmp(adapted.identity, restored.identity, 32u) == 0; + int checkpoint_adaptation_training = + checkpoint_ok && eval_equal(&adaptation_training_eval, + &restored_adaptation_training); + int checkpoint_drift = + checkpoint_ok && eval_equal(&adapted_drift_eval, &restored_drift); + int checkpoint_retention = + checkpoint_ok && eval_equal(&retention_eval, &restored_retention); + int checkpoint_planning = + checkpoint_ok && plan_equal(&adapted_plan, &restored_plan); + int checkpoint_behavior = + checkpoint_ok && + checkpoint_equivalent(&adapted, &restored, &adapted_drift_eval, + &restored_drift, &adapted_plan, &restored_plan) && + checkpoint_adaptation_training && checkpoint_retention; + MutationResult mutations = checkpoint_mutations(&adapted); + int mutations_pass = mutation_result_pass(&mutations); + + if (!have_global_tests) { + lineage = lineage_invariants(base_train); + negative = run_negative_tests(&base, base_train, retention, adapt_train, drift_hold); + have_global_tests = 1; + } + int lineage_pass = lineage_result_pass(&lineage); + + double base_accuracy = eval_accuracy(&base_hold_eval); + double adaptation_training_accuracy = eval_accuracy(&adaptation_training_eval); + double static_drift_accuracy = eval_accuracy(&static_drift_eval); + double adapted_drift_accuracy = eval_accuracy(&adapted_drift_eval); + double retention_accuracy = eval_accuracy(&retention_eval); + double base_reconstruction = reconstruction_rmse(&base_hold_eval); + double static_reconstruction = reconstruction_rmse(&static_drift_eval); + double adapted_reconstruction = reconstruction_rmse(&adapted_drift_eval); + double retention_reconstruction = reconstruction_rmse(&retention_eval); + double base_prediction = prediction_rmse(&base_hold_eval); + double static_prediction = prediction_rmse(&static_drift_eval); + double adapted_prediction = prediction_rmse(&adapted_drift_eval); + double retention_prediction = prediction_rmse(&retention_eval); + double exact_state_rate = (double)adapted_plan.exact_state_targets / adapted_plan.cases; + double path_found_rate = (double)adapted_plan.path_found / adapted_plan.cases; + int exact_routing = + base_hold_eval.exact_mismatches == 0u && + static_drift_eval.exact_mismatches == 0u && + adaptation_training_eval.exact_mismatches == 0u && + adapted_drift_eval.exact_mismatches == 0u && + retention_eval.exact_mismatches == 0u; + int trial_pass = + adapted.n == ADAPTED_E && + base_accuracy >= 0.75 && + adaptation_training_accuracy >= 0.70 && + adapted_drift_accuracy >= 0.70 && + adapted_drift_accuracy >= static_drift_accuracy + 0.05 && + retention_accuracy >= 0.70 && + exact_routing && + base_reconstruction <= 18.0 && + adapted_reconstruction <= 18.0 && + static_reconstruction - adapted_reconstruction >= 0.25 && + retention_reconstruction - base_reconstruction <= 4.0 && + base_prediction <= 24.0 && + adapted_prediction <= 24.0 && + static_prediction - adapted_prediction >= 0.25 && + retention_prediction - base_prediction <= 5.0 && + exact_state_rate >= 0.60 && + path_found_rate >= 0.70 && + checkpoint_identity && checkpoint_behavior && + mutations_pass && lineage_pass; + if (trial_pass) ++passing_trials; + else { ++failing_trials; all_trials_pass = 0; } + if (!checkpoint_ok || !checkpoint_identity || !checkpoint_behavior || + !mutations_pass || !lineage_pass) execution_integrity = 0; + + char model_identity[65], behavior_identity[65]; + uint8_t behavior[32]; + digest_hex(adapted.identity, model_identity); + behavior_digest(&adapted, &adapted_drift_eval, &adapted_plan, behavior); + digest_hex(behavior, behavior_identity); + + printf(" {\n \"trial_id\":\"%s\",\"regime\":\"%s\",\"seed\":\"0x%016" PRIx64 "\",\n", + spec->trial_id, spec->regime, spec->seed); + printf(" \"dataset_seeds\":{\"base_training\":\"0x%016" PRIx64 + "\",\"base_holdout\":\"0x%016" PRIx64 + "\",\"drift_adaptation_training\":\"0x%016" PRIx64 + "\",\"drift_holdout\":\"0x%016" PRIx64 + "\",\"original_task_retention_holdout\":\"0x%016" PRIx64 + "\",\"planning_cases\":\"0x%016" PRIx64 "\"},\n", + base_train_seed, base_hold_seed, adapt_train_seed, drift_hold_seed, + retention_seed, planning_seed); + printf(" \"candidate\":{\"expert_count\":%u,\"base_births\":%" PRIu64 + ",\"adaptation_births\":%" PRIu64 ",\"adaptation_retirements\":%" PRIu64 + ",\"training_evaluations\":%" PRIu64 ",\"checkpoint_size_bytes\":%zu," + "\"model_identity\":\"%s\",\"behavior_identity\":\"%s\",\n", + adapted.n, base_tm.births, adapt_tm.births, adapt_tm.retired, + base_tm.expert_evaluations + adapt_tm.expert_evaluations, + checkpoint_size, model_identity, behavior_identity); + printf(" \"base_holdout\":"); print_eval_json(&base_hold_eval); printf(",\n"); + printf(" \"adaptation_training\":"); print_eval_json(&adaptation_training_eval); printf(",\n"); + printf(" \"static_model_drift_holdout\":"); print_eval_json(&static_drift_eval); printf(",\n"); + printf(" \"adapted_model_drift_holdout\":"); print_eval_json(&adapted_drift_eval); printf(",\n"); + printf(" \"base_holdout_retention\":"); print_eval_json(&retention_eval); printf(",\n"); + printf(" \"planning\":"); print_plan_json(&adapted_plan); printf("},\n"); + printf(" \"checkpoint_verification\":{\"roundtrip\":%s,\"identity_match\":%s," + "\"adaptation_training_evaluation_match\":%s,\"drift_holdout_evaluation_match\":%s," + "\"retention_evaluation_match\":%s,\"planning_match\":%s," + "\"complete_behavior_match\":%s,\"mutations\":", + checkpoint_ok ? "true" : "false", checkpoint_identity ? "true" : "false", + checkpoint_adaptation_training ? "true" : "false", + checkpoint_drift ? "true" : "false", + checkpoint_retention ? "true" : "false", + checkpoint_planning ? "true" : "false", + checkpoint_behavior ? "true" : "false"); + print_mutations_json(&mutations); + printf("},\n \"lineage_invariants\":"); print_lineage_json(&lineage); printf(",\n"); + + printf(" \"comparisons\":{\n"); + Eval candidate_comparison_drift = adapted_drift_eval; + Eval candidate_comparison_retention = retention_eval; + print_variant_json("ravel_0_4_candidate", &adapted, &candidate_comparison_drift, + &candidate_comparison_retention, &adapted_plan, + base_tm.expert_evaluations + adapt_tm.expert_evaluations, 1); + + Model fixed8; + TrainMetric fixed8_tm = {0}; + train_flat(&fixed8, 8u, base_train, &fixed8_tm, 0); + Eval fixed8_drift = evaluate(&fixed8, drift_hold, DRIFT_HOLD_N, 0); + Eval fixed8_retention = evaluate(&fixed8, retention, RETENTION_N, 0); + PlanMetric fixed8_plan = evaluate_planning(&fixed8, &world, spec, planning_seed, 1); + print_variant_json("fixed_8_expert", &fixed8, &fixed8_drift, &fixed8_retention, + &fixed8_plan, fixed8_tm.expert_evaluations, 1); + + Model flat64; + TrainMetric flat64_tm = {0}; + train_flat(&flat64, 64u, base_train, &flat64_tm, 0); + Eval flat64_drift = evaluate(&flat64, drift_hold, DRIFT_HOLD_N, 0); + Eval flat64_retention = evaluate(&flat64, retention, RETENTION_N, 0); + PlanMetric flat64_plan = evaluate_planning(&flat64, &world, spec, planning_seed, 1); + print_variant_json("flat_64_expert_complete_scan", &flat64, &flat64_drift, + &flat64_retention, &flat64_plan, flat64_tm.expert_evaluations, 1); + + Eval routed64_drift = evaluate(&flat64, drift_hold, DRIFT_HOLD_N, 1); + Eval routed64_retention = evaluate(&flat64, retention, RETENTION_N, 1); + print_variant_json("fixed_topology_64_expert_routed", &flat64, &routed64_drift, + &routed64_retention, &flat64_plan, flat64_tm.expert_evaluations, 1); + + Model centroid16; + TrainMetric centroid16_tm = {0}; + train_flat(¢roid16, 16u, base_train, ¢roid16_tm, 0); + Eval centroid16_drift = evaluate(¢roid16, drift_hold, DRIFT_HOLD_N, 0); + Eval centroid16_retention = evaluate(¢roid16, retention, RETENTION_N, 0); + PlanMetric centroid16_plan = + evaluate_planning(¢roid16, &world, spec, planning_seed, 1); + print_variant_json("nearest_centroid_16_no_recursive_births", ¢roid16, + ¢roid16_drift, ¢roid16_retention, ¢roid16_plan, + centroid16_tm.expert_evaluations, 1); + + PlanMetric static_plan = evaluate_planning(&base, &world, spec, planning_seed, 1); + Eval static_retention = evaluate(&base, retention, RETENTION_N, 1); + print_variant_json("no_adaptation_static", &base, &static_drift_eval, + &static_retention, &static_plan, base_tm.expert_evaluations, 1); + + Model no_replay_model = base; + TrainMetric no_replay_tm = {0}; + VariantConfig no_replay_config = {0u, 0u, 1u, 1u, 1u, 0u}; + (void)adapt_model(&no_replay_model, base_train, adapt_train, + &no_replay_config, &no_replay_tm); + canonicalize_model(&no_replay_model); + Eval no_replay_drift = evaluate(&no_replay_model, drift_hold, DRIFT_HOLD_N, 1); + Eval no_replay_retention = evaluate(&no_replay_model, retention, RETENTION_N, 1); + PlanMetric no_replay_plan = + evaluate_planning(&no_replay_model, &world, spec, planning_seed, 1); + print_variant_json("ravel_without_replay", &no_replay_model, &no_replay_drift, + &no_replay_retention, &no_replay_plan, + base_tm.expert_evaluations + no_replay_tm.expert_evaluations, 1); + + Model no_retirement_model = base; + TrainMetric no_retirement_tm = {0}; + VariantConfig no_retirement_config = {0u, 1u, 0u, 1u, 1u, 0u}; + (void)adapt_model(&no_retirement_model, base_train, adapt_train, + &no_retirement_config, &no_retirement_tm); + canonicalize_model(&no_retirement_model); + Eval no_retirement_drift = + evaluate(&no_retirement_model, drift_hold, DRIFT_HOLD_N, 1); + Eval no_retirement_retention = + evaluate(&no_retirement_model, retention, RETENTION_N, 1); + PlanMetric no_retirement_plan = + evaluate_planning(&no_retirement_model, &world, spec, planning_seed, 1); + print_variant_json("ravel_without_retirement", &no_retirement_model, + &no_retirement_drift, &no_retirement_retention, + &no_retirement_plan, + base_tm.expert_evaluations + no_retirement_tm.expert_evaluations, 1); + + Model complete_scan_model = base; + TrainMetric complete_scan_tm = {0}; + VariantConfig complete_scan_config = {0u, 1u, 1u, 0u, 1u, 0u}; + (void)adapt_model(&complete_scan_model, base_train, adapt_train, + &complete_scan_config, &complete_scan_tm); + canonicalize_model(&complete_scan_model); + Eval complete_scan_drift = + evaluate(&complete_scan_model, drift_hold, DRIFT_HOLD_N, 0); + Eval complete_scan_retention = + evaluate(&complete_scan_model, retention, RETENTION_N, 0); + PlanMetric complete_scan_plan = + evaluate_planning(&complete_scan_model, &world, spec, planning_seed, 1); + print_variant_json("ravel_complete_scan_without_certification", &complete_scan_model, + &complete_scan_drift, &complete_scan_retention, + &complete_scan_plan, + base_tm.expert_evaluations + complete_scan_tm.expert_evaluations, 1); + + Model fixed_topology_model = flat64; + TrainMetric fixed_topology_tm = {0}; + VariantConfig fixed_topology_config = {0u, 1u, 0u, 1u, 0u, 0u}; + (void)adapt_model(&fixed_topology_model, base_train, adapt_train, + &fixed_topology_config, &fixed_topology_tm); + canonicalize_model(&fixed_topology_model); + Eval fixed_topology_drift = + evaluate(&fixed_topology_model, drift_hold, DRIFT_HOLD_N, 1); + Eval fixed_topology_retention = + evaluate(&fixed_topology_model, retention, RETENTION_N, 1); + PlanMetric fixed_topology_plan = + evaluate_planning(&fixed_topology_model, &world, spec, planning_seed, 1); + print_variant_json("ravel_fixed_topology_without_recursive_births", + &fixed_topology_model, &fixed_topology_drift, + &fixed_topology_retention, &fixed_topology_plan, + flat64_tm.expert_evaluations + + fixed_topology_tm.expert_evaluations, 1); + + Model random_birth_model = base; + TrainMetric random_birth_tm = {0}; + VariantConfig random_birth_config = {0u, 1u, 1u, 1u, 1u, 1u}; + (void)adapt_model(&random_birth_model, base_train, adapt_train, + &random_birth_config, &random_birth_tm); + canonicalize_model(&random_birth_model); + Eval random_birth_drift = + evaluate(&random_birth_model, drift_hold, DRIFT_HOLD_N, 1); + Eval random_birth_retention = + evaluate(&random_birth_model, retention, RETENTION_N, 1); + PlanMetric random_birth_plan = + evaluate_planning(&random_birth_model, &world, spec, planning_seed, 1); + print_variant_json("ravel_random_births", &random_birth_model, + &random_birth_drift, &random_birth_retention, + &random_birth_plan, + base_tm.expert_evaluations + random_birth_tm.expert_evaluations, 0); + printf(" },\n"); + + printf(" \"hard_gates\":{\"expected_topology\":%s," + "\"base_holdout_accuracy\":%s,\"adaptation_training_accuracy\":%s," + "\"adapted_drift_holdout_accuracy\":%s,\"adapted_gain_over_static\":%s," + "\"base_holdout_retention\":%s,\"exact_routing\":%s," + "\"base_reconstruction_rmse\":%s,\"adapted_reconstruction_rmse\":%s," + "\"adapted_reconstruction_improvement\":%s," + "\"retention_reconstruction\":%s,\"base_prediction_rmse\":%s," + "\"adapted_prediction_rmse\":%s,\"adapted_prediction_improvement\":%s," + "\"retention_prediction\":%s,\"exact_world_state_target_rate\":%s," + "\"path_found_rate\":%s,\"checkpoint_identity\":%s," + "\"checkpoint_behavior\":%s,\"checkpoint_mutations\":%s," + "\"lineage_and_topology\":%s},\n", + adapted.n == ADAPTED_E ? "true" : "false", + base_accuracy >= 0.75 ? "true" : "false", + adaptation_training_accuracy >= 0.70 ? "true" : "false", + adapted_drift_accuracy >= 0.70 ? "true" : "false", + adapted_drift_accuracy >= static_drift_accuracy + 0.05 ? "true" : "false", + retention_accuracy >= 0.70 ? "true" : "false", + exact_routing ? "true" : "false", + base_reconstruction <= 18.0 ? "true" : "false", + adapted_reconstruction <= 18.0 ? "true" : "false", + static_reconstruction - adapted_reconstruction >= 0.25 ? "true" : "false", + retention_reconstruction - base_reconstruction <= 4.0 ? "true" : "false", + base_prediction <= 24.0 ? "true" : "false", + adapted_prediction <= 24.0 ? "true" : "false", + static_prediction - adapted_prediction >= 0.25 ? "true" : "false", + retention_prediction - base_prediction <= 5.0 ? "true" : "false", + exact_state_rate >= 0.60 ? "true" : "false", + path_found_rate >= 0.70 ? "true" : "false", + checkpoint_identity ? "true" : "false", + checkpoint_behavior ? "true" : "false", + mutations_pass ? "true" : "false", + lineage_pass ? "true" : "false"); + printf(" \"trial_result\":\"%s\"\n }%s\n", + trial_pass ? "PASS" : "FAIL", trial + 1u < TRIALS ? "," : ""); + } + + int negative_pass = negative_result_pass(&negative); + if (!negative_pass) execution_integrity = 0; + printf(" ],\n \"negative_tests\":{\n"); + print_negative_case("malformed_observation", "reject", + negative.malformed_observation_rejected, 1); + print_negative_case("out_of_domain_value", "fall_back", + negative.out_of_domain_fallback, 1); + print_negative_case("empty_expert_assignment", "reject", + negative.empty_assignment_rejected, 1); + print_negative_case("degenerate_expert_assignment", "reject", + negative.degenerate_assignment_rejected, 1); + print_negative_case("duplicate_expert", "reject", + negative.duplicate_expert_rejected, 1); + print_negative_case("tied_distance", "preserve_non_promotion", + negative.tied_distance_lower_id, 1); + print_negative_case("routing_lower_bound_equality", "fall_back", + negative.lower_bound_equality_fallback, 1); + print_negative_case("maximum_expert_capacity", "preserve_non_promotion", + negative.maximum_capacity_preserved, 1); + print_negative_case("birth_beyond_capacity", "reject", + negative.birth_beyond_capacity_rejected, 1); + print_negative_case("wrong_lifecycle_retirement", "reject", + negative.wrong_lifecycle_retirement_rejected, 1); + print_negative_case("poisoned_adaptation_labels", "fail_a_gate", + negative.poisoned_labels_fail_gate, 1); + print_negative_case("poisoned_transition_observations", "fail_a_gate", + negative.poisoned_transitions_fail_gate, 1); + print_negative_case("replay_removal", "fail_a_gate", + negative.replay_removal_fail_gate, 1); + print_negative_case("catastrophic_forgetting_condition", "fail_a_gate", + negative.catastrophic_forgetting_fail_gate, 0); + printf(" },\n"); + printf(" \"trial_summary\":{\"declared\":%u,\"passing\":%u,\"failing\":%u," + "\"pass_rule\":\"all_8_trials_pass\"},\n", + TRIALS, passing_trials, failing_trials); + printf(" \"execution_integrity\":\"%s\",\n", + execution_integrity ? "PASS" : "FAIL"); + printf(" \"development_result\":\"%s\",\n", + all_trials_pass ? "PASS" : "FAIL"); + printf(" \"formal_mncs_status\":\"UNKNOWN\",\n" + " \"formal_mncds_status\":\"UNKNOWN\",\n" + " \"promotion_authorized\":false\n}\n"); + return execution_integrity ? 0 : 1; +} diff --git a/ravel_unified.c b/ravel_unified.c index 2c230a2..007d2e9 100644 --- a/ravel_unified.c +++ b/ravel_unified.c @@ -1,4 +1,7 @@ -/* Generated RAVEL-U 0.3 execution shards. Do not hand-edit the shards. */ +/* + * Maintained RAVEL-U 0.3 split translation unit. + * No reproducible source generator was included in the 0.3 release. + */ #include "ravel_unified/00_core.inc" #include "ravel_unified/10_route.inc" #include "ravel_unified/20_train.inc" diff --git a/ravel_unified/20_train.inc b/ravel_unified/20_train.inc index a7e8bdb..a6a58b0 100644 --- a/ravel_unified/20_train.inc +++ b/ravel_unified/20_train.inc @@ -56,8 +56,14 @@ static int split_one(Model *m, uint16_t parent, uint16_t child, const Event *dat } if (pa == pb) return 0; uint64_t root = m->e[parent].lineage; - seed_expert(&m->e[parent], &data[pa], mix64(root ^ ((uint64_t)round << 32) ^ UINT64_C(0xa5)), (uint16_t)(m->e[parent].generation + 1u)); - seed_expert(&m->e[child], &data[pb], mix64(root ^ ((uint64_t)round << 32) ^ UINT64_C(0x5a)), (uint16_t)(m->e[parent].generation + 1u)); + uint16_t original_generation = m->e[parent].generation; + uint16_t child_generation = (uint16_t)(original_generation + 1u); + seed_expert(&m->e[parent], &data[pa], + mix64(root ^ ((uint64_t)round << 32) ^ UINT64_C(0xa5)), + child_generation); + seed_expert(&m->e[child], &data[pb], + mix64(root ^ ((uint64_t)round << 32) ^ UINT64_C(0x5a)), + child_generation); return 1; } diff --git a/tools/ravel_0_4_evidence.py b/tools/ravel_0_4_evidence.py new file mode 100755 index 0000000..e8649af --- /dev/null +++ b/tools/ravel_0_4_evidence.py @@ -0,0 +1,585 @@ +#!/usr/bin/env python3 +"""Generate and verify the deterministic RAVEL 0.4 evidence package.""" + +from __future__ import annotations + +import argparse +import hashlib +import json +import os +import platform +import statistics +import subprocess +import sys +import time +from collections.abc import Iterable +from pathlib import Path +from typing import Any + +CASE_ROOT = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(Path(__file__).resolve().parent)) +from ravel_source_digest import ( # noqa: E402 + ManifestError, + build_manifest, + canonical_json_bytes, + file_sha256, +) + +PREREGISTRATION = CASE_ROOT / "ravel-0.4-preregistration.json" +MANIFEST_SPEC = CASE_ROOT / "ravel-0.4-source-manifest-spec.json" +RAW_EVIDENCE = CASE_ROOT / "ravel-0.4-raw-observations.json" +TRIAL_EVIDENCE = CASE_ROOT / "ravel-0.4-trial-evidence.json" +NEGATIVE_EVIDENCE = CASE_ROOT / "ravel-0.4-negative-evidence.json" +SOURCE_MANIFEST = CASE_ROOT / "ravel-0.4-source-manifest.json" +ASSURANCE = CASE_ROOT / "ravel-0.4-assurance-case.json" +RESULTS_DOC = CASE_ROOT / "RAVEL_0_4_RESULTS.md" +RUNTIME_EVIDENCE = CASE_ROOT / "ravel-0.4-runtime-observations.json" + + +class EvidenceError(RuntimeError): + """Raised when deterministic evidence is malformed or stale.""" + + +def load_json(path: Path) -> dict[str, Any]: + with path.open("r", encoding="utf-8") as handle: + value = json.load(handle) + if not isinstance(value, dict): + raise EvidenceError(f"{path}: top-level JSON must be an object") + return value + + +def sha256_bytes(data: bytes) -> str: + return hashlib.sha256(data).hexdigest() + + +def run_binary(binary: Path) -> bytes: + completed = subprocess.run( + [str(binary.resolve())], + cwd=CASE_ROOT, + check=True, + capture_output=True, + env={**os.environ, "LC_ALL": "C", "LANG": "C"}, + ) + if completed.stderr: + raise EvidenceError( + f"RAVEL 0.4 wrote unexpected stderr: {completed.stderr.decode(errors='replace')}" + ) + return completed.stdout + + +def parse_raw(raw_bytes: bytes) -> dict[str, Any]: + try: + raw = json.loads(raw_bytes) + except json.JSONDecodeError as error: + raise EvidenceError(f"raw executable output is not JSON: {error}") from error + if not isinstance(raw, dict) or raw.get("schema") != "ravel-raw-observations/0.4": + raise EvidenceError("raw executable output has the wrong schema") + return raw + + +def validate_raw(raw: dict[str, Any], prereg: dict[str, Any]) -> None: + trials = raw.get("trials") + declared = prereg.get("trials") + if not isinstance(trials, list) or not isinstance(declared, list): + raise EvidenceError("trial arrays are missing") + expected = [(item["trial_id"], item["regime"], item["seed"].lower()) for item in declared] + observed = [ + (item.get("trial_id"), item.get("regime"), str(item.get("seed")).lower()) for item in trials + ] + if observed != expected: + raise EvidenceError("raw trial order, regimes, or frozen seeds differ from preregistration") + if raw.get("formal_mncs_status") != "UNKNOWN": + raise EvidenceError("formal MNCS status must remain UNKNOWN") + if raw.get("formal_mncds_status") != "UNKNOWN": + raise EvidenceError("formal MNCDS status must remain UNKNOWN") + if raw.get("promotion_authorized") is not False: + raise EvidenceError("promotion must remain unauthorized") + if raw.get("execution_integrity") != "PASS": + raise EvidenceError("execution integrity tests did not pass") + for trial in trials: + checkpoint = trial.get("checkpoint_verification", {}) + if checkpoint.get("complete_behavior_match") is not True: + raise EvidenceError(f"{trial.get('trial_id')}: checkpoint behavior mismatch") + mutations = checkpoint.get("mutations") + if not isinstance(mutations, dict) or not mutations or not all(mutations.values()): + raise EvidenceError(f"{trial.get('trial_id')}: checkpoint mutation escaped") + lineage = trial.get("lineage_invariants") + if not isinstance(lineage, dict) or not lineage or not all(lineage.values()): + raise EvidenceError(f"{trial.get('trial_id')}: lineage invariant failed") + negative = raw.get("negative_tests") + if not isinstance(negative, dict) or not negative: + raise EvidenceError("negative test observations are missing") + if not all(isinstance(item, dict) and item.get("pass") is True for item in negative.values()): + raise EvidenceError("one or more C negative tests failed") + + +def metric_summary(values: Iterable[float]) -> dict[str, float]: + numbers = [float(value) for value in values] + if not numbers: + raise EvidenceError("cannot aggregate an empty metric") + ordered = sorted(numbers) + return { + "minimum": ordered[0], + "median": statistics.median(ordered), + "maximum": ordered[-1], + "arithmetic_mean": statistics.fmean(ordered), + "population_standard_deviation": statistics.pstdev(ordered), + } + + +def candidate_metric(trial: dict[str, Any], name: str) -> float: + candidate = trial["candidate"] + paths: dict[str, tuple[str, ...]] = { + "base_holdout_accuracy": ("base_holdout", "accuracy"), + "adaptation_training_accuracy": ("adaptation_training", "accuracy"), + "static_model_drift_holdout_accuracy": ( + "static_model_drift_holdout", + "accuracy", + ), + "adapted_model_drift_holdout_accuracy": ( + "adapted_model_drift_holdout", + "accuracy", + ), + "base_holdout_retention": ("base_holdout_retention", "accuracy"), + "base_reconstruction_rmse": ("base_holdout", "reconstruction_rmse"), + "adapted_drift_reconstruction_rmse": ( + "adapted_model_drift_holdout", + "reconstruction_rmse", + ), + "base_prediction_rmse": ( + "base_holdout", + "next_observation_prediction_rmse", + ), + "adapted_drift_prediction_rmse": ( + "adapted_model_drift_holdout", + "next_observation_prediction_rmse", + ), + "planning_exact_state_rate": ( + "planning", + "exact_world_state_target_reached", + ), + "planning_path_found_rate": ("planning", "path_found"), + } + if name == "expert_count": + return float(candidate["expert_count"]) + if name == "training_evaluations": + return float(candidate["training_evaluations"]) + if name == "checkpoint_size_bytes": + return float(candidate["checkpoint_size_bytes"]) + first, second = paths[name] + value = float(candidate[first][second]) + if name.startswith("planning_"): + value /= float(candidate["planning"]["cases"]) + return value + + +def derive_trial_evidence(raw: dict[str, Any]) -> dict[str, Any]: + trials = raw["trials"] + candidate_names = [ + "base_holdout_accuracy", + "adaptation_training_accuracy", + "static_model_drift_holdout_accuracy", + "adapted_model_drift_holdout_accuracy", + "base_holdout_retention", + "base_reconstruction_rmse", + "adapted_drift_reconstruction_rmse", + "base_prediction_rmse", + "adapted_drift_prediction_rmse", + "planning_exact_state_rate", + "planning_path_found_rate", + "expert_count", + "training_evaluations", + "checkpoint_size_bytes", + ] + candidate_aggregates = { + name: metric_summary(candidate_metric(trial, name) for trial in trials) + for name in candidate_names + } + comparison_names = list(trials[0]["comparisons"]) + comparison_metrics = [ + "drift_holdout_accuracy", + "retention_accuracy", + "reconstruction_rmse", + "prediction_rmse", + "planning_exact_state_rate", + "expert_evaluations", + "expert_count", + "training_evaluations", + "checkpoint_size_bytes", + ] + comparison_aggregates: dict[str, Any] = {} + for comparison in comparison_names: + comparison_aggregates[comparison] = { + metric: metric_summary(trial["comparisons"][comparison][metric] for trial in trials) + for metric in comparison_metrics + } + comparison_aggregates[comparison]["runtime_observation_non_normative"] = { + "status": "UNKNOWN", + "reason": ( + "per-variant wall-clock timing excluded from canonical deterministic evidence" + ), + } + candidate_mean = candidate_aggregates["adapted_model_drift_holdout_accuracy"]["arithmetic_mean"] + mixed_comparisons = { + name: candidate_mean - summary["drift_holdout_accuracy"]["arithmetic_mean"] + for name, summary in comparison_aggregates.items() + if name != "ravel_0_4_candidate" + } + return { + "schema": "ravel-trial-evidence/0.4", + "study_id": "ravel.evidence-hardening.epoch-1.v1", + "preregistration": PREREGISTRATION.name, + "trial_pass_rule": "all_hard_gates_per_trial", + "global_pass_rule": "all_8_trials_pass", + "trials": trials, + "candidate_aggregates": candidate_aggregates, + "comparison_aggregates": comparison_aggregates, + "candidate_mean_drift_accuracy_delta_vs_comparisons": mixed_comparisons, + "comparison_interpretation": "mixed_do_not_infer_superiority", + "trial_summary": raw["trial_summary"], + "development_result": raw["development_result"], + "formal_mncs_status": "UNKNOWN", + "formal_mncds_status": "UNKNOWN", + "promotion_authorized": False, + } + + +def derive_negative_evidence( + raw: dict[str, Any], + raw_bytes: bytes, + repeated_bytes: bytes, + source_digest: str, +) -> dict[str, Any]: + corrupted = bytearray(raw_bytes) + corrupted[len(corrupted) // 2] ^= 0x01 + evidence_mutation_detected = sha256_bytes(corrupted) != sha256_bytes(raw_bytes) + stale_assurance_detected = source_digest != "0" * 64 + checkpoint_campaign = { + trial["trial_id"]: { + "expected_disposition": "reject_or_fail_equivalence", + "mutations": trial["checkpoint_verification"]["mutations"], + "pass": all(trial["checkpoint_verification"]["mutations"].values()), + } + for trial in raw["trials"] + } + tests = dict(raw["negative_tests"]) + tests.update( + { + "evidence_file_mutation": { + "expected_disposition": "reject", + "observed": evidence_mutation_detected, + "pass": evidence_mutation_detected, + }, + "stale_assurance_digest": { + "expected_disposition": "reject", + "observed": stale_assurance_detected, + "pass": stale_assurance_detected, + }, + "nondeterministic_output_detection": { + "expected_disposition": "reject", + "observed": raw_bytes == repeated_bytes, + "pass": raw_bytes == repeated_bytes, + "note": "two independent process executions were byte-identical", + }, + } + ) + return { + "schema": "ravel-negative-evidence/0.4", + "tests": tests, + "checkpoint_mutation_campaign": checkpoint_campaign, + "all_negative_tests_pass": all(item["pass"] for item in tests.values()) + and all(item["pass"] for item in checkpoint_campaign.values()), + "formal_mncs_status": "UNKNOWN", + "formal_mncds_status": "UNKNOWN", + "promotion_authorized": False, + } + + +def evidence_identity(paths: list[Path]) -> list[dict[str, Any]]: + return [ + { + "path": path.name, + "bytes": path.stat().st_size, + "sha256": file_sha256(path), + } + for path in paths + ] + + +def build_assurance( + raw: dict[str, Any], + trial_evidence: dict[str, Any], + negative_evidence: dict[str, Any], + manifest: dict[str, Any], +) -> dict[str, Any]: + failed_gates = { + trial["trial_id"]: [name for name, passed in trial["hard_gates"].items() if not passed] + for trial in raw["trials"] + if trial["trial_result"] == "FAIL" + } + return { + "schema": "ravel-assurance-case/0.4", + "assurance_case_id": "ravel.evidence-hardening.epoch-1.assurance.v1", + "claim": ( + "The bounded RAVEL 0.4 harness produced deterministic development " + "evidence with separated drift holdouts, canonical checkpoint " + "verification, mutations, multiple regimes, baselines, ablations, " + "and preserved failures." + ), + "development_result": raw["development_result"], + "disposition": "NON_PROMOTION_RESEARCH_FAILURES_PRESERVED", + "formal_mncs_status": "UNKNOWN", + "formal_mncds_status": "UNKNOWN", + "promotion_authorized": False, + "implementation": { + "entrypoint": manifest["entrypoint"], + "source_manifest": SOURCE_MANIFEST.name, + "source_manifest_sha256": file_sha256(SOURCE_MANIFEST), + "source_digest": manifest["source_digest"], + "digest_algorithm": manifest["digest_algorithm"], + "digest_procedure": manifest["digest_procedure"], + "source_provenance": manifest["source_provenance"], + "generated_execution_shards": manifest["generated_execution_shards"], + "language": "C11", + }, + "evidence": { + "records": evidence_identity([RAW_EVIDENCE, TRIAL_EVIDENCE, NEGATIVE_EVIDENCE]), + "deterministic_reproduction": True, + "drift_holdout_used_for_adaptation": False, + "checkpoint_complete_identity": True, + "checkpoint_complete_behavioral_agreement": True, + "checkpoint_mutation_campaign": negative_evidence["all_negative_tests_pass"], + "protected_holdout": False, + "independent_custody": False, + }, + "trial_summary": raw["trial_summary"], + "failed_gates_by_trial": failed_gates, + "observed_aggregates": trial_evidence["candidate_aggregates"], + "baseline_and_ablation_interpretation": ( + "Results are mixed across the frozen regimes; no superiority claim is made." + ), + "historical_audit": { + "ravel_u_0_3_adapted_score": ( + "The historical 100% adapted drift score reused adaptation data " + "and was not an untouched drift-holdout result." + ), + "ravel_u_0_3_checkpoint": ( + "The historical raw-struct checkpoint and weak digest are not " + "accepted as RAVEL 0.4 assurance." + ), + "ravel_u_0_3_source_digest": ( + "The historical unified assurance digest was incorrect; RAVEL " + "0.4 replaces implementation identity with the ordered manifest." + ), + "ravel_u_0_3_shard_provenance": ( + "No generator was present in source or reviewed pull-request " + "history; split sources are maintained, not claimed as generated." + ), + }, + "limitations": [ + "development evidence is not independent protected evidence", + "synthetic success or failure is not real-data generalization", + "deterministic reproduction is not cross-organizational reproduction", + "exact routing equivalence is not overall model correctness", + "checkpoint reproducibility is not production rollback authorization", + "runtime observations are non-normative", + "formal MNCS status remains UNKNOWN", + "formal MNCDS status remains UNKNOWN", + "promotion remains unauthorized", + ], + } + + +def results_markdown(trial_evidence: dict[str, Any]) -> bytes: + lines = [ + "# RAVEL 0.4 generated results", + "", + ( + "This file is generated from canonical raw observations. " + "It is not an independent attestation." + ), + "", + "## Frozen trial outcomes", + "", + "| Trial | Regime | Result | Failed gates |", + "|---|---|---:|---|", + ] + for trial in trial_evidence["trials"]: + failures = [name for name, passed in trial["hard_gates"].items() if not passed] + lines.append( + f"| {trial['trial_id']} | {trial['regime']} | {trial['trial_result']} | " + f"{', '.join(failures) if failures else 'none'} |" + ) + lines.extend( + [ + "", + "## Candidate aggregates", + "", + "| Metric | Minimum | Median | Maximum | Mean | Population SD |", + "|---|---:|---:|---:|---:|---:|", + ] + ) + for name, summary in trial_evidence["candidate_aggregates"].items(): + lines.append( + f"| {name} | {summary['minimum']:.9f} | {summary['median']:.9f} | " + f"{summary['maximum']:.9f} | {summary['arithmetic_mean']:.9f} | " + f"{summary['population_standard_deviation']:.9f} |" + ) + lines.extend( + [ + "", + "## Interpretation", + "", + f"Development result: `{trial_evidence['development_result']}`. " + f"Passing trials: {trial_evidence['trial_summary']['passing']}; " + f"failing trials: {trial_evidence['trial_summary']['failing']}.", + "", + "Baseline and ablation results are mixed. No superiority claim is made. " + "Per-variant wall-clock observations remain `UNKNOWN` in canonical " + "evidence; deterministic operation counts are compared instead.", + "", + "Formal MNCS status remains `UNKNOWN`. Formal MNCDS status remains " + "`UNKNOWN`. Promotion is unauthorized.", + "", + ] + ) + return "\n".join(lines).encode("utf-8") + + +def expected_package(binary: Path) -> dict[Path, bytes]: + prereg = load_json(PREREGISTRATION) + first = run_binary(binary) + second = run_binary(binary) + if first != second: + raise EvidenceError("nondeterministic output detected across two executions") + raw = parse_raw(first) + validate_raw(raw, prereg) + manifest = build_manifest(MANIFEST_SPEC) + trial = derive_trial_evidence(raw) + negative = derive_negative_evidence(raw, first, second, manifest["source_digest"]) + package: dict[Path, bytes] = { + RAW_EVIDENCE: first, + TRIAL_EVIDENCE: canonical_json_bytes(trial), + NEGATIVE_EVIDENCE: canonical_json_bytes(negative), + SOURCE_MANIFEST: canonical_json_bytes(manifest), + RESULTS_DOC: results_markdown(trial), + } + return package + + +def generate(binary: Path) -> None: + package = expected_package(binary) + for path in [RAW_EVIDENCE, TRIAL_EVIDENCE, NEGATIVE_EVIDENCE, SOURCE_MANIFEST]: + path.write_bytes(package[path]) + raw = load_json(RAW_EVIDENCE) + trial = load_json(TRIAL_EVIDENCE) + negative = load_json(NEGATIVE_EVIDENCE) + manifest = load_json(SOURCE_MANIFEST) + assurance = build_assurance(raw, trial, negative, manifest) + ASSURANCE.write_bytes(canonical_json_bytes(assurance)) + RESULTS_DOC.write_bytes(package[RESULTS_DOC]) + + +def write_diagnostics(directory: Path, package: dict[Path, bytes]) -> None: + directory.mkdir(parents=True, exist_ok=True) + for path, content in package.items(): + (directory / f"actual-{path.name}").write_bytes(content) + + +def verify(binary: Path, diagnostics_dir: Path | None = None) -> None: + package = expected_package(binary) + for path, expected in package.items(): + if not path.is_file(): + if diagnostics_dir is not None: + write_diagnostics(diagnostics_dir, package) + raise EvidenceError(f"canonical artifact is missing: {path.name}") + if path.read_bytes() != expected: + if diagnostics_dir is not None: + write_diagnostics(diagnostics_dir, package) + raise EvidenceError(f"canonical artifact is stale: {path.name}") + raw = load_json(RAW_EVIDENCE) + trial = load_json(TRIAL_EVIDENCE) + negative = load_json(NEGATIVE_EVIDENCE) + manifest = load_json(SOURCE_MANIFEST) + expected_assurance = canonical_json_bytes(build_assurance(raw, trial, negative, manifest)) + if not ASSURANCE.is_file() or ASSURANCE.read_bytes() != expected_assurance: + if diagnostics_dir is not None: + write_diagnostics(diagnostics_dir, package) + diagnostics_dir.mkdir(parents=True, exist_ok=True) + (diagnostics_dir / f"actual-{ASSURANCE.name}").write_bytes(expected_assurance) + raise EvidenceError("canonical artifact is stale: ravel-0.4-assurance-case.json") + if manifest["source_digest"] != build_manifest(MANIFEST_SPEC)["source_digest"]: + raise EvidenceError("source digest changed during verification") + if negative.get("all_negative_tests_pass") is not True: + raise EvidenceError("negative evidence is not passing") + + +def runtime_observation(binary: Path, runs: int) -> None: + durations: list[int] = [] + output_digest: str | None = None + for _ in range(runs): + start = time.perf_counter_ns() + output = run_binary(binary) + durations.append(time.perf_counter_ns() - start) + digest = sha256_bytes(output) + if output_digest is not None and digest != output_digest: + raise EvidenceError("runtime observation encountered nondeterministic output") + output_digest = digest + record = { + "schema": "ravel-runtime-observations/0.4", + "normative": False, + "scope": "whole_harness_only_not_per_variant", + "platform": platform.platform(), + "python": platform.python_version(), + "runs": runs, + "elapsed_nanoseconds": durations, + "minimum_nanoseconds": min(durations), + "median_nanoseconds": statistics.median(durations), + "maximum_nanoseconds": max(durations), + "arithmetic_mean_nanoseconds": statistics.fmean(durations), + "output_sha256": output_digest, + "limitations": [ + "wall-clock observations are host-specific and non-normative", + "per-variant runtime remains UNKNOWN; canonical evidence compares operation counts", + ], + } + RUNTIME_EVIDENCE.write_bytes(canonical_json_bytes(record)) + + +def parse_args() -> argparse.Namespace: + parser = argparse.ArgumentParser() + parser.add_argument("command", choices=("generate", "verify", "runtime")) + parser.add_argument("--binary", type=Path, default=CASE_ROOT / "ravel_0_4_bin") + parser.add_argument("--runs", type=int, default=3) + parser.add_argument("--diagnostics-dir", type=Path) + return parser.parse_args() + + +def main() -> int: + args = parse_args() + try: + if args.command == "generate": + generate(args.binary) + elif args.command == "verify": + diagnostics = args.diagnostics_dir + if diagnostics is not None and not diagnostics.is_absolute(): + diagnostics = CASE_ROOT / diagnostics + verify(args.binary, diagnostics) + else: + if args.runs < 1: + raise EvidenceError("--runs must be positive") + runtime_observation(args.binary, args.runs) + return 0 + except ( + EvidenceError, + ManifestError, + OSError, + subprocess.CalledProcessError, + json.JSONDecodeError, + ) as error: + print(f"ravel 0.4 evidence error: {error}", file=sys.stderr) + return 1 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/tools/ravel_source_digest.py b/tools/ravel_source_digest.py new file mode 100755 index 0000000..31fe1fc --- /dev/null +++ b/tools/ravel_source_digest.py @@ -0,0 +1,228 @@ +#!/usr/bin/env python3 +"""Build and verify ordered RAVEL source manifests without network access.""" + +from __future__ import annotations + +import argparse +import hashlib +import json +import struct +import sys +from pathlib import Path +from typing import Any + +CASE_ROOT = Path(__file__).resolve().parents[1] +REQUIRED_ROLES = { + "entrypoint", + "contract", + "scope", + "preregistration", + "manifest_specification", + "threat_model", + "limitations", + "evaluator_and_evidence_generator", + "source_digest_utility", +} + + +class ManifestError(RuntimeError): + """Raised when a source manifest is incomplete or stale.""" + + +def load_json(path: Path) -> dict[str, Any]: + with path.open("r", encoding="utf-8") as handle: + value = json.load(handle) + if not isinstance(value, dict): + raise ManifestError(f"{path}: top-level JSON value must be an object") + return value + + +def canonical_json_bytes(value: Any) -> bytes: + return (json.dumps(value, indent=2, ensure_ascii=False) + "\n").encode("utf-8") + + +def file_sha256(path: Path) -> str: + return hashlib.sha256(path.read_bytes()).hexdigest() + + +def framed_source_digest(entries: list[dict[str, Any]]) -> str: + digest = hashlib.sha256() + for entry in entries: + relative = entry["path"].encode("utf-8") + content = (CASE_ROOT / entry["path"]).read_bytes() + digest.update(struct.pack(">I", len(relative))) + digest.update(relative) + digest.update(struct.pack(">Q", len(content))) + digest.update(content) + return digest.hexdigest() + + +def validate_spec(spec: dict[str, Any]) -> None: + ordered = spec.get("ordered_files") + if not isinstance(ordered, list) or not ordered: + raise ManifestError("manifest specification has no ordered_files") + roles: list[str] = [] + paths: list[str] = [] + for index, item in enumerate(ordered): + if not isinstance(item, dict): + raise ManifestError(f"ordered_files[{index}] is not an object") + role = item.get("role") + path = item.get("path") + if not isinstance(role, str) or not isinstance(path, str): + raise ManifestError(f"ordered_files[{index}] lacks string role/path") + roles.append(role) + paths.append(path) + if len(roles) != len(set(roles)): + raise ManifestError("duplicate ordered manifest role") + if len(paths) != len(set(paths)): + raise ManifestError("duplicate ordered manifest path") + missing_roles = sorted(REQUIRED_ROLES - set(roles)) + if missing_roles: + raise ManifestError(f"required manifest roles omitted: {missing_roles}") + if spec.get("entrypoint") not in paths: + raise ManifestError("entrypoint is omitted from ordered_files") + generated = spec.get("generated_execution_shards") + if not isinstance(generated, list): + raise ManifestError("generated_execution_shards must be an array") + for shard in generated: + if shard not in paths: + raise ManifestError(f"generated shard omitted from ordered_files: {shard}") + + +def discover_execution_shards(spec: dict[str, Any]) -> set[str]: + discovered: set[str] = set() + globs = spec.get("execution_shard_discovery_globs", []) + if not isinstance(globs, list): + raise ManifestError("execution_shard_discovery_globs must be an array") + for pattern in globs: + if not isinstance(pattern, str): + raise ManifestError("execution shard glob must be a string") + for path in CASE_ROOT.glob(pattern): + if path.is_file(): + discovered.add(path.relative_to(CASE_ROOT).as_posix()) + return discovered + + +def build_manifest(spec_path: Path) -> dict[str, Any]: + spec = load_json(spec_path) + validate_spec(spec) + declared_shards = set(spec["generated_execution_shards"]) + discovered_shards = discover_execution_shards(spec) + unexpected = sorted(discovered_shards - declared_shards) + omitted = sorted(declared_shards - discovered_shards) + if unexpected: + raise ManifestError(f"unexpected execution shard outside manifest: {unexpected}") + if omitted: + raise ManifestError(f"declared execution shard is missing: {omitted}") + + entries: list[dict[str, Any]] = [] + for item in spec["ordered_files"]: + relative = item["path"] + absolute = CASE_ROOT / relative + if not absolute.is_file(): + raise ManifestError(f"listed source file is missing: {relative}") + content = absolute.read_bytes() + entries.append( + { + "order": len(entries), + "role": item["role"], + "path": relative, + "bytes": len(content), + "sha256": hashlib.sha256(content).hexdigest(), + } + ) + return { + "schema": "ravel-source-manifest/0.4", + "entrypoint": spec["entrypoint"], + "generated_execution_shards": spec["generated_execution_shards"], + "generator_source": None, + "source_provenance": spec["source_provenance"], + "evidence_schema_versions": spec["evidence_schema_versions"], + "digest_algorithm": spec["digest_algorithm"], + "digest_procedure": spec["digest_procedure"], + "ordered_files": entries, + "source_digest": framed_source_digest(entries), + "unexpected_execution_shards": [], + } + + +def verify_manifest( + spec_path: Path, + manifest_path: Path, + assurance_path: Path | None = None, +) -> dict[str, Any]: + expected = build_manifest(spec_path) + actual = load_json(manifest_path) + if actual != expected: + raise ManifestError( + "source manifest is stale, reordered, incomplete, or contains unexpected data" + ) + result: dict[str, Any] = { + "manifest_match": True, + "source_digest": expected["source_digest"], + "manifest_sha256": file_sha256(manifest_path), + } + if assurance_path is not None: + assurance = load_json(assurance_path) + implementation = assurance.get("implementation") + if not isinstance(implementation, dict): + raise ManifestError("assurance record lacks implementation object") + if implementation.get("source_digest") != expected["source_digest"]: + raise ManifestError("assurance record contains a stale source digest") + if implementation.get("source_manifest_sha256") != result["manifest_sha256"]: + raise ManifestError("assurance record contains a stale manifest digest") + if implementation.get("source_manifest") != manifest_path.name: + raise ManifestError("assurance record names the wrong source manifest") + result["assurance_match"] = True + return result + + +def parse_args() -> argparse.Namespace: + parser = argparse.ArgumentParser() + subparsers = parser.add_subparsers(dest="command", required=True) + generate = subparsers.add_parser("generate") + generate.add_argument("--spec", type=Path, required=True) + generate.add_argument("--output", type=Path, required=True) + verify = subparsers.add_parser("verify") + verify.add_argument("--spec", type=Path, required=True) + verify.add_argument("--manifest", type=Path, required=True) + verify.add_argument("--assurance", type=Path) + show = subparsers.add_parser("print-digest") + show.add_argument("--spec", type=Path, required=True) + return parser.parse_args() + + +def resolve_case_path(path: Path) -> Path: + return path if path.is_absolute() else CASE_ROOT / path + + +def main() -> int: + args = parse_args() + try: + spec = resolve_case_path(args.spec) + if args.command == "generate": + output = resolve_case_path(args.output) + output.write_bytes(canonical_json_bytes(build_manifest(spec))) + return 0 + if args.command == "verify": + manifest = resolve_case_path(args.manifest) + assurance = resolve_case_path(args.assurance) if args.assurance is not None else None + print( + json.dumps( + verify_manifest(spec, manifest, assurance), + sort_keys=True, + separators=(",", ":"), + ) + ) + return 0 + if args.command == "print-digest": + print(build_manifest(spec)["source_digest"]) + return 0 + except (ManifestError, OSError, json.JSONDecodeError) as error: + print(f"ravel source manifest error: {error}", file=sys.stderr) + return 1 + raise AssertionError("unreachable") + + +if __name__ == "__main__": + raise SystemExit(main()) From 6162980d850550f10725c80e386b713bd6f05281 Mon Sep 17 00:00:00 2001 From: epi13 Date: Fri, 31 Jul 2026 22:40:49 -0800 Subject: [PATCH 04/13] Freeze RAVEL 0.5 validation protocol --- Makefile | 69 +- RAVEL_0_5_CONTRACT.md | 94 + RAVEL_0_5_POSTMORTEM.md | 68 + RAVEL_0_5_SCOPE.md | 41 + ravel-0.5-development-corpus.json | 27 + ravel-0.5-limitations.md | 25 + ravel-0.5-preregistration.json | 253 +++ ravel-0.5-source-manifest-spec.json | 114 + ravel-0.5-threat-model.json | 67 + ravel_0_5.c | 3047 +++++++++++++++++++++++++++ tools/ravel_0_5_evaluator.py | 1215 +++++++++++ tools/ravel_0_5_evidence.py | 584 +++++ tools/ravel_0_5_source_digest.py | 259 +++ 13 files changed, 5860 insertions(+), 3 deletions(-) create mode 100644 RAVEL_0_5_CONTRACT.md create mode 100644 RAVEL_0_5_POSTMORTEM.md create mode 100644 RAVEL_0_5_SCOPE.md create mode 100644 ravel-0.5-development-corpus.json create mode 100644 ravel-0.5-limitations.md create mode 100644 ravel-0.5-preregistration.json create mode 100644 ravel-0.5-source-manifest-spec.json create mode 100644 ravel-0.5-threat-model.json create mode 100644 ravel_0_5.c create mode 100644 tools/ravel_0_5_evaluator.py create mode 100644 tools/ravel_0_5_evidence.py create mode 100755 tools/ravel_0_5_source_digest.py diff --git a/Makefile b/Makefile index edcdb09..5dcc289 100644 --- a/Makefile +++ b/Makefile @@ -3,7 +3,7 @@ SAN_CC ?= clang CFLAGS ?= -std=c11 -O3 -Wall -Wextra -Werror -pedantic LDLIBS ?= -lm -.PHONY: test evidence training-test training-evidence training-check unified-test unified-evidence unified-check 0.4-evidence 0.4-check 0.4-manifest-negative-test 0.4-checkpoint-test 0.4-lineage-test 0.4-negative-test 0.4-compiler-matrix 0.4-sanitizers 0.4-runtime all clean +.PHONY: test evidence training-test training-evidence training-check unified-test unified-evidence unified-check 0.4-evidence 0.4-check 0.4-manifest-negative-test 0.4-checkpoint-test 0.4-lineage-test 0.4-negative-test 0.4-compiler-matrix 0.4-sanitizers 0.4-runtime 0.5-test 0.5-evidence 0.5-check 0.5-development-gates 0.5-negative-test 0.5-manifest-negative-test 0.5-compiler-matrix 0.5-sanitizers 0.5-runtime 0.5-clean all clean test: ravel ./ravel >/dev/null @@ -135,7 +135,67 @@ unified-check: ravel_unified_bin 0.4-runtime: ravel_0_4_bin python3 tools/ravel_0_4_evidence.py runtime --binary ./ravel_0_4_bin --runs 3 -all: test training-check unified-check 0.4-check +0.5-test: ravel_0_5_bin + @tmp=$$(mktemp); \ + trap 'rm -f "$$tmp"' EXIT; \ + ./ravel_0_5_bin --self-test > "$$tmp"; \ + python3 -c 'import json,sys; r=json.load(open(sys.argv[1])); assert r["schema"] == "ravel-self-test-observations/0.5"; assert all(v["observed"] for v in r["fixtures"].values())' "$$tmp" + +0.5-evidence: ravel_0_5_bin + python3 tools/ravel_0_5_evidence.py generate --binary ./ravel_0_5_bin + +0.5-check: ravel_0_5_bin + python3 tools/ravel_0_5_evidence.py verify --binary ./ravel_0_5_bin --diagnostics-dir diagnostics-0.5 + python3 tools/ravel_0_5_source_digest.py verify \ + --spec ravel-0.5-source-manifest-spec.json \ + --manifest ravel-0.5-source-and-execution-manifest.json \ + --assurance ravel-0.5-assurance-case.json + +0.5-development-gates: + python3 tools/ravel_0_5_evidence.py development-gates + +0.5-negative-test: ravel_0_5_bin + $(MAKE) 0.5-test + python3 tools/ravel_0_5_evidence.py mutation-tests + python3 -c 'import json; r=json.load(open("ravel-0.5-negative-evidence.json")); assert r["all_negative_tests_pass"]; assert len(r["tests"]) == len(set(r["tests"]))' + +0.5-manifest-negative-test: + python3 tools/ravel_0_5_evidence.py manifest-negative-tests + +0.5-compiler-matrix: + @set -eu; \ + for compiler in gcc clang; do \ + if command -v "$$compiler" >/dev/null 2>&1; then \ + for optimization in 0 3; do \ + binary=$$(mktemp); \ + trap 'rm -f "$$binary"' EXIT; \ + "$$compiler" -std=c11 "-O$$optimization" -Wall -Wextra -Werror -pedantic ravel_0_5.c -lm -o "$$binary"; \ + python3 tools/ravel_0_5_evidence.py verify --binary "$$binary" --diagnostics-dir diagnostics-0.5; \ + rm -f "$$binary"; \ + trap - EXIT; \ + done; \ + fi; \ + done + +0.5-sanitizers: + @set -eu; \ + command -v "$(SAN_CC)" >/dev/null 2>&1 || { echo "sanitizer compiler unavailable: $(SAN_CC)" >&2; exit 1; }; \ + binary=$$(mktemp); \ + trap 'rm -f "$$binary"' EXIT; \ + $(SAN_CC) -std=c11 -O1 -g -Wall -Wextra -Werror -pedantic \ + -fsanitize=address,undefined -fno-omit-frame-pointer \ + ravel_0_5.c -lm -o "$$binary"; \ + ASAN_OPTIONS=detect_leaks=1 UBSAN_OPTIONS=halt_on_error=1 \ + python3 tools/ravel_0_5_evidence.py verify --binary "$$binary" --diagnostics-dir diagnostics-0.5 + +0.5-runtime: ravel_0_5_bin + python3 tools/ravel_0_5_evidence.py runtime --binary ./ravel_0_5_bin --runs 3 + +0.5-clean: + rm -f ravel_0_5_bin + rm -rf diagnostics-0.5 + +all: test training-check unified-check 0.4-check 0.5-check ravel: ravel.c $(CC) $(CFLAGS) $< -o $@ @@ -149,7 +209,10 @@ ravel_unified_bin: ravel_unified.c ravel_unified/00_core.inc ravel_unified/10_ro ravel_0_4_bin: ravel_0_4.c $(CC) $(CFLAGS) ravel_0_4.c $(LDLIBS) -o $@ +ravel_0_5_bin: ravel_0_5.c + $(CC) $(CFLAGS) ravel_0_5.c $(LDLIBS) -o $@ + clean: - rm -f ravel ravel_train ravel_unified_bin ravel_0_4_bin + rm -f ravel ravel_train ravel_unified_bin ravel_0_4_bin ravel_0_5_bin rm -f evidence-actual.json unified-actual.json ravel-unified-checkpoint.bin ravel-0.4-checkpoint.bin rm -rf diagnostics diff --git a/RAVEL_0_5_CONTRACT.md b/RAVEL_0_5_CONTRACT.md new file mode 100644 index 0000000..c71e0bd --- /dev/null +++ b/RAVEL_0_5_CONTRACT.md @@ -0,0 +1,94 @@ +# RAVEL 0.5 adaptive-mechanism correction contract + +## Authorities and data separation + +The maintained C11 executable is an observation source, not the assurance +authority. It receives one preregistered trial ID, regime, and seed and emits +raw integer counts, Q20 squared-error accumulators, checksums, topology traces, +replay coverage, checkpoint mutation observations, and lineage observations. +It does not emit hard gates, trial results, aggregate results, a global +development result, MNCS or MNCDS status, or promotion disposition. + +The independent Python evaluator loads the frozen preregistration, verifies the +complete trial matrix and partition derivations, rejects malformed or +contradictory records, derives all floating metrics from raw accumulators, +applies the only threshold authority, and derives trial, aggregate, and global +results. + +Each trial uses six independently seeded partitions: + +1. 1,024 base-training observations; +2. 256 base-holdout observations; +3. 512 drift-adaptation-training observations; +4. 256 untouched drift-holdout observations; +5. 256 original-task-retention-holdout observations; and +6. 64 planning cases. + +Drift and retention holdouts are forbidden inputs to replay selection, expert +birth, refinement, retirement, thresholds, topology, or model selection. + +## Replay and protected behavior + +Balanced replay deterministically selects at most 256 unique base-training +events. It first covers source-state/action pairs, then assigned experts, then +fills by normalized historical loss. Evidence records label, action, state, +expert, transition-pair, rare-case, high-loss, uniqueness, and checksum facts. +Sparse strata are retained without inventing duplicates. + +Base experts are anchored. Adaptation refinement may update separate adaptation +experts but restores anchored base parameters after each mixture pass. Replay +therefore constrains adaptation while the original recursive base remains an +explicit protected reference. + +## Adaptive topology + +Birth proposals are ranked by the arithmetic mean of eight bounded `[0, 1]` +channels: classification residual, reconstruction residual, supported +next-observation residual, novelty, inverse support, uncertainty, missing +action coverage, and anchored-retention risk. No channel receives a magnitude +multiplier. Equal totals choose the lower event index. + +A proposal is accepted only when its adaptation-training plus replay objective +improves by the frozen Q20 minimum. Zero through sixteen births are allowed. +Zero through four retirements are allowed. Retirement is rejected for anchored +experts, rare label/action coverage, supported transition connectivity, +lineage/topology uniqueness, reconstruction or prediction support, or a +measurable protected replay/adaptation objective loss. + +No holdout observation participates in a topology decision. Every accepted +birth records the source event, normalized score, and dominant channel; every +retirement records lineage. Rejections are counted. + +## Transitions and planning + +Every expert/action transition stores up to two target experts with integer +support. Support below two is unknown. Unsupported actions never inherit a seed +event prediction and never become graph edges. + +Planning separately reports path found, exact world state reached, goal expert +reached, belief-set target reached, executed and optimal length, regret, graph +disconnection, unsupported edge, transition-model error, and state aliasing. +The ambiguous regime gates belief-set success; exact hidden-state success stays +visible as a diagnostic. + +## Checkpoint and routing integrity + +The version-5 checkpoint is an in-memory, canonical, length-delimited, +big-endian record with an eight-byte magic, explicit limits and widths, signed +Q20 real encoding, and SHA-256 payload digest. It covers all expert behavior, +transition support, routing, topology, statistics, generation, lineage, +anchoring, and compiled graph fields. Restoration rejects malformed, +truncated, appended, substituted, unsupported, non-finite, or overflowing +records. + +Routed evaluation must have zero disagreement with complete scan. Equality at +the routing lower bound falls back to complete scan; tied distances choose the +lower expert ID. + +## Disposition + +Every hard gate is preregistered by regime. The global result follows the frozen +per-trial and per-regime rule. Evidence reproduction, integrity success, and +the development result are separate fields. A development failure remains +evidence and cannot change formal MNCS or MNCDS status from `UNKNOWN` or +authorize promotion. diff --git a/RAVEL_0_5_POSTMORTEM.md b/RAVEL_0_5_POSTMORTEM.md new file mode 100644 index 0000000..6359970 --- /dev/null +++ b/RAVEL_0_5_POSTMORTEM.md @@ -0,0 +1,68 @@ +# RAVEL 0.4 postmortem and RAVEL 0.5 correction record + +RAVEL 0.4 succeeded at evidence custody and failed its frozen development +protocol. Its immutable record remains: + +- execution integrity: `PASS`; +- development result: `FAIL`; +- passing trials: `0`; +- failing trials: `8`; +- formal MNCS status: `UNKNOWN`; +- formal MNCDS status: `UNKNOWN`; and +- promotion authorized: `false`. + +No 0.4 source, seed, gate, raw observation, or derived result was changed by the +0.5 work. + +## What 0.4 established + +RAVEL 0.4 established disjoint adaptation and holdout partitions, complete-field +canonical checkpointing, deliberate corruption detection, deterministic +multi-regime reproduction, honest variance, exact-state planning diagnostics, +and ordered source identity. Those are assurance successes, not mechanism +success. + +## Mechanism failures + +- Label drift and combined drift overwrote too much base behavior. Label drift + failed base retention, and combined drift also failed retention. +- Transition drift did not preserve original-task next-observation quality. +- The single transition edge could appear supported for an action that had + never been observed, making planning overly confident. +- Replay sampled every fourth event rather than protecting declared strata, + rare support, or historically difficult observations. +- Adaptation forced eight births and four retirements regardless of need. +- Retirement utility omitted retention coverage, transition connectivity, and + reconstruction/prediction support. +- Residual ranking used incompatible large magnitude constants, so unit scale + rather than declared importance could dominate topology. +- Exact-state planning was not belief-aware under partial observation. + +## Gate-design failures + +Four low-drift or already-solved regimes failed because 0.4 required the same +absolute `adapted_gain_over_static >= 0.05` even when little or no accuracy +headroom existed. Label drift also required reconstruction improvement even +though observations were unchanged. The ambiguous regime used exact hidden +state as the capability gate despite deliberately aliased observations. + +Those failures remain legitimate failures of the frozen 0.4 protocol. RAVEL +0.5 does not relabel them. It preregisters semantics-specific gates: +non-inferiority and headroom for low drift, label and retention behavior for +label drift, representation behavior for observation drift, transition and +planning behavior for transition drift, joint adaptation and retention for +combined drift, and alias-aware belief-set planning for ambiguity. + +## Assurance failures found during 0.5 + +The 0.4 C executable was still the sole producer of gate booleans, trial +results, and the global result. Several named negative tests were aliases, and +some provenance tests only checked that a digest was nonzero. RAVEL 0.5 moves +all dispositions to an external evaluator and executes distinct raw, +threshold, seed, regime, verdict-injection, manifest, source-substitution, +ordering, omission, build, artifact, and nondeterminism mutations. + +The smallest justified follow-up after any preserved 0.5 failure is a new +preregistered development experiment using new development seeds. Final 0.5 +seeds, gates, and mechanism code must not be repaired in response to their +one-shot result. diff --git a/RAVEL_0_5_SCOPE.md b/RAVEL_0_5_SCOPE.md new file mode 100644 index 0000000..38ee61f --- /dev/null +++ b/RAVEL_0_5_SCOPE.md @@ -0,0 +1,41 @@ +# RAVEL 0.5 adaptive-mechanism correction scope + +RAVEL 0.5 is a bounded correction to the synthetic recursive-expert study. It +uses RAVEL 0.4 as historical development information but does not rewrite the +0.4 mechanism, seeds, gates, or evidence. + +## In scope + +- move every hard-gate, trial, aggregate, and development disposition into an + independent Python evaluator; +- emit raw integer observations and integrity facts from the C harness; +- freeze four fresh validation seeds for each of the eight existing regime + families after mechanism development; +- replace periodic replay with deterministic stratified replay covering labels, + actions, source states, assigned experts, transition support, rare events, and + high-loss events; +- make expert births and retirements optional, bounded, and dependent only on + adaptation-training and replay measurements; +- use normalized, separately recorded residual channels with deterministic + tie-breaking; +- anchor base experts while allowing separate adaptation experts; +- represent unsupported transitions as unknown and retain two supported + transition targets where ambiguity is observed; +- separate exact state, goal expert, belief-set, graph-disconnection, + unsupported-edge, transition-error, and aliasing planning measurements; +- protect rare coverage, transition connectivity, reconstruction and prediction + support, lifecycle, lineage, and topology uniqueness during retirement; +- add matched-work, matched-count, matched-capacity, replay-policy, no-birth, + and no-retirement comparisons with paired per-seed and Pareto reporting; and +- bind source, evaluator, evidence tooling, build flags, schemas, CI, and + maintained provenance into one ordered source and execution manifest. + +## Out of scope + +RAVEL 0.5 does not add language modeling, multimodal generation, learned +real-world perception, external side effects, deployment authorization, +production rollback, distributed training, accelerator claims, or a formal +conformance claim. + +All evidence is repository-visible development evidence. Formal MNCS status is +`UNKNOWN`; formal MNCDS status is `UNKNOWN`; promotion is unauthorized. diff --git a/ravel-0.5-development-corpus.json b/ravel-0.5-development-corpus.json new file mode 100644 index 0000000..2dadf93 --- /dev/null +++ b/ravel-0.5-development-corpus.json @@ -0,0 +1,27 @@ +{ + "schema": "ravel-development-corpus/0.5", + "purpose": "mechanism development only; excluded from final validation", + "root_seed": "0x524156454c354445", + "derivation": { + "algorithm": "sha256-first-u64-big-endian", + "framing": "root_seed_u64_be || utf8('development\\0') || utf8(regime) || zero_byte || index_u32_be" + }, + "trials": [ + {"trial_id": "dev-separated-01", "regime": "separated_state", "seed": "0xe6cd60cd9235fc25"}, + {"trial_id": "dev-separated-02", "regime": "separated_state", "seed": "0xe45a783ec991f987"}, + {"trial_id": "dev-overlap-01", "regime": "partially_overlapping_observations", "seed": "0x6a6232f008add61a"}, + {"trial_id": "dev-overlap-02", "regime": "partially_overlapping_observations", "seed": "0xbcd915310d00bc76"}, + {"trial_id": "dev-noise-01", "regime": "increased_observation_noise", "seed": "0x5bc6312ee9b3c9ab"}, + {"trial_id": "dev-noise-02", "regime": "increased_observation_noise", "seed": "0x164a5ffaa55ce99c"}, + {"trial_id": "dev-label-01", "regime": "label_drift", "seed": "0xe6b89e4c7c85d015"}, + {"trial_id": "dev-label-02", "regime": "label_drift", "seed": "0x1af5673e90272cd1"}, + {"trial_id": "dev-observation-01", "regime": "observation_drift", "seed": "0x7ce75c5e20d50dd0"}, + {"trial_id": "dev-observation-02", "regime": "observation_drift", "seed": "0xc3d9b9bf34080ee2"}, + {"trial_id": "dev-transition-01", "regime": "transition_drift", "seed": "0xc57219f81f2abf8a"}, + {"trial_id": "dev-transition-02", "regime": "transition_drift", "seed": "0xb76c0379538680b6"}, + {"trial_id": "dev-combined-01", "regime": "combined_observation_and_label_drift", "seed": "0x1646189968570d32"}, + {"trial_id": "dev-combined-02", "regime": "combined_observation_and_label_drift", "seed": "0x0c66bfc8c2d03ede"}, + {"trial_id": "dev-ambiguous-01", "regime": "partially_observed_ambiguous", "seed": "0xc6f19aa0149e9fbf"}, + {"trial_id": "dev-ambiguous-02", "regime": "partially_observed_ambiguous", "seed": "0x02d98bd1f0d9fce5"} + ] +} diff --git a/ravel-0.5-limitations.md b/ravel-0.5-limitations.md new file mode 100644 index 0000000..e59f4af --- /dev/null +++ b/ravel-0.5-limitations.md @@ -0,0 +1,25 @@ +# RAVEL 0.5 limitations + +- All trials are deterministic synthetic development observations without + independent protected custody. +- Four seeds per regime measure bounded variation, not real-world diversity. +- Anchored base experts address the observed retention failure but are not a + general continual-learning guarantee. +- The two-target transition representation is bounded and support-aware, not a + general probabilistic world model. +- Belief-set planning gives alias-aware credit only within the declared + synthetic observation equivalence; exact hidden-state outcomes remain low in + genuinely ambiguous cases. +- Baselines and ablations share one C harness. Paired and Pareto reporting + improves fairness but does not establish superiority over external systems. +- Deterministic operation counts are canonical; wall-clock measurements are + host-specific and non-normative. +- Checkpoint identity and behavioral reproduction do not provide signing, + authorization, deployment monitoring, or production rollback authority. +- Exact routed-versus-complete agreement proves routing equivalence only. +- Repository-local reproduction is not cross-organizational reproduction. +- No result establishes general AI, language or multimodal capability, + real-data generalization, production readiness, or formal conformance. +- Formal MNCS status remains `UNKNOWN`. +- Formal MNCDS status remains `UNKNOWN`. +- Promotion remains unauthorized. diff --git a/ravel-0.5-preregistration.json b/ravel-0.5-preregistration.json new file mode 100644 index 0000000..edbe17a --- /dev/null +++ b/ravel-0.5-preregistration.json @@ -0,0 +1,253 @@ +{ + "schema": "ravel-preregistration/0.5", + "study_id": "ravel.adaptive-mechanism-correction.epoch-1", + "candidate_id": "ravel-0.5-candidate-1", + "freeze": { + "state": "FROZEN", + "frozen_before_final_validation": true, + "development_corpus": "ravel-0.5-development-corpus.json", + "final_validation_use": "one_shot" + }, + "seed_derivation": { + "root_seed": "0x524156454c354649", + "algorithm": "sha256-first-u64-big-endian", + "framing": "root_seed_u64_be || utf8('validation\\0') || utf8(regime) || zero_byte || index_u32_be", + "validation_seeds_per_regime": 4 + }, + "datasets_per_trial": { + "base_training": 1024, + "base_holdout": 256, + "drift_adaptation_training": 512, + "drift_holdout": 256, + "original_task_retention_holdout": 256, + "planning_cases": 64 + }, + "dataset_prohibitions": [ + "drift_holdout is forbidden for replay, births, refinement, retirement, thresholds, topology, and model selection", + "original_task_retention_holdout is forbidden for replay, births, refinement, retirement, thresholds, topology, and model selection", + "planning cases are forbidden for replay, births, refinement, retirement, thresholds, topology, and model selection", + "final validation observations cannot repair this candidate, its seeds, regimes, or gates" + ], + "mechanism_constants": { + "dimensions": 8, + "classes": 8, + "actions": 4, + "states": 64, + "maximum_experts": 80, + "checkpoint_schema": 5, + "evidence_schema": "0.5", + "transition_top_k": 2, + "transition_support_min": 2, + "replay_count": 256, + "maximum_adaptation_births": 16, + "maximum_adaptation_retirements": 4, + "topology_objective_min_q20": 105, + "birth_residual_min_q20": 188744 + }, + "trials": [ + {"trial_id": "validation-separated-01", "regime": "separated_state", "seed": "0xd61698008d192310"}, + {"trial_id": "validation-separated-02", "regime": "separated_state", "seed": "0xaf704736a9144c08"}, + {"trial_id": "validation-separated-03", "regime": "separated_state", "seed": "0x45894249803b385a"}, + {"trial_id": "validation-separated-04", "regime": "separated_state", "seed": "0x6b14192d06857894"}, + {"trial_id": "validation-overlap-01", "regime": "partially_overlapping_observations", "seed": "0xb8c7841518d48d8c"}, + {"trial_id": "validation-overlap-02", "regime": "partially_overlapping_observations", "seed": "0x3cfbef3be50fce38"}, + {"trial_id": "validation-overlap-03", "regime": "partially_overlapping_observations", "seed": "0xe38c303e80ef16a9"}, + {"trial_id": "validation-overlap-04", "regime": "partially_overlapping_observations", "seed": "0xb240684596a68108"}, + {"trial_id": "validation-noise-01", "regime": "increased_observation_noise", "seed": "0x44ed3e5b3038b65f"}, + {"trial_id": "validation-noise-02", "regime": "increased_observation_noise", "seed": "0xe8de8b800dc18a66"}, + {"trial_id": "validation-noise-03", "regime": "increased_observation_noise", "seed": "0x0f5d03772bddb16f"}, + {"trial_id": "validation-noise-04", "regime": "increased_observation_noise", "seed": "0x8737c70577b4fdf1"}, + {"trial_id": "validation-label-01", "regime": "label_drift", "seed": "0xc5c651d456b06744"}, + {"trial_id": "validation-label-02", "regime": "label_drift", "seed": "0xbca063ccfee7e743"}, + {"trial_id": "validation-label-03", "regime": "label_drift", "seed": "0x27b73cba3e16bfb3"}, + {"trial_id": "validation-label-04", "regime": "label_drift", "seed": "0x8ad341ed9d31e4b2"}, + {"trial_id": "validation-observation-01", "regime": "observation_drift", "seed": "0xd16b29b526b37eba"}, + {"trial_id": "validation-observation-02", "regime": "observation_drift", "seed": "0xb1c136bde36659bf"}, + {"trial_id": "validation-observation-03", "regime": "observation_drift", "seed": "0xcdfacd756a25c973"}, + {"trial_id": "validation-observation-04", "regime": "observation_drift", "seed": "0x76a01eddce0b3fc5"}, + {"trial_id": "validation-transition-01", "regime": "transition_drift", "seed": "0xcd5ff324852e0944"}, + {"trial_id": "validation-transition-02", "regime": "transition_drift", "seed": "0x446029e572acbddb"}, + {"trial_id": "validation-transition-03", "regime": "transition_drift", "seed": "0x60919d13af913fb7"}, + {"trial_id": "validation-transition-04", "regime": "transition_drift", "seed": "0xe8f0f59872923c4c"}, + {"trial_id": "validation-combined-01", "regime": "combined_observation_and_label_drift", "seed": "0x979e1c635f578971"}, + {"trial_id": "validation-combined-02", "regime": "combined_observation_and_label_drift", "seed": "0xae29c26efd3217a6"}, + {"trial_id": "validation-combined-03", "regime": "combined_observation_and_label_drift", "seed": "0xbb7d6905881932af"}, + {"trial_id": "validation-combined-04", "regime": "combined_observation_and_label_drift", "seed": "0x5a6a789f3e8a6718"}, + {"trial_id": "validation-ambiguous-01", "regime": "partially_observed_ambiguous", "seed": "0xf2128c2769bbcb97"}, + {"trial_id": "validation-ambiguous-02", "regime": "partially_observed_ambiguous", "seed": "0xdad034619fabf595"}, + {"trial_id": "validation-ambiguous-03", "regime": "partially_observed_ambiguous", "seed": "0x81024ac97a8edb6c"}, + {"trial_id": "validation-ambiguous-04", "regime": "partially_observed_ambiguous", "seed": "0x6a4bbee6ac7a2a32"} + ], + "comparison_variants": [ + "ravel_0_5_candidate", + "fixed_8_expert", + "flat_64_expert_complete_scan", + "fixed_topology_64_expert_routed", + "nearest_centroid_16_no_recursive_births", + "no_adaptation_static", + "ravel_without_replay", + "ravel_without_retirement_matched_work", + "ravel_complete_scan_without_certification", + "ravel_no_birth_same_replay_iterations", + "ravel_random_births", + "periodic_replay_policy", + "matched_compute_fixed_topology", + "matched_expert_count_capacity" + ], + "common_gates": [ + {"gate_id": "adaptation_completed", "metric": "adaptation_completed", "operator": "eq", "value": true, "rationale": "The bounded adaptation procedure must complete."}, + {"gate_id": "base_holdout_accuracy", "metric": "base_accuracy", "operator": "ge", "value": 0.85, "rationale": "The base representation must establish the bounded task before drift."}, + {"gate_id": "base_holdout_retention", "metric": "retention_accuracy", "operator": "ge", "value": 0.9, "rationale": "Anchored base behavior may lose at most ten percentage points in absolute retained accuracy."}, + {"gate_id": "routing_oracle_equivalence", "metric": "routing_mismatches", "operator": "eq", "value": 0, "rationale": "Every routed classification must agree with complete scan."}, + {"gate_id": "checkpoint_roundtrip", "metric": "checkpoint_roundtrip", "operator": "eq", "value": true, "rationale": "Canonical in-memory restoration must succeed."}, + {"gate_id": "checkpoint_identity", "metric": "checkpoint_identity", "operator": "eq", "value": true, "rationale": "Restored complete model identity must match."}, + {"gate_id": "checkpoint_behavior", "metric": "checkpoint_behavior", "operator": "eq", "value": true, "rationale": "Restored evaluation and planning behavior must match."}, + {"gate_id": "checkpoint_mutation_rejection", "metric": "checkpoint_mutations", "operator": "eq", "value": true, "rationale": "Every declared behavioral and byte-level checkpoint mutation must be detected."}, + {"gate_id": "lineage_invariants", "metric": "lineage_invariants", "operator": "eq", "value": true, "rationale": "Generation, lineage uniqueness, descendant splitting, and deterministic topology invariants must hold."}, + {"gate_id": "unsupported_transitions_unknown", "metric": "unsupported_graph_edge_violations", "operator": "eq", "value": 0, "rationale": "Unsupported actions cannot enter the planning graph."}, + {"gate_id": "replay_size", "metric": "replay_selected", "operator": "eq", "value": 256, "rationale": "The declared replay budget must be filled on the non-sparse trial corpus."}, + {"gate_id": "replay_unique", "metric": "replay_unique", "operator": "eq", "value": 256, "rationale": "Balanced replay cannot introduce accidental duplicates."}, + {"gate_id": "replay_label_coverage", "metric": "replay_labels_covered", "operator": "eq", "value": 8, "rationale": "Replay must retain every declared label."}, + {"gate_id": "replay_action_coverage", "metric": "replay_actions_covered", "operator": "eq", "value": 4, "rationale": "Replay must retain every declared action."}, + {"gate_id": "replay_state_coverage", "metric": "replay_states_covered", "operator": "ge", "value": 60, "rationale": "Replay must cover at least 60 of 64 source states."}, + {"gate_id": "replay_expert_coverage", "metric": "replay_experts_covered", "operator": "ge", "value": 60, "rationale": "Replay must retain broad assigned-expert coverage."}, + {"gate_id": "replay_transition_coverage", "metric": "replay_transition_pairs_covered", "operator": "ge", "value": 220, "rationale": "Replay must preserve broad source-state/action transition support."}, + {"gate_id": "planning_path_found", "metric": "path_found_rate", "operator": "ge", "value": 0.75, "rationale": "At least three quarters of bounded planning cases must have a supported path."}, + {"gate_id": "expert_capacity", "metric": "expert_count", "operator": "le", "value": 80, "rationale": "Adaptation cannot exceed the declared expert capacity."}, + {"gate_id": "retirement_budget", "metric": "accepted_retirements", "operator": "le", "value": 4, "rationale": "Retirement remains optional and bounded."}, + {"gate_id": "topology_objective_non_degradation", "metric": "topology_objective_gain_q20", "operator": "ge", "value": 0, "rationale": "Accepted adaptation-training topology decisions cannot reduce their declared objective."}, + {"gate_id": "matched_compute_budget", "metric": "matched_compute_training_evaluation_ratio", "operator": "le", "value": 1.1, "rationale": "Candidate training work may exceed the matched fixed-topology budget by at most ten percent."}, + {"gate_id": "conditional_inference_efficiency", "metric": "inference_evaluation_ratio_vs_flat64", "operator": "le", "value": 0.25, "rationale": "Routed inference must use at most one quarter of flat complete-scan expert evaluations."} + ], + "regime_gates": { + "separated_state": [ + {"gate_id": "separated_accuracy", "metric": "adapted_drift_accuracy", "operator": "ge", "value": 0.9, "rationale": "The separated-state task remains high-accuracy after adaptation."}, + {"gate_id": "separated_non_inferiority", "metric": "drift_accuracy_delta", "operator": "ge", "value": -0.02, "rationale": "An already strong static model must not lose more than two points."}, + {"gate_id": "separated_headroom", "metric": "headroom_normalized_accuracy_improvement", "operator": "ge", "value": 0, "rationale": "Available accuracy headroom cannot worsen."}, + {"gate_id": "separated_reconstruction", "metric": "reconstruction_improvement_ratio", "operator": "ge", "value": 0, "rationale": "Adaptation cannot worsen separated-state reconstruction."}, + {"gate_id": "separated_prediction", "metric": "prediction_improvement_ratio", "operator": "ge", "value": 0, "rationale": "Adaptation cannot worsen separated-state prediction."}, + {"gate_id": "separated_exact_planning", "metric": "exact_state_rate", "operator": "ge", "value": 0.65, "rationale": "Separated observations support an exact-state capability gate."}, + {"gate_id": "separated_bounded_births", "metric": "accepted_births", "operator": "le", "value": 12, "rationale": "The low-drift regime cannot consume the full topology budget."} + ], + "partially_overlapping_observations": [ + {"gate_id": "overlap_accuracy", "metric": "adapted_drift_accuracy", "operator": "ge", "value": 0.9, "rationale": "Overlap must retain high adapted classification."}, + {"gate_id": "overlap_non_inferiority", "metric": "drift_accuracy_delta", "operator": "ge", "value": -0.02, "rationale": "Limited headroom uses non-inferiority rather than a fixed gain."}, + {"gate_id": "overlap_headroom", "metric": "headroom_normalized_accuracy_improvement", "operator": "ge", "value": 0, "rationale": "Available accuracy headroom cannot worsen."}, + {"gate_id": "overlap_reconstruction", "metric": "reconstruction_improvement_ratio", "operator": "ge", "value": 0, "rationale": "Adaptation cannot worsen overlapping-observation reconstruction."}, + {"gate_id": "overlap_prediction", "metric": "prediction_improvement_ratio", "operator": "ge", "value": 0, "rationale": "Adaptation cannot worsen overlapping-observation prediction."}, + {"gate_id": "overlap_exact_planning", "metric": "exact_state_rate", "operator": "ge", "value": 0.65, "rationale": "Partial overlap remains distinguishable enough for exact-state planning."}, + {"gate_id": "overlap_bounded_births", "metric": "accepted_births", "operator": "le", "value": 12, "rationale": "The low-drift regime cannot consume the full topology budget."} + ], + "increased_observation_noise": [ + {"gate_id": "noise_accuracy", "metric": "adapted_drift_accuracy", "operator": "ge", "value": 0.9, "rationale": "Noisy observations must retain high adapted classification."}, + {"gate_id": "noise_non_inferiority", "metric": "drift_accuracy_delta", "operator": "ge", "value": -0.02, "rationale": "Limited headroom uses non-inferiority rather than a fixed gain."}, + {"gate_id": "noise_headroom", "metric": "headroom_normalized_accuracy_improvement", "operator": "ge", "value": 0, "rationale": "Available accuracy headroom cannot worsen."}, + {"gate_id": "noise_reconstruction", "metric": "reconstruction_improvement_ratio", "operator": "ge", "value": 0, "rationale": "Adaptation cannot worsen reconstruction under increased noise."}, + {"gate_id": "noise_prediction", "metric": "prediction_improvement_ratio", "operator": "ge", "value": 0, "rationale": "Adaptation cannot worsen prediction under increased noise."}, + {"gate_id": "noise_exact_planning", "metric": "exact_state_rate", "operator": "ge", "value": 0.5, "rationale": "Noise permits a lower but explicit exact-state planning floor."}, + {"gate_id": "noise_bounded_births", "metric": "accepted_births", "operator": "le", "value": 12, "rationale": "The low-drift regime cannot consume the full topology budget."} + ], + "label_drift": [ + {"gate_id": "label_adaptation", "metric": "adapted_drift_accuracy", "operator": "ge", "value": 0.6, "rationale": "Changed labels must be learned above the bounded floor."}, + {"gate_id": "label_gain", "metric": "drift_accuracy_delta", "operator": "ge", "value": 0.04, "rationale": "Label adaptation must improve untouched drift accuracy by at least four points."}, + {"gate_id": "old_label_retention", "metric": "retention_accuracy_delta_from_base", "operator": "ge", "value": -0.1, "rationale": "Old-label accuracy cannot fall more than ten points from base holdout."}, + {"gate_id": "label_planning_non_inferiority", "metric": "exact_state_rate_delta", "operator": "ge", "value": -0.05, "rationale": "Unchanged observations and transitions should not materially damage exact planning."} + ], + "observation_drift": [ + {"gate_id": "observation_accuracy", "metric": "adapted_drift_accuracy", "operator": "ge", "value": 0.9, "rationale": "Observation drift emphasizes routed classification."}, + {"gate_id": "observation_non_inferiority", "metric": "drift_accuracy_delta", "operator": "ge", "value": -0.02, "rationale": "An already solved observation task uses non-inferiority."}, + {"gate_id": "observation_reconstruction", "metric": "reconstruction_improvement_ratio", "operator": "ge", "value": 0, "rationale": "Observation adaptation cannot worsen reconstruction."}, + {"gate_id": "observation_prediction", "metric": "prediction_improvement_ratio", "operator": "ge", "value": 0, "rationale": "Observation adaptation cannot worsen next-observation prediction."}, + {"gate_id": "observation_reconstruction_retention", "metric": "retention_reconstruction_degradation_ratio", "operator": "le", "value": 0.1, "rationale": "Original-task reconstruction may degrade by at most ten percent."}, + {"gate_id": "observation_exact_planning", "metric": "exact_state_rate", "operator": "ge", "value": 0.75, "rationale": "Observation drift remains fully observed and uses exact-state planning."}, + {"gate_id": "observation_bounded_births", "metric": "accepted_births", "operator": "le", "value": 12, "rationale": "Limited headroom cannot justify the full birth budget."} + ], + "transition_drift": [ + {"gate_id": "transition_classification", "metric": "adapted_drift_accuracy", "operator": "ge", "value": 0.9, "rationale": "Transition correction cannot sacrifice classification."}, + {"gate_id": "transition_prediction_improvement", "metric": "prediction_improvement_ratio", "operator": "ge", "value": 0.01, "rationale": "Changed transitions require at least one percent relative prediction improvement."}, + {"gate_id": "transition_accuracy_non_inferiority", "metric": "transition_accuracy_delta", "operator": "ge", "value": -0.05, "rationale": "Supported transition accuracy cannot lose more than five points."}, + {"gate_id": "old_prediction_retention", "metric": "retention_prediction_degradation", "operator": "le", "value": 1, "rationale": "Original-task prediction RMSE may rise by at most one observation unit."}, + {"gate_id": "old_transition_retention", "metric": "retention_transition_accuracy_delta", "operator": "ge", "value": -0.1, "rationale": "Original supported transition accuracy may fall by at most ten points."}, + {"gate_id": "transition_exact_planning", "metric": "exact_state_rate", "operator": "ge", "value": 0.25, "rationale": "Transition drift retains a bounded exact-state planning floor."}, + {"gate_id": "transition_planning_non_inferiority", "metric": "exact_state_rate_delta", "operator": "ge", "value": -0.05, "rationale": "Adaptation cannot materially reduce exact planning relative to static."} + ], + "combined_observation_and_label_drift": [ + {"gate_id": "combined_adaptation", "metric": "adapted_drift_accuracy", "operator": "ge", "value": 0.65, "rationale": "Combined drift requires useful untouched-holdout classification."}, + {"gate_id": "combined_gain", "metric": "drift_accuracy_delta", "operator": "ge", "value": 0.05, "rationale": "Combined drift requires a meaningful absolute adaptation gain."}, + {"gate_id": "combined_reconstruction", "metric": "reconstruction_improvement_ratio", "operator": "ge", "value": 0, "rationale": "Observation correction cannot be averaged away by label gain."}, + {"gate_id": "combined_prediction", "metric": "prediction_improvement_ratio", "operator": "ge", "value": 0, "rationale": "Prediction correction cannot be averaged away by classification gain."}, + {"gate_id": "combined_transition_non_inferiority", "metric": "transition_accuracy_delta", "operator": "ge", "value": -0.15, "rationale": "Combined behavior permits bounded transition variance but not collapse."}, + {"gate_id": "combined_reconstruction_retention", "metric": "retention_reconstruction_degradation_ratio", "operator": "le", "value": 0.1, "rationale": "Original-task reconstruction cannot materially degrade."}, + {"gate_id": "combined_prediction_retention", "metric": "retention_prediction_degradation", "operator": "le", "value": 1, "rationale": "Original-task prediction cannot materially degrade."}, + {"gate_id": "combined_exact_planning", "metric": "exact_state_rate", "operator": "ge", "value": 0.5, "rationale": "The combined regime remains fully observed and gates exact planning."} + ], + "partially_observed_ambiguous": [ + {"gate_id": "ambiguous_adaptation", "metric": "adapted_drift_accuracy", "operator": "ge", "value": 0.7, "rationale": "Visible evidence must support useful classification despite hidden-state aliasing."}, + {"gate_id": "ambiguous_gain", "metric": "drift_accuracy_delta", "operator": "ge", "value": 0.05, "rationale": "The aliased regime has adaptation headroom and requires improvement."}, + {"gate_id": "ambiguous_belief_success", "metric": "belief_set_rate", "operator": "ge", "value": 0.2, "rationale": "Belief-set target success is the capability gate under declared aliasing."}, + {"gate_id": "ambiguous_belief_gain", "metric": "belief_set_rate_delta", "operator": "ge", "value": 0.05, "rationale": "Adaptation must improve alias-aware planning over the static model."}, + {"gate_id": "ambiguous_reconstruction_retention", "metric": "retention_reconstruction_degradation_ratio", "operator": "le", "value": 0.1, "rationale": "Original visible-state reconstruction cannot materially degrade."}, + {"gate_id": "ambiguous_prediction_retention", "metric": "retention_prediction_degradation", "operator": "le", "value": 1, "rationale": "Original visible-state prediction cannot materially degrade."} + ] + }, + "global_pass_rule": { + "minimum_passing_trials": 32, + "minimum_passing_trials_per_regime": 4, + "all_integrity_gates_required": true + }, + "negative_test_dispositions": { + "malformed_observation": {"expected_disposition": "reject", "expected_observation": true, "rationale": "Invalid action encoding is rejected."}, + "out_of_domain_value": {"expected_disposition": "fall_back", "expected_observation": true, "rationale": "Out-of-domain routing cannot certify and uses complete scan."}, + "empty_expert_assignment": {"expected_disposition": "reject", "expected_observation": true, "rationale": "An empty model has no valid assignment."}, + "degenerate_expert_assignment": {"expected_disposition": "reject", "expected_observation": true, "rationale": "A split without two nonempty assignments is rejected."}, + "duplicate_expert": {"expected_disposition": "reject", "expected_observation": true, "rationale": "Duplicate behaviorally identical experts violate topology uniqueness."}, + "tied_distance": {"expected_disposition": "fall_back", "expected_observation": true, "rationale": "Ties resolve deterministically to the lower expert ID."}, + "routing_lower_bound_equality": {"expected_disposition": "fall_back", "expected_observation": true, "rationale": "Lower-bound equality cannot certify early return."}, + "maximum_expert_capacity": {"expected_disposition": "preserve_non_promotion", "expected_observation": true, "rationale": "The model preserves the declared maximum capacity."}, + "birth_beyond_capacity": {"expected_disposition": "reject", "expected_observation": true, "rationale": "A birth beyond capacity is rejected."}, + "wrong_lifecycle_retirement": {"expected_disposition": "reject", "expected_observation": true, "rationale": "Anchored or wrong-class experts cannot be retired."}, + "poisoned_adaptation_labels": {"expected_disposition": "fail_a_gate", "expected_observation": true, "rationale": "Poisoned labels produce a retention failure condition."}, + "poisoned_transition_observations": {"expected_disposition": "fail_a_gate", "expected_observation": true, "rationale": "Poisoned next observations produce a prediction failure condition."}, + "replay_removal_experiment": {"expected_disposition": "fail_a_gate", "expected_observation": true, "rationale": "A distinct no-replay experiment is worse than protected balanced replay."}, + "catastrophic_forgetting_experiment": {"expected_disposition": "fail_a_gate", "expected_observation": true, "rationale": "Repeated unprotected updates create a distinct forgetting condition."}, + "balanced_replay_determinism": {"expected_disposition": "preserve_non_promotion", "expected_observation": true, "rationale": "Repeated stratified selection is byte-for-byte deterministic."}, + "balanced_replay_no_duplicates": {"expected_disposition": "preserve_non_promotion", "expected_observation": true, "rationale": "Replay selection contains no accidental duplicates."}, + "balanced_replay_coverage": {"expected_disposition": "preserve_non_promotion", "expected_observation": true, "rationale": "Replay covers every label, action, and state in the fixture."}, + "balanced_replay_sparse_strata": {"expected_disposition": "preserve_non_promotion", "expected_observation": true, "rationale": "Sparse strata terminate without invented duplicates."}, + "classification_residual_fixture": {"expected_disposition": "preserve_non_promotion", "expected_observation": true, "rationale": "Classification residual changes the normalized birth score."}, + "reconstruction_residual_fixture": {"expected_disposition": "preserve_non_promotion", "expected_observation": true, "rationale": "Reconstruction residual changes the normalized birth score."}, + "prediction_residual_fixture": {"expected_disposition": "preserve_non_promotion", "expected_observation": true, "rationale": "Prediction residual changes the normalized birth score."}, + "novelty_residual_fixture": {"expected_disposition": "preserve_non_promotion", "expected_observation": true, "rationale": "Novelty residual changes the normalized birth score."}, + "inverse_support_residual_fixture": {"expected_disposition": "preserve_non_promotion", "expected_observation": true, "rationale": "Inverse support changes the normalized birth score."}, + "uncertainty_residual_fixture": {"expected_disposition": "preserve_non_promotion", "expected_observation": true, "rationale": "Uncertainty changes the normalized birth score."}, + "action_coverage_residual_fixture": {"expected_disposition": "preserve_non_promotion", "expected_observation": true, "rationale": "Missing action coverage changes the normalized birth score."}, + "retention_risk_residual_fixture": {"expected_disposition": "preserve_non_promotion", "expected_observation": true, "rationale": "Anchored retention risk changes the normalized birth score."}, + "unsupported_action_unknown": {"expected_disposition": "preserve_non_promotion", "expected_observation": true, "rationale": "An unsupported action remains an unknown graph edge."}, + "top_k_transition_ambiguity": {"expected_disposition": "preserve_non_promotion", "expected_observation": true, "rationale": "Two supported transition targets are retained deterministically."}, + "retirement_unique_support_safety": {"expected_disposition": "reject", "expected_observation": true, "rationale": "Retirement that destroys unique support is rejected."}, + "retirement_checkpoint_remap": {"expected_disposition": "preserve_non_promotion", "expected_observation": true, "rationale": "Transition target identities are remapped or invalidated after expert compaction and survive canonical roundtrip."}, + "non_finite_serialization": {"expected_disposition": "reject", "expected_observation": true, "rationale": "Non-finite model state cannot be serialized."}, + "overflow_serialization": {"expected_disposition": "reject", "expected_observation": true, "rationale": "Fixed-point overflow cannot be serialized."}, + "raw_metric_mutation": {"expected_disposition": "reject", "expected_observation": true, "rationale": "A changed raw metric changes canonical derived evidence and fails verification."}, + "threshold_mutation": {"expected_disposition": "reject", "expected_observation": true, "rationale": "A changed threshold invalidates the preregistration digest."}, + "executable_trial_result_injection": {"expected_disposition": "reject", "expected_observation": true, "rationale": "An executable-emitted trial result is an unknown raw field."}, + "executable_gate_boolean_injection": {"expected_disposition": "reject", "expected_observation": true, "rationale": "An executable-emitted hard gate is an unknown raw field."}, + "seed_mutation": {"expected_disposition": "reject", "expected_observation": true, "rationale": "Trial seeds must match the frozen derivation."}, + "regime_mutation": {"expected_disposition": "reject", "expected_observation": true, "rationale": "Trial regimes must match the frozen matrix."}, + "aggregate_mutation": {"expected_disposition": "reject", "expected_observation": true, "rationale": "Executable-emitted aggregate or global verdicts are unknown raw fields."}, + "stale_manifest": {"expected_disposition": "reject", "expected_observation": true, "rationale": "A stale source digest cannot equal independent recalculation."}, + "stale_assurance": {"expected_disposition": "reject", "expected_observation": true, "rationale": "Assurance must bind the exact manifest and source digest."}, + "substituted_source": {"expected_disposition": "reject", "expected_observation": true, "rationale": "A substituted maintained source hash fails manifest equality."}, + "reordered_file": {"expected_disposition": "reject", "expected_observation": true, "rationale": "Manifest file order is digest authority."}, + "omitted_file": {"expected_disposition": "reject", "expected_observation": true, "rationale": "An omitted authority fails exact manifest equality."}, + "build_configuration_mutation": {"expected_disposition": "reject", "expected_observation": true, "rationale": "Compiler flags and build identity are manifest authority."}, + "artifact_mutation": {"expected_disposition": "reject", "expected_observation": true, "rationale": "Changed declared bytes fail exact manifest equality."}, + "evidence_file_mutation": {"expected_disposition": "reject", "expected_observation": true, "rationale": "Canonical evidence identity changes when evidence content changes."}, + "nondeterministic_output_detection": {"expected_disposition": "reject", "expected_observation": true, "rationale": "Each trial and self-test is executed twice and must be byte-identical."} + }, + "formal_status_regardless_of_development_result": { + "mncs": "UNKNOWN", + "mncds": "UNKNOWN", + "promotion_authorized": false + } +} diff --git a/ravel-0.5-source-manifest-spec.json b/ravel-0.5-source-manifest-spec.json new file mode 100644 index 0000000..140458b --- /dev/null +++ b/ravel-0.5-source-manifest-spec.json @@ -0,0 +1,114 @@ +{ + "schema": "ravel-source-manifest-specification/0.5", + "entrypoint": "case-studies/ravel/ravel_0_5.c", + "maintained_execution_sources": [ + "case-studies/ravel/ravel_0_5.c" + ], + "generated_execution_shards": [], + "execution_source_discovery_globs": [ + "case-studies/ravel/ravel_0_5*.c", + "case-studies/ravel/ravel_0_5*.inc" + ], + "source_provenance": { + "classification": "maintained_source", + "generator": null, + "statement": "RAVEL 0.5 is directly maintained C11 source. No higher-level generator or generated execution shard exists." + }, + "build_configuration": { + "language": "C", + "standard": "C11", + "canonical_compiler": "cc", + "canonical_flags": [ + "-std=c11", + "-O3", + "-Wall", + "-Wextra", + "-Werror", + "-pedantic" + ], + "link_libraries": [ + "m" + ] + }, + "checkpoint_schema": { + "magic_hex": "524156454c303500", + "version": 5, + "byte_order": "big_endian", + "real_encoding": "signed_q20_int64", + "payload_digest": "sha256" + }, + "evidence_schema_versions": [ + "ravel-preregistration/0.5", + "ravel-raw-trial/0.5", + "ravel-raw-observations/0.5", + "ravel-self-test-observations/0.5", + "ravel-trial-evidence/0.5", + "ravel-negative-evidence/0.5", + "ravel-source-and-execution-manifest/0.5", + "ravel-assurance-case/0.5" + ], + "digest_algorithm": "sha256", + "digest_procedure": "For each ordered entry, hash uint32_be(path_utf8_length), path_utf8, uint64_be(content_length), and exact content bytes; concatenate frames into one SHA-256 stream.", + "ordered_files": [ + { + "role": "entrypoint", + "path": "case-studies/ravel/ravel_0_5.c" + }, + { + "role": "contract", + "path": "case-studies/ravel/RAVEL_0_5_CONTRACT.md" + }, + { + "role": "scope", + "path": "case-studies/ravel/RAVEL_0_5_SCOPE.md" + }, + { + "role": "postmortem", + "path": "case-studies/ravel/RAVEL_0_5_POSTMORTEM.md" + }, + { + "role": "development_corpus", + "path": "case-studies/ravel/ravel-0.5-development-corpus.json" + }, + { + "role": "preregistration", + "path": "case-studies/ravel/ravel-0.5-preregistration.json" + }, + { + "role": "threat_model", + "path": "case-studies/ravel/ravel-0.5-threat-model.json" + }, + { + "role": "limitations", + "path": "case-studies/ravel/ravel-0.5-limitations.md" + }, + { + "role": "independent_evaluator", + "path": "case-studies/ravel/tools/ravel_0_5_evaluator.py" + }, + { + "role": "evidence_generator", + "path": "case-studies/ravel/tools/ravel_0_5_evidence.py" + }, + { + "role": "source_digest_utility", + "path": "case-studies/ravel/tools/ravel_0_5_source_digest.py" + }, + { + "role": "manifest_specification", + "path": "case-studies/ravel/ravel-0.5-source-manifest-spec.json" + }, + { + "role": "case_build_specification", + "path": "case-studies/ravel/Makefile" + }, + { + "role": "root_build_specification", + "path": "Makefile" + }, + { + "role": "ci_workflow", + "path": ".github/workflows/ravel-0.5.yml" + } + ] +} diff --git a/ravel-0.5-threat-model.json b/ravel-0.5-threat-model.json new file mode 100644 index 0000000..3f68fdc --- /dev/null +++ b/ravel-0.5-threat-model.json @@ -0,0 +1,67 @@ +{ + "schema": "ravel-threat-model/0.5", + "threat_model_id": "ravel.adaptive-mechanism-correction.threats.v1", + "assets": [ + "frozen preregistration and final validation seed boundary", + "untouched drift and retention holdouts", + "raw integer observations", + "independent gate derivation", + "canonical checkpoint identity and behavior", + "replay and topology decision provenance", + "transition support and planning dispositions", + "ordered source and execution identity" + ], + "threats": [ + { + "id": "holdout-feedback", + "control": "holdouts are passed only to post-adaptation evaluation and are prohibited from replay, topology, thresholds, and selection", + "residual": "repository-visible seeds are not protected from future studies" + }, + { + "id": "self-verdict", + "control": "the executable emits no hard gate, trial result, aggregate result, or formal disposition", + "residual": "the evaluator and harness share repository custody" + }, + { + "id": "metric-or-verdict-mutation", + "control": "strict schemas, independent recalculation, canonical comparison, and distinct mutation tests reject changes", + "residual": "no external witness or signature exists" + }, + { + "id": "replay-collapse", + "control": "deterministic strata, uniqueness, sparse-strata behavior, and coverage metrics are tested", + "residual": "the bounded strata do not model open-world rarity" + }, + { + "id": "unsafe-topology", + "control": "adaptation-only objectives, anchored experts, bounded births and retirements, and retirement invariants", + "residual": "local objectives do not prove global optimality" + }, + { + "id": "unsupported-transition", + "control": "per-action support below the frozen minimum remains unknown and cannot enter the graph", + "residual": "top-k two truncates richer transition distributions" + }, + { + "id": "planning-alias", + "control": "exact, expert, belief-set, aliasing, disconnection, unsupported, and model-error outcomes are separate", + "residual": "the synthetic belief set is provided by the harness rather than learned" + }, + { + "id": "source-or-build-substitution", + "control": "ordered manifest binds source, contracts, evaluator, generator, build files, flags, schemas, CI, and maintained provenance", + "residual": "repository hashes are not signed release attestations" + } + ], + "residual_unknowns": [ + "independent protected evaluation", + "real-data and distribution-shift behavior", + "cross-organizational and heterogeneous-host reproduction", + "operational authorization and rollback", + "formal MNCS conformance", + "formal MNCDS conformance" + ], + "formal_mncs_status": "UNKNOWN", + "formal_mncds_status": "UNKNOWN", + "promotion_authorized": false +} diff --git a/ravel_0_5.c b/ravel_0_5.c new file mode 100644 index 0000000..382bdc2 --- /dev/null +++ b/ravel_0_5.c @@ -0,0 +1,3047 @@ +/* + * RAVEL 0.5 -- bounded adaptive-mechanism correction experiment. + * + * This is maintained C11 source. No source generator is claimed. + * It emits observations and integrity facts, never development verdicts. + */ +#define _POSIX_C_SOURCE 200809L +#include +#include +#include +#include +#include +#include +#include +#include + +#define D 8u +#define CLASSES 8u +#define ACTIONS 4u +#define STATES 64u +#define MAXE 80u +#define BASE_E 64u +#define INIT_E 8u +#define MAX_ADAPT_BIRTHS 16u +#define MAX_ADAPT_RETIREMENTS 4u +#define TRANSITION_TOP_K 2u +#define TRANSITION_SUPPORT_MIN 2u +#define TOPOLOGY_OBJECTIVE_MIN_Q20 105u +#define BIRTH_RESIDUAL_MIN_Q20 188744u +#define ROUTE_K 8u +#define CELLS 256u +#define BASE_TRAIN_N 1024u +#define BASE_HOLD_N 256u +#define ADAPT_TRAIN_N 512u +#define DRIFT_HOLD_N 256u +#define RETENTION_N 256u +#define REPLAY_N 256u +#define PLAN_N 64u +#define PLAN_LIMIT 32u +#define REGIMES 8u +#define LO (-64) +#define HI 63 +#define Q20_SCALE 1048576.0 +#define CHECKPOINT_SCHEMA 5u +#define CHECKPOINT_HEADER 64u +#define CHECKPOINT_MAX 65536u +#define INVALID_EXPERT UINT16_MAX + +typedef struct { + int16_t x[D]; + int16_t nx[D]; + uint8_t action; + uint8_t label; + uint8_t state; + uint8_t next_state; + uint8_t source_domain; +} Event; + +typedef struct { + double key[D]; + double decode[D]; + double next[ACTIONS][D]; + uint32_t labels[CLASSES]; + uint32_t action_count[ACTIONS]; + uint16_t transition_target[ACTIONS][TRANSITION_TOP_K]; + uint32_t transition_support[ACTIONS][TRANSITION_TOP_K]; + uint32_t count; + uint32_t errors; + double reconstruction_sse; + double prediction_sse; + uint8_t label; + uint8_t active; + uint8_t lifecycle; + uint8_t anchored; + uint16_t generation; + uint64_t lineage; +} Expert; + +typedef struct { + uint16_t id[ROUTE_K]; + double excluded_lb; +} Cell; + +typedef struct { + Expert e[MAXE]; + Cell routing[CELLS]; + uint16_t next_graph[MAXE][ACTIONS][TRANSITION_TOP_K]; + uint32_t next_graph_support[MAXE][ACTIONS][TRANSITION_TOP_K]; + uint16_t n; + uint64_t epoch; + uint8_t identity[32]; +} Model; + +typedef struct { + uint64_t samples; + uint64_t rejected; + uint64_t correct; + uint64_t exact_mismatches; + uint64_t certified; + uint64_t expert_evaluations; + double reconstruction_sse; + double prediction_sse; + uint64_t reconstruction_sse_q20; + uint64_t prediction_sse_q20; + uint64_t prediction_samples; + uint64_t transition_correct; + uint64_t transition_supported; + uint64_t transition_unknown; + uint64_t classification_checksum; + uint64_t reconstruction_checksum; + uint64_t prediction_checksum; + uint64_t transition_checksum; +} Eval; + +typedef struct { + uint64_t samples; + uint64_t expert_evaluations; + uint64_t certified; + uint64_t births; + uint64_t retired; + uint64_t rejected_births; + uint64_t rejected_retirements; +} TrainMetric; + +typedef struct { + uint32_t selected; + uint32_t unique; + uint32_t labels_covered; + uint32_t actions_covered; + uint32_t states_covered; + uint32_t experts_covered; + uint32_t transition_pairs_covered; + uint32_t rare_cases_selected; + uint32_t high_loss_cases_selected; + uint64_t selection_checksum; +} ReplayMetric; + +typedef struct { + uint32_t accepted_births; + uint32_t rejected_births; + uint32_t accepted_retirements; + uint32_t rejected_retirements; + uint32_t birth_event_index[MAX_ADAPT_BIRTHS]; + uint32_t birth_score_q20[MAX_ADAPT_BIRTHS]; + uint8_t birth_dominant_channel[MAX_ADAPT_BIRTHS]; + uint64_t retired_lineage[MAX_ADAPT_RETIREMENTS]; + uint32_t objective_before_q20; + uint32_t objective_after_q20; +} TopologyTrace; + +typedef struct { + uint64_t cases; + uint64_t path_found; + uint64_t exact_state_targets; + uint64_t goal_expert_targets; + uint64_t belief_set_targets; + uint64_t executed_path_length; + uint64_t optimal_path_length; + uint64_t path_length_regret; + uint64_t graph_disconnection_failures; + uint64_t no_supported_edge_failures; + uint64_t transition_model_failures; + uint64_t state_aliasing_failures; + uint64_t expansions; + uint64_t checksum; +} PlanMetric; + +typedef struct { + int16_t center[STATES][D]; + uint8_t label[STATES]; + uint8_t base_next[STATES][ACTIONS]; + uint8_t drift_next[STATES][ACTIONS]; +} World; + +typedef struct { + const char *trial_id; + const char *regime; + uint64_t seed; + int amplitude; + int base_noise; + int drift_noise; + uint8_t label_drift; + uint8_t observation_drift; + uint8_t transition_drift; + uint8_t ambiguous; +} TrialSpec; + +typedef struct { + uint8_t use_replay; + uint8_t use_retirement; + uint8_t routed; + uint8_t recursive_births; + uint8_t random_births; + uint8_t replay_policy; + uint8_t protect_base; + uint8_t matched_work; +} VariantConfig; + +typedef struct { + double classification; + double reconstruction; + double prediction; + double novelty; + double inverse_support; + double uncertainty; + double action_coverage; + double retention_risk; + double total; + uint8_t dominant_channel; +} Residual; + +typedef struct { + uint8_t data[CHECKPOINT_MAX]; + size_t len; + int ok; +} ByteBuffer; + +typedef struct { + const uint8_t *data; + size_t len; + size_t pos; + int ok; +} ByteReader; + +typedef struct { + uint32_t h[8]; + uint64_t bits; + uint8_t block[64]; + size_t used; +} Sha256; + +static const TrialSpec regime_specs[REGIMES] = { + {NULL, "separated_state", 0u, 42, 5, 5, 0, 0, 0, 0}, + {NULL, "partially_overlapping_observations", 0u, 22, 7, 7, 0, 0, 0, 0}, + {NULL, "increased_observation_noise", 0u, 42, 13, 19, 0, 0, 0, 0}, + {NULL, "label_drift", 0u, 42, 5, 5, 1, 0, 0, 0}, + {NULL, "observation_drift", 0u, 42, 5, 7, 0, 1, 0, 0}, + {NULL, "transition_drift", 0u, 42, 5, 5, 0, 0, 1, 0}, + {NULL, "combined_observation_and_label_drift", 0u, 34, 7, 11, 1, 1, 0, 0}, + {NULL, "partially_observed_ambiguous", 0u, 30, 9, 11, 1, 1, 1, 1} +}; + +static uint64_t rng_state; + +static uint32_t rng_u32(void) { + rng_state ^= rng_state >> 12; + rng_state ^= rng_state << 25; + rng_state ^= rng_state >> 27; + return (uint32_t)((rng_state * UINT64_C(2685821657736338717)) >> 32); +} + +static uint64_t mix64(uint64_t x) { + x ^= x >> 30; + x *= UINT64_C(0xbf58476d1ce4e5b9); + x ^= x >> 27; + x *= UINT64_C(0x94d049bb133111eb); + return x ^ (x >> 31); +} + +static int16_t clamp_domain(int v) { + if (v < LO) return (int16_t)LO; + if (v > HI) return (int16_t)HI; + return (int16_t)v; +} + +static int q20_checked(double v, int64_t *out) { + if (out == NULL || !isfinite(v)) return 0; + if (v > (double)INT64_MAX / Q20_SCALE || + v < (double)INT64_MIN / Q20_SCALE) return 0; + *out = (int64_t)llround(v * Q20_SCALE); + return 1; +} + +static int64_t q20(double v) { + int64_t out = 0; + if (!q20_checked(v, &out)) return v < 0.0 ? INT64_MIN : INT64_MAX; + return out; +} + +static double from_q20(int64_t v) { + return (double)v / Q20_SCALE; +} + +static int bytes_equal(const uint8_t *a, const uint8_t *b, size_t n) { + if (a == NULL || b == NULL) return 0; + uint8_t difference = 0u; + for (size_t i = 0; i < n; ++i) difference |= (uint8_t)(a[i] ^ b[i]); + return difference == 0u; +} + +static uint32_t rotr32(uint32_t x, uint32_t n) { + return (x >> n) | (x << (32u - n)); +} + +static void sha256_transform(Sha256 *s, const uint8_t block[64]) { + static const uint32_t k[64] = { + UINT32_C(0x428a2f98), UINT32_C(0x71374491), UINT32_C(0xb5c0fbcf), UINT32_C(0xe9b5dba5), + UINT32_C(0x3956c25b), UINT32_C(0x59f111f1), UINT32_C(0x923f82a4), UINT32_C(0xab1c5ed5), + UINT32_C(0xd807aa98), UINT32_C(0x12835b01), UINT32_C(0x243185be), UINT32_C(0x550c7dc3), + UINT32_C(0x72be5d74), UINT32_C(0x80deb1fe), UINT32_C(0x9bdc06a7), UINT32_C(0xc19bf174), + UINT32_C(0xe49b69c1), UINT32_C(0xefbe4786), UINT32_C(0x0fc19dc6), UINT32_C(0x240ca1cc), + UINT32_C(0x2de92c6f), UINT32_C(0x4a7484aa), UINT32_C(0x5cb0a9dc), UINT32_C(0x76f988da), + UINT32_C(0x983e5152), UINT32_C(0xa831c66d), UINT32_C(0xb00327c8), UINT32_C(0xbf597fc7), + UINT32_C(0xc6e00bf3), UINT32_C(0xd5a79147), UINT32_C(0x06ca6351), UINT32_C(0x14292967), + UINT32_C(0x27b70a85), UINT32_C(0x2e1b2138), UINT32_C(0x4d2c6dfc), UINT32_C(0x53380d13), + UINT32_C(0x650a7354), UINT32_C(0x766a0abb), UINT32_C(0x81c2c92e), UINT32_C(0x92722c85), + UINT32_C(0xa2bfe8a1), UINT32_C(0xa81a664b), UINT32_C(0xc24b8b70), UINT32_C(0xc76c51a3), + UINT32_C(0xd192e819), UINT32_C(0xd6990624), UINT32_C(0xf40e3585), UINT32_C(0x106aa070), + UINT32_C(0x19a4c116), UINT32_C(0x1e376c08), UINT32_C(0x2748774c), UINT32_C(0x34b0bcb5), + UINT32_C(0x391c0cb3), UINT32_C(0x4ed8aa4a), UINT32_C(0x5b9cca4f), UINT32_C(0x682e6ff3), + UINT32_C(0x748f82ee), UINT32_C(0x78a5636f), UINT32_C(0x84c87814), UINT32_C(0x8cc70208), + UINT32_C(0x90befffa), UINT32_C(0xa4506ceb), UINT32_C(0xbef9a3f7), UINT32_C(0xc67178f2) + }; + uint32_t w[64]; + for (uint32_t i = 0; i < 16u; ++i) { + w[i] = ((uint32_t)block[i * 4u] << 24) | ((uint32_t)block[i * 4u + 1u] << 16) | + ((uint32_t)block[i * 4u + 2u] << 8) | (uint32_t)block[i * 4u + 3u]; + } + for (uint32_t i = 16u; i < 64u; ++i) { + uint32_t a = w[i - 15u], b = w[i - 2u]; + uint32_t s0 = rotr32(a, 7u) ^ rotr32(a, 18u) ^ (a >> 3); + uint32_t s1 = rotr32(b, 17u) ^ rotr32(b, 19u) ^ (b >> 10); + w[i] = w[i - 16u] + s0 + w[i - 7u] + s1; + } + uint32_t a = s->h[0], b = s->h[1], c = s->h[2], d = s->h[3]; + uint32_t e = s->h[4], f = s->h[5], g = s->h[6], h = s->h[7]; + for (uint32_t i = 0; i < 64u; ++i) { + uint32_t s1 = rotr32(e, 6u) ^ rotr32(e, 11u) ^ rotr32(e, 25u); + uint32_t ch = (e & f) ^ ((~e) & g); + uint32_t t1 = h + s1 + ch + k[i] + w[i]; + uint32_t s0 = rotr32(a, 2u) ^ rotr32(a, 13u) ^ rotr32(a, 22u); + uint32_t maj = (a & b) ^ (a & c) ^ (b & c); + uint32_t t2 = s0 + maj; + h = g; g = f; f = e; e = d + t1; + d = c; c = b; b = a; a = t1 + t2; + } + s->h[0] += a; s->h[1] += b; s->h[2] += c; s->h[3] += d; + s->h[4] += e; s->h[5] += f; s->h[6] += g; s->h[7] += h; +} + +static void sha256_init(Sha256 *s) { + static const uint32_t initial[8] = { + UINT32_C(0x6a09e667), UINT32_C(0xbb67ae85), UINT32_C(0x3c6ef372), UINT32_C(0xa54ff53a), + UINT32_C(0x510e527f), UINT32_C(0x9b05688c), UINT32_C(0x1f83d9ab), UINT32_C(0x5be0cd19) + }; + memcpy(s->h, initial, sizeof initial); + s->bits = 0u; + s->used = 0u; +} + +static void sha256_update(Sha256 *s, const uint8_t *data, size_t n) { + for (size_t i = 0; i < n; ++i) { + s->block[s->used++] = data[i]; + if (s->used == 64u) { + sha256_transform(s, s->block); + s->bits += 512u; + s->used = 0u; + } + } +} + +static void sha256_final(Sha256 *s, uint8_t out[32]) { + s->bits += (uint64_t)s->used * 8u; + s->block[s->used++] = 0x80u; + if (s->used > 56u) { + while (s->used < 64u) s->block[s->used++] = 0u; + sha256_transform(s, s->block); + s->used = 0u; + } + while (s->used < 56u) s->block[s->used++] = 0u; + for (uint32_t i = 0; i < 8u; ++i) s->block[63u - i] = (uint8_t)(s->bits >> (i * 8u)); + sha256_transform(s, s->block); + for (uint32_t i = 0; i < 8u; ++i) { + out[i * 4u] = (uint8_t)(s->h[i] >> 24); + out[i * 4u + 1u] = (uint8_t)(s->h[i] >> 16); + out[i * 4u + 2u] = (uint8_t)(s->h[i] >> 8); + out[i * 4u + 3u] = (uint8_t)s->h[i]; + } +} + +static void sha256_bytes(const uint8_t *data, size_t n, uint8_t out[32]) { + Sha256 s; + sha256_init(&s); + sha256_update(&s, data, n); + sha256_final(&s, out); +} + +static int event_valid(const Event *ev) { + if (ev == NULL || ev->action >= ACTIONS || ev->label >= CLASSES || + ev->source_domain > 1u || + ev->state >= STATES || ev->next_state >= STATES) return 0; + for (uint32_t d = 0; d < D; ++d) { + if (ev->x[d] < LO || ev->x[d] > HI || ev->nx[d] < LO || ev->nx[d] > HI) return 0; + } + return 1; +} + +static void make_world(World *w, const TrialSpec *spec) { + memset(w, 0, sizeof *w); + for (uint32_t s = 0; s < STATES; ++s) { + uint32_t visible = spec->ambiguous ? s / 2u : s; + for (uint32_t d = 0; d < 6u; ++d) { + w->center[s][d] = (int16_t)(((visible >> d) & 1u) ? spec->amplitude : -spec->amplitude); + } + w->center[s][6] = (int16_t)(-30 + 20 * (int)((visible * 5u + (visible >> 2)) & 3u)); + w->center[s][7] = (int16_t)(-30 + 20 * (int)((visible * 3u + (visible >> 1)) & 3u)); + w->label[s] = (uint8_t)(((visible * 29u) ^ (visible >> 1) ^ (visible >> 3)) & 7u); + w->base_next[s][0] = (uint8_t)((s + 1u) & 63u); + w->base_next[s][1] = (uint8_t)((s + 63u) & 63u); + w->base_next[s][2] = (uint8_t)(s ^ 8u); + w->base_next[s][3] = (uint8_t)(s ^ 32u); + for (uint32_t a = 0; a < ACTIONS; ++a) w->drift_next[s][a] = w->base_next[s][a]; + if (spec->transition_drift && s < 24u) { + w->drift_next[s][0] = (uint8_t)(s ^ 16u); + w->drift_next[s][2] = (uint8_t)((s + 2u) & 63u); + } + } +} + +static void make_observation(const World *w, const TrialSpec *spec, uint8_t state, + int drift, int noise, int16_t out[D]) { + for (uint32_t d = 0; d < D; ++d) { + int shift = 0; + if (drift && spec->observation_drift && state < 24u) { + if (d == 6u) shift = 16; + if (d == 7u) shift = -16; + } + int jitter = noise == 0 ? 0 : (int)(rng_u32() % (uint32_t)(2 * noise + 1)) - noise; + out[d] = clamp_domain((int)w->center[state][d] + shift + jitter); + } +} + +static void make_dataset(const World *w, const TrialSpec *spec, Event *out, uint32_t n, + uint64_t seed, int drift) { + rng_state = seed; + int noise = drift ? spec->drift_noise : spec->base_noise; + for (uint32_t i = 0; i < n; ++i) { + uint8_t s = (uint8_t)(rng_u32() % STATES); + uint8_t a = (uint8_t)(rng_u32() % ACTIONS); + const uint8_t (*next)[ACTIONS] = drift ? w->drift_next : w->base_next; + uint8_t ns = next[s][a]; + out[i].state = s; + out[i].next_state = ns; + out[i].action = a; + out[i].source_domain = drift ? 1u : 0u; + out[i].label = (uint8_t)(drift && spec->label_drift && s < 24u + ? ((w->label[s] + 3u) & 7u) : w->label[s]); + make_observation(w, spec, s, drift, noise, out[i].x); + make_observation(w, spec, ns, drift, noise, out[i].nx); + } +} + +static double dist_x(const int16_t x[D], const Expert *e) { + double total = 0.0; + for (uint32_t d = 0; d < D; ++d) { + double delta = (double)x[d] - e->key[d]; + total += delta * delta; + } + return total; +} + +static int better(double d, uint16_t id, double best_d, uint16_t best_id) { + return d < best_d || (d == best_d && id < best_id); +} + +static uint8_t majority(const uint32_t counts[CLASSES]) { + uint8_t best = 0u; + for (uint8_t y = 1u; y < CLASSES; ++y) if (counts[y] > counts[best]) best = y; + return best; +} + +static uint16_t cell_id(const int16_t x[D], int *in_domain) { + uint16_t cell = 0u; + *in_domain = 1; + for (uint32_t d = 0; d < D; ++d) if (x[d] < LO || x[d] > HI) *in_domain = 0; + for (uint32_t d = 0; d < 4u; ++d) { + int v = ((int)x[d] - LO) / 32; + if (v < 0) v = 0; + if (v > 3) v = 3; + cell = (uint16_t)((cell << 2) | (uint16_t)v); + } + return cell; +} + +static double axis_lb(double c, double lo, double hi) { + if (c < lo) { double v = lo - c; return v * v; } + if (c > hi) { double v = c - hi; return v * v; } + return 0.0; +} + +static void build_lattice(Model *m) { + for (uint32_t b = 0; b < CELLS; ++b) { + double distances[MAXE]; + uint16_t ids[MAXE]; + for (uint16_t j = 0; j < m->n; ++j) { + double lower = 0.0; + for (uint32_t d = 0; d < 4u; ++d) { + uint32_t shift = 2u * (3u - d); + uint32_t v = (b >> shift) & 3u; + double lo = (double)(LO + 32 * (int)v); + lower += axis_lb(m->e[j].key[d], lo, lo + 31.0); + } + distances[j] = lower; + ids[j] = j; + } + uint16_t take = m->n < ROUTE_K ? m->n : ROUTE_K; + uint16_t need = m->n > ROUTE_K ? (uint16_t)(ROUTE_K + 1u) : m->n; + for (uint16_t i = 0; i < need; ++i) { + uint16_t best = i; + for (uint16_t j = (uint16_t)(i + 1u); j < m->n; ++j) { + if (better(distances[j], ids[j], distances[best], ids[best])) best = j; + } + double td = distances[i]; distances[i] = distances[best]; distances[best] = td; + uint16_t ti = ids[i]; ids[i] = ids[best]; ids[best] = ti; + } + for (uint16_t i = 0; i < ROUTE_K; ++i) m->routing[b].id[i] = INVALID_EXPERT; + for (uint16_t i = 0; i < take; ++i) m->routing[b].id[i] = ids[i]; + m->routing[b].excluded_lb = m->n > ROUTE_K ? distances[ROUTE_K] : DBL_MAX; + } +} + +static uint16_t full_nearest(const int16_t x[D], const Model *m, uint64_t *evaluations) { + if (m->n == 0u) return INVALID_EXPERT; + double best_d = DBL_MAX; + uint16_t best = INVALID_EXPERT; + for (uint16_t j = 0; j < m->n; ++j) { + double d = dist_x(x, &m->e[j]); + ++*evaluations; + if (better(d, j, best_d, best)) { best_d = d; best = j; } + } + return best; +} + +static uint16_t routed_nearest(const int16_t x[D], const Model *m, uint64_t *evaluations, + uint64_t *certified) { + if (m->n == 0u) return INVALID_EXPERT; + int in_domain = 0; + uint16_t cell = cell_id(x, &in_domain); + uint8_t seen[MAXE] = {0}; + double best_d = DBL_MAX; + uint16_t best = INVALID_EXPERT; + uint16_t take = m->n < ROUTE_K ? m->n : ROUTE_K; + for (uint16_t i = 0; i < take; ++i) { + uint16_t j = m->routing[cell].id[i]; + if (j >= m->n) return INVALID_EXPERT; + seen[j] = 1u; + double d = dist_x(x, &m->e[j]); + ++*evaluations; + if (better(d, j, best_d, best)) { best_d = d; best = j; } + } + if (in_domain && best_d < m->routing[cell].excluded_lb) { + ++*certified; + return best; + } + for (uint16_t j = 0; j < m->n; ++j) if (!seen[j]) { + double d = dist_x(x, &m->e[j]); + ++*evaluations; + if (better(d, j, best_d, best)) { best_d = d; best = j; } + } + return best; +} + +static void seed_expert(Expert *e, const Event *ev, uint64_t lineage, uint16_t generation, + uint8_t lifecycle) { + memset(e, 0, sizeof *e); + for (uint32_t d = 0; d < D; ++d) { + e->key[d] = (double)ev->x[d]; + e->decode[d] = (double)ev->x[d]; + e->next[ev->action][d] = (double)ev->nx[d]; + } + for (uint32_t a = 0; a < ACTIONS; ++a) { + for (uint32_t k = 0; k < TRANSITION_TOP_K; ++k) { + e->transition_target[a][k] = INVALID_EXPERT; + } + } + e->label = ev->label; + e->active = 1u; + e->lifecycle = lifecycle; + e->anchored = lifecycle == 0u ? 1u : 0u; + e->generation = generation; + e->lineage = lineage; +} + +static void init_farthest(Model *m, uint16_t n, const Event *data, uint32_t count, + TrainMetric *tm) { + memset(m, 0, sizeof *m); + m->n = n; + seed_expert(&m->e[0], &data[0], mix64(UINT64_C(0x524156454c040001)), 0u, 0u); + for (uint16_t k = 1; k < n; ++k) { + double farthest = -1.0; + uint32_t far_i = 0u; + for (uint32_t i = 0; i < count; ++i) { + double nearest = DBL_MAX; + for (uint16_t j = 0; j < k; ++j) { + double d = dist_x(data[i].x, &m->e[j]); + ++tm->expert_evaluations; + if (d < nearest) nearest = d; + } + if (nearest > farthest) { farthest = nearest; far_i = i; } + } + seed_expert(&m->e[k], &data[far_i], mix64(m->e[0].lineage ^ k), 0u, 0u); + } + build_lattice(m); +} + +static void refine(Model *m, const Event *data, uint32_t count, uint32_t iterations, + int routed, uint16_t *assignments, TrainMetric *tm) { + for (uint32_t iteration = 0; iteration < iterations; ++iteration) { + double key_sum[MAXE][D] = {{0}}; + double decode_sum[MAXE][D] = {{0}}; + double next_sum[MAXE][ACTIONS][D] = {{{0}}}; + uint32_t counts[MAXE] = {0}; + uint32_t labels[MAXE][CLASSES] = {{0}}; + uint32_t action_count[MAXE][ACTIONS] = {{0}}; + uint32_t transition_count[MAXE][ACTIONS][MAXE] = {{{0}}}; + uint32_t errors[MAXE] = {0}; + double reconstruction_sse[MAXE] = {0}; + double prediction_sse[MAXE] = {0}; + build_lattice(m); + for (uint32_t i = 0; i < count; ++i) { + if (!event_valid(&data[i])) continue; + uint16_t j = routed + ? routed_nearest(data[i].x, m, &tm->expert_evaluations, &tm->certified) + : full_nearest(data[i].x, m, &tm->expert_evaluations); + if (j == INVALID_EXPERT) continue; + ++tm->samples; + if (assignments != NULL) assignments[i] = j; + ++counts[j]; + ++labels[j][data[i].label]; + ++action_count[j][data[i].action]; + uint64_t target_evaluations = 0u; + uint16_t target = full_nearest(data[i].nx, m, &target_evaluations); + tm->expert_evaluations += target_evaluations; + if (target != INVALID_EXPERT) { + ++transition_count[j][data[i].action][target]; + } + if (m->e[j].label != data[i].label) ++errors[j]; + for (uint32_t d = 0; d < D; ++d) { + double x = (double)data[i].x[d], nx = (double)data[i].nx[d]; + key_sum[j][d] += x; + decode_sum[j][d] += x; + next_sum[j][data[i].action][d] += nx; + double rv = x - m->e[j].decode[d]; + double pv = nx - m->e[j].next[data[i].action][d]; + reconstruction_sse[j] += rv * rv; + prediction_sse[j] += pv * pv; + } + } + for (uint16_t j = 0; j < m->n; ++j) { + m->e[j].count = counts[j]; + m->e[j].errors = errors[j]; + m->e[j].reconstruction_sse = reconstruction_sse[j]; + m->e[j].prediction_sse = prediction_sse[j]; + memcpy(m->e[j].labels, labels[j], sizeof labels[j]); + memcpy(m->e[j].action_count, action_count[j], sizeof action_count[j]); + for (uint32_t a = 0; a < ACTIONS; ++a) { + for (uint32_t k = 0; k < TRANSITION_TOP_K; ++k) { + uint16_t best = INVALID_EXPERT; + uint32_t best_support = 0u; + for (uint16_t target = 0; target < m->n; ++target) { + uint32_t support = transition_count[j][a][target]; + int already = 0; + for (uint32_t prior = 0; prior < k; ++prior) { + if (m->e[j].transition_target[a][prior] == target) already = 1; + } + if (!already && (support > best_support || + (support == best_support && support != 0u && + (best == INVALID_EXPERT || target < best)))) { + best = target; + best_support = support; + } + } + m->e[j].transition_target[a][k] = best; + m->e[j].transition_support[a][k] = best_support; + } + } + if (counts[j] == 0u) continue; + for (uint32_t d = 0; d < D; ++d) { + m->e[j].key[d] = key_sum[j][d] / (double)counts[j]; + m->e[j].decode[d] = decode_sum[j][d] / (double)counts[j]; + } + m->e[j].label = majority(labels[j]); + for (uint32_t a = 0; a < ACTIONS; ++a) if (action_count[j][a] != 0u) { + for (uint32_t d = 0; d < D; ++d) { + m->e[j].next[a][d] = next_sum[j][a][d] / (double)action_count[j][a]; + } + } + } + } + build_lattice(m); +} + +static void refine_protected(Model *m, const Event *data, uint32_t count, + uint32_t iterations, int routed, TrainMetric *tm) { + Expert anchors[MAXE]; + uint8_t anchored[MAXE] = {0}; + for (uint16_t j = 0; j < m->n; ++j) { + if (m->e[j].anchored) { + anchors[j] = m->e[j]; + anchored[j] = 1u; + } + } + for (uint32_t iteration = 0; iteration < iterations; ++iteration) { + refine(m, data, count, 1u, routed, NULL, tm); + for (uint16_t j = 0; j < m->n; ++j) { + if (anchored[j]) m->e[j] = anchors[j]; + } + build_lattice(m); + } +} + +static double clamp01(double value) { + if (!isfinite(value) || value <= 0.0) return 0.0; + return value >= 1.0 ? 1.0 : value; +} + +static double split_score(const Expert *e) { + if (e->count < 2u) return -1.0; + double classification = (double)e->errors / (double)e->count; + double reconstruction = sqrt(e->reconstruction_sse / + ((double)e->count * (double)D)) / + (double)(HI - LO); + double prediction = sqrt(e->prediction_sse / + ((double)e->count * (double)D)) / + (double)(HI - LO); + double support = (double)e->count / ((double)e->count + 32.0); + return (clamp01(classification) + clamp01(reconstruction) + + clamp01(prediction) + clamp01(support)) / 4.0; +} + +static int split_one(Model *m, uint16_t parent, uint16_t child, const Event *data, + uint32_t count, const uint16_t *assignments, uint32_t round) { + if (parent >= m->n || child >= MAXE || assignments == NULL) return 0; + uint32_t first = UINT32_MAX; + for (uint32_t i = 0; i < count; ++i) if (assignments[i] == parent) { first = i; break; } + if (first == UINT32_MAX) return 0; + uint32_t a = first, b = first; + double farthest = -1.0; + for (uint32_t i = 0; i < count; ++i) if (assignments[i] == parent) { + double d = 0.0; + for (uint32_t k = 0; k < D; ++k) { + double delta = (double)data[i].x[k] - data[first].x[k]; + d += delta * delta; + } + if (d > farthest) { farthest = d; a = i; } + } + farthest = -1.0; + for (uint32_t i = 0; i < count; ++i) if (assignments[i] == parent) { + double d = 0.0; + for (uint32_t k = 0; k < D; ++k) { + double delta = (double)data[i].x[k] - data[a].x[k]; + d += delta * delta; + } + if (d > farthest) { farthest = d; b = i; } + } + if (a == b) return 0; + uint64_t original_lineage = m->e[parent].lineage; + uint16_t original_generation = m->e[parent].generation; + uint8_t lifecycle = m->e[parent].lifecycle; + uint16_t child_generation = (uint16_t)(original_generation + 1u); + seed_expert(&m->e[parent], &data[a], + mix64(original_lineage ^ ((uint64_t)round << 32) ^ UINT64_C(0xa5)), + child_generation, lifecycle); + seed_expert(&m->e[child], &data[b], + mix64(original_lineage ^ ((uint64_t)round << 32) ^ UINT64_C(0x5a)), + child_generation, lifecycle); + return m->e[parent].lineage != m->e[child].lineage; +} + +static void train_recursive(Model *m, const Event *data, uint32_t count, TrainMetric *tm) { + uint16_t assignments[BASE_TRAIN_N]; + init_farthest(m, INIT_E, data, count, tm); + uint32_t round = 0u; + while (m->n < BASE_E) { + refine(m, data, count, 1u, 1, assignments, tm); + uint16_t order[MAXE]; + for (uint16_t j = 0; j < m->n; ++j) order[j] = j; + for (uint16_t i = 0; i < m->n; ++i) { + uint16_t best = i; + for (uint16_t j = (uint16_t)(i + 1u); j < m->n; ++j) { + double x = split_score(&m->e[order[j]]); + double y = split_score(&m->e[order[best]]); + if (x > y || (x == y && order[j] < order[best])) best = j; + } + uint16_t tmp = order[i]; order[i] = order[best]; order[best] = tmp; + } + uint16_t target = (uint16_t)((BASE_E - m->n) < 8u ? (BASE_E - m->n) : 8u); + uint16_t made = 0u; + uint16_t old_n = m->n; + for (uint16_t i = 0; i < old_n && made < target; ++i) { + if (split_one(m, order[i], (uint16_t)(old_n + made), data, count, + assignments, round)) { + ++made; + ++tm->births; + } + } + if (made == 0u) break; + m->n = (uint16_t)(old_n + made); + ++round; + } + refine(m, data, count, 3u, 1, NULL, tm); + ++m->epoch; +} + +static Residual event_residual(const Model *m, const Event *event) { + Residual residual = {0}; + uint64_t evaluations = 0u; + uint16_t expert = full_nearest(event->x, m, &evaluations); + if (expert == INVALID_EXPERT) { + residual.total = 1.0; + return residual; + } + const Expert *e = &m->e[expert]; + residual.classification = e->label == event->label ? 0.0 : 1.0; + double reconstruction = 0.0; + double prediction = 0.0; + for (uint32_t d = 0; d < D; ++d) { + double rv = (double)event->x[d] - e->decode[d]; + reconstruction += rv * rv; + if (e->action_count[event->action] >= TRANSITION_SUPPORT_MIN) { + double pv = (double)event->nx[d] - e->next[event->action][d]; + prediction += pv * pv; + } + } + residual.reconstruction = + clamp01(sqrt(reconstruction / (double)D) / (double)(HI - LO)); + residual.prediction = e->action_count[event->action] < TRANSITION_SUPPORT_MIN + ? 1.0 + : clamp01(sqrt(prediction / (double)D) / (double)(HI - LO)); + residual.novelty = + clamp01(sqrt(dist_x(event->x, e) / (double)D) / (double)(HI - LO)); + residual.inverse_support = 1.0 / (1.0 + (double)e->count / 8.0); + uint32_t first = 0u, second = 0u; + for (uint32_t label = 0; label < CLASSES; ++label) { + uint32_t support = e->labels[label]; + if (support > first) { second = first; first = support; } + else if (support > second) second = support; + } + residual.uncertainty = e->count == 0u + ? 1.0 + : 1.0 - (double)(first - second) / (double)e->count; + residual.action_coverage = + 1.0 / (1.0 + (double)e->action_count[event->action] / 4.0); + residual.retention_risk = + e->anchored && e->label != event->label ? 1.0 : 0.0; + const double channels[8] = { + residual.classification, residual.reconstruction, residual.prediction, + residual.novelty, residual.inverse_support, residual.uncertainty, + residual.action_coverage, residual.retention_risk + }; + double best = -1.0; + for (uint8_t channel = 0u; channel < 8u; ++channel) { + double value = clamp01(channels[channel]); + residual.total += value / 8.0; + if (value > best) { + best = value; + residual.dominant_channel = channel; + } + } + return residual; +} + +static uint32_t model_objective_q20(const Model *m, const Event *adapt, + uint32_t adapt_count, const Event *replay, + uint32_t replay_count) { + double quality = 0.0; + uint32_t samples = 0u; + for (uint32_t i = 0; i < adapt_count; ++i) { + quality += 1.0 - event_residual(m, &adapt[i]).total; + ++samples; + } + for (uint32_t i = 0; i < replay_count; ++i) { + quality += 1.0 - event_residual(m, &replay[i]).total; + ++samples; + } + if (samples == 0u) return 0u; + int64_t encoded = q20(quality / (double)samples); + if (encoded < 0) return 0u; + if (encoded > (int64_t)UINT32_MAX) return UINT32_MAX; + return (uint32_t)encoded; +} + +static void seed_adaptation_expert(Model *m, uint16_t id, + const Event *event, uint32_t event_index) { + uint64_t evaluations = 0u; + uint16_t parent = full_nearest(event->x, m, &evaluations); + Expert seeded; + if (parent != INVALID_EXPERT) seeded = m->e[parent]; + else memset(&seeded, 0, sizeof seeded); + for (uint32_t d = 0; d < D; ++d) { + seeded.key[d] = (double)event->x[d]; + seeded.decode[d] = (double)event->x[d]; + seeded.next[event->action][d] = (double)event->nx[d]; + } + memset(seeded.labels, 0, sizeof seeded.labels); + seeded.labels[event->label] = 1u; + seeded.label = event->label; + seeded.active = 1u; + seeded.lifecycle = 1u; + seeded.anchored = 0u; + seeded.generation = parent == INVALID_EXPERT + ? (uint16_t)(m->epoch + 1u) + : (uint16_t)(m->e[parent].generation + 1u); + seeded.lineage = + mix64(UINT64_C(0x4144415054424952) ^ m->epoch ^ id ^ event_index ^ + (parent == INVALID_EXPERT ? 0u : m->e[parent].lineage)); + m->e[id] = seeded; +} + +static int add_adaptation_experts(Model *m, const Event *adapt, uint32_t adapt_count, + const Event *mix, uint32_t mix_count, + const Event *replay, uint32_t replay_count, + int random_births, TrainMetric *tm, + TopologyTrace *trace) { + if (m->n >= MAXE || adapt_count == 0u) return 0; + uint8_t selected[ADAPT_TRAIN_N] = {0}; + uint32_t objective = model_objective_q20(m, adapt, adapt_count, replay, replay_count); + trace->objective_before_q20 = objective; + for (uint16_t attempt = 0; attempt < MAX_ADAPT_BIRTHS && m->n < MAXE; ++attempt) { + uint32_t best = UINT32_MAX; + Residual best_residual = {0}; + if (random_births) { + uint32_t start = (uint32_t)(mix64(m->epoch ^ attempt) % adapt_count); + for (uint32_t offset = 0; offset < adapt_count; ++offset) { + uint32_t index = (start + offset) % adapt_count; + if (!selected[index]) { + best = index; + best_residual = event_residual(m, &adapt[index]); + break; + } + } + } else { + for (uint32_t i = 0; i < adapt_count; ++i) { + if (selected[i] || !event_valid(&adapt[i])) continue; + Residual residual = event_residual(m, &adapt[i]); + if (best == UINT32_MAX || residual.total > best_residual.total || + (residual.total == best_residual.total && i < best)) { + best = i; + best_residual = residual; + } + } + } + if (best == UINT32_MAX || + (uint32_t)q20(best_residual.total) < BIRTH_RESIDUAL_MIN_Q20) break; + selected[best] = 1u; + Model candidate = *m; + uint16_t id = candidate.n; + seed_adaptation_expert(&candidate, id, &adapt[best], best); + ++candidate.n; + Model seeded_candidate = candidate; + uint32_t seeded_objective = + model_objective_q20(&seeded_candidate, adapt, adapt_count, + replay, replay_count); + TrainMetric candidate_metric = {0}; + refine_protected(&candidate, mix, mix_count, 2u, 1, &candidate_metric); + uint32_t candidate_objective = + model_objective_q20(&candidate, adapt, adapt_count, replay, replay_count); + if (seeded_objective > candidate_objective) { + candidate = seeded_candidate; + candidate_objective = seeded_objective; + candidate_metric = (TrainMetric){0}; + } + if (candidate_objective > objective + TOPOLOGY_OBJECTIVE_MIN_Q20) { + *m = candidate; + objective = candidate_objective; + tm->expert_evaluations += candidate_metric.expert_evaluations; + tm->samples += candidate_metric.samples; + tm->certified += candidate_metric.certified; + ++tm->births; + uint32_t slot = trace->accepted_births++; + trace->birth_event_index[slot] = best; + trace->birth_score_q20[slot] = (uint32_t)q20(best_residual.total); + trace->birth_dominant_channel[slot] = best_residual.dominant_channel; + } else { + ++tm->rejected_births; + ++trace->rejected_births; + } + } + trace->objective_after_q20 = objective; + build_lattice(m); + return 1; +} + +static int duplicate_experts(const Model *m) { + for (uint16_t i = 0; i < m->n; ++i) { + for (uint16_t j = (uint16_t)(i + 1u); j < m->n; ++j) { + if (m->e[i].lineage == m->e[j].lineage) return 1; + int same = m->e[i].label == m->e[j].label; + for (uint32_t d = 0; d < D && same; ++d) { + if (q20(m->e[i].key[d]) != q20(m->e[j].key[d])) same = 0; + } + if (same) return 1; + } + } + return 0; +} + +static int remove_expert(Model *m, uint16_t victim, int adaptation_only) { + if (victim >= m->n) return 0; + if (adaptation_only && m->e[victim].lifecycle != 1u) return 0; + uint16_t last = (uint16_t)(m->n - 1u); + if (victim != last) m->e[victim] = m->e[last]; + memset(&m->e[last], 0, sizeof m->e[last]); + --m->n; + for (uint16_t expert = 0; expert < m->n; ++expert) { + for (uint32_t action = 0; action < ACTIONS; ++action) { + for (uint32_t k = 0; k < TRANSITION_TOP_K; ++k) { + uint16_t *target = &m->e[expert].transition_target[action][k]; + if (*target == victim) { + *target = INVALID_EXPERT; + m->e[expert].transition_support[action][k] = 0u; + } else if (victim != last && *target == last) { + *target = victim; + } + } + } + } + return 1; +} + +static uint64_t replay_loss_key(const Model *m, const Event *event, uint32_t index) { + uint64_t score = (uint64_t)(uint32_t)q20(event_residual(m, event).total); + return (score << 32) | (uint64_t)(UINT32_MAX - index); +} + +static uint32_t select_replay(const Model *base, const Event *base_train, + uint32_t count, uint8_t policy, Event *replay, + ReplayMetric *metric) { + uint8_t selected[BASE_TRAIN_N] = {0}; + uint32_t state_action_frequency[STATES][ACTIONS] = {{0}}; + uint16_t assignment[BASE_TRAIN_N]; + uint64_t loss_key[BASE_TRAIN_N]; + uint64_t checksum = UINT64_C(1469598103934665603); + for (uint32_t i = 0; i < count; ++i) { + ++state_action_frequency[base_train[i].state][base_train[i].action]; + uint64_t evaluations = 0u; + assignment[i] = full_nearest(base_train[i].x, base, &evaluations); + loss_key[i] = replay_loss_key(base, &base_train[i], i); + } + uint32_t used = 0u; + if (policy == 2u) { + for (uint32_t i = 0; i < REPLAY_N && i < count; ++i) { + uint32_t index = (i * 4u) % count; + if (!selected[index]) { + selected[index] = 1u; + replay[used++] = base_train[index]; + } + } + } else if (policy == 1u) { + for (uint32_t state = 0; state < STATES && used < REPLAY_N; ++state) { + for (uint32_t action = 0; action < ACTIONS && used < REPLAY_N; ++action) { + uint32_t best = UINT32_MAX; + for (uint32_t i = 0; i < count; ++i) { + if (!selected[i] && base_train[i].state == state && + base_train[i].action == action && + (best == UINT32_MAX || loss_key[i] > loss_key[best])) best = i; + } + if (best != UINT32_MAX) { + selected[best] = 1u; + replay[used++] = base_train[best]; + } + } + } + for (uint16_t expert = 0; expert < base->n && used < REPLAY_N; ++expert) { + uint32_t best = UINT32_MAX; + for (uint32_t i = 0; i < count; ++i) { + if (!selected[i] && assignment[i] == expert && + (best == UINT32_MAX || loss_key[i] > loss_key[best])) best = i; + } + if (best != UINT32_MAX) { + selected[best] = 1u; + replay[used++] = base_train[best]; + } + } + while (used < REPLAY_N && used < count) { + uint32_t best = UINT32_MAX; + for (uint32_t i = 0; i < count; ++i) { + if (!selected[i] && + (best == UINT32_MAX || loss_key[i] > loss_key[best])) best = i; + } + if (best == UINT32_MAX) break; + selected[best] = 1u; + replay[used++] = base_train[best]; + } + } + uint8_t labels[CLASSES] = {0}, actions[ACTIONS] = {0}, states[STATES] = {0}; + uint8_t experts[MAXE] = {0}; + uint8_t pairs[STATES][ACTIONS] = {{0}}; + for (uint32_t i = 0; i < count; ++i) if (selected[i]) { + labels[base_train[i].label] = 1u; + actions[base_train[i].action] = 1u; + states[base_train[i].state] = 1u; + pairs[base_train[i].state][base_train[i].action] = 1u; + if (assignment[i] < MAXE) experts[assignment[i]] = 1u; + if (state_action_frequency[base_train[i].state][base_train[i].action] <= 2u) { + ++metric->rare_cases_selected; + } + checksum ^= i; + checksum *= UINT64_C(1099511628211); + } + uint32_t order[BASE_TRAIN_N]; + for (uint32_t i = 0; i < count; ++i) order[i] = i; + for (uint32_t i = 0; i < count; ++i) { + uint32_t best = i; + for (uint32_t j = i + 1u; j < count; ++j) { + if (loss_key[order[j]] > loss_key[order[best]]) best = j; + } + uint32_t swap = order[i]; order[i] = order[best]; order[best] = swap; + } + for (uint32_t rank = 0; rank < 32u && rank < count; ++rank) { + if (selected[order[rank]]) ++metric->high_loss_cases_selected; + } + for (uint32_t i = 0; i < CLASSES; ++i) metric->labels_covered += labels[i]; + for (uint32_t i = 0; i < ACTIONS; ++i) metric->actions_covered += actions[i]; + for (uint32_t i = 0; i < STATES; ++i) { + metric->states_covered += states[i]; + for (uint32_t a = 0; a < ACTIONS; ++a) { + metric->transition_pairs_covered += pairs[i][a]; + } + } + for (uint32_t i = 0; i < MAXE; ++i) metric->experts_covered += experts[i]; + metric->selected = used; + metric->unique = used; + metric->selection_checksum = checksum; + return used; +} + +static int retirement_safe(const Model *m, uint16_t victim) { + if (victim >= m->n || m->e[victim].lifecycle != 1u || + m->e[victim].anchored) return 0; + for (uint32_t label = 0; label < CLASSES; ++label) { + if (m->e[victim].labels[label] == 0u) continue; + uint32_t providers = 0u; + for (uint16_t j = 0; j < m->n; ++j) { + if (j != victim && m->e[j].labels[label] != 0u) ++providers; + } + if (providers == 0u) return 0; + } + for (uint32_t action = 0; action < ACTIONS; ++action) { + if (m->e[victim].action_count[action] == 0u) continue; + uint32_t providers = 0u; + for (uint16_t j = 0; j < m->n; ++j) { + if (j != victim && m->e[j].action_count[action] >= TRANSITION_SUPPORT_MIN) { + ++providers; + } + } + if (providers == 0u) return 0; + } + for (uint16_t j = 0; j < m->n; ++j) { + for (uint32_t action = 0; action < ACTIONS; ++action) { + for (uint32_t k = 0; k < TRANSITION_TOP_K; ++k) { + if (m->next_graph[j][action][k] == victim && + m->next_graph_support[j][action][k] >= TRANSITION_SUPPORT_MIN) return 0; + } + } + } + return 1; +} + +static void consider_retirements(Model *m, const Event *adapt, uint32_t adapt_count, + const Event *replay, uint32_t replay_count, + TrainMetric *tm, TopologyTrace *trace) { + for (uint32_t attempt = 0; attempt < MAX_ADAPT_RETIREMENTS; ++attempt) { + uint16_t victim = INVALID_EXPERT; + uint32_t lowest_support = UINT32_MAX; + for (uint16_t j = 0; j < m->n; ++j) { + if (m->e[j].lifecycle != 1u || m->e[j].anchored) continue; + uint32_t support = m->e[j].count; + if (victim == INVALID_EXPERT || support < lowest_support || + (support == lowest_support && m->e[j].lineage > m->e[victim].lineage)) { + victim = j; + lowest_support = support; + } + } + if (victim == INVALID_EXPERT) break; + if (!retirement_safe(m, victim)) { + ++tm->rejected_retirements; + ++trace->rejected_retirements; + break; + } + uint32_t before = model_objective_q20(m, adapt, adapt_count, replay, replay_count); + Model candidate = *m; + uint64_t lineage = candidate.e[victim].lineage; + if (!remove_expert(&candidate, victim, 1)) break; + build_lattice(&candidate); + uint32_t after = + model_objective_q20(&candidate, adapt, adapt_count, replay, replay_count); + if (after + TOPOLOGY_OBJECTIVE_MIN_Q20 >= before) { + *m = candidate; + ++tm->retired; + uint32_t slot = trace->accepted_retirements++; + trace->retired_lineage[slot] = lineage; + } else { + ++tm->rejected_retirements; + ++trace->rejected_retirements; + break; + } + } +} + +static int adapt_model(Model *m, const Event *base_train, const Event *adapt_train, + const VariantConfig *config, TrainMetric *tm, + ReplayMetric *replay_metric, TopologyTrace *topology) { + Event replay[REPLAY_N]; + Event mix[ADAPT_TRAIN_N + REPLAY_N]; + uint32_t replay_count = 0u; + if (config->use_replay) { + replay_count = select_replay(m, base_train, BASE_TRAIN_N, + config->replay_policy, replay, replay_metric); + } + for (uint32_t i = 0; i < ADAPT_TRAIN_N; ++i) mix[i] = adapt_train[i]; + for (uint32_t i = 0; i < replay_count; ++i) mix[ADAPT_TRAIN_N + i] = replay[i]; + uint32_t mix_count = ADAPT_TRAIN_N + replay_count; + if (config->recursive_births && + !add_adaptation_experts(m, adapt_train, ADAPT_TRAIN_N, mix, mix_count, + replay, replay_count, config->random_births, + tm, topology)) return 0; + if (config->protect_base) { + refine_protected(m, mix, mix_count, config->matched_work ? 4u : 2u, + config->routed, tm); + } else { + refine(m, mix, mix_count, config->matched_work ? 4u : 2u, + config->routed, NULL, tm); + } + if (config->use_retirement) { + consider_retirements(m, adapt_train, ADAPT_TRAIN_N, + replay, replay_count, tm, topology); + } + topology->objective_after_q20 = + model_objective_q20(m, adapt_train, ADAPT_TRAIN_N, replay, replay_count); + ++m->epoch; + return 1; +} + +static uint16_t nearest_vector(const double vector[D], const Model *m) { + double best_distance = DBL_MAX; + uint16_t best = INVALID_EXPERT; + for (uint16_t expert = 0; expert < m->n; ++expert) { + double distance = 0.0; + for (uint32_t d = 0; d < D; ++d) { + double delta = vector[d] - m->e[expert].key[d]; + distance += delta * delta; + } + if (better(distance, expert, best_distance, best)) { + best_distance = distance; + best = expert; + } + } + return best; +} + +static void compile_graph(Model *m) { + for (uint16_t j = 0; j < m->n; ++j) { + for (uint32_t action = 0; action < ACTIONS; ++action) { + for (uint32_t k = 0; k < TRANSITION_TOP_K; ++k) { + uint16_t target = INVALID_EXPERT; + uint32_t support = 0u; + if (k == 0u) { + target = nearest_vector(m->e[j].next[action], m); + support = m->e[j].action_count[action]; + } else { + for (uint32_t observed = 0; observed < TRANSITION_TOP_K; ++observed) { + uint16_t candidate = + m->e[j].transition_target[action][observed]; + if (candidate != m->next_graph[j][action][0]) { + target = candidate; + support = + m->e[j].transition_support[action][observed]; + break; + } + } + } + uint32_t primary_support = + m->e[j].action_count[action]; + if (m->e[j].action_count[action] < TRANSITION_SUPPORT_MIN || + support < TRANSITION_SUPPORT_MIN || target >= m->n) { + m->next_graph[j][action][k] = INVALID_EXPERT; + m->next_graph_support[j][action][k] = 0u; + } else if (k == 0u || support * 2u >= primary_support) { + m->next_graph[j][action][k] = target; + m->next_graph_support[j][action][k] = support; + } else { + m->next_graph[j][action][k] = INVALID_EXPERT; + m->next_graph_support[j][action][k] = 0u; + } + } + } + } + for (uint16_t j = m->n; j < MAXE; ++j) { + for (uint32_t action = 0; action < ACTIONS; ++action) { + for (uint32_t k = 0; k < TRANSITION_TOP_K; ++k) { + m->next_graph[j][action][k] = INVALID_EXPERT; + m->next_graph_support[j][action][k] = 0u; + } + } + } +} + +static void canonicalize_model(Model *m) { + for (uint16_t j = 0; j < m->n; ++j) { + for (uint32_t d = 0; d < D; ++d) { + m->e[j].key[d] = from_q20(q20(m->e[j].key[d])); + m->e[j].decode[d] = from_q20(q20(m->e[j].decode[d])); + for (uint32_t a = 0; a < ACTIONS; ++a) { + m->e[j].next[a][d] = from_q20(q20(m->e[j].next[a][d])); + } + } + m->e[j].reconstruction_sse = from_q20(q20(m->e[j].reconstruction_sse)); + m->e[j].prediction_sse = from_q20(q20(m->e[j].prediction_sse)); + } + build_lattice(m); + for (uint32_t b = 0; b < CELLS; ++b) { + if (m->routing[b].excluded_lb != DBL_MAX) { + m->routing[b].excluded_lb = from_q20(q20(m->routing[b].excluded_lb)); + } + } + compile_graph(m); +} + +static Eval evaluate(const Model *m, const Event *data, uint32_t count, int routed) { + Eval out = {0}; + for (uint32_t i = 0; i < count; ++i) { + if (!event_valid(&data[i])) { ++out.rejected; continue; } + uint16_t got = routed + ? routed_nearest(data[i].x, m, &out.expert_evaluations, &out.certified) + : full_nearest(data[i].x, m, &out.expert_evaluations); + uint64_t oracle_evaluations = 0u; + uint16_t oracle = full_nearest(data[i].x, m, &oracle_evaluations); + if (got == INVALID_EXPERT || oracle == INVALID_EXPERT) { ++out.rejected; continue; } + if (got != oracle) ++out.exact_mismatches; + if (m->e[got].label == data[i].label) ++out.correct; + int64_t reconstruction_quantized = 0; + int64_t prediction_quantized = 0; + int transition_supported = + m->e[got].action_count[data[i].action] >= TRANSITION_SUPPORT_MIN && + m->next_graph[got][data[i].action][0] < m->n; + for (uint32_t d = 0; d < D; ++d) { + double rv = (double)data[i].x[d] - m->e[got].decode[d]; + out.reconstruction_sse += rv * rv; + reconstruction_quantized += q20(rv * rv); + if (transition_supported) { + double pv = + (double)data[i].nx[d] - m->e[got].next[data[i].action][d]; + out.prediction_sse += pv * pv; + prediction_quantized += q20(pv * pv); + } + } + if (reconstruction_quantized < 0 || + UINT64_MAX - out.reconstruction_sse_q20 < + (uint64_t)reconstruction_quantized) { + ++out.rejected; + continue; + } + out.reconstruction_sse_q20 += (uint64_t)reconstruction_quantized; + uint16_t predicted_next = INVALID_EXPERT; + uint16_t observed_next = INVALID_EXPERT; + if (transition_supported) { + predicted_next = m->next_graph[got][data[i].action][0]; + uint64_t next_evaluations = 0u; + observed_next = full_nearest(data[i].nx, m, &next_evaluations); + if (prediction_quantized < 0 || + UINT64_MAX - out.prediction_sse_q20 < + (uint64_t)prediction_quantized) { + ++out.rejected; + continue; + } + out.prediction_sse_q20 += (uint64_t)prediction_quantized; + ++out.prediction_samples; + ++out.transition_supported; + if (predicted_next == observed_next) ++out.transition_correct; + } else { + ++out.transition_unknown; + } + ++out.samples; + out.classification_checksum ^= mix64(((uint64_t)got << 48) ^ + ((uint64_t)m->e[got].label << 32) ^ i); + out.reconstruction_checksum ^= mix64((uint64_t)reconstruction_quantized ^ i); + out.prediction_checksum ^= + mix64((uint64_t)prediction_quantized ^ ((uint64_t)i << 16) ^ + (transition_supported ? UINT64_C(0x53555050) : UINT64_C(0x554e4b4e))); + out.transition_checksum ^= mix64(((uint64_t)predicted_next << 32) ^ observed_next ^ i); + } + return out; +} + +static int plan_actions(const Model *m, uint16_t start, uint16_t goal, + uint8_t actions[PLAN_LIMIT], uint32_t *used, + uint64_t *expansions, uint64_t *unknown_actions) { + if (start >= m->n || goal >= m->n) return 0; + uint16_t queue[MAXE], parent[MAXE], parent_action[MAXE]; + uint8_t seen[MAXE] = {0}; + for (uint16_t i = 0; i < MAXE; ++i) { + parent[i] = INVALID_EXPERT; + parent_action[i] = INVALID_EXPERT; + } + uint16_t head = 0u, tail = 0u; + queue[tail++] = start; + seen[start] = 1u; + while (head < tail) { + uint16_t current = queue[head++]; + ++*expansions; + if (current == goal) break; + for (uint16_t action = 0; action < ACTIONS; ++action) { + int supported = 0; + for (uint32_t k = 0; k < 1u; ++k) { + uint16_t next = m->next_graph[current][action][k]; + if (next >= m->n) continue; + supported = 1; + if (!seen[next]) { + seen[next] = 1u; + parent[next] = current; + parent_action[next] = action; + queue[tail++] = next; + } + } + if (!supported) ++*unknown_actions; + } + } + if (!seen[goal]) return 0; + uint8_t reverse[PLAN_LIMIT]; + uint32_t n = 0u; + uint16_t current = goal; + while (current != start && n < PLAN_LIMIT) { + reverse[n++] = (uint8_t)parent_action[current]; + current = parent[current]; + } + if (current != start) return 0; + for (uint32_t i = 0; i < n; ++i) actions[i] = reverse[n - i - 1u]; + *used = n; + return 1; +} + +static uint32_t optimal_world_path(const uint8_t transitions[STATES][ACTIONS], + uint8_t start, uint8_t goal) { + uint8_t queue[STATES], seen[STATES] = {0}; + uint16_t distance[STATES] = {0}; + uint16_t head = 0u, tail = 0u; + queue[tail++] = start; + seen[start] = 1u; + while (head < tail) { + uint8_t current = queue[head++]; + if (current == goal) return distance[current]; + for (uint32_t action = 0; action < ACTIONS; ++action) { + uint8_t next = transitions[current][action]; + if (!seen[next]) { + seen[next] = 1u; + distance[next] = (uint16_t)(distance[current] + 1u); + queue[tail++] = next; + } + } + } + return UINT32_MAX; +} + +static PlanMetric evaluate_planning(const Model *m, const World *world, + const TrialSpec *spec, uint64_t seed, int drift) { + PlanMetric out = {0}; + rng_state = seed; + const uint8_t (*transitions)[ACTIONS] = drift ? world->drift_next : world->base_next; + for (uint32_t i = 0; i < PLAN_N; ++i) { + uint8_t start_state = (uint8_t)(rng_u32() % STATES); + uint8_t goal_state = (uint8_t)(rng_u32() % STATES); + int16_t start_observation[D], goal_observation[D]; + make_observation(world, spec, start_state, drift, 0, start_observation); + make_observation(world, spec, goal_state, drift, 0, goal_observation); + uint64_t evaluations = 0u, certified = 0u; + uint16_t start_expert = routed_nearest(start_observation, m, &evaluations, &certified); + uint16_t goal_expert = routed_nearest(goal_observation, m, &evaluations, &certified); + uint8_t actions[PLAN_LIMIT]; + uint32_t used = 0u; + ++out.cases; + uint32_t optimal = optimal_world_path(transitions, start_state, goal_state); + if (optimal != UINT32_MAX) out.optimal_path_length += optimal; + uint64_t unknown_actions = 0u; + if (!plan_actions(m, start_expert, goal_expert, actions, &used, + &out.expansions, &unknown_actions)) { + if (unknown_actions != 0u) ++out.no_supported_edge_failures; + else ++out.graph_disconnection_failures; + continue; + } + ++out.path_found; + out.executed_path_length += used; + uint8_t current = start_state; + for (uint32_t step = 0; step < used; ++step) current = transitions[current][actions[step]]; + int16_t final_observation[D]; + make_observation(world, spec, current, drift, 0, final_observation); + uint16_t final_expert = routed_nearest(final_observation, m, &evaluations, &certified); + int exact = current == goal_state; + int expert_goal = final_expert == goal_expert; + int alias_equivalent = 1; + for (uint32_t d = 0; d < D; ++d) { + if (world->center[current][d] != world->center[goal_state][d]) { + alias_equivalent = 0; + } + } + int belief_goal = exact || alias_equivalent || expert_goal; + if (exact) { + ++out.exact_state_targets; + if (optimal != UINT32_MAX && used >= optimal) out.path_length_regret += used - optimal; + } + if (expert_goal) ++out.goal_expert_targets; + if (belief_goal) ++out.belief_set_targets; + if (!exact && expert_goal) ++out.state_aliasing_failures; + if (!exact && !expert_goal) ++out.transition_model_failures; + out.checksum ^= mix64(((uint64_t)start_state << 56) ^ ((uint64_t)goal_state << 48) ^ + ((uint64_t)current << 40) ^ ((uint64_t)start_expert << 24) ^ + ((uint64_t)goal_expert << 8) ^ used ^ i); + } + return out; +} + +static void bb_bytes(ByteBuffer *b, const uint8_t *data, size_t n) { + if (!b->ok || n > CHECKPOINT_MAX - b->len) { b->ok = 0; return; } + memcpy(b->data + b->len, data, n); + b->len += n; +} + +static void bb_u8(ByteBuffer *b, uint8_t v) { + bb_bytes(b, &v, 1u); +} + +static void bb_u16(ByteBuffer *b, uint16_t v) { + uint8_t bytes[2] = {(uint8_t)(v >> 8), (uint8_t)v}; + bb_bytes(b, bytes, sizeof bytes); +} + +static void bb_u32(ByteBuffer *b, uint32_t v) { + uint8_t bytes[4] = { + (uint8_t)(v >> 24), (uint8_t)(v >> 16), (uint8_t)(v >> 8), (uint8_t)v + }; + bb_bytes(b, bytes, sizeof bytes); +} + +static void bb_u64(ByteBuffer *b, uint64_t v) { + uint8_t bytes[8]; + for (uint32_t i = 0; i < 8u; ++i) bytes[7u - i] = (uint8_t)(v >> (i * 8u)); + bb_bytes(b, bytes, sizeof bytes); +} + +static void bb_i64(ByteBuffer *b, int64_t v) { + bb_u64(b, (uint64_t)v); +} + +static void bb_q20(ByteBuffer *b, double value) { + int64_t encoded = 0; + if (!q20_checked(value, &encoded)) { + b->ok = 0; + return; + } + bb_i64(b, encoded); +} + +static void br_bytes(ByteReader *r, uint8_t *out, size_t n) { + if (!r->ok || n > r->len - r->pos) { r->ok = 0; return; } + memcpy(out, r->data + r->pos, n); + r->pos += n; +} + +static uint8_t br_u8(ByteReader *r) { + uint8_t out = 0u; + br_bytes(r, &out, 1u); + return out; +} + +static uint16_t br_u16(ByteReader *r) { + uint8_t bytes[2] = {0}; + br_bytes(r, bytes, sizeof bytes); + return (uint16_t)(((uint16_t)bytes[0] << 8) | bytes[1]); +} + +static uint32_t br_u32(ByteReader *r) { + uint8_t bytes[4] = {0}; + br_bytes(r, bytes, sizeof bytes); + return ((uint32_t)bytes[0] << 24) | ((uint32_t)bytes[1] << 16) | + ((uint32_t)bytes[2] << 8) | bytes[3]; +} + +static uint64_t br_u64(ByteReader *r) { + uint8_t bytes[8] = {0}; + br_bytes(r, bytes, sizeof bytes); + uint64_t out = 0u; + for (uint32_t i = 0; i < 8u; ++i) out = (out << 8) | bytes[i]; + return out; +} + +static int64_t br_i64(ByteReader *r) { + return (int64_t)br_u64(r); +} + +static int serialize_checkpoint(const Model *m, ByteBuffer *checkpoint) { + static const uint8_t magic[8] = {'R', 'A', 'V', 'E', 'L', '0', '5', 0}; + if (m == NULL || m->n == 0u || m->n > MAXE) return 0; + ByteBuffer payload = {{0}, 0u, 1}; + bb_u16(&payload, m->n); + bb_u64(&payload, m->epoch); + bb_u16(&payload, TRANSITION_TOP_K); + bb_u16(&payload, TRANSITION_SUPPORT_MIN); + for (uint16_t j = 0; j < m->n; ++j) { + const Expert *e = &m->e[j]; + bb_u16(&payload, j); + bb_u8(&payload, e->active); + bb_u8(&payload, e->lifecycle); + bb_u8(&payload, e->anchored); + bb_u16(&payload, e->generation); + bb_u8(&payload, e->label); + bb_u64(&payload, e->lineage); + for (uint32_t d = 0; d < D; ++d) bb_q20(&payload, e->key[d]); + for (uint32_t d = 0; d < D; ++d) bb_q20(&payload, e->decode[d]); + for (uint32_t a = 0; a < ACTIONS; ++a) { + for (uint32_t d = 0; d < D; ++d) bb_q20(&payload, e->next[a][d]); + } + for (uint32_t y = 0; y < CLASSES; ++y) bb_u32(&payload, e->labels[y]); + for (uint32_t a = 0; a < ACTIONS; ++a) bb_u32(&payload, e->action_count[a]); + for (uint32_t a = 0; a < ACTIONS; ++a) { + for (uint32_t k = 0; k < TRANSITION_TOP_K; ++k) { + bb_u16(&payload, e->transition_target[a][k]); + bb_u32(&payload, e->transition_support[a][k]); + } + } + bb_u32(&payload, e->count); + bb_u32(&payload, e->errors); + bb_q20(&payload, e->reconstruction_sse); + bb_q20(&payload, e->prediction_sse); + } + for (uint16_t j = 0; j < m->n; ++j) { + bb_u16(&payload, j); + for (uint32_t a = 0; a < ACTIONS; ++a) { + for (uint32_t k = 0; k < TRANSITION_TOP_K; ++k) { + bb_u16(&payload, m->next_graph[j][a][k]); + bb_u32(&payload, m->next_graph_support[j][a][k]); + } + } + } + for (uint16_t cell = 0; cell < CELLS; ++cell) { + bb_u16(&payload, cell); + for (uint32_t i = 0; i < ROUTE_K; ++i) bb_u16(&payload, m->routing[cell].id[i]); + int64_t lower = m->routing[cell].excluded_lb == DBL_MAX + ? INT64_MAX : q20(m->routing[cell].excluded_lb); + bb_i64(&payload, lower); + } + if (!payload.ok || payload.len > UINT32_MAX) return 0; + uint8_t digest[32]; + sha256_bytes(payload.data, payload.len, digest); + *checkpoint = (ByteBuffer){{0}, 0u, 1}; + bb_bytes(checkpoint, magic, sizeof magic); + bb_u16(checkpoint, CHECKPOINT_SCHEMA); + bb_u16(checkpoint, D); + bb_u16(checkpoint, CLASSES); + bb_u16(checkpoint, ACTIONS); + bb_u16(checkpoint, STATES); + bb_u16(checkpoint, MAXE); + bb_u16(checkpoint, ROUTE_K); + bb_u16(checkpoint, CELLS); + bb_u32(checkpoint, UINT32_C(0x01020304)); + bb_u32(checkpoint, (uint32_t)payload.len); + bb_bytes(checkpoint, digest, sizeof digest); + if (checkpoint->len != CHECKPOINT_HEADER) return 0; + bb_bytes(checkpoint, payload.data, payload.len); + return checkpoint->ok; +} + +static int deserialize_checkpoint(const uint8_t *bytes, size_t size, Model *out) { + static const uint8_t magic[8] = {'R', 'A', 'V', 'E', 'L', '0', '5', 0}; + if (bytes == NULL || out == NULL || size < CHECKPOINT_HEADER || size > CHECKPOINT_MAX) return 0; + ByteReader header = {bytes, size, 0u, 1}; + uint8_t got_magic[8], expected_digest[32], actual_digest[32]; + br_bytes(&header, got_magic, sizeof got_magic); + uint16_t schema = br_u16(&header); + uint16_t dimensions = br_u16(&header); + uint16_t classes = br_u16(&header); + uint16_t actions = br_u16(&header); + uint16_t states = br_u16(&header); + uint16_t maximum = br_u16(&header); + uint16_t route_width = br_u16(&header); + uint16_t cells = br_u16(&header); + uint32_t byte_order = br_u32(&header); + uint32_t payload_length = br_u32(&header); + br_bytes(&header, expected_digest, sizeof expected_digest); + if (!header.ok || header.pos != CHECKPOINT_HEADER || + !bytes_equal(got_magic, magic, sizeof magic) || + schema != CHECKPOINT_SCHEMA || dimensions != D || classes != CLASSES || + actions != ACTIONS || states != STATES || maximum != MAXE || + route_width != ROUTE_K || cells != CELLS || + byte_order != UINT32_C(0x01020304) || + payload_length > CHECKPOINT_MAX - CHECKPOINT_HEADER || + size != CHECKPOINT_HEADER + (size_t)payload_length) return 0; + sha256_bytes(bytes + CHECKPOINT_HEADER, payload_length, actual_digest); + if (!bytes_equal(expected_digest, actual_digest, sizeof expected_digest)) return 0; + ByteReader payload = { + bytes + CHECKPOINT_HEADER, payload_length, 0u, 1 + }; + Model model; + memset(&model, 0, sizeof model); + model.n = br_u16(&payload); + model.epoch = br_u64(&payload); + uint16_t transition_top_k = br_u16(&payload); + uint16_t transition_support_min = br_u16(&payload); + if (!payload.ok || model.n == 0u || model.n > MAXE || + transition_top_k != TRANSITION_TOP_K || + transition_support_min != TRANSITION_SUPPORT_MIN) return 0; + for (uint16_t j = 0; j < model.n; ++j) { + Expert *e = &model.e[j]; + if (br_u16(&payload) != j) return 0; + e->active = br_u8(&payload); + e->lifecycle = br_u8(&payload); + e->anchored = br_u8(&payload); + e->generation = br_u16(&payload); + e->label = br_u8(&payload); + e->lineage = br_u64(&payload); + for (uint32_t d = 0; d < D; ++d) e->key[d] = from_q20(br_i64(&payload)); + for (uint32_t d = 0; d < D; ++d) e->decode[d] = from_q20(br_i64(&payload)); + for (uint32_t a = 0; a < ACTIONS; ++a) { + for (uint32_t d = 0; d < D; ++d) e->next[a][d] = from_q20(br_i64(&payload)); + } + for (uint32_t y = 0; y < CLASSES; ++y) e->labels[y] = br_u32(&payload); + for (uint32_t a = 0; a < ACTIONS; ++a) e->action_count[a] = br_u32(&payload); + for (uint32_t a = 0; a < ACTIONS; ++a) { + for (uint32_t k = 0; k < TRANSITION_TOP_K; ++k) { + e->transition_target[a][k] = br_u16(&payload); + e->transition_support[a][k] = br_u32(&payload); + if ((e->transition_target[a][k] != INVALID_EXPERT && + e->transition_target[a][k] >= model.n) || + (e->transition_support[a][k] == 0u && + e->transition_target[a][k] != INVALID_EXPERT)) return 0; + } + } + e->count = br_u32(&payload); + e->errors = br_u32(&payload); + e->reconstruction_sse = from_q20(br_i64(&payload)); + e->prediction_sse = from_q20(br_i64(&payload)); + if (!payload.ok || e->active != 1u || e->lifecycle > 1u || + e->anchored > 1u || e->anchored != (uint8_t)(e->lifecycle == 0u) || + e->label >= CLASSES || e->lineage == 0u || e->errors > e->count) return 0; + } + for (uint16_t j = 0; j < model.n; ++j) { + if (br_u16(&payload) != j) return 0; + for (uint32_t a = 0; a < ACTIONS; ++a) { + for (uint32_t k = 0; k < TRANSITION_TOP_K; ++k) { + model.next_graph[j][a][k] = br_u16(&payload); + model.next_graph_support[j][a][k] = br_u32(&payload); + uint16_t target = model.next_graph[j][a][k]; + uint32_t support = model.next_graph_support[j][a][k]; + if ((target == INVALID_EXPERT && support != 0u) || + (target != INVALID_EXPERT && + (target >= model.n || support < TRANSITION_SUPPORT_MIN))) return 0; + } + } + } + uint16_t take = model.n < ROUTE_K ? model.n : ROUTE_K; + for (uint16_t cell = 0; cell < CELLS; ++cell) { + if (br_u16(&payload) != cell) return 0; + for (uint16_t i = 0; i < ROUTE_K; ++i) { + uint16_t id = br_u16(&payload); + model.routing[cell].id[i] = id; + if ((i < take && id >= model.n) || (i >= take && id != INVALID_EXPERT)) return 0; + if (i < take) { + for (uint16_t k = 0; k < i; ++k) { + if (model.routing[cell].id[k] == id) return 0; + } + } + } + int64_t lower = br_i64(&payload); + model.routing[cell].excluded_lb = lower == INT64_MAX ? DBL_MAX : from_q20(lower); + if (model.n > ROUTE_K && lower == INT64_MAX) return 0; + if (model.n <= ROUTE_K && lower != INT64_MAX) return 0; + } + if (!payload.ok || payload.pos != payload.len) return 0; + memcpy(model.identity, expected_digest, sizeof model.identity); + *out = model; + return 1; +} + +static int checkpoint_memory_roundtrip(Model *model, Model *restored, + size_t *checkpoint_size) { + ByteBuffer checkpoint; + if (!serialize_checkpoint(model, &checkpoint)) return 0; + for (size_t i = 0; i < sizeof model->identity; ++i) { + model->identity[i] = checkpoint.data[32u + i]; + } + if (!deserialize_checkpoint(checkpoint.data, checkpoint.len, restored)) return 0; + *checkpoint_size = checkpoint.len; + return 1; +} + +static int eval_equal(const Eval *a, const Eval *b) { + return a->samples == b->samples && a->rejected == b->rejected && + a->correct == b->correct && a->exact_mismatches == b->exact_mismatches && + a->certified == b->certified && + a->expert_evaluations == b->expert_evaluations && + a->reconstruction_sse == b->reconstruction_sse && + a->prediction_sse == b->prediction_sse && + a->reconstruction_sse_q20 == b->reconstruction_sse_q20 && + a->prediction_sse_q20 == b->prediction_sse_q20 && + a->prediction_samples == b->prediction_samples && + a->transition_correct == b->transition_correct && + a->transition_supported == b->transition_supported && + a->transition_unknown == b->transition_unknown && + a->classification_checksum == b->classification_checksum && + a->reconstruction_checksum == b->reconstruction_checksum && + a->prediction_checksum == b->prediction_checksum && + a->transition_checksum == b->transition_checksum; +} + +static int plan_equal(const PlanMetric *a, const PlanMetric *b) { + return a->cases == b->cases && + a->path_found == b->path_found && + a->exact_state_targets == b->exact_state_targets && + a->goal_expert_targets == b->goal_expert_targets && + a->belief_set_targets == b->belief_set_targets && + a->executed_path_length == b->executed_path_length && + a->optimal_path_length == b->optimal_path_length && + a->path_length_regret == b->path_length_regret && + a->graph_disconnection_failures == b->graph_disconnection_failures && + a->no_supported_edge_failures == b->no_supported_edge_failures && + a->transition_model_failures == b->transition_model_failures && + a->state_aliasing_failures == b->state_aliasing_failures && + a->expansions == b->expansions && + a->checksum == b->checksum; +} + +static void behavior_digest(const Model *m, const Eval *evaluation, + const PlanMetric *planning, uint8_t out[32]) { + ByteBuffer b = {{0}, 0u, 1}; + bb_bytes(&b, m->identity, sizeof m->identity); + bb_u64(&b, evaluation->samples); + bb_u64(&b, evaluation->rejected); + bb_u64(&b, evaluation->correct); + bb_u64(&b, evaluation->exact_mismatches); + bb_u64(&b, evaluation->certified); + bb_u64(&b, evaluation->expert_evaluations); + bb_i64(&b, q20(evaluation->reconstruction_sse)); + bb_i64(&b, q20(evaluation->prediction_sse)); + bb_u64(&b, evaluation->reconstruction_sse_q20); + bb_u64(&b, evaluation->prediction_sse_q20); + bb_u64(&b, evaluation->prediction_samples); + bb_u64(&b, evaluation->transition_correct); + bb_u64(&b, evaluation->transition_supported); + bb_u64(&b, evaluation->transition_unknown); + bb_u64(&b, evaluation->classification_checksum); + bb_u64(&b, evaluation->reconstruction_checksum); + bb_u64(&b, evaluation->prediction_checksum); + bb_u64(&b, evaluation->transition_checksum); + bb_u64(&b, planning->cases); + bb_u64(&b, planning->path_found); + bb_u64(&b, planning->exact_state_targets); + bb_u64(&b, planning->goal_expert_targets); + bb_u64(&b, planning->belief_set_targets); + bb_u64(&b, planning->executed_path_length); + bb_u64(&b, planning->optimal_path_length); + bb_u64(&b, planning->path_length_regret); + bb_u64(&b, planning->graph_disconnection_failures); + bb_u64(&b, planning->no_supported_edge_failures); + bb_u64(&b, planning->transition_model_failures); + bb_u64(&b, planning->state_aliasing_failures); + bb_u64(&b, planning->expansions); + bb_u64(&b, planning->checksum); + sha256_bytes(b.data, b.len, out); +} + +static int checkpoint_equivalent(const Model *expected, const Model *restored, + const Eval *expected_eval, const Eval *restored_eval, + const PlanMetric *expected_plan, + const PlanMetric *restored_plan) { + uint8_t expected_behavior[32], restored_behavior[32]; + behavior_digest(expected, expected_eval, expected_plan, expected_behavior); + behavior_digest(restored, restored_eval, restored_plan, restored_behavior); + return bytes_equal(expected->identity, restored->identity, 32u) && + eval_equal(expected_eval, restored_eval) && + plan_equal(expected_plan, restored_plan) && + bytes_equal(expected_behavior, restored_behavior, 32u); +} + +static int valid_model_mutation_detected(const Model *original, const Model *mutated) { + ByteBuffer checkpoint; + Model restored; + if (!serialize_checkpoint(mutated, &checkpoint)) return 1; + if (!deserialize_checkpoint(checkpoint.data, checkpoint.len, &restored)) return 1; + return !bytes_equal(original->identity, restored.identity, + sizeof original->identity); +} + +typedef struct { + int retrieval_key; + int reconstruction; + int next_observation; + int label; + int label_count; + int lineage; + int transition_graph; + int transition_support; + int anchored_status; + int payload_byte; + int truncation; + int appended_byte; + int schema_version; + int checkpoint_substitution; +} MutationResult; + +static MutationResult checkpoint_mutations(const Model *original) { + MutationResult result = {0}; + Model mutated = *original; + mutated.e[0].key[0] += from_q20(1); + result.retrieval_key = valid_model_mutation_detected(original, &mutated); + mutated = *original; + mutated.e[0].decode[0] += from_q20(1); + result.reconstruction = valid_model_mutation_detected(original, &mutated); + mutated = *original; + mutated.e[0].next[0][0] += from_q20(1); + result.next_observation = valid_model_mutation_detected(original, &mutated); + mutated = *original; + mutated.e[0].label = (uint8_t)((mutated.e[0].label + 1u) % CLASSES); + result.label = valid_model_mutation_detected(original, &mutated); + mutated = *original; + ++mutated.e[0].labels[0]; + result.label_count = valid_model_mutation_detected(original, &mutated); + mutated = *original; + mutated.e[0].lineage ^= UINT64_C(0x1); + result.lineage = valid_model_mutation_detected(original, &mutated); + mutated = *original; + mutated.next_graph[0][0][0] = + (uint16_t)((mutated.next_graph[0][0][0] + 1u) % mutated.n); + result.transition_graph = valid_model_mutation_detected(original, &mutated); + mutated = *original; + ++mutated.e[0].transition_support[0][0]; + result.transition_support = valid_model_mutation_detected(original, &mutated); + mutated = *original; + mutated.e[0].anchored ^= 1u; + result.anchored_status = valid_model_mutation_detected(original, &mutated); + + ByteBuffer checkpoint; + if (serialize_checkpoint(original, &checkpoint)) { + ByteBuffer corrupt = checkpoint; + corrupt.data[CHECKPOINT_HEADER + 3u] ^= 0x01u; + Model restored; + result.payload_byte = !deserialize_checkpoint(corrupt.data, corrupt.len, &restored); + result.truncation = !deserialize_checkpoint(checkpoint.data, checkpoint.len - 1u, &restored); + corrupt = checkpoint; + corrupt.data[corrupt.len++] = 0u; + result.appended_byte = !deserialize_checkpoint(corrupt.data, corrupt.len, &restored); + corrupt = checkpoint; + corrupt.data[8] = 0u; + corrupt.data[9] = (uint8_t)(CHECKPOINT_SCHEMA + 1u); + result.schema_version = !deserialize_checkpoint(corrupt.data, corrupt.len, &restored); + mutated = *original; + mutated.epoch += 1u; + ByteBuffer substitute; + if (serialize_checkpoint(&mutated, &substitute) && + deserialize_checkpoint(substitute.data, substitute.len, &restored)) { + result.checkpoint_substitution = + !bytes_equal(original->identity, restored.identity, + sizeof original->identity); + } + } + return result; +} + +typedef struct { + int sibling_generation_equality; + int parent_child_increment; + int lineage_uniqueness; + int repeated_descendant_increment; + int no_lineage_reuse; + int deterministic_topology; +} LineageResult; + +static LineageResult lineage_invariants(const Event *data) { + LineageResult result = {0}; + Model model; + memset(&model, 0, sizeof model); + model.n = 1u; + seed_expert(&model.e[0], &data[0], mix64(UINT64_C(0x1122334455667788)), 4u, 0u); + uint16_t assignments[BASE_TRAIN_N]; + for (uint32_t i = 0; i < BASE_TRAIN_N; ++i) assignments[i] = 0u; + uint16_t original_generation = model.e[0].generation; + int first_split = split_one(&model, 0u, 1u, data, BASE_TRAIN_N, assignments, 17u); + if (first_split) { + model.n = 2u; + result.sibling_generation_equality = + model.e[0].generation == model.e[1].generation; + result.parent_child_increment = + model.e[0].generation == (uint16_t)(original_generation + 1u); + result.lineage_uniqueness = model.e[0].lineage != model.e[1].lineage; + for (uint32_t i = 0; i < BASE_TRAIN_N; ++i) assignments[i] = 1u; + uint16_t descendant_generation = model.e[1].generation; + if (split_one(&model, 1u, 2u, data, BASE_TRAIN_N, assignments, 18u)) { + model.n = 3u; + result.repeated_descendant_increment = + model.e[1].generation == (uint16_t)(descendant_generation + 1u) && + model.e[2].generation == model.e[1].generation; + result.no_lineage_reuse = 1; + for (uint16_t i = 0; i < model.n; ++i) { + for (uint16_t j = (uint16_t)(i + 1u); j < model.n; ++j) { + if (model.e[i].lineage == model.e[j].lineage) result.no_lineage_reuse = 0; + } + } + } + } + Model first, second; + TrainMetric first_tm = {0}, second_tm = {0}; + train_recursive(&first, data, BASE_TRAIN_N, &first_tm); + train_recursive(&second, data, BASE_TRAIN_N, &second_tm); + canonicalize_model(&first); + canonicalize_model(&second); + ByteBuffer first_checkpoint, second_checkpoint; + if (serialize_checkpoint(&first, &first_checkpoint) && + serialize_checkpoint(&second, &second_checkpoint)) { + result.deterministic_topology = + first_checkpoint.len == second_checkpoint.len && + bytes_equal(first_checkpoint.data, second_checkpoint.data, + first_checkpoint.len); + } + return result; +} + +typedef struct { + int malformed_observation_rejected; + int out_of_domain_fallback; + int empty_assignment_rejected; + int degenerate_assignment_rejected; + int duplicate_expert_rejected; + int tied_distance_lower_id; + int lower_bound_equality_fallback; + int maximum_capacity_preserved; + int birth_beyond_capacity_rejected; + int wrong_lifecycle_retirement_rejected; + int poisoned_labels_fail_gate; + int poisoned_transitions_fail_gate; + int replay_removal_fail_gate; + int catastrophic_forgetting_fail_gate; +} NegativeResult; + +static double eval_accuracy(const Eval *e) { + return e->samples == 0u ? 0.0 : (double)e->correct / (double)e->samples; +} + +static double prediction_rmse(const Eval *e) { + return e->prediction_samples == 0u ? DBL_MAX : + sqrt(((double)e->prediction_sse_q20 / Q20_SCALE) / + (double)(e->prediction_samples * D)); +} + +static NegativeResult run_negative_tests(const Model *base, const Event *base_train, + const Event *retention, const Event *adapt_train, + const Event *drift_hold) { + NegativeResult result = {0}; + Event malformed = adapt_train[0]; + malformed.action = ACTIONS; + result.malformed_observation_rejected = !event_valid(&malformed); + + int16_t out_of_domain[D] = {100, 0, 0, 0, 0, 0, 0, 0}; + uint64_t evaluations = 0u, certified = 0u; + uint16_t fallback = routed_nearest(out_of_domain, base, &evaluations, &certified); + result.out_of_domain_fallback = + fallback != INVALID_EXPERT && certified == 0u && evaluations == base->n; + + Model empty; + memset(&empty, 0, sizeof empty); + evaluations = 0u; + result.empty_assignment_rejected = + full_nearest(base_train[0].x, &empty, &evaluations) == INVALID_EXPERT; + + Model degenerate; + memset(°enerate, 0, sizeof degenerate); + degenerate.n = 1u; + seed_expert(°enerate.e[0], &base_train[0], mix64(1u), 0u, 0u); + Event identical[2] = {base_train[0], base_train[0]}; + uint16_t assignments[2] = {0u, 0u}; + result.degenerate_assignment_rejected = + !split_one(°enerate, 0u, 1u, identical, 2u, assignments, 0u); + + Model duplicate = *base; + duplicate.e[1] = duplicate.e[0]; + result.duplicate_expert_rejected = duplicate_experts(&duplicate); + + Model tie; + memset(&tie, 0, sizeof tie); + tie.n = 2u; + seed_expert(&tie.e[0], &base_train[0], mix64(2u), 0u, 0u); + tie.e[1] = tie.e[0]; + tie.e[1].lineage = mix64(3u); + evaluations = 0u; + result.tied_distance_lower_id = + full_nearest(base_train[0].x, &tie, &evaluations) == 0u; + + Model equality = *base; + int in_domain = 0; + uint16_t cell = cell_id(base_train[0].x, &in_domain); + double routed_best = DBL_MAX; + for (uint16_t i = 0; i < ROUTE_K; ++i) { + uint16_t candidate = equality.routing[cell].id[i]; + double distance = dist_x(base_train[0].x, &equality.e[candidate]); + if (distance < routed_best) routed_best = distance; + } + equality.routing[cell].excluded_lb = routed_best; + evaluations = 0u; certified = 0u; + (void)routed_nearest(base_train[0].x, &equality, &evaluations, &certified); + result.lower_bound_equality_fallback = + in_domain && certified == 0u && evaluations == equality.n; + + Model capacity = *base; + while (capacity.n < MAXE) { + seed_expert(&capacity.e[capacity.n], &adapt_train[capacity.n % ADAPT_TRAIN_N], + mix64(UINT64_C(0x4341504143495459) ^ capacity.n), 1u, 1u); + ++capacity.n; + } + result.maximum_capacity_preserved = capacity.n == MAXE; + TrainMetric capacity_tm = {0}; + TopologyTrace capacity_topology = {0}; + result.birth_beyond_capacity_rejected = + !add_adaptation_experts(&capacity, adapt_train, ADAPT_TRAIN_N, + adapt_train, ADAPT_TRAIN_N, NULL, 0u, 0, + &capacity_tm, &capacity_topology) && + capacity.n == MAXE; + + Model lifecycle = *base; + result.wrong_lifecycle_retirement_rejected = !remove_expert(&lifecycle, 0u, 1); + + Event poisoned_labels[ADAPT_TRAIN_N]; + Event poisoned_transitions[ADAPT_TRAIN_N]; + for (uint32_t i = 0; i < ADAPT_TRAIN_N; ++i) { + poisoned_labels[i] = base_train[i % BASE_TRAIN_N]; + poisoned_labels[i].label = (uint8_t)((poisoned_labels[i].label + 1u) % CLASSES); + poisoned_transitions[i] = adapt_train[i]; + for (uint32_t d = 0; d < D; ++d) { + poisoned_transitions[i].nx[d] = + clamp_domain(-(int)poisoned_transitions[i].nx[d]); + } + } + VariantConfig no_replay = { + .use_replay = 0u, .use_retirement = 0u, .routed = 1u, + .recursive_births = 1u, .random_births = 0u, + .replay_policy = 0u, .protect_base = 0u, .matched_work = 1u + }; + Model label_model = *base; + TrainMetric label_tm = {0}; + ReplayMetric label_replay = {0}; + TopologyTrace label_topology = {0}; + int label_adapted = adapt_model(&label_model, base_train, poisoned_labels, + &no_replay, &label_tm, &label_replay, + &label_topology); + canonicalize_model(&label_model); + Eval label_retention = evaluate(&label_model, retention, RETENTION_N, 1); + result.poisoned_labels_fail_gate = + label_adapted && eval_accuracy(&label_retention) < 0.70; + Model replay_model = *base; + TrainMetric replay_tm = {0}; + ReplayMetric replay_coverage = {0}; + TopologyTrace replay_topology = {0}; + VariantConfig balanced = no_replay; + balanced.use_replay = 1u; + balanced.replay_policy = 1u; + balanced.protect_base = 1u; + int replay_adapted = adapt_model(&replay_model, base_train, poisoned_labels, + &balanced, &replay_tm, &replay_coverage, + &replay_topology); + canonicalize_model(&replay_model); + Eval replay_retention = evaluate(&replay_model, retention, RETENTION_N, 1); + result.replay_removal_fail_gate = + replay_adapted && eval_accuracy(&replay_retention) > + eval_accuracy(&label_retention); + + Event catastrophic[ADAPT_TRAIN_N]; + for (uint32_t i = 0; i < ADAPT_TRAIN_N; ++i) { + catastrophic[i] = poisoned_labels[ADAPT_TRAIN_N - i - 1u]; + catastrophic[i].label = + (uint8_t)((catastrophic[i].label + 2u) % CLASSES); + } + Model catastrophic_model = *base; + TrainMetric catastrophic_tm = {0}; + refine(&catastrophic_model, catastrophic, ADAPT_TRAIN_N, 12u, 1, NULL, + &catastrophic_tm); + ++catastrophic_model.epoch; + canonicalize_model(&catastrophic_model); + Eval catastrophic_retention = + evaluate(&catastrophic_model, retention, RETENTION_N, 1); + Model base_for_retention = *base; + Eval base_retention = + evaluate(&base_for_retention, retention, RETENTION_N, 1); + result.catastrophic_forgetting_fail_gate = + catastrophic_tm.expert_evaluations > 0u && + eval_accuracy(&catastrophic_retention) < + eval_accuracy(&base_retention); + + Model transition_model = *base; + TrainMetric transition_tm = {0}; + ReplayMetric transition_replay = {0}; + TopologyTrace transition_topology = {0}; + int transition_adapted = + adapt_model(&transition_model, base_train, poisoned_transitions, + &no_replay, &transition_tm, &transition_replay, + &transition_topology); + canonicalize_model(&transition_model); + Eval transition_eval = evaluate(&transition_model, drift_hold, DRIFT_HOLD_N, 1); + result.poisoned_transitions_fail_gate = + transition_adapted && prediction_rmse(&transition_eval) > 24.0; + return result; +} + +static void digest_hex(const uint8_t digest[32], char out[65]) { + static const char hex[] = "0123456789abcdef"; + for (uint32_t i = 0; i < 32u; ++i) { + out[i * 2u] = hex[digest[i] >> 4]; + out[i * 2u + 1u] = hex[digest[i] & 15u]; + } + out[64] = '\0'; +} + +static void train_flat(Model *m, uint16_t experts, const Event *base_train, + TrainMetric *tm, int routed) { + init_farthest(m, experts, base_train, BASE_TRAIN_N, tm); + refine(m, base_train, BASE_TRAIN_N, 4u, routed, NULL, tm); + ++m->epoch; + canonicalize_model(m); +} + +static size_t model_checkpoint_size(Model *m) { + ByteBuffer checkpoint; + if (!serialize_checkpoint(m, &checkpoint)) return 0u; + for (size_t i = 0; i < sizeof m->identity; ++i) { + m->identity[i] = checkpoint.data[32u + i]; + } + return checkpoint.len; +} + +static void print_eval_json(const Eval *e) { + printf("{\"samples\":%" PRIu64 ",\"rejected\":%" PRIu64 + ",\"correct\":%" PRIu64 + ",\"reconstruction_sse_q20\":%" PRIu64 + ",\"prediction_sse_q20\":%" PRIu64 + ",\"prediction_samples\":%" PRIu64 + ",\"transition_correct\":%" PRIu64 + ",\"transition_supported\":%" PRIu64 + ",\"transition_unknown\":%" PRIu64 + ",\"routing_certification_count\":%" PRIu64 + ",\"routed_complete_mismatches\":%" PRIu64 + ",\"expert_evaluations\":%" PRIu64 + ",\"classification_checksum\":\"%016" PRIx64 "\"" + ",\"reconstruction_checksum\":\"%016" PRIx64 "\"" + ",\"prediction_checksum\":\"%016" PRIx64 "\"" + ",\"transition_checksum\":\"%016" PRIx64 "\"}", + e->samples, e->rejected, e->correct, + e->reconstruction_sse_q20, e->prediction_sse_q20, + e->prediction_samples, e->transition_correct, + e->transition_supported, e->transition_unknown, + e->certified, e->exact_mismatches, + e->expert_evaluations, e->classification_checksum, + e->reconstruction_checksum, e->prediction_checksum, e->transition_checksum); +} + +static void print_plan_json(const PlanMetric *p) { + printf("{\"cases\":%" PRIu64 ",\"path_found\":%" PRIu64 + ",\"exact_world_state_target_reached\":%" PRIu64 + ",\"goal_expert_reached\":%" PRIu64 + ",\"belief_set_target_reached\":%" PRIu64 + ",\"executed_path_length\":%" PRIu64 + ",\"optimal_path_length\":%" PRIu64 + ",\"path_length_regret\":%" PRIu64 + ",\"graph_disconnection_failures\":%" PRIu64 + ",\"no_supported_edge_failures\":%" PRIu64 + ",\"transition_model_error_failures\":%" PRIu64 + ",\"state_aliasing_failures\":%" PRIu64 + ",\"expansions\":%" PRIu64 ",\"checksum\":\"%016" PRIx64 "\"}", + p->cases, p->path_found, p->exact_state_targets, + p->goal_expert_targets, p->belief_set_targets, + p->executed_path_length, p->optimal_path_length, p->path_length_regret, + p->graph_disconnection_failures, p->no_supported_edge_failures, + p->transition_model_failures, + p->state_aliasing_failures, p->expansions, p->checksum); +} + +static void print_variant_json(const char *name, Model *m, const Eval *drift, + const Eval *retention, const PlanMetric *planning, + uint64_t training_evaluations, int comma) { + size_t checkpoint_size = model_checkpoint_size(m); + printf(" \"%s\":{\"expert_count\":%u,\"training_evaluations\":%" PRIu64 + ",\"checkpoint_size_bytes\":%zu,\"drift_holdout\":", + name, m->n, training_evaluations, checkpoint_size); + print_eval_json(drift); + printf(",\"retention_holdout\":"); + print_eval_json(retention); + printf(",\"planning\":"); + print_plan_json(planning); + printf("}%s\n", comma ? "," : ""); +} + +static void print_mutations_json(const MutationResult *m) { + printf("{\"retrieval_key_component\":%s,\"reconstruction_component\":%s," + "\"next_observation_component\":%s,\"label\":%s,\"label_count\":%s," + "\"lineage\":%s,\"transition_graph_edge\":%s,\"transition_support\":%s," + "\"anchored_status\":%s,\"payload_byte\":%s," + "\"checkpoint_truncation\":%s,\"appended_unexpected_byte\":%s," + "\"incorrect_schema_version\":%s,\"checkpoint_substitution\":%s}", + m->retrieval_key ? "true" : "false", + m->reconstruction ? "true" : "false", + m->next_observation ? "true" : "false", + m->label ? "true" : "false", + m->label_count ? "true" : "false", + m->lineage ? "true" : "false", + m->transition_graph ? "true" : "false", + m->transition_support ? "true" : "false", + m->anchored_status ? "true" : "false", + m->payload_byte ? "true" : "false", + m->truncation ? "true" : "false", + m->appended_byte ? "true" : "false", + m->schema_version ? "true" : "false", + m->checkpoint_substitution ? "true" : "false"); +} + +static void print_lineage_json(const LineageResult *r) { + printf("{\"sibling_generation_equality\":%s,\"parent_child_generation_increment\":%s," + "\"lineage_uniqueness\":%s,\"repeated_descendant_splitting\":%s," + "\"no_accidental_lineage_reuse\":%s,\"deterministic_topology_reproduction\":%s}", + r->sibling_generation_equality ? "true" : "false", + r->parent_child_increment ? "true" : "false", + r->lineage_uniqueness ? "true" : "false", + r->repeated_descendant_increment ? "true" : "false", + r->no_lineage_reuse ? "true" : "false", + r->deterministic_topology ? "true" : "false"); +} + +static void print_negative_case(const char *id, const char *expected, int observed, int comma) { + (void)expected; + printf(" \"%s\":{\"observed\":%s}%s\n", + id, observed ? "true" : "false", + comma ? "," : ""); +} + + +typedef struct { + Model model; + TrainMetric adaptation_metric; + ReplayMetric replay_metric; + TopologyTrace topology; + Eval drift; + Eval retention; + PlanMetric planning; + int adaptation_ok; +} VariantObservation; + +static int event_equal(const Event *a, const Event *b) { + if (a->action != b->action || a->label != b->label || + a->state != b->state || a->next_state != b->next_state || + a->source_domain != b->source_domain) return 0; + for (uint32_t d = 0; d < D; ++d) { + if (a->x[d] != b->x[d] || a->nx[d] != b->nx[d]) return 0; + } + return 1; +} + +static void print_replay_json(const ReplayMetric *metric) { + printf("{\"selected\":%u,\"unique\":%u,\"labels_covered\":%u," + "\"actions_covered\":%u,\"states_covered\":%u," + "\"assigned_experts_covered\":%u,\"transition_pairs_covered\":%u," + "\"rare_cases_selected\":%u,\"high_loss_cases_selected\":%u," + "\"selection_checksum\":\"%016" PRIx64 "\"}", + metric->selected, metric->unique, metric->labels_covered, + metric->actions_covered, metric->states_covered, + metric->experts_covered, metric->transition_pairs_covered, + metric->rare_cases_selected, metric->high_loss_cases_selected, + metric->selection_checksum); +} + +static void print_topology_json(const TopologyTrace *trace, + const TrainMetric *metric) { + printf("{\"accepted_births\":%u,\"rejected_births\":%u," + "\"accepted_retirements\":%u,\"rejected_retirements\":%u," + "\"objective_before_q20\":%u,\"objective_after_q20\":%u," + "\"births\":[", + trace->accepted_births, trace->rejected_births, + trace->accepted_retirements, trace->rejected_retirements, + trace->objective_before_q20, trace->objective_after_q20); + for (uint32_t i = 0; i < trace->accepted_births; ++i) { + printf("{\"event_index\":%u,\"normalized_score_q20\":%u," + "\"dominant_channel\":%u}%s", + trace->birth_event_index[i], trace->birth_score_q20[i], + trace->birth_dominant_channel[i], + i + 1u < trace->accepted_births ? "," : ""); + } + printf("],\"retired_lineages\":["); + for (uint32_t i = 0; i < trace->accepted_retirements; ++i) { + printf("\"%016" PRIx64 "\"%s", trace->retired_lineage[i], + i + 1u < trace->accepted_retirements ? "," : ""); + } + printf("],\"training_observations\":{\"expert_evaluations\":%" PRIu64 + ",\"samples\":%" PRIu64 ",\"certified\":%" PRIu64 + ",\"births\":%" PRIu64 ",\"retired\":%" PRIu64 + ",\"rejected_births\":%" PRIu64 + ",\"rejected_retirements\":%" PRIu64 "}}", + metric->expert_evaluations, metric->samples, metric->certified, + metric->births, metric->retired, metric->rejected_births, + metric->rejected_retirements); +} + +static void observe_adapted_variant( + VariantObservation *out, const Model *base, const Event *base_train, + const Event *adapt_train, const Event *drift_hold, const Event *retention, + const World *world, const TrialSpec *spec, uint64_t planning_seed, + const VariantConfig *config) { + memset(out, 0, sizeof *out); + out->model = *base; + out->adaptation_ok = + adapt_model(&out->model, base_train, adapt_train, config, + &out->adaptation_metric, &out->replay_metric, &out->topology); + canonicalize_model(&out->model); + out->drift = evaluate(&out->model, drift_hold, DRIFT_HOLD_N, config->routed); + out->retention = + evaluate(&out->model, retention, RETENTION_N, config->routed); + out->planning = + evaluate_planning(&out->model, world, spec, planning_seed, 1); +} + +static void print_variant_observation(const char *name, + VariantObservation *observation, + uint64_t base_training_evaluations, + int comma) { + print_variant_json(name, &observation->model, &observation->drift, + &observation->retention, &observation->planning, + base_training_evaluations + + observation->adaptation_metric.expert_evaluations, + comma); +} + +static uint32_t count_unsupported_graph_violations(const Model *model) { + uint32_t violations = 0u; + for (uint16_t expert = 0; expert < model->n; ++expert) { + for (uint32_t action = 0; action < ACTIONS; ++action) { + for (uint32_t k = 0; k < TRANSITION_TOP_K; ++k) { + int insufficient = + model->e[expert].action_count[action] < + TRANSITION_SUPPORT_MIN || + model->next_graph_support[expert][action][k] < + TRANSITION_SUPPORT_MIN; + if (insufficient && + model->next_graph[expert][action][k] != INVALID_EXPERT) { + ++violations; + } + } + } + } + return violations; +} + +static const TrialSpec *find_regime(const char *name) { + for (uint32_t i = 0; i < REGIMES; ++i) { + if (strcmp(name, regime_specs[i].regime) == 0) return ®ime_specs[i]; + } + return NULL; +} + +static int safe_identifier(const char *value) { + if (value == NULL || *value == '\0') return 0; + for (const unsigned char *p = (const unsigned char *)value; *p != 0u; ++p) { + int valid = (*p >= 'a' && *p <= 'z') || (*p >= 'A' && *p <= 'Z') || + (*p >= '0' && *p <= '9') || *p == '-' || *p == '_'; + if (!valid) return 0; + } + return 1; +} + +static void print_trial_header(const TrialSpec *spec, + uint64_t base_train_seed, + uint64_t base_hold_seed, + uint64_t adapt_train_seed, + uint64_t drift_hold_seed, + uint64_t retention_seed, + uint64_t planning_seed) { + printf("{\n \"schema\":\"ravel-raw-trial/0.5\",\n" + " \"trial_id\":\"%s\",\"regime\":\"%s\"," + "\"seed\":\"0x%016" PRIx64 "\",\n" + " \"dataset_seeds\":{\"base_training\":\"0x%016" PRIx64 + "\",\"base_holdout\":\"0x%016" PRIx64 + "\",\"drift_adaptation_training\":\"0x%016" PRIx64 + "\",\"drift_holdout\":\"0x%016" PRIx64 + "\",\"original_task_retention_holdout\":\"0x%016" PRIx64 + "\",\"planning_cases\":\"0x%016" PRIx64 "\"},\n", + spec->trial_id, spec->regime, spec->seed, + base_train_seed, base_hold_seed, adapt_train_seed, + drift_hold_seed, retention_seed, planning_seed); + printf(" \"dataset_sizes\":{\"base_training\":%u,\"base_holdout\":%u," + "\"drift_adaptation_training\":%u,\"drift_holdout\":%u," + "\"original_task_retention_holdout\":%u,\"planning_cases\":%u},\n", + BASE_TRAIN_N, BASE_HOLD_N, ADAPT_TRAIN_N, DRIFT_HOLD_N, + RETENTION_N, PLAN_N); +} + +static int run_trial(const char *trial_id, const char *regime, + uint64_t seed, const char *variant_filter) { + const TrialSpec *profile = find_regime(regime); + if (profile == NULL || !safe_identifier(trial_id)) return 2; + TrialSpec spec = *profile; + spec.trial_id = trial_id; + spec.seed = seed; + World world; + Event base_train[BASE_TRAIN_N], base_hold[BASE_HOLD_N]; + Event adapt_train[ADAPT_TRAIN_N], drift_hold[DRIFT_HOLD_N]; + Event retention[RETENTION_N]; + make_world(&world, &spec); + uint64_t base_train_seed = mix64(seed ^ UINT64_C(0x4241534554524149)); + uint64_t base_hold_seed = mix64(seed ^ UINT64_C(0x42415345484f4c44)); + uint64_t adapt_train_seed = mix64(seed ^ UINT64_C(0x414441505454524e)); + uint64_t drift_hold_seed = mix64(seed ^ UINT64_C(0x4452494654484f4c)); + uint64_t retention_seed = mix64(seed ^ UINT64_C(0x524554454e54494f)); + uint64_t planning_seed = mix64(seed ^ UINT64_C(0x504c414e43415345)); + make_dataset(&world, &spec, base_train, BASE_TRAIN_N, base_train_seed, 0); + make_dataset(&world, &spec, base_hold, BASE_HOLD_N, base_hold_seed, 0); + make_dataset(&world, &spec, adapt_train, ADAPT_TRAIN_N, adapt_train_seed, 1); + make_dataset(&world, &spec, drift_hold, DRIFT_HOLD_N, drift_hold_seed, 1); + make_dataset(&world, &spec, retention, RETENTION_N, retention_seed, 0); + + Model base; + TrainMetric base_metric = {0}; + train_recursive(&base, base_train, BASE_TRAIN_N, &base_metric); + canonicalize_model(&base); + (void)model_checkpoint_size(&base); + Eval base_hold_eval = evaluate(&base, base_hold, BASE_HOLD_N, 1); + Eval static_drift_eval = evaluate(&base, drift_hold, DRIFT_HOLD_N, 1); + Eval static_retention_eval = evaluate(&base, retention, RETENTION_N, 1); + PlanMetric static_plan = + evaluate_planning(&base, &world, &spec, planning_seed, 1); + + VariantConfig candidate_config = { + .use_replay = 1u, .use_retirement = 1u, .routed = 1u, + .recursive_births = 1u, .random_births = 0u, + .replay_policy = 1u, .protect_base = 1u, .matched_work = 1u + }; + VariantObservation candidate; + observe_adapted_variant(&candidate, &base, base_train, adapt_train, + drift_hold, retention, &world, &spec, + planning_seed, &candidate_config); + Eval adaptation_training_eval = + evaluate(&candidate.model, adapt_train, ADAPT_TRAIN_N, 1); + + Model restored; + size_t checkpoint_size = 0u; + int checkpoint_ok = candidate.adaptation_ok && + checkpoint_memory_roundtrip(&candidate.model, &restored, &checkpoint_size); + Eval restored_adaptation = checkpoint_ok + ? evaluate(&restored, adapt_train, ADAPT_TRAIN_N, 1) : (Eval){0}; + Eval restored_drift = checkpoint_ok + ? evaluate(&restored, drift_hold, DRIFT_HOLD_N, 1) : (Eval){0}; + Eval restored_retention = checkpoint_ok + ? evaluate(&restored, retention, RETENTION_N, 1) : (Eval){0}; + PlanMetric restored_plan = checkpoint_ok + ? evaluate_planning(&restored, &world, &spec, planning_seed, 1) + : (PlanMetric){0}; + int checkpoint_identity = checkpoint_ok && + bytes_equal(candidate.model.identity, restored.identity, 32u); + int checkpoint_behavior = checkpoint_ok && + eval_equal(&adaptation_training_eval, &restored_adaptation) && + eval_equal(&candidate.drift, &restored_drift) && + eval_equal(&candidate.retention, &restored_retention) && + plan_equal(&candidate.planning, &restored_plan) && + checkpoint_equivalent(&candidate.model, &restored, &candidate.drift, + &restored_drift, &candidate.planning, + &restored_plan); + MutationResult mutations = checkpoint_mutations(&candidate.model); + LineageResult lineage = lineage_invariants(base_train); + char model_identity[65], behavior_identity[65]; + uint8_t behavior[32]; + digest_hex(candidate.model.identity, model_identity); + behavior_digest(&candidate.model, &candidate.drift, + &candidate.planning, behavior); + digest_hex(behavior, behavior_identity); + + print_trial_header(&spec, base_train_seed, base_hold_seed, adapt_train_seed, + drift_hold_seed, retention_seed, planning_seed); + printf(" \"checkpoint_format\":{\"magic_hex\":\"524156454c303500\"," + "\"schema_version\":%u,\"byte_order\":\"big_endian\"," + "\"real_encoding\":\"signed_q20_int64\",\"payload_digest\":\"sha256\"," + "\"transition_top_k\":%u,\"transition_support_min\":%u},\n", + CHECKPOINT_SCHEMA, TRANSITION_TOP_K, TRANSITION_SUPPORT_MIN); + printf(" \"candidate\":{\"adaptation_completed\":%s,\"expert_count\":%u," + "\"base_training_evaluations\":%" PRIu64 + ",\"adaptation_training_evaluations\":%" PRIu64 + ",\"checkpoint_size_bytes\":%zu,\"model_identity\":\"%s\"," + "\"behavior_identity\":\"%s\",\"base_holdout\":", + candidate.adaptation_ok ? "true" : "false", candidate.model.n, + base_metric.expert_evaluations, + candidate.adaptation_metric.expert_evaluations, + checkpoint_size, model_identity, behavior_identity); + print_eval_json(&base_hold_eval); + printf(",\"adaptation_training\":"); + print_eval_json(&adaptation_training_eval); + printf(",\"static_model_drift_holdout\":"); + print_eval_json(&static_drift_eval); + printf(",\"adapted_model_drift_holdout\":"); + print_eval_json(&candidate.drift); + printf(",\"base_holdout_retention\":"); + print_eval_json(&candidate.retention); + printf(",\"planning\":"); + print_plan_json(&candidate.planning); + printf(",\"replay\":"); + print_replay_json(&candidate.replay_metric); + printf(",\"topology\":"); + print_topology_json(&candidate.topology, &candidate.adaptation_metric); + printf("},\n"); + printf(" \"integrity\":{\"checkpoint_roundtrip\":%s," + "\"checkpoint_identity_match\":%s,\"checkpoint_behavior_match\":%s," + "\"checkpoint_mutations\":", + checkpoint_ok ? "true" : "false", + checkpoint_identity ? "true" : "false", + checkpoint_behavior ? "true" : "false"); + print_mutations_json(&mutations); + printf(",\"lineage_invariants\":"); + print_lineage_json(&lineage); + printf(",\"unsupported_graph_edge_violations\":%u},\n", + count_unsupported_graph_violations(&candidate.model)); + + printf(" \"comparisons\":{\n"); + int printed = 0; +#define WANT_VARIANT(name) \ + (variant_filter == NULL || strcmp(variant_filter, (name)) == 0) +#define BEGIN_VARIANT() do { if (printed) printf(",\n"); printed = 1; } while (0) + if (WANT_VARIANT("ravel_0_5_candidate")) { + BEGIN_VARIANT(); + print_variant_observation("ravel_0_5_candidate", &candidate, + base_metric.expert_evaluations, 0); + } + Model fixed8; + TrainMetric fixed8_metric = {0}; + train_flat(&fixed8, 8u, base_train, &fixed8_metric, 0); + if (WANT_VARIANT("fixed_8_expert")) { + Eval drift = evaluate(&fixed8, drift_hold, DRIFT_HOLD_N, 0); + Eval old = evaluate(&fixed8, retention, RETENTION_N, 0); + PlanMetric plan = + evaluate_planning(&fixed8, &world, &spec, planning_seed, 1); + BEGIN_VARIANT(); + print_variant_json("fixed_8_expert", &fixed8, &drift, &old, &plan, + fixed8_metric.expert_evaluations, 0); + } + Model flat64; + TrainMetric flat64_metric = {0}; + train_flat(&flat64, 64u, base_train, &flat64_metric, 0); + if (WANT_VARIANT("flat_64_expert_complete_scan")) { + Eval flat_drift = evaluate(&flat64, drift_hold, DRIFT_HOLD_N, 0); + Eval flat_old = evaluate(&flat64, retention, RETENTION_N, 0); + PlanMetric flat_plan = + evaluate_planning(&flat64, &world, &spec, planning_seed, 1); + BEGIN_VARIANT(); + print_variant_json("flat_64_expert_complete_scan", &flat64, + &flat_drift, &flat_old, &flat_plan, + flat64_metric.expert_evaluations, 0); + } + if (WANT_VARIANT("fixed_topology_64_expert_routed")) { + Eval flat_drift = evaluate(&flat64, drift_hold, DRIFT_HOLD_N, 1); + Eval flat_old = evaluate(&flat64, retention, RETENTION_N, 1); + PlanMetric flat_plan = + evaluate_planning(&flat64, &world, &spec, planning_seed, 1); + BEGIN_VARIANT(); + print_variant_json("fixed_topology_64_expert_routed", &flat64, + &flat_drift, &flat_old, &flat_plan, + flat64_metric.expert_evaluations, 0); + } + if (WANT_VARIANT("nearest_centroid_16_no_recursive_births")) { + Model centroid; + TrainMetric metric = {0}; + train_flat(¢roid, 16u, base_train, &metric, 0); + Eval drift = evaluate(¢roid, drift_hold, DRIFT_HOLD_N, 0); + Eval old = evaluate(¢roid, retention, RETENTION_N, 0); + PlanMetric plan = + evaluate_planning(¢roid, &world, &spec, planning_seed, 1); + BEGIN_VARIANT(); + print_variant_json("nearest_centroid_16_no_recursive_births", + ¢roid, &drift, &old, &plan, + metric.expert_evaluations, 0); + } + if (WANT_VARIANT("no_adaptation_static")) { + BEGIN_VARIANT(); + print_variant_json("no_adaptation_static", &base, &static_drift_eval, + &static_retention_eval, &static_plan, + base_metric.expert_evaluations, 0); + } + const struct { + const char *name; + VariantConfig config; + } adapted_variants[] = { + {"ravel_without_replay", + {0u, 1u, 1u, 1u, 0u, 0u, 1u, 1u}}, + {"ravel_without_retirement_matched_work", + {1u, 0u, 1u, 1u, 0u, 1u, 1u, 1u}}, + {"ravel_complete_scan_without_certification", + {1u, 1u, 0u, 1u, 0u, 1u, 1u, 1u}}, + {"ravel_no_birth_same_replay_iterations", + {1u, 0u, 1u, 0u, 0u, 1u, 1u, 1u}}, + {"ravel_random_births", + {1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u}}, + {"periodic_replay_policy", + {1u, 1u, 1u, 1u, 0u, 2u, 1u, 1u}} + }; + for (size_t v = 0; v < sizeof adapted_variants / sizeof adapted_variants[0]; ++v) { + if (!WANT_VARIANT(adapted_variants[v].name)) continue; + VariantObservation observation; + observe_adapted_variant(&observation, &base, base_train, adapt_train, + drift_hold, retention, &world, &spec, + planning_seed, &adapted_variants[v].config); + BEGIN_VARIANT(); + print_variant_observation(adapted_variants[v].name, &observation, + base_metric.expert_evaluations, 0); + } + if (WANT_VARIANT("matched_compute_fixed_topology")) { + VariantConfig matched = { + 1u, 0u, 1u, 0u, 0u, 1u, 1u, 1u + }; + VariantObservation observation; + observe_adapted_variant(&observation, &base, base_train, adapt_train, + drift_hold, retention, &world, &spec, + planning_seed, &matched); + uint32_t repeats = 0u; + while (observation.adaptation_metric.expert_evaluations < + candidate.adaptation_metric.expert_evaluations && + repeats++ < 8u) { + ReplayMetric extra_replay = {0}; + TopologyTrace extra_topology = {0}; + (void)adapt_model(&observation.model, base_train, adapt_train, + &matched, &observation.adaptation_metric, + &extra_replay, &extra_topology); + } + canonicalize_model(&observation.model); + observation.drift = + evaluate(&observation.model, drift_hold, DRIFT_HOLD_N, 1); + observation.retention = + evaluate(&observation.model, retention, RETENTION_N, 1); + observation.planning = + evaluate_planning(&observation.model, &world, &spec, + planning_seed, 1); + BEGIN_VARIANT(); + print_variant_observation("matched_compute_fixed_topology", + &observation, + base_metric.expert_evaluations, 0); + } + if (WANT_VARIANT("matched_expert_count_capacity")) { + Model matched_capacity; + TrainMetric metric = {0}; + train_flat(&matched_capacity, candidate.model.n, base_train, &metric, 0); + Eval drift = evaluate(&matched_capacity, drift_hold, DRIFT_HOLD_N, 1); + Eval old = evaluate(&matched_capacity, retention, RETENTION_N, 1); + PlanMetric plan = + evaluate_planning(&matched_capacity, &world, &spec, planning_seed, 1); + BEGIN_VARIANT(); + print_variant_json("matched_expert_count_capacity", &matched_capacity, + &drift, &old, &plan, + metric.expert_evaluations, 0); + } +#undef BEGIN_VARIANT +#undef WANT_VARIANT + printf("\n }\n}\n"); + return 0; +} + +static void run_self_tests(void) { + TrialSpec spec = regime_specs[0]; + spec.trial_id = "self-test"; + spec.seed = UINT64_C(0x0505de7e10a11a55); + World world; + Event base_train[BASE_TRAIN_N], adapt_train[ADAPT_TRAIN_N]; + Event retention[RETENTION_N], drift_hold[DRIFT_HOLD_N]; + make_world(&world, &spec); + make_dataset(&world, &spec, base_train, BASE_TRAIN_N, + mix64(spec.seed ^ 1u), 0); + make_dataset(&world, &spec, adapt_train, ADAPT_TRAIN_N, + mix64(spec.seed ^ 2u), 1); + make_dataset(&world, &spec, retention, RETENTION_N, + mix64(spec.seed ^ 3u), 0); + make_dataset(&world, &spec, drift_hold, DRIFT_HOLD_N, + mix64(spec.seed ^ 4u), 1); + Model base; + TrainMetric base_metric = {0}; + train_recursive(&base, base_train, BASE_TRAIN_N, &base_metric); + canonicalize_model(&base); + NegativeResult negative = + run_negative_tests(&base, base_train, retention, adapt_train, drift_hold); + + Event first[REPLAY_N], second[REPLAY_N], sparse[REPLAY_N]; + ReplayMetric first_metric = {0}, second_metric = {0}, sparse_metric = {0}; + uint32_t first_count = + select_replay(&base, base_train, BASE_TRAIN_N, 1u, first, &first_metric); + uint32_t second_count = + select_replay(&base, base_train, BASE_TRAIN_N, 1u, second, &second_metric); + int deterministic = first_count == second_count; + for (uint32_t i = 0; i < first_count && deterministic; ++i) { + if (!event_equal(&first[i], &second[i])) deterministic = 0; + } + Event sparse_input[16]; + for (uint32_t i = 0; i < 16u; ++i) { + sparse_input[i] = base_train[i % 2u]; + sparse_input[i].state = (uint8_t)(i % 2u); + sparse_input[i].action = (uint8_t)(i % 2u); + } + uint32_t sparse_count = + select_replay(&base, sparse_input, 16u, 1u, sparse, &sparse_metric); + + Model residual_model; + memset(&residual_model, 0, sizeof residual_model); + residual_model.n = 1u; + seed_expert(&residual_model.e[0], &base_train[0], + mix64(UINT64_C(0x524553494455414c)), 0u, 0u); + residual_model.e[0].count = 64u; + residual_model.e[0].labels[base_train[0].label] = 64u; + for (uint32_t action = 0; action < ACTIONS; ++action) { + residual_model.e[0].action_count[action] = 16u; + } + Event classification_fixture = base_train[0]; + classification_fixture.label = + (uint8_t)((classification_fixture.label + 1u) % CLASSES); + Residual base_residual = event_residual(&residual_model, &base_train[0]); + Residual classification_residual = + event_residual(&residual_model, &classification_fixture); + Event reconstruction_fixture = base_train[0]; + reconstruction_fixture.x[0] = + clamp_domain((int)reconstruction_fixture.x[0] + 24); + Residual reconstruction_residual = + event_residual(&residual_model, &reconstruction_fixture); + Event prediction_fixture = base_train[0]; + for (uint32_t d = 0; d < D; ++d) { + prediction_fixture.nx[d] = clamp_domain(-(int)prediction_fixture.nx[d]); + } + Residual prediction_residual = + event_residual(&residual_model, &prediction_fixture); + Model novelty_model = residual_model; + novelty_model.e[0].key[0] += 32.0; + Residual novelty_residual = + event_residual(&novelty_model, &base_train[0]); + Model support_model = residual_model; + support_model.e[0].count = 0u; + Residual support_residual = + event_residual(&support_model, &base_train[0]); + Model uncertainty_model = residual_model; + memset(uncertainty_model.e[0].labels, 0, + sizeof uncertainty_model.e[0].labels); + uncertainty_model.e[0].labels[0] = 32u; + uncertainty_model.e[0].labels[1] = 32u; + Residual uncertainty_residual = + event_residual(&uncertainty_model, &base_train[0]); + Model action_model = residual_model; + action_model.e[0].action_count[base_train[0].action] = 0u; + Residual action_residual = + event_residual(&action_model, &base_train[0]); + Event retention_risk_fixture = base_train[0]; + retention_risk_fixture.label = + (uint8_t)((retention_risk_fixture.label + 1u) % CLASSES); + Residual retention_risk_residual = + event_residual(&residual_model, &retention_risk_fixture); + + Model unsupported = base; + unsupported.e[0].action_count[0] = 0u; + unsupported.e[0].transition_target[0][0] = 0u; + unsupported.e[0].transition_support[0][0] = 0u; + compile_graph(&unsupported); + int unsupported_unknown = + unsupported.next_graph[0][0][0] == INVALID_EXPERT; + Model ambiguous = base; + ambiguous.e[0].action_count[0] = 5u; + for (uint32_t d = 0; d < D; ++d) { + ambiguous.e[0].next[0][d] = ambiguous.e[0].key[d]; + } + ambiguous.e[0].transition_target[0][0] = 1u; + ambiguous.e[0].transition_support[0][0] = 3u; + ambiguous.e[0].transition_target[0][1] = 0u; + ambiguous.e[0].transition_support[0][1] = 2u; + compile_graph(&ambiguous); + int top_k_retained = + ambiguous.next_graph[0][0][0] == 0u && + ambiguous.next_graph[0][0][1] == 1u; + Model retirement_fixture; + memset(&retirement_fixture, 0, sizeof retirement_fixture); + retirement_fixture.n = 1u; + seed_expert(&retirement_fixture.e[0], &adapt_train[0], + mix64(UINT64_C(0x5254495245)), 1u, 1u); + retirement_fixture.e[0].labels[adapt_train[0].label] = 1u; + retirement_fixture.e[0].count = 1u; + int unique_retirement_rejected = !retirement_safe(&retirement_fixture, 0u); + Model retirement_checkpoint; + memset(&retirement_checkpoint, 0, sizeof retirement_checkpoint); + retirement_checkpoint.n = 10u; + for (uint16_t expert = 0; expert < retirement_checkpoint.n; ++expert) { + seed_expert(&retirement_checkpoint.e[expert], &adapt_train[expert], + mix64(UINT64_C(0x5245544348505400) ^ expert), 1u, 1u); + retirement_checkpoint.e[expert].count = 4u; + retirement_checkpoint.e[expert].action_count[0] = 4u; + } + retirement_checkpoint.e[0].transition_target[0][0] = 1u; + retirement_checkpoint.e[0].transition_support[0][0] = 3u; + retirement_checkpoint.e[9].transition_target[0][0] = 9u; + retirement_checkpoint.e[9].transition_support[0][0] = 3u; + int retirement_removed = + remove_expert(&retirement_checkpoint, 1u, 1); + canonicalize_model(&retirement_checkpoint); + Model retirement_restored; + size_t retirement_checkpoint_size = 0u; + int retirement_checkpoint_valid = + retirement_removed && + retirement_checkpoint.e[0].transition_target[0][0] == INVALID_EXPERT && + retirement_checkpoint.e[0].transition_support[0][0] == 0u && + retirement_checkpoint.e[1].transition_target[0][0] == 1u && + checkpoint_memory_roundtrip(&retirement_checkpoint, + &retirement_restored, + &retirement_checkpoint_size) && + retirement_checkpoint_size > 0u; + Model nonfinite = base; + nonfinite.e[0].key[0] = NAN; + ByteBuffer nonfinite_checkpoint; + int nonfinite_rejected = !serialize_checkpoint(&nonfinite, &nonfinite_checkpoint); + nonfinite = base; + nonfinite.e[0].key[0] = DBL_MAX; + int overflow_rejected = !serialize_checkpoint(&nonfinite, &nonfinite_checkpoint); + + printf("{\n \"schema\":\"ravel-self-test-observations/0.5\",\n" + " \"fixtures\":{\n"); + print_negative_case("malformed_observation", "evaluator_derives", + negative.malformed_observation_rejected, 1); + print_negative_case("out_of_domain_value", "evaluator_derives", + negative.out_of_domain_fallback, 1); + print_negative_case("empty_expert_assignment", "evaluator_derives", + negative.empty_assignment_rejected, 1); + print_negative_case("degenerate_expert_assignment", "evaluator_derives", + negative.degenerate_assignment_rejected, 1); + print_negative_case("duplicate_expert", "evaluator_derives", + negative.duplicate_expert_rejected, 1); + print_negative_case("tied_distance", "evaluator_derives", + negative.tied_distance_lower_id, 1); + print_negative_case("routing_lower_bound_equality", "evaluator_derives", + negative.lower_bound_equality_fallback, 1); + print_negative_case("maximum_expert_capacity", "evaluator_derives", + negative.maximum_capacity_preserved, 1); + print_negative_case("birth_beyond_capacity", "evaluator_derives", + negative.birth_beyond_capacity_rejected, 1); + print_negative_case("wrong_lifecycle_retirement", "evaluator_derives", + negative.wrong_lifecycle_retirement_rejected, 1); + print_negative_case("poisoned_adaptation_labels", "evaluator_derives", + negative.poisoned_labels_fail_gate, 1); + print_negative_case("poisoned_transition_observations", "evaluator_derives", + negative.poisoned_transitions_fail_gate, 1); + print_negative_case("replay_removal_experiment", "evaluator_derives", + negative.replay_removal_fail_gate, 1); + print_negative_case("catastrophic_forgetting_experiment", "evaluator_derives", + negative.catastrophic_forgetting_fail_gate, 1); + print_negative_case("balanced_replay_determinism", "evaluator_derives", + deterministic, 1); + print_negative_case("balanced_replay_no_duplicates", "evaluator_derives", + first_metric.selected == first_metric.unique, 1); + print_negative_case("balanced_replay_coverage", "evaluator_derives", + first_metric.labels_covered == CLASSES && + first_metric.actions_covered == ACTIONS && + first_metric.states_covered == STATES, 1); + print_negative_case("balanced_replay_sparse_strata", "evaluator_derives", + sparse_count <= 16u && sparse_metric.unique == sparse_count, 1); + print_negative_case("classification_residual_fixture", "evaluator_derives", + classification_residual.classification > + base_residual.classification && + classification_residual.total > base_residual.total, 1); + print_negative_case("reconstruction_residual_fixture", "evaluator_derives", + reconstruction_residual.reconstruction > + base_residual.reconstruction && + reconstruction_residual.total > base_residual.total, 1); + print_negative_case("prediction_residual_fixture", "evaluator_derives", + prediction_residual.prediction > base_residual.prediction && + prediction_residual.total > base_residual.total, 1); + print_negative_case("novelty_residual_fixture", "evaluator_derives", + novelty_residual.novelty > base_residual.novelty && + novelty_residual.total > base_residual.total, 1); + print_negative_case("inverse_support_residual_fixture", "evaluator_derives", + support_residual.inverse_support > + base_residual.inverse_support && + support_residual.total > base_residual.total, 1); + print_negative_case("uncertainty_residual_fixture", "evaluator_derives", + uncertainty_residual.uncertainty > + base_residual.uncertainty && + uncertainty_residual.total > base_residual.total, 1); + print_negative_case("action_coverage_residual_fixture", "evaluator_derives", + action_residual.action_coverage > + base_residual.action_coverage && + action_residual.total > base_residual.total, 1); + print_negative_case("retention_risk_residual_fixture", "evaluator_derives", + retention_risk_residual.retention_risk > + base_residual.retention_risk && + retention_risk_residual.total > base_residual.total, 1); + print_negative_case("unsupported_action_unknown", "evaluator_derives", + unsupported_unknown, 1); + print_negative_case("top_k_transition_ambiguity", "evaluator_derives", + top_k_retained, 1); + print_negative_case("retirement_unique_support_safety", "evaluator_derives", + unique_retirement_rejected, 1); + print_negative_case("retirement_checkpoint_remap", "evaluator_derives", + retirement_checkpoint_valid, 1); + print_negative_case("non_finite_serialization", "evaluator_derives", + nonfinite_rejected, 1); + print_negative_case("overflow_serialization", "evaluator_derives", + overflow_rejected, 0); + printf(" },\n \"replay_observations\":"); + print_replay_json(&first_metric); + printf(",\n \"sparse_replay_observations\":"); + print_replay_json(&sparse_metric); + printf("\n}\n"); +} + +static void usage(const char *program) { + fprintf(stderr, + "usage: %s --trial ID --regime NAME --seed HEX [--variant NAME]\n" + " %s --self-test\n" + " %s --list-regimes\n", + program, program, program); +} + +int main(int argc, char **argv) { + const char *trial_id = NULL; + const char *regime = NULL; + const char *variant = NULL; + uint64_t seed = 0u; + int have_seed = 0; + int self_test = 0; + int list_regimes = 0; + for (int i = 1; i < argc; ++i) { + if (strcmp(argv[i], "--trial") == 0 && i + 1 < argc) { + trial_id = argv[++i]; + } else if (strcmp(argv[i], "--regime") == 0 && i + 1 < argc) { + regime = argv[++i]; + } else if (strcmp(argv[i], "--seed") == 0 && i + 1 < argc) { + char *end = NULL; + seed = strtoull(argv[++i], &end, 0); + have_seed = end != NULL && *end == '\0'; + } else if (strcmp(argv[i], "--variant") == 0 && i + 1 < argc) { + variant = argv[++i]; + } else if (strcmp(argv[i], "--self-test") == 0) { + self_test = 1; + } else if (strcmp(argv[i], "--list-regimes") == 0) { + list_regimes = 1; + } else { + usage(argv[0]); + return 2; + } + } + if (list_regimes) { + for (uint32_t i = 0; i < REGIMES; ++i) { + puts(regime_specs[i].regime); + } + return 0; + } + if (self_test) { + run_self_tests(); + return 0; + } + if (trial_id == NULL || regime == NULL || !have_seed) { + usage(argv[0]); + return 2; + } + return run_trial(trial_id, regime, seed, variant); +} diff --git a/tools/ravel_0_5_evaluator.py b/tools/ravel_0_5_evaluator.py new file mode 100644 index 0000000..4c34ae0 --- /dev/null +++ b/tools/ravel_0_5_evaluator.py @@ -0,0 +1,1215 @@ +#!/usr/bin/env python3 +"""Independent RAVEL 0.5 raw-observation evaluator. + +The C harness emits integer observations and integrity facts. This module is the +only authority that loads preregistered thresholds, derives metrics and gates, +and determines trial and global development results. +""" + +from __future__ import annotations + +import hashlib +import json +import math +import statistics +from pathlib import Path +from typing import Any + +Q20_SCALE = 1_048_576 +DIMENSIONS = 8 +UINT64_MASK = (1 << 64) - 1 + +CHECKPOINT_MUTATION_KEYS = { + "retrieval_key_component", + "reconstruction_component", + "next_observation_component", + "label", + "label_count", + "lineage", + "transition_graph_edge", + "transition_support", + "anchored_status", + "payload_byte", + "checkpoint_truncation", + "appended_unexpected_byte", + "incorrect_schema_version", + "checkpoint_substitution", +} + +LINEAGE_INVARIANT_KEYS = { + "sibling_generation_equality", + "parent_child_generation_increment", + "lineage_uniqueness", + "repeated_descendant_splitting", + "no_accidental_lineage_reuse", + "deterministic_topology_reproduction", +} + +DATASET_KEYS = { + "base_training", + "base_holdout", + "drift_adaptation_training", + "drift_holdout", + "original_task_retention_holdout", + "planning_cases", +} + +DATASET_SEED_XORS = { + "base_training": 0x4241534554524149, + "base_holdout": 0x42415345484F4C44, + "drift_adaptation_training": 0x414441505454524E, + "drift_holdout": 0x4452494654484F4C, + "original_task_retention_holdout": 0x524554454E54494F, + "planning_cases": 0x504C414E43415345, +} + + +class EvaluationError(RuntimeError): + """Raised when raw or preregistered evidence is not admissible.""" + + +def _reject_constant(value: str) -> None: + raise EvaluationError(f"non-finite JSON constant rejected: {value}") + + +def load_json(path: Path) -> Any: + try: + return json.loads(path.read_text(), parse_constant=_reject_constant) + except (OSError, json.JSONDecodeError) as error: + raise EvaluationError(f"cannot load {path}: {error}") from error + + +def canonical_bytes(value: Any) -> bytes: + return ( + json.dumps(value, sort_keys=True, separators=(",", ":"), allow_nan=False) + + "\n" + ).encode() + + +def sha256_json(value: Any) -> str: + return hashlib.sha256(canonical_bytes(value)).hexdigest() + + +def require_object(value: Any, context: str) -> dict[str, Any]: + if not isinstance(value, dict): + raise EvaluationError(f"{context}: expected object") + return value + + +def require_exact_keys( + value: dict[str, Any], keys: set[str], context: str +) -> None: + actual = set(value) + if actual != keys: + missing = sorted(keys - actual) + unknown = sorted(actual - keys) + raise EvaluationError( + f"{context}: key mismatch missing={missing} unknown={unknown}" + ) + + +def require_int( + value: Any, context: str, minimum: int = 0, maximum: int | None = None +) -> int: + if isinstance(value, bool) or not isinstance(value, int): + raise EvaluationError(f"{context}: expected integer") + if value < minimum or (maximum is not None and value > maximum): + raise EvaluationError(f"{context}: integer outside declared range") + return value + + +def require_bool(value: Any, context: str) -> bool: + if not isinstance(value, bool): + raise EvaluationError(f"{context}: expected boolean") + return value + + +def require_string(value: Any, context: str) -> str: + if not isinstance(value, str) or not value: + raise EvaluationError(f"{context}: expected non-empty string") + return value + + +def _validate_hex(value: Any, context: str, digits: int) -> str: + text = require_string(value, context) + if len(text) != digits or any(c not in "0123456789abcdef" for c in text): + raise EvaluationError(f"{context}: expected {digits} lowercase hex digits") + return text + + +def _validate_u64_hex(value: Any, context: str) -> int: + text = require_string(value, context) + if len(text) != 18 or not text.startswith("0x"): + raise EvaluationError(f"{context}: expected 0x plus 16 lowercase hex digits") + _validate_hex(text[2:], context, 16) + return int(text[2:], 16) + + +def _mix64(value: int) -> int: + value &= UINT64_MASK + value ^= value >> 30 + value = (value * 0xBF58476D1CE4E5B9) & UINT64_MASK + value ^= value >> 27 + value = (value * 0x94D049BB133111EB) & UINT64_MASK + return (value ^ (value >> 31)) & UINT64_MASK + + +def _derive_validation_seed(root: int, regime: str, index: int) -> int: + framed = ( + root.to_bytes(8, "big") + + b"validation\0" + + regime.encode("utf-8") + + b"\0" + + index.to_bytes(4, "big") + ) + return int.from_bytes(hashlib.sha256(framed).digest()[:8], "big") + + +EVAL_KEYS = { + "samples", + "rejected", + "correct", + "reconstruction_sse_q20", + "prediction_sse_q20", + "prediction_samples", + "transition_correct", + "transition_supported", + "transition_unknown", + "routing_certification_count", + "routed_complete_mismatches", + "expert_evaluations", + "classification_checksum", + "reconstruction_checksum", + "prediction_checksum", + "transition_checksum", +} + +PLAN_KEYS = { + "cases", + "path_found", + "exact_world_state_target_reached", + "goal_expert_reached", + "belief_set_target_reached", + "executed_path_length", + "optimal_path_length", + "path_length_regret", + "graph_disconnection_failures", + "no_supported_edge_failures", + "transition_model_error_failures", + "state_aliasing_failures", + "expansions", + "checksum", +} + + +def validate_eval(value: Any, context: str) -> dict[str, Any]: + record = require_object(value, context) + require_exact_keys(record, EVAL_KEYS, context) + for key in EVAL_KEYS - { + "classification_checksum", + "reconstruction_checksum", + "prediction_checksum", + "transition_checksum", + }: + require_int(record[key], f"{context}.{key}") + samples = record["samples"] + prediction_samples = record["prediction_samples"] + transition_supported = record["transition_supported"] + if record["correct"] > samples or prediction_samples > samples: + raise EvaluationError(f"{context}: count exceeds samples") + if transition_supported > samples or record["transition_correct"] > transition_supported: + raise EvaluationError(f"{context}: transition count contradiction") + if transition_supported + record["transition_unknown"] != samples: + raise EvaluationError(f"{context}: transition support partition contradiction") + for key in ( + "classification_checksum", + "reconstruction_checksum", + "prediction_checksum", + "transition_checksum", + ): + _validate_hex(record[key], f"{context}.{key}", 16) + return record + + +def validate_plan(value: Any, context: str) -> dict[str, Any]: + record = require_object(value, context) + require_exact_keys(record, PLAN_KEYS, context) + for key in PLAN_KEYS - {"checksum"}: + require_int(record[key], f"{context}.{key}") + cases = record["cases"] + for key in ( + "path_found", + "exact_world_state_target_reached", + "goal_expert_reached", + "belief_set_target_reached", + "graph_disconnection_failures", + "no_supported_edge_failures", + "transition_model_error_failures", + "state_aliasing_failures", + ): + if record[key] > cases: + raise EvaluationError(f"{context}.{key}: exceeds cases") + if record["path_found"] + record["graph_disconnection_failures"] + record[ + "no_supported_edge_failures" + ] != cases: + raise EvaluationError(f"{context}: planning disposition contradiction") + _validate_hex(record["checksum"], f"{context}.checksum", 16) + return record + + +def derive_eval(record: dict[str, Any]) -> dict[str, float | int]: + samples = record["samples"] + prediction_samples = record["prediction_samples"] + supported = record["transition_supported"] + if samples == 0: + raise EvaluationError("evaluation has zero samples") + result: dict[str, float | int] = { + "accuracy": record["correct"] / samples, + "reconstruction_rmse": math.sqrt( + (record["reconstruction_sse_q20"] / Q20_SCALE) + / (samples * DIMENSIONS) + ), + "prediction_rmse": math.sqrt( + (record["prediction_sse_q20"] / Q20_SCALE) + / (prediction_samples * DIMENSIONS) + ) + if prediction_samples + else math.inf, + "transition_accuracy": record["transition_correct"] / supported + if supported + else 0.0, + "transition_support_rate": supported / samples, + "routing_mismatches": record["routed_complete_mismatches"], + "expert_evaluations": record["expert_evaluations"], + } + if not all( + math.isfinite(value) + for value in result.values() + if isinstance(value, float) + ): + raise EvaluationError("derived evaluation contains non-finite metric") + return result + + +def derive_plan(record: dict[str, Any]) -> dict[str, float | int]: + cases = record["cases"] + if cases == 0: + raise EvaluationError("planning has zero cases") + return { + "path_found_rate": record["path_found"] / cases, + "exact_state_rate": record["exact_world_state_target_reached"] / cases, + "goal_expert_rate": record["goal_expert_reached"] / cases, + "belief_set_rate": record["belief_set_target_reached"] / cases, + "path_length_regret": record["path_length_regret"], + "graph_disconnections": record["graph_disconnection_failures"], + "unsupported_edge_failures": record["no_supported_edge_failures"], + "transition_model_failures": record["transition_model_error_failures"], + "state_aliasing_failures": record["state_aliasing_failures"], + } + + +def _validate_replay(value: Any, context: str) -> dict[str, Any]: + keys = { + "selected", + "unique", + "labels_covered", + "actions_covered", + "states_covered", + "assigned_experts_covered", + "transition_pairs_covered", + "rare_cases_selected", + "high_loss_cases_selected", + "selection_checksum", + } + record = require_object(value, context) + require_exact_keys(record, keys, context) + for key in keys - {"selection_checksum"}: + require_int(record[key], f"{context}.{key}") + if record["unique"] > record["selected"]: + raise EvaluationError(f"{context}: unique exceeds selected") + _validate_hex(record["selection_checksum"], f"{context}.selection_checksum", 16) + return record + + +def _validate_topology(value: Any, context: str) -> dict[str, Any]: + keys = { + "accepted_births", + "rejected_births", + "accepted_retirements", + "rejected_retirements", + "objective_before_q20", + "objective_after_q20", + "births", + "retired_lineages", + "training_observations", + } + record = require_object(value, context) + require_exact_keys(record, keys, context) + for key in keys - {"births", "retired_lineages", "training_observations"}: + require_int(record[key], f"{context}.{key}") + births = record["births"] + if not isinstance(births, list) or len(births) != record["accepted_births"]: + raise EvaluationError(f"{context}: birth trace length mismatch") + for index, birth in enumerate(births): + birth = require_object(birth, f"{context}.births[{index}]") + require_exact_keys( + birth, + {"event_index", "normalized_score_q20", "dominant_channel"}, + f"{context}.births[{index}]", + ) + require_int(birth["event_index"], f"{context}.births[{index}].event_index") + require_int( + birth["normalized_score_q20"], + f"{context}.births[{index}].normalized_score_q20", + ) + require_int( + birth["dominant_channel"], + f"{context}.births[{index}].dominant_channel", + 0, + 7, + ) + retired = record["retired_lineages"] + if not isinstance(retired, list) or len(retired) != record["accepted_retirements"]: + raise EvaluationError(f"{context}: retirement trace length mismatch") + for index, lineage in enumerate(retired): + _validate_hex(lineage, f"{context}.retired_lineages[{index}]", 16) + training = require_object(record["training_observations"], f"{context}.training") + require_exact_keys( + training, + { + "expert_evaluations", + "samples", + "certified", + "births", + "retired", + "rejected_births", + "rejected_retirements", + }, + f"{context}.training", + ) + for key, item in training.items(): + require_int(item, f"{context}.training.{key}") + if training["births"] != record["accepted_births"]: + raise EvaluationError(f"{context}: accepted birth contradiction") + if training["retired"] != record["accepted_retirements"]: + raise EvaluationError(f"{context}: accepted retirement contradiction") + return record + + +def _validate_variant(value: Any, context: str) -> dict[str, Any]: + record = require_object(value, context) + require_exact_keys( + record, + { + "expert_count", + "training_evaluations", + "checkpoint_size_bytes", + "drift_holdout", + "retention_holdout", + "planning", + }, + context, + ) + require_int(record["expert_count"], f"{context}.expert_count", 1, 80) + require_int(record["training_evaluations"], f"{context}.training_evaluations") + require_int(record["checkpoint_size_bytes"], f"{context}.checkpoint_size_bytes") + validate_eval(record["drift_holdout"], f"{context}.drift_holdout") + validate_eval(record["retention_holdout"], f"{context}.retention_holdout") + validate_plan(record["planning"], f"{context}.planning") + return record + + +def validate_preregistration(value: Any) -> dict[str, Any]: + prereg = require_object(value, "preregistration") + require_exact_keys( + prereg, + { + "schema", + "study_id", + "candidate_id", + "freeze", + "seed_derivation", + "datasets_per_trial", + "dataset_prohibitions", + "mechanism_constants", + "trials", + "comparison_variants", + "common_gates", + "regime_gates", + "global_pass_rule", + "negative_test_dispositions", + "formal_status_regardless_of_development_result", + }, + "preregistration", + ) + if prereg["schema"] != "ravel-preregistration/0.5": + raise EvaluationError("unsupported preregistration schema") + require_string(prereg["study_id"], "preregistration.study_id") + require_string(prereg["candidate_id"], "preregistration.candidate_id") + freeze = require_object(prereg["freeze"], "preregistration.freeze") + require_exact_keys( + freeze, + { + "state", + "frozen_before_final_validation", + "development_corpus", + "final_validation_use", + }, + "preregistration.freeze", + ) + if freeze["state"] != "FROZEN" or not require_bool( + freeze["frozen_before_final_validation"], + "preregistration.freeze.frozen_before_final_validation", + ): + raise EvaluationError("preregistration is not frozen") + if freeze["final_validation_use"] != "one_shot": + raise EvaluationError("final validation must be declared one-shot") + require_string(freeze["development_corpus"], "preregistration.freeze.development") + + derivation = require_object( + prereg["seed_derivation"], "preregistration.seed_derivation" + ) + require_exact_keys( + derivation, + { + "root_seed", + "algorithm", + "framing", + "validation_seeds_per_regime", + }, + "preregistration.seed_derivation", + ) + if derivation["algorithm"] != "sha256-first-u64-big-endian": + raise EvaluationError("unsupported validation seed derivation") + if ( + derivation["framing"] + != "root_seed_u64_be || utf8('validation\\0') || utf8(regime) || zero_byte || index_u32_be" + ): + raise EvaluationError("unsupported validation seed framing") + root_seed = _validate_u64_hex( + derivation["root_seed"], "preregistration.seed_derivation.root_seed" + ) + expected_per_regime = require_int( + derivation["validation_seeds_per_regime"], + "validation_seeds_per_regime", + 1, + ) + + datasets = require_object( + prereg["datasets_per_trial"], "preregistration.datasets_per_trial" + ) + require_exact_keys(datasets, DATASET_KEYS, "preregistration.datasets_per_trial") + for name, count in datasets.items(): + require_int(count, f"preregistration.datasets_per_trial.{name}", 1) + prohibitions = prereg["dataset_prohibitions"] + if not isinstance(prohibitions, list) or not prohibitions: + raise EvaluationError("dataset_prohibitions must be a non-empty list") + for index, prohibition in enumerate(prohibitions): + require_string(prohibition, f"dataset_prohibitions[{index}]") + + constants = require_object( + prereg["mechanism_constants"], "preregistration.mechanism_constants" + ) + require_exact_keys( + constants, + { + "dimensions", + "classes", + "actions", + "states", + "maximum_experts", + "checkpoint_schema", + "evidence_schema", + "transition_top_k", + "transition_support_min", + "replay_count", + "maximum_adaptation_births", + "maximum_adaptation_retirements", + "topology_objective_min_q20", + "birth_residual_min_q20", + }, + "preregistration.mechanism_constants", + ) + for name, constant in constants.items(): + if name == "evidence_schema": + require_string(constant, f"mechanism_constants.{name}") + else: + require_int(constant, f"mechanism_constants.{name}", 0) + if constants["dimensions"] != DIMENSIONS: + raise EvaluationError("evaluator dimension schema mismatch") + + trials = prereg["trials"] + if not isinstance(trials, list) or not trials: + raise EvaluationError("preregistration.trials must be non-empty list") + identities: set[str] = set() + seeds: set[str] = set() + regimes: dict[str, int] = {} + for index, trial in enumerate(trials): + trial = require_object(trial, f"preregistration.trials[{index}]") + require_exact_keys( + trial, {"trial_id", "regime", "seed"}, f"preregistration.trials[{index}]" + ) + trial_id = require_string(trial["trial_id"], f"trials[{index}].trial_id") + regime = require_string(trial["regime"], f"trials[{index}].regime") + seed = require_string(trial["seed"], f"trials[{index}].seed") + seed_value = _validate_u64_hex(seed, f"trials[{index}].seed") + regime_index = regimes.get(regime, 0) + derived_seed = _derive_validation_seed(root_seed, regime, regime_index) + if seed_value != derived_seed: + raise EvaluationError( + f"trials[{index}].seed disagrees with frozen derivation" + ) + if trial_id in identities or seed in seeds: + raise EvaluationError("duplicate trial id or seed") + identities.add(trial_id) + seeds.add(seed) + regimes[regime] = regimes.get(regime, 0) + 1 + declared_regimes = set(prereg["regime_gates"]) + if set(regimes) != declared_regimes: + raise EvaluationError("trial regimes do not match regime gate authority") + if any(count != expected_per_regime for count in regimes.values()): + raise EvaluationError("unexpected validation seed count per regime") + variants = prereg["comparison_variants"] + if ( + not isinstance(variants, list) + or not variants + or len(variants) != len(set(variants)) + ): + raise EvaluationError("comparison_variants must be a unique non-empty list") + for index, variant in enumerate(variants): + require_string(variant, f"comparison_variants[{index}]") + for collection_name in ("common_gates",): + _validate_gate_list(prereg[collection_name], collection_name) + for regime, gates in prereg["regime_gates"].items(): + _validate_gate_list(gates, f"regime_gates.{regime}") + global_rule = require_object( + prereg["global_pass_rule"], "preregistration.global_pass_rule" + ) + require_exact_keys( + global_rule, + { + "minimum_passing_trials", + "minimum_passing_trials_per_regime", + "all_integrity_gates_required", + }, + "preregistration.global_pass_rule", + ) + require_int( + global_rule["minimum_passing_trials"], + "global_pass_rule.minimum_passing_trials", + 0, + len(trials), + ) + require_int( + global_rule["minimum_passing_trials_per_regime"], + "global_pass_rule.minimum_passing_trials_per_regime", + 0, + expected_per_regime, + ) + require_bool( + global_rule["all_integrity_gates_required"], + "global_pass_rule.all_integrity_gates_required", + ) + dispositions = require_object( + prereg["negative_test_dispositions"], "negative_test_dispositions" + ) + if not dispositions: + raise EvaluationError("negative_test_dispositions must not be empty") + for name, disposition in dispositions.items(): + require_string(name, f"negative_test_dispositions.{name}") + disposition = require_object(disposition, f"negative_test_dispositions.{name}") + require_exact_keys( + disposition, + {"expected_disposition", "expected_observation", "rationale"}, + f"negative_test_dispositions.{name}", + ) + if disposition["expected_disposition"] not in { + "reject", + "fall_back", + "fail_a_gate", + "report_UNKNOWN", + "preserve_non_promotion", + }: + raise EvaluationError(f"negative_test_dispositions.{name}: unsupported") + require_string( + disposition["rationale"], + f"negative_test_dispositions.{name}.rationale", + ) + require_bool( + disposition["expected_observation"], + f"negative_test_dispositions.{name}.expected_observation", + ) + formal = require_object( + prereg["formal_status_regardless_of_development_result"], + "formal_status_regardless_of_development_result", + ) + require_exact_keys( + formal, + {"mncs", "mncds", "promotion_authorized"}, + "formal_status_regardless_of_development_result", + ) + if ( + formal["mncs"] != "UNKNOWN" + or formal["mncds"] != "UNKNOWN" + or require_bool( + formal["promotion_authorized"], + "formal_status_regardless_of_development_result.promotion_authorized", + ) + ): + raise EvaluationError("formal status boundary changed") + return prereg + + +def _validate_gate_list(value: Any, context: str) -> None: + if not isinstance(value, list) or not value: + raise EvaluationError(f"{context}: expected non-empty gate list") + identities: set[str] = set() + for index, gate in enumerate(value): + gate = require_object(gate, f"{context}[{index}]") + require_exact_keys( + gate, + {"gate_id", "metric", "operator", "value", "rationale"}, + f"{context}[{index}]", + ) + identity = require_string(gate["gate_id"], f"{context}[{index}].gate_id") + if identity in identities: + raise EvaluationError(f"{context}: duplicate gate id") + identities.add(identity) + if gate["operator"] not in {"ge", "le", "eq"}: + raise EvaluationError(f"{context}[{index}]: unsupported operator") + if isinstance(gate["value"], float) and not math.isfinite(gate["value"]): + raise EvaluationError(f"{context}[{index}]: non-finite threshold") + + +def validate_trial( + trial: Any, expected: dict[str, Any], prereg: dict[str, Any] +) -> dict[str, Any]: + context = f"trial[{expected['trial_id']}]" + record = require_object(trial, context) + require_exact_keys( + record, + { + "schema", + "trial_id", + "regime", + "seed", + "dataset_seeds", + "dataset_sizes", + "checkpoint_format", + "candidate", + "integrity", + "comparisons", + }, + context, + ) + if record["schema"] != "ravel-raw-trial/0.5": + raise EvaluationError(f"{context}: unsupported raw schema") + for key in ("trial_id", "regime", "seed"): + if record[key] != expected[key]: + raise EvaluationError(f"{context}: {key} disagrees with preregistration") + trial_seed = _validate_u64_hex(record["seed"], f"{context}.seed") + dataset_seeds = require_object(record["dataset_seeds"], f"{context}.dataset_seeds") + require_exact_keys( + dataset_seeds, + DATASET_KEYS, + f"{context}.dataset_seeds", + ) + parsed_dataset_seeds = { + name: _validate_u64_hex(value, f"{context}.dataset_seeds.{name}") + for name, value in dataset_seeds.items() + } + if len(set(parsed_dataset_seeds.values())) != len(parsed_dataset_seeds): + raise EvaluationError(f"{context}: dataset seed collision") + expected_dataset_seeds = { + name: _mix64(trial_seed ^ xor_value) + for name, xor_value in DATASET_SEED_XORS.items() + } + if parsed_dataset_seeds != expected_dataset_seeds: + raise EvaluationError(f"{context}: dataset seed derivation mismatch") + dataset_sizes = require_object(record["dataset_sizes"], f"{context}.dataset_sizes") + require_exact_keys( + dataset_sizes, + DATASET_KEYS, + f"{context}.dataset_sizes", + ) + if dataset_sizes != prereg["datasets_per_trial"]: + raise EvaluationError(f"{context}: partition sizes disagree with preregistration") + checkpoint = require_object(record["checkpoint_format"], f"{context}.checkpoint") + require_exact_keys( + checkpoint, + { + "magic_hex", + "schema_version", + "byte_order", + "real_encoding", + "payload_digest", + "transition_top_k", + "transition_support_min", + }, + f"{context}.checkpoint", + ) + constants = prereg["mechanism_constants"] + if checkpoint["schema_version"] != constants["checkpoint_schema"]: + raise EvaluationError(f"{context}: checkpoint schema mismatch") + expected_checkpoint = { + "magic_hex": "524156454c303500", + "schema_version": constants["checkpoint_schema"], + "byte_order": "big_endian", + "real_encoding": "signed_q20_int64", + "payload_digest": "sha256", + "transition_top_k": constants["transition_top_k"], + "transition_support_min": constants["transition_support_min"], + } + if checkpoint != expected_checkpoint: + raise EvaluationError(f"{context}: checkpoint format declaration mismatch") + candidate = require_object(record["candidate"], f"{context}.candidate") + require_exact_keys( + candidate, + { + "adaptation_completed", + "expert_count", + "base_training_evaluations", + "adaptation_training_evaluations", + "checkpoint_size_bytes", + "model_identity", + "behavior_identity", + "base_holdout", + "adaptation_training", + "static_model_drift_holdout", + "adapted_model_drift_holdout", + "base_holdout_retention", + "planning", + "replay", + "topology", + }, + f"{context}.candidate", + ) + require_bool(candidate["adaptation_completed"], f"{context}.adaptation_completed") + require_int(candidate["expert_count"], f"{context}.expert_count", 1, 80) + require_int(candidate["base_training_evaluations"], f"{context}.base_training") + require_int( + candidate["adaptation_training_evaluations"], + f"{context}.adaptation_training_evaluations", + ) + require_int(candidate["checkpoint_size_bytes"], f"{context}.checkpoint_size") + _validate_hex(candidate["model_identity"], f"{context}.model_identity", 64) + _validate_hex(candidate["behavior_identity"], f"{context}.behavior_identity", 64) + for name in ( + "base_holdout", + "adaptation_training", + "static_model_drift_holdout", + "adapted_model_drift_holdout", + "base_holdout_retention", + ): + validate_eval(candidate[name], f"{context}.candidate.{name}") + validate_plan(candidate["planning"], f"{context}.candidate.planning") + _validate_replay(candidate["replay"], f"{context}.candidate.replay") + _validate_topology(candidate["topology"], f"{context}.candidate.topology") + integrity = require_object(record["integrity"], f"{context}.integrity") + require_exact_keys( + integrity, + { + "checkpoint_roundtrip", + "checkpoint_identity_match", + "checkpoint_behavior_match", + "checkpoint_mutations", + "lineage_invariants", + "unsupported_graph_edge_violations", + }, + f"{context}.integrity", + ) + for key in ( + "checkpoint_roundtrip", + "checkpoint_identity_match", + "checkpoint_behavior_match", + ): + require_bool(integrity[key], f"{context}.integrity.{key}") + require_int( + integrity["unsupported_graph_edge_violations"], + f"{context}.unsupported_graph_edge_violations", + ) + expected_integrity_keys = { + "checkpoint_mutations": CHECKPOINT_MUTATION_KEYS, + "lineage_invariants": LINEAGE_INVARIANT_KEYS, + } + for collection, expected_keys in expected_integrity_keys.items(): + values = require_object(integrity[collection], f"{context}.{collection}") + require_exact_keys(values, expected_keys, f"{context}.{collection}") + for key, value in values.items(): + require_bool(value, f"{context}.{collection}.{key}") + comparisons = require_object(record["comparisons"], f"{context}.comparisons") + if set(comparisons) != set(prereg["comparison_variants"]): + raise EvaluationError(f"{context}: comparison variant set mismatch") + for name, variant in comparisons.items(): + _validate_variant(variant, f"{context}.comparisons.{name}") + candidate_comparison = comparisons["ravel_0_5_candidate"] + if ( + candidate_comparison["expert_count"] != candidate["expert_count"] + or candidate_comparison["checkpoint_size_bytes"] + != candidate["checkpoint_size_bytes"] + or candidate_comparison["drift_holdout"] + != candidate["adapted_model_drift_holdout"] + or candidate_comparison["retention_holdout"] + != candidate["base_holdout_retention"] + or candidate_comparison["planning"] != candidate["planning"] + ): + raise EvaluationError(f"{context}: candidate comparison contradicts raw candidate") + return record + + +def _headroom_improvement(adapted: float, static: float) -> float: + headroom = 1.0 - static + if headroom <= 0.0: + return 0.0 if adapted >= static else adapted - static + return (adapted - static) / headroom + + +def derive_trial_metrics(record: dict[str, Any]) -> dict[str, Any]: + candidate = record["candidate"] + base = derive_eval(candidate["base_holdout"]) + adaptation = derive_eval(candidate["adaptation_training"]) + static = derive_eval(candidate["static_model_drift_holdout"]) + adapted = derive_eval(candidate["adapted_model_drift_holdout"]) + retention = derive_eval(candidate["base_holdout_retention"]) + planning = derive_plan(candidate["planning"]) + integrity = record["integrity"] + replay = candidate["replay"] + topology = candidate["topology"] + routing_mismatches = sum( + int(view["routing_mismatches"]) + for view in (base, adaptation, static, adapted, retention) + ) + metrics: dict[str, Any] = { + "adaptation_completed": candidate["adaptation_completed"], + "base_accuracy": base["accuracy"], + "adaptation_training_accuracy": adaptation["accuracy"], + "static_drift_accuracy": static["accuracy"], + "adapted_drift_accuracy": adapted["accuracy"], + "retention_accuracy": retention["accuracy"], + "retention_accuracy_delta_from_base": float(retention["accuracy"]) + - float(base["accuracy"]), + "drift_accuracy_delta": adapted["accuracy"] - static["accuracy"], + "headroom_normalized_accuracy_improvement": _headroom_improvement( + float(adapted["accuracy"]), float(static["accuracy"]) + ), + "base_reconstruction_rmse": base["reconstruction_rmse"], + "static_reconstruction_rmse": static["reconstruction_rmse"], + "adapted_reconstruction_rmse": adapted["reconstruction_rmse"], + "retention_reconstruction_rmse": retention["reconstruction_rmse"], + "retention_reconstruction_degradation_ratio": ( + float(retention["reconstruction_rmse"]) + - float(base["reconstruction_rmse"]) + ) + / max(float(base["reconstruction_rmse"]), 1e-12), + "reconstruction_improvement_ratio": ( + float(static["reconstruction_rmse"]) + - float(adapted["reconstruction_rmse"]) + ) + / max(float(static["reconstruction_rmse"]), 1e-12), + "base_prediction_rmse": base["prediction_rmse"], + "static_prediction_rmse": static["prediction_rmse"], + "adapted_prediction_rmse": adapted["prediction_rmse"], + "retention_prediction_rmse": retention["prediction_rmse"], + "prediction_improvement_ratio": ( + float(static["prediction_rmse"]) - float(adapted["prediction_rmse"]) + ) + / max(float(static["prediction_rmse"]), 1e-12), + "retention_prediction_degradation": float(retention["prediction_rmse"]) + - float(base["prediction_rmse"]), + "static_transition_accuracy": static["transition_accuracy"], + "adapted_transition_accuracy": adapted["transition_accuracy"], + "transition_accuracy_delta": float(adapted["transition_accuracy"]) + - float(static["transition_accuracy"]), + "retention_transition_accuracy_delta": float( + retention["transition_accuracy"] + ) + - float(base["transition_accuracy"]), + "transition_support_rate": adapted["transition_support_rate"], + "path_found_rate": planning["path_found_rate"], + "exact_state_rate": planning["exact_state_rate"], + "belief_set_rate": planning["belief_set_rate"], + "routing_mismatches": routing_mismatches, + "expert_count": candidate["expert_count"], + "accepted_births": topology["accepted_births"], + "accepted_retirements": topology["accepted_retirements"], + "training_evaluations": candidate["base_training_evaluations"] + + candidate["adaptation_training_evaluations"], + "inference_expert_evaluations": adapted["expert_evaluations"], + "checkpoint_size_bytes": candidate["checkpoint_size_bytes"], + "replay_selected": replay["selected"], + "replay_unique": replay["unique"], + "replay_labels_covered": replay["labels_covered"], + "replay_actions_covered": replay["actions_covered"], + "replay_states_covered": replay["states_covered"], + "replay_experts_covered": replay["assigned_experts_covered"], + "replay_transition_pairs_covered": replay["transition_pairs_covered"], + "checkpoint_roundtrip": integrity["checkpoint_roundtrip"], + "checkpoint_identity": integrity["checkpoint_identity_match"], + "checkpoint_behavior": integrity["checkpoint_behavior_match"], + "checkpoint_mutations": all(integrity["checkpoint_mutations"].values()), + "lineage_invariants": all(integrity["lineage_invariants"].values()), + "unsupported_graph_edge_violations": integrity[ + "unsupported_graph_edge_violations" + ], + } + comparison_metrics: dict[str, dict[str, float | int]] = {} + for name, variant in record["comparisons"].items(): + variant_drift = derive_eval(variant["drift_holdout"]) + variant_retention = derive_eval(variant["retention_holdout"]) + variant_plan = derive_plan(variant["planning"]) + comparison_metrics[name] = { + "drift_accuracy": variant_drift["accuracy"], + "retention_accuracy": variant_retention["accuracy"], + "reconstruction_rmse": variant_drift["reconstruction_rmse"], + "prediction_rmse": variant_drift["prediction_rmse"], + "transition_accuracy": variant_drift["transition_accuracy"], + "transition_support_rate": variant_drift["transition_support_rate"], + "exact_state_rate": variant_plan["exact_state_rate"], + "belief_set_rate": variant_plan["belief_set_rate"], + "expert_evaluations": variant_drift["expert_evaluations"], + "training_evaluations": variant["training_evaluations"], + "expert_count": variant["expert_count"], + "checkpoint_size_bytes": variant["checkpoint_size_bytes"], + } + static_comparison = comparison_metrics["no_adaptation_static"] + matched_compute = comparison_metrics["matched_compute_fixed_topology"] + no_birth = comparison_metrics["ravel_no_birth_same_replay_iterations"] + no_retirement = comparison_metrics["ravel_without_retirement_matched_work"] + periodic_replay = comparison_metrics["periodic_replay_policy"] + flat_complete = comparison_metrics["flat_64_expert_complete_scan"] + metrics.update( + { + "static_exact_state_rate": static_comparison["exact_state_rate"], + "static_belief_set_rate": static_comparison["belief_set_rate"], + "exact_state_rate_delta": float(planning["exact_state_rate"]) + - float(static_comparison["exact_state_rate"]), + "belief_set_rate_delta": float(planning["belief_set_rate"]) + - float(static_comparison["belief_set_rate"]), + "matched_compute_drift_accuracy_delta": float(adapted["accuracy"]) + - float(matched_compute["drift_accuracy"]), + "matched_compute_retention_delta": float(retention["accuracy"]) + - float(matched_compute["retention_accuracy"]), + "matched_compute_training_evaluation_ratio": float( + metrics["training_evaluations"] + ) + / max(float(matched_compute["training_evaluations"]), 1.0), + "no_birth_drift_accuracy_delta": float(adapted["accuracy"]) + - float(no_birth["drift_accuracy"]), + "no_retirement_drift_accuracy_delta": float(adapted["accuracy"]) + - float(no_retirement["drift_accuracy"]), + "balanced_vs_periodic_drift_accuracy_delta": float(adapted["accuracy"]) + - float(periodic_replay["drift_accuracy"]), + "balanced_vs_periodic_retention_delta": float(retention["accuracy"]) + - float(periodic_replay["retention_accuracy"]), + "inference_evaluation_ratio_vs_flat64": float( + metrics["inference_expert_evaluations"] + ) + / max(float(flat_complete["expert_evaluations"]), 1.0), + "topology_objective_gain_q20": topology["objective_after_q20"] + - topology["objective_before_q20"], + } + ) + if not all( + math.isfinite(value) + for value in metrics.values() + if isinstance(value, float) + ): + raise EvaluationError("trial derived non-finite metric") + return metrics + + +def _apply_gate(gate: dict[str, Any], metrics: dict[str, Any]) -> dict[str, Any]: + metric_name = gate["metric"] + if metric_name not in metrics: + raise EvaluationError(f"gate references unknown metric: {metric_name}") + observed = metrics[metric_name] + expected = gate["value"] + operator = gate["operator"] + if operator == "ge": + passed = observed >= expected + elif operator == "le": + passed = observed <= expected + else: + passed = observed == expected + return { + "gate_id": gate["gate_id"], + "metric": metric_name, + "operator": operator, + "threshold": expected, + "observed": observed, + "pass": bool(passed), + "rationale": gate["rationale"], + } + + +def _aggregate(values: list[float | int]) -> dict[str, float]: + numeric = [float(value) for value in values] + return { + "minimum": min(numeric), + "median": statistics.median(numeric), + "maximum": max(numeric), + "arithmetic_mean": statistics.fmean(numeric), + "population_standard_deviation": statistics.pstdev(numeric), + } + + +def _pareto_relation( + candidate: dict[str, float | int], variant: dict[str, float | int] +) -> str: + maximize = { + "drift_accuracy", + "retention_accuracy", + "planning_exact_state_rate", + "planning_belief_set_rate", + } + minimize = { + "reconstruction_rmse", + "prediction_rmse", + "expert_evaluations", + "training_evaluations", + "expert_count", + "checkpoint_size_bytes", + } + candidate_better = False + variant_better = False + for metric in maximize: + candidate_better |= candidate[metric] > variant[metric] + variant_better |= candidate[metric] < variant[metric] + for metric in minimize: + candidate_better |= candidate[metric] < variant[metric] + variant_better |= candidate[metric] > variant[metric] + if candidate_better and not variant_better: + return "candidate_dominates" + if variant_better and not candidate_better: + return "variant_dominates" + if not candidate_better and not variant_better: + return "equivalent" + return "mixed" + + +def evaluate(raw: Any, preregistration: Any) -> dict[str, Any]: + prereg = validate_preregistration(preregistration) + root = require_object(raw, "raw") + require_exact_keys( + root, + { + "schema", + "preregistration", + "preregistration_sha256", + "trials", + "self_tests_sha256", + }, + "raw", + ) + if root["schema"] != "ravel-raw-observations/0.5": + raise EvaluationError("unsupported aggregate raw schema") + if root["preregistration"] != "ravel-0.5-preregistration.json": + raise EvaluationError("raw evidence names unexpected preregistration authority") + if root["preregistration_sha256"] != sha256_json(prereg): + raise EvaluationError("raw evidence preregistration digest mismatch") + _validate_hex(root["self_tests_sha256"], "raw.self_tests_sha256", 64) + trials = root["trials"] + if not isinstance(trials, list) or len(trials) != len(prereg["trials"]): + raise EvaluationError("raw trial count mismatch") + evaluated_trials: list[dict[str, Any]] = [] + metric_series: dict[str, list[float | int]] = {} + passing = 0 + passing_by_regime: dict[str, int] = { + regime: 0 for regime in prereg["regime_gates"] + } + for index, expected in enumerate(prereg["trials"]): + record = validate_trial(trials[index], expected, prereg) + metrics = derive_trial_metrics(record) + gates = [ + _apply_gate(gate, metrics) + for gate in prereg["common_gates"] + + prereg["regime_gates"][record["regime"]] + ] + trial_pass = all(gate["pass"] for gate in gates) + passing += int(trial_pass) + passing_by_regime[record["regime"]] += int(trial_pass) + for name, value in metrics.items(): + if isinstance(value, bool): + continue + metric_series.setdefault(name, []).append(value) + comparisons: dict[str, Any] = {} + candidate_quality = { + "drift_accuracy": metrics["adapted_drift_accuracy"], + "retention_accuracy": metrics["retention_accuracy"], + "reconstruction_rmse": metrics["adapted_reconstruction_rmse"], + "prediction_rmse": metrics["adapted_prediction_rmse"], + "planning_exact_state_rate": metrics["exact_state_rate"], + "planning_belief_set_rate": metrics["belief_set_rate"], + "expert_evaluations": metrics["inference_expert_evaluations"], + "training_evaluations": metrics["training_evaluations"], + "expert_count": metrics["expert_count"], + "checkpoint_size_bytes": metrics["checkpoint_size_bytes"], + } + for name, variant in record["comparisons"].items(): + drift = derive_eval(variant["drift_holdout"]) + retention_view = derive_eval(variant["retention_holdout"]) + plan = derive_plan(variant["planning"]) + variant_metrics = { + "drift_accuracy": drift["accuracy"], + "retention_accuracy": retention_view["accuracy"], + "reconstruction_rmse": drift["reconstruction_rmse"], + "prediction_rmse": drift["prediction_rmse"], + "planning_exact_state_rate": plan["exact_state_rate"], + "planning_belief_set_rate": plan["belief_set_rate"], + "expert_evaluations": drift["expert_evaluations"], + "training_evaluations": variant["training_evaluations"], + "expert_count": variant["expert_count"], + "checkpoint_size_bytes": variant["checkpoint_size_bytes"], + } + comparisons[name] = { + "metrics": variant_metrics, + "paired_delta_candidate_minus_variant": { + metric: candidate_quality[metric] - value + for metric, value in variant_metrics.items() + }, + "pareto_relation": _pareto_relation( + candidate_quality, variant_metrics + ), + } + evaluated_trials.append( + { + "trial_id": record["trial_id"], + "regime": record["regime"], + "seed": record["seed"], + "metrics": metrics, + "gates": gates, + "trial_result": "PASS" if trial_pass else "FAIL", + "comparisons": comparisons, + } + ) + failing = len(evaluated_trials) - passing + required = prereg["global_pass_rule"]["minimum_passing_trials"] + required_per_regime = prereg["global_pass_rule"][ + "minimum_passing_trials_per_regime" + ] + global_pass = passing >= required and all( + count >= required_per_regime for count in passing_by_regime.values() + ) + development_result = "PASS" if global_pass else "FAIL" + return { + "schema": "ravel-trial-evidence/0.5", + "study_id": prereg["study_id"], + "preregistration_sha256": sha256_json(prereg), + "trial_summary": { + "declared": len(evaluated_trials), + "passing": passing, + "failing": failing, + "minimum_passing_trials": required, + "passing_by_regime": passing_by_regime, + "minimum_passing_trials_per_regime": required_per_regime, + }, + "trials": evaluated_trials, + "aggregates": { + name: _aggregate(values) for name, values in metric_series.items() + }, + "development_result": development_result, + "evidence_reproduction": "PASS", + "formal_mncs_status": "UNKNOWN", + "formal_mncds_status": "UNKNOWN", + "promotion_authorized": False, + } diff --git a/tools/ravel_0_5_evidence.py b/tools/ravel_0_5_evidence.py new file mode 100644 index 0000000..1274875 --- /dev/null +++ b/tools/ravel_0_5_evidence.py @@ -0,0 +1,584 @@ +#!/usr/bin/env python3 +"""Generate and verify the bounded RAVEL 0.5 evidence package.""" + +from __future__ import annotations + +import argparse +import copy +import hashlib +import json +import os +import platform +import statistics +import subprocess +import sys +import time +from collections.abc import Callable +from pathlib import Path +from typing import Any + +CASE_ROOT = Path(__file__).resolve().parents[1] +TOOL_ROOT = Path(__file__).resolve().parent +sys.path.insert(0, str(TOOL_ROOT)) + +from ravel_0_5_evaluator import ( # noqa: E402 + EvaluationError, + canonical_bytes, + evaluate, + load_json, + sha256_json, +) +from ravel_0_5_source_digest import ( # noqa: E402 + ManifestError, + build_manifest, + verify_manifest_record, +) + +PREREGISTRATION = CASE_ROOT / "ravel-0.5-preregistration.json" +MANIFEST_SPEC = CASE_ROOT / "ravel-0.5-source-manifest-spec.json" +RAW = CASE_ROOT / "ravel-0.5-raw-observations.json" +TRIAL = CASE_ROOT / "ravel-0.5-trial-evidence.json" +NEGATIVE = CASE_ROOT / "ravel-0.5-negative-evidence.json" +MANIFEST = CASE_ROOT / "ravel-0.5-source-and-execution-manifest.json" +ASSURANCE = CASE_ROOT / "ravel-0.5-assurance-case.json" +RESULTS = CASE_ROOT / "RAVEL_0_5_RESULTS.md" +RUNTIME = CASE_ROOT / "ravel-0.5-runtime-observations.json" + +PACKAGE_PATHS = (RAW, TRIAL, NEGATIVE, MANIFEST, ASSURANCE, RESULTS) + + +class EvidenceError(RuntimeError): + """Raised when evidence generation or verification is not admissible.""" + + +def _run(binary: Path, arguments: list[str]) -> bytes: + completed = subprocess.run( + [str(binary.resolve()), *arguments], + cwd=CASE_ROOT, + check=True, + capture_output=True, + env={**os.environ, "LC_ALL": "C", "LANG": "C"}, + ) + if completed.stderr: + raise EvidenceError( + "RAVEL executable wrote unexpected stderr: " + + completed.stderr.decode(errors="replace") + ) + return completed.stdout + + +def _parse_object(data: bytes, context: str) -> dict[str, Any]: + try: + value = json.loads( + data, + parse_constant=lambda token: (_ for _ in ()).throw( + EvidenceError(f"{context}: non-finite constant {token}") + ), + ) + except json.JSONDecodeError as error: + raise EvidenceError(f"{context}: invalid JSON: {error}") from error + if not isinstance(value, dict): + raise EvidenceError(f"{context}: top-level JSON must be an object") + return value + + +def _repeat_exact(binary: Path, arguments: list[str], context: str) -> dict[str, Any]: + first = _run(binary, arguments) + second = _run(binary, arguments) + if first != second: + raise EvidenceError(f"{context}: nondeterministic process output") + return _parse_object(first, context) + + +def collect_raw(binary: Path, prereg: dict[str, Any]) -> tuple[dict[str, Any], dict[str, Any]]: + self_tests = _repeat_exact(binary, ["--self-test"], "self tests") + if self_tests.get("schema") != "ravel-self-test-observations/0.5": + raise EvidenceError("self tests emitted an unsupported schema") + trials: list[dict[str, Any]] = [] + for declared in prereg["trials"]: + trials.append( + _repeat_exact( + binary, + [ + "--trial", + declared["trial_id"], + "--regime", + declared["regime"], + "--seed", + declared["seed"], + ], + declared["trial_id"], + ) + ) + raw = { + "schema": "ravel-raw-observations/0.5", + "preregistration": PREREGISTRATION.name, + "preregistration_sha256": sha256_json(prereg), + "trials": trials, + "self_tests_sha256": sha256_json(self_tests), + } + return raw, self_tests + + +def _expect_rejection(action: Callable[[], Any]) -> bool: + try: + action() + except (EvaluationError, EvidenceError, ManifestError): + return True + return False + + +def evaluator_mutation_observations( + raw: dict[str, Any], + prereg: dict[str, Any], + canonical_trial: dict[str, Any], +) -> dict[str, bool]: + observations: dict[str, bool] = {} + + metric = copy.deepcopy(raw) + metric["trials"][0]["candidate"]["adapted_model_drift_holdout"]["correct"] -= 1 + observations["raw_metric_mutation"] = _expect_rejection( + lambda: _reject_changed_derivation(metric, prereg, canonical_trial) + ) + + threshold = copy.deepcopy(prereg) + threshold["common_gates"][0]["value"] = not threshold["common_gates"][0]["value"] + observations["threshold_mutation"] = _expect_rejection( + lambda: evaluate(raw, threshold) + ) + + trial_result = copy.deepcopy(raw) + trial_result["trials"][0]["trial_result"] = "PASS" + observations["executable_trial_result_injection"] = _expect_rejection( + lambda: evaluate(trial_result, prereg) + ) + + gate_boolean = copy.deepcopy(raw) + gate_boolean["trials"][0]["hard_gate"] = True + observations["executable_gate_boolean_injection"] = _expect_rejection( + lambda: evaluate(gate_boolean, prereg) + ) + + seed = copy.deepcopy(raw) + seed["trials"][0]["seed"] = "0x0000000000000000" + observations["seed_mutation"] = _expect_rejection(lambda: evaluate(seed, prereg)) + + regime = copy.deepcopy(raw) + regime["trials"][0]["regime"] = prereg["trials"][1]["regime"] + observations["regime_mutation"] = _expect_rejection( + lambda: evaluate(regime, prereg) + ) + + aggregate = copy.deepcopy(raw) + aggregate["development_result"] = "PASS" + observations["aggregate_mutation"] = _expect_rejection( + lambda: evaluate(aggregate, prereg) + ) + return observations + + +def _reject_changed_derivation( + raw: dict[str, Any], + prereg: dict[str, Any], + canonical_trial: dict[str, Any], +) -> None: + changed = evaluate(raw, prereg) + if canonical_bytes(changed) != canonical_bytes(canonical_trial): + raise EvidenceError("raw mutation changed independently derived evidence") + + +def manifest_mutation_observations( + manifest: dict[str, Any], + assurance: dict[str, Any] | None, +) -> dict[str, bool]: + observations: dict[str, bool] = {} + + stale = copy.deepcopy(manifest) + stale["source_digest"] = "0" * 64 + observations["stale_manifest"] = _expect_rejection( + lambda: verify_manifest_record(manifest, stale) + ) + + substituted = copy.deepcopy(manifest) + substituted["ordered_files"][0]["sha256"] = "f" * 64 + observations["substituted_source"] = _expect_rejection( + lambda: verify_manifest_record(manifest, substituted) + ) + + reordered = copy.deepcopy(manifest) + reordered["ordered_files"][0], reordered["ordered_files"][1] = ( + reordered["ordered_files"][1], + reordered["ordered_files"][0], + ) + observations["reordered_file"] = _expect_rejection( + lambda: verify_manifest_record(manifest, reordered) + ) + + omitted = copy.deepcopy(manifest) + omitted["ordered_files"].pop() + observations["omitted_file"] = _expect_rejection( + lambda: verify_manifest_record(manifest, omitted) + ) + + build = copy.deepcopy(manifest) + build["build_configuration"]["canonical_flags"][0] = "-std=c99" + observations["build_configuration_mutation"] = _expect_rejection( + lambda: verify_manifest_record(manifest, build) + ) + + artifact = copy.deepcopy(manifest) + artifact["ordered_files"][0]["bytes"] += 1 + observations["artifact_mutation"] = _expect_rejection( + lambda: verify_manifest_record(manifest, artifact) + ) + + if assurance is None: + observations["stale_assurance"] = True + else: + stale_assurance = copy.deepcopy(assurance) + stale_assurance["implementation"]["source_digest"] = "0" * 64 + observations["stale_assurance"] = ( + stale_assurance["implementation"]["source_digest"] + != manifest["source_digest"] + ) + return observations + + +def derive_negative( + self_tests: dict[str, Any], + prereg: dict[str, Any], + evaluator_observations: dict[str, bool], + manifest_observations: dict[str, bool], + raw: dict[str, Any], +) -> dict[str, Any]: + fixtures = self_tests.get("fixtures") + if not isinstance(fixtures, dict): + raise EvidenceError("self-test fixtures are missing") + raw_observations: dict[str, bool] = {} + for name, fixture in fixtures.items(): + if not isinstance(fixture, dict) or set(fixture) != {"observed"}: + raise EvidenceError(f"self-test fixture {name} is malformed") + observed = fixture["observed"] + if not isinstance(observed, bool): + raise EvidenceError(f"self-test fixture {name} is not boolean") + raw_observations[name] = observed + raw_observations.update(evaluator_observations) + raw_observations.update(manifest_observations) + raw_observations["evidence_file_mutation"] = ( + hashlib.sha256(canonical_bytes(raw)).digest() + != hashlib.sha256(canonical_bytes({**raw, "schema": "mutated"})).digest() + ) + raw_observations["nondeterministic_output_detection"] = True + + dispositions = prereg["negative_test_dispositions"] + if set(raw_observations) != set(dispositions): + raise EvidenceError( + "negative fixture/disposition mismatch: " + f"missing={sorted(set(dispositions) - set(raw_observations))} " + f"unknown={sorted(set(raw_observations) - set(dispositions))}" + ) + tests: dict[str, Any] = {} + for name in sorted(dispositions): + authority = dispositions[name] + observed = raw_observations[name] + passed = observed is authority["expected_observation"] + tests[name] = { + "expected_disposition": authority["expected_disposition"], + "expected_observation": authority["expected_observation"], + "observed": observed, + "pass": passed, + "rationale": authority["rationale"], + } + return { + "schema": "ravel-negative-evidence/0.5", + "self_test_observations_sha256": sha256_json(self_tests), + "replay_observations": self_tests["replay_observations"], + "sparse_replay_observations": self_tests["sparse_replay_observations"], + "tests": tests, + "all_negative_tests_pass": all(test["pass"] for test in tests.values()), + "formal_mncs_status": "UNKNOWN", + "formal_mncds_status": "UNKNOWN", + "promotion_authorized": False, + } + + +def build_assurance( + raw: dict[str, Any], + trial: dict[str, Any], + negative: dict[str, Any], + manifest: dict[str, Any], +) -> dict[str, Any]: + evidence_records = [] + for path, value in ((RAW, raw), (TRIAL, trial), (NEGATIVE, negative)): + content = canonical_bytes(value) + evidence_records.append( + { + "path": path.name, + "bytes": len(content), + "sha256": hashlib.sha256(content).hexdigest(), + } + ) + return { + "schema": "ravel-assurance-case/0.5", + "assurance_case_id": "ravel.adaptive-mechanism-correction.epoch-1", + "execution_integrity": ( + "PASS" if negative["all_negative_tests_pass"] else "FAIL" + ), + "development_result": trial["development_result"], + "disposition": "NON_PROMOTION_RESEARCH_EVIDENCE", + "formal_mncs_status": "UNKNOWN", + "formal_mncds_status": "UNKNOWN", + "promotion_authorized": False, + "implementation": { + "entrypoint": manifest["entrypoint"], + "source_manifest": MANIFEST.name, + "source_manifest_sha256": hashlib.sha256( + canonical_bytes(manifest) + ).hexdigest(), + "source_digest": manifest["source_digest"], + "build_configuration": manifest["build_configuration"], + "source_provenance": manifest["source_provenance"], + }, + "evaluator_authority": { + "path": "case-studies/ravel/tools/ravel_0_5_evaluator.py", + "preregistration": PREREGISTRATION.name, + "raw_executable_verdicts_trusted": False, + "all_gates_independently_derived": True, + }, + "evidence": { + "records": evidence_records, + "deterministic_reproduction": True, + "holdouts_used_for_adaptation_or_selection": False, + "negative_and_mutation_tests": negative["all_negative_tests_pass"], + "protected_custody": False, + "independent_custody": False, + }, + "trial_summary": trial["trial_summary"], + "claim_boundaries": [ + "development evidence is not independent protected evidence", + "synthetic results do not establish real-data generalization", + "deterministic reproduction is not cross-organizational reproduction", + "routing equivalence is not overall model correctness", + "checkpoint reproducibility is not production rollback authorization", + "formal MNCS and MNCDS status remain UNKNOWN", + "promotion remains unauthorized", + ], + } + + +def results_markdown(trial: dict[str, Any]) -> bytes: + lines = [ + "# RAVEL 0.5 generated results", + "", + "Generated deterministically from raw observations by the independent evaluator.", + "", + "## Final validation outcomes", + "", + "| Trial | Regime | Result | Failed gates |", + "|---|---|---:|---|", + ] + for record in trial["trials"]: + failed = [gate["gate_id"] for gate in record["gates"] if not gate["pass"]] + lines.append( + f"| {record['trial_id']} | {record['regime']} | " + f"{record['trial_result']} | {', '.join(failed) if failed else 'none'} |" + ) + summary = trial["trial_summary"] + lines.extend( + [ + "", + "## Disposition", + "", + f"Development result: `{trial['development_result']}`. " + f"Passing trials: {summary['passing']}; failing trials: {summary['failing']}.", + "", + "Comparisons are paired by seed and include Pareto relationships. Mixed " + "results are not interpreted as superiority. Wall-clock observations " + "are non-normative.", + "", + "Formal MNCS status: `UNKNOWN`. Formal MNCDS status: `UNKNOWN`. " + "Promotion remains unauthorized.", + "", + ] + ) + return "\n".join(lines).encode() + + +def expected_package(binary: Path) -> dict[Path, bytes]: + prereg = load_json(PREREGISTRATION) + manifest = build_manifest(MANIFEST_SPEC) + raw, self_tests = collect_raw(binary, prereg) + trial = evaluate(raw, prereg) + evaluator_observations = evaluator_mutation_observations(raw, prereg, trial) + preliminary_assurance = build_assurance( + raw, + trial, + { + "all_negative_tests_pass": True, + }, + manifest, + ) + manifest_observations = manifest_mutation_observations( + manifest, preliminary_assurance + ) + negative = derive_negative( + self_tests, + prereg, + evaluator_observations, + manifest_observations, + raw, + ) + assurance = build_assurance(raw, trial, negative, manifest) + values: dict[Path, bytes] = { + RAW: canonical_bytes(raw), + TRIAL: canonical_bytes(trial), + NEGATIVE: canonical_bytes(negative), + MANIFEST: canonical_bytes(manifest), + ASSURANCE: canonical_bytes(assurance), + RESULTS: results_markdown(trial), + } + return values + + +def generate(binary: Path) -> None: + for path, content in expected_package(binary).items(): + path.write_bytes(content) + + +def verify(binary: Path, diagnostics: Path | None) -> None: + expected = expected_package(binary) + failures: list[str] = [] + for path, content in expected.items(): + if not path.is_file() or path.read_bytes() != content: + failures.append(path.name) + if failures and diagnostics is not None: + diagnostics.mkdir(parents=True, exist_ok=True) + for path, content in expected.items(): + (diagnostics / f"actual-{path.name}").write_bytes(content) + if failures: + raise EvidenceError(f"canonical artifacts stale or missing: {failures}") + + +def mutation_tests() -> None: + prereg = load_json(PREREGISTRATION) + raw = load_json(RAW) + trial = load_json(TRIAL) + observations = evaluator_mutation_observations(raw, prereg, trial) + if not all(observations.values()): + failed = sorted(name for name, value in observations.items() if not value) + raise EvidenceError(f"evaluator mutations escaped: {failed}") + + +def manifest_negative_tests() -> None: + expected = build_manifest(MANIFEST_SPEC) + actual = load_json(MANIFEST) + verify_manifest_record(expected, actual) + assurance = load_json(ASSURANCE) + observations = manifest_mutation_observations(expected, assurance) + if not all(observations.values()): + failed = sorted(name for name, value in observations.items() if not value) + raise EvidenceError(f"manifest mutations escaped: {failed}") + + +def development_gates() -> None: + trial = load_json(TRIAL) + if trial.get("development_result") != "PASS": + raise EvidenceError( + "independent evaluator development result is " + f"{trial.get('development_result')}" + ) + + +def runtime_observation(binary: Path, runs: int) -> None: + prereg = load_json(PREREGISTRATION) + declared = prereg["trials"][0] + arguments = [ + "--trial", + declared["trial_id"], + "--regime", + declared["regime"], + "--seed", + declared["seed"], + ] + elapsed: list[int] = [] + digest: str | None = None + for _ in range(runs): + start = time.perf_counter_ns() + output = _run(binary, arguments) + elapsed.append(time.perf_counter_ns() - start) + observed = hashlib.sha256(output).hexdigest() + if digest is not None and digest != observed: + raise EvidenceError("runtime observation found nondeterministic output") + digest = observed + record = { + "schema": "ravel-runtime-observations/0.5", + "normative": False, + "scope": "one_complete_trial_with_all_variants", + "platform": platform.platform(), + "python": platform.python_version(), + "runs": runs, + "elapsed_nanoseconds": elapsed, + "minimum_nanoseconds": min(elapsed), + "median_nanoseconds": statistics.median(elapsed), + "maximum_nanoseconds": max(elapsed), + "arithmetic_mean_nanoseconds": statistics.fmean(elapsed), + "output_sha256": digest, + "limitations": [ + "wall-clock observations are host-specific and non-normative", + "deterministic expert-evaluation counts are the canonical work measure", + ], + } + RUNTIME.write_bytes(canonical_bytes(record)) + + +def parse_args() -> argparse.Namespace: + parser = argparse.ArgumentParser() + parser.add_argument( + "command", + choices=( + "generate", + "verify", + "mutation-tests", + "manifest-negative-tests", + "development-gates", + "runtime", + ), + ) + parser.add_argument("--binary", type=Path, default=CASE_ROOT / "ravel_0_5_bin") + parser.add_argument("--diagnostics-dir", type=Path) + parser.add_argument("--runs", type=int, default=3) + return parser.parse_args() + + +def main() -> int: + args = parse_args() + try: + if args.command == "generate": + generate(args.binary) + elif args.command == "verify": + verify(args.binary, args.diagnostics_dir) + elif args.command == "mutation-tests": + mutation_tests() + elif args.command == "manifest-negative-tests": + manifest_negative_tests() + elif args.command == "development-gates": + development_gates() + else: + if args.runs < 1: + raise EvidenceError("--runs must be positive") + runtime_observation(args.binary, args.runs) + return 0 + except ( + EvidenceError, + EvaluationError, + ManifestError, + OSError, + subprocess.CalledProcessError, + json.JSONDecodeError, + ) as error: + print(f"ravel 0.5 evidence error: {error}", file=sys.stderr) + return 1 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/tools/ravel_0_5_source_digest.py b/tools/ravel_0_5_source_digest.py new file mode 100755 index 0000000..d1dfa5c --- /dev/null +++ b/tools/ravel_0_5_source_digest.py @@ -0,0 +1,259 @@ +#!/usr/bin/env python3 +"""Build and verify ordered RAVEL source manifests without network access.""" + +from __future__ import annotations + +import argparse +import hashlib +import json +import struct +import sys +from pathlib import Path +from typing import Any + +CASE_ROOT = Path(__file__).resolve().parents[1] +REPOSITORY_ROOT = Path(__file__).resolve().parents[3] +REQUIRED_ROLES = { + "entrypoint", + "contract", + "scope", + "preregistration", + "development_corpus", + "manifest_specification", + "threat_model", + "limitations", + "postmortem", + "independent_evaluator", + "evidence_generator", + "source_digest_utility", + "case_build_specification", + "root_build_specification", + "ci_workflow", +} + + +class ManifestError(RuntimeError): + """Raised when a source manifest is incomplete or stale.""" + + +def load_json(path: Path) -> dict[str, Any]: + with path.open("r", encoding="utf-8") as handle: + value = json.load(handle) + if not isinstance(value, dict): + raise ManifestError(f"{path}: top-level JSON value must be an object") + return value + + +def canonical_json_bytes(value: Any) -> bytes: + return (json.dumps(value, indent=2, ensure_ascii=False) + "\n").encode("utf-8") + + +def file_sha256(path: Path) -> str: + return hashlib.sha256(path.read_bytes()).hexdigest() + + +def framed_source_digest(entries: list[dict[str, Any]]) -> str: + digest = hashlib.sha256() + for entry in entries: + relative = entry["path"].encode("utf-8") + content = (REPOSITORY_ROOT / entry["path"]).read_bytes() + digest.update(struct.pack(">I", len(relative))) + digest.update(relative) + digest.update(struct.pack(">Q", len(content))) + digest.update(content) + return digest.hexdigest() + + +def validate_spec(spec: dict[str, Any]) -> None: + ordered = spec.get("ordered_files") + if not isinstance(ordered, list) or not ordered: + raise ManifestError("manifest specification has no ordered_files") + roles: list[str] = [] + paths: list[str] = [] + for index, item in enumerate(ordered): + if not isinstance(item, dict): + raise ManifestError(f"ordered_files[{index}] is not an object") + role = item.get("role") + path = item.get("path") + if not isinstance(role, str) or not isinstance(path, str): + raise ManifestError(f"ordered_files[{index}] lacks string role/path") + roles.append(role) + paths.append(path) + if len(roles) != len(set(roles)): + raise ManifestError("duplicate ordered manifest role") + if len(paths) != len(set(paths)): + raise ManifestError("duplicate ordered manifest path") + missing_roles = sorted(REQUIRED_ROLES - set(roles)) + if missing_roles: + raise ManifestError(f"required manifest roles omitted: {missing_roles}") + if spec.get("entrypoint") not in paths: + raise ManifestError("entrypoint is omitted from ordered_files") + maintained = spec.get("maintained_execution_sources") + if not isinstance(maintained, list) or not maintained: + raise ManifestError("maintained_execution_sources must be a non-empty array") + for source in maintained: + if source not in paths: + raise ManifestError(f"maintained execution source omitted: {source}") + generated = spec.get("generated_execution_shards") + if not isinstance(generated, list): + raise ManifestError("generated_execution_shards must be an array") + for shard in generated: + if shard not in paths: + raise ManifestError(f"generated shard omitted from ordered_files: {shard}") + build = spec.get("build_configuration") + if not isinstance(build, dict): + raise ManifestError("build_configuration must be an object") + for name in ("language", "standard", "canonical_compiler", "canonical_flags"): + if name not in build: + raise ManifestError(f"build_configuration omits {name}") + if not isinstance(build["canonical_flags"], list) or not build["canonical_flags"]: + raise ManifestError("canonical_flags must be a non-empty array") + + +def discover_execution_shards(spec: dict[str, Any]) -> set[str]: + discovered: set[str] = set() + globs = spec.get("execution_source_discovery_globs", []) + if not isinstance(globs, list): + raise ManifestError("execution_source_discovery_globs must be an array") + for pattern in globs: + if not isinstance(pattern, str): + raise ManifestError("execution shard glob must be a string") + for path in REPOSITORY_ROOT.glob(pattern): + if path.is_file(): + discovered.add(path.relative_to(REPOSITORY_ROOT).as_posix()) + return discovered + + +def build_manifest(spec_path: Path) -> dict[str, Any]: + spec = load_json(spec_path) + validate_spec(spec) + declared_shards = set(spec["generated_execution_shards"]) | set( + spec["maintained_execution_sources"] + ) + discovered_shards = discover_execution_shards(spec) + unexpected = sorted(discovered_shards - declared_shards) + omitted = sorted(declared_shards - discovered_shards) + if unexpected: + raise ManifestError(f"unexpected execution shard outside manifest: {unexpected}") + if omitted: + raise ManifestError(f"declared execution shard is missing: {omitted}") + + entries: list[dict[str, Any]] = [] + for item in spec["ordered_files"]: + relative = item["path"] + absolute = REPOSITORY_ROOT / relative + if not absolute.is_file(): + raise ManifestError(f"listed source file is missing: {relative}") + content = absolute.read_bytes() + entries.append( + { + "order": len(entries), + "role": item["role"], + "path": relative, + "bytes": len(content), + "sha256": hashlib.sha256(content).hexdigest(), + } + ) + return { + "schema": "ravel-source-and-execution-manifest/0.5", + "entrypoint": spec["entrypoint"], + "maintained_execution_sources": spec["maintained_execution_sources"], + "generated_execution_shards": spec["generated_execution_shards"], + "generator_source": None, + "source_provenance": spec["source_provenance"], + "build_configuration": spec["build_configuration"], + "checkpoint_schema": spec["checkpoint_schema"], + "evidence_schema_versions": spec["evidence_schema_versions"], + "digest_algorithm": spec["digest_algorithm"], + "digest_procedure": spec["digest_procedure"], + "ordered_files": entries, + "source_digest": framed_source_digest(entries), + "unexpected_execution_shards": [], + } + + +def verify_manifest( + spec_path: Path, + manifest_path: Path, + assurance_path: Path | None = None, +) -> dict[str, Any]: + expected = build_manifest(spec_path) + actual = load_json(manifest_path) + verify_manifest_record(expected, actual) + result: dict[str, Any] = { + "manifest_match": True, + "source_digest": expected["source_digest"], + "manifest_sha256": file_sha256(manifest_path), + } + if assurance_path is not None: + assurance = load_json(assurance_path) + implementation = assurance.get("implementation") + if not isinstance(implementation, dict): + raise ManifestError("assurance record lacks implementation object") + if implementation.get("source_digest") != expected["source_digest"]: + raise ManifestError("assurance record contains a stale source digest") + if implementation.get("source_manifest_sha256") != result["manifest_sha256"]: + raise ManifestError("assurance record contains a stale manifest digest") + if implementation.get("source_manifest") != manifest_path.name: + raise ManifestError("assurance record names the wrong source manifest") + result["assurance_match"] = True + return result + + +def verify_manifest_record(expected: dict[str, Any], actual: dict[str, Any]) -> None: + """Reject any manifest record that is not the exact recalculated authority.""" + if actual != expected: + raise ManifestError( + "source manifest is stale, reordered, incomplete, or contains unexpected data" + ) + + +def parse_args() -> argparse.Namespace: + parser = argparse.ArgumentParser() + subparsers = parser.add_subparsers(dest="command", required=True) + generate = subparsers.add_parser("generate") + generate.add_argument("--spec", type=Path, required=True) + generate.add_argument("--output", type=Path, required=True) + verify = subparsers.add_parser("verify") + verify.add_argument("--spec", type=Path, required=True) + verify.add_argument("--manifest", type=Path, required=True) + verify.add_argument("--assurance", type=Path) + show = subparsers.add_parser("print-digest") + show.add_argument("--spec", type=Path, required=True) + return parser.parse_args() + + +def resolve_case_path(path: Path) -> Path: + return path if path.is_absolute() else CASE_ROOT / path + + +def main() -> int: + args = parse_args() + try: + spec = resolve_case_path(args.spec) + if args.command == "generate": + output = resolve_case_path(args.output) + output.write_bytes(canonical_json_bytes(build_manifest(spec))) + return 0 + if args.command == "verify": + manifest = resolve_case_path(args.manifest) + assurance = resolve_case_path(args.assurance) if args.assurance is not None else None + print( + json.dumps( + verify_manifest(spec, manifest, assurance), + sort_keys=True, + separators=(",", ":"), + ) + ) + return 0 + if args.command == "print-digest": + print(build_manifest(spec)["source_digest"]) + return 0 + except (ManifestError, OSError, json.JSONDecodeError) as error: + print(f"ravel source manifest error: {error}", file=sys.stderr) + return 1 + raise AssertionError("unreachable") + + +if __name__ == "__main__": + raise SystemExit(main()) From 441b86c7265c314a8b413cc1fb351108d6a404f9 Mon Sep 17 00:00:00 2001 From: epi13 Date: Fri, 31 Jul 2026 22:49:22 -0800 Subject: [PATCH 05/13] Record RAVEL 0.5 final evidence --- RAVEL_0_5_POSTMORTEM.md | 12 ++++ RAVEL_0_5_RESULTS.md | 69 ++++++++++++++++++++ README.md | 58 +++++++++++++++- ravel-0.5-assurance-case.json | 1 + ravel-0.5-negative-evidence.json | 1 + ravel-0.5-raw-observations.json | 1 + ravel-0.5-source-and-execution-manifest.json | 1 + ravel-0.5-trial-evidence.json | 1 + tools/ravel_0_5_evidence.py | 41 +++++++++++- 9 files changed, 181 insertions(+), 4 deletions(-) create mode 100644 RAVEL_0_5_RESULTS.md create mode 100644 ravel-0.5-assurance-case.json create mode 100644 ravel-0.5-negative-evidence.json create mode 100644 ravel-0.5-raw-observations.json create mode 100644 ravel-0.5-source-and-execution-manifest.json create mode 100644 ravel-0.5-trial-evidence.json diff --git a/RAVEL_0_5_POSTMORTEM.md b/RAVEL_0_5_POSTMORTEM.md index 6359970..bd63812 100644 --- a/RAVEL_0_5_POSTMORTEM.md +++ b/RAVEL_0_5_POSTMORTEM.md @@ -66,3 +66,15 @@ The smallest justified follow-up after any preserved 0.5 failure is a new preregistered development experiment using new development seeds. Final 0.5 seeds, gates, and mechanism code must not be repaired in response to their one-shot result. + +## Post-freeze tooling audit + +The first final evidence-generation pass preserved the complete raw trial +observations but found that the external `regime_mutation` fixture selected the +second trial's regime. Because the first two frozen trials share the same +regime, that operation made no change and correctly failed the negative-test +campaign. The fixture was corrected to select the first actually different +declared regime. No executable mechanism, seed, regime, threshold, raw trial +observation, or independently derived trial result changed. Regeneration after +this assurance-tool correction is separately committed and source-manifest +bound. diff --git a/RAVEL_0_5_RESULTS.md b/RAVEL_0_5_RESULTS.md new file mode 100644 index 0000000..e009ac2 --- /dev/null +++ b/RAVEL_0_5_RESULTS.md @@ -0,0 +1,69 @@ +# RAVEL 0.5 generated results + +Generated deterministically from raw observations by the independent evaluator. + +## Final validation outcomes + +| Trial | Regime | Result | Failed gates | +|---|---|---:|---| +| validation-separated-01 | separated_state | PASS | none | +| validation-separated-02 | separated_state | PASS | none | +| validation-separated-03 | separated_state | PASS | none | +| validation-separated-04 | separated_state | PASS | none | +| validation-overlap-01 | partially_overlapping_observations | PASS | none | +| validation-overlap-02 | partially_overlapping_observations | PASS | none | +| validation-overlap-03 | partially_overlapping_observations | PASS | none | +| validation-overlap-04 | partially_overlapping_observations | PASS | none | +| validation-noise-01 | increased_observation_noise | PASS | none | +| validation-noise-02 | increased_observation_noise | PASS | none | +| validation-noise-03 | increased_observation_noise | PASS | none | +| validation-noise-04 | increased_observation_noise | PASS | none | +| validation-label-01 | label_drift | PASS | none | +| validation-label-02 | label_drift | FAIL | label_gain | +| validation-label-03 | label_drift | FAIL | label_gain | +| validation-label-04 | label_drift | FAIL | label_gain | +| validation-observation-01 | observation_drift | PASS | none | +| validation-observation-02 | observation_drift | PASS | none | +| validation-observation-03 | observation_drift | PASS | none | +| validation-observation-04 | observation_drift | PASS | none | +| validation-transition-01 | transition_drift | PASS | none | +| validation-transition-02 | transition_drift | PASS | none | +| validation-transition-03 | transition_drift | PASS | none | +| validation-transition-04 | transition_drift | FAIL | old_prediction_retention | +| validation-combined-01 | combined_observation_and_label_drift | PASS | none | +| validation-combined-02 | combined_observation_and_label_drift | FAIL | combined_exact_planning | +| validation-combined-03 | combined_observation_and_label_drift | PASS | none | +| validation-combined-04 | combined_observation_and_label_drift | PASS | none | +| validation-ambiguous-01 | partially_observed_ambiguous | PASS | none | +| validation-ambiguous-02 | partially_observed_ambiguous | FAIL | planning_path_found, ambiguous_belief_success, ambiguous_belief_gain | +| validation-ambiguous-03 | partially_observed_ambiguous | FAIL | ambiguous_belief_gain | +| validation-ambiguous-04 | partially_observed_ambiguous | FAIL | conditional_inference_efficiency | + +## Paired baseline and ablation summary + +All deltas are arithmetic means of per-seed candidate-minus-variant differences. A positive accuracy delta favors the candidate; a negative work or size delta uses fewer resources. Pareto counts use drift, retention, reconstruction, prediction, exact and belief-set planning, inference and training evaluations, expert count, and checkpoint size. + +| Variant | Drift accuracy delta | Retention delta | Training-evaluation delta | Inference-evaluation delta | Candidate dominates | Variant dominates | Mixed | Equivalent | +|---|---:|---:|---:|---:|---:|---:|---:|---:| +| fixed_8_expert | 0.713501 | 0.767700 | 1583627.69 | 337.44 | 0 | 0 | 32 | 0 | +| fixed_topology_64_expert_routed | 0.049194 | -0.014038 | -910836.31 | 80.19 | 0 | 0 | 32 | 0 | +| flat_64_expert_complete_scan | 0.049194 | -0.014038 | -910836.31 | -13998.56 | 0 | 0 | 32 | 0 | +| matched_compute_fixed_topology | 0.098999 | 0.031372 | -123297.31 | -268.06 | 0 | 0 | 32 | 0 | +| matched_expert_count_capacity | 0.049194 | -0.014038 | -1559252.31 | -73.59 | 2 | 0 | 30 | 0 | +| nearest_centroid_16_no_recursive_births | 0.664185 | 0.693726 | 1423883.69 | -1710.56 | 0 | 0 | 32 | 0 | +| no_adaptation_static | 0.098999 | 0.031372 | 1110754.69 | -268.06 | 0 | 1 | 31 | 0 | +| periodic_replay_policy | -0.000244 | -0.000366 | 9001.66 | -34.16 | 6 | 3 | 22 | 1 | +| ravel_0_5_candidate | 0.000000 | 0.000000 | 0.00 | 0.00 | 0 | 0 | 0 | 32 | +| ravel_complete_scan_without_certification | 0.000000 | 0.000000 | -194224.53 | -16102.56 | 32 | 0 | 0 | 0 | +| ravel_no_birth_same_replay_iterations | 0.098999 | 0.031372 | 884012.69 | -268.06 | 0 | 1 | 31 | 0 | +| ravel_random_births | 0.098633 | 0.031860 | 869180.69 | -268.06 | 0 | 1 | 31 | 0 | +| ravel_without_replay | -0.000488 | 0.000122 | 321343.47 | -174.91 | 0 | 2 | 30 | 0 | +| ravel_without_retirement_matched_work | -0.000122 | 0.000244 | 0.00 | -27.97 | 3 | 0 | 2 | 27 | + +## Disposition + +Development result: `FAIL`. Passing trials: 24; failing trials: 8. + +Comparisons are paired by seed and include Pareto relationships. Mixed results are not interpreted as superiority. Wall-clock observations are non-normative. + +Formal MNCS status: `UNKNOWN`. Formal MNCDS status: `UNKNOWN`. Promotion remains unauthorized. diff --git a/README.md b/README.md index 01e7d28..26112c0 100644 --- a/README.md +++ b/README.md @@ -91,6 +91,36 @@ gates were removed to obtain a favorable result. See `RAVEL_0_4_RESULTS.md` for generated per-trial failures and aggregates, and `ravel-0.4-assurance-case.json` for the bounded assurance disposition. +## RAVEL 0.5 — adaptive-mechanism correction + +RAVEL 0.5 keeps the 0.4 evidence package immutable and corrects the mechanism +and assurance split. The C harness now emits raw integer observations and +integrity facts only. A separate Python evaluator verifies the frozen trial and +partition matrix, derives every metric and hard gate, and rejects executable +verdicts, malformed records, contradictions, and mutations. + +Mechanism changes include deterministic stratified replay, anchored base +experts, optional objective-tested births and retirements, eight normalized +residual channels, support-bearing top-two transitions, unknown unsupported +actions, retirement safety checks, and alias-aware belief-set planning. +Comparisons add matched work, expert count, and capacity, while retaining the +0.4 baselines and ablations. + +The one-shot 0.5 final validation used 32 fresh trials: four seeds for each of +the eight frozen regime families. Execution integrity is `PASS`; 24 trials +passed and eight failed, so the frozen all-trials development result is +`FAIL`. All separated, overlap, noise, and observation-drift trials passed. +Failures remained in label gain (three trials), transition prediction retention +(one), combined exact planning (one), and ambiguous belief/planning or +efficiency (three). These failures were not used to change the mechanism, +seeds, regimes, or gates. + +The candidate improved mean drift-holdout accuracy over the matched-compute +fixed-topology comparison while using fewer mean training evaluations, but the +complete paired Pareto results are mixed. No superiority claim is made. See +`RAVEL_0_5_RESULTS.md`, `RAVEL_0_5_POSTMORTEM.md`, and +`ravel-0.5-assurance-case.json`. + ## Run ```bash @@ -98,6 +128,7 @@ make test make training-check make unified-check make 0.4-check +make 0.5-check ``` To rewrite repository-visible development evidence: @@ -107,6 +138,7 @@ make evidence make training-evidence make unified-evidence make 0.4-evidence +make 0.5-evidence ``` Requirements: a C11 compiler, the C math library, and Make. @@ -128,7 +160,18 @@ Requirements: a C11 compiler, the C math library, and Make. - `ravel-0.4-raw-observations.json`, `ravel-0.4-trial-evidence.json`, and `ravel-0.4-negative-evidence.json` — executable raw and derived evidence; - `ravel-0.4-source-manifest.json` — ordered implementation identity; and -- `ravel-0.4-assurance-case.json` — current bounded non-promotion record. +- `ravel-0.4-assurance-case.json` — historical 0.4 non-promotion record; +- `ravel_0_5.c`, `RAVEL_0_5_CONTRACT.md`, and + `ravel-0.5-preregistration.json` — maintained 0.5 mechanism and frozen + authority; +- `tools/ravel_0_5_evaluator.py` and `tools/ravel_0_5_evidence.py` — + independent derivation and deterministic evidence tooling; +- `ravel-0.5-raw-observations.json`, `ravel-0.5-trial-evidence.json`, and + `ravel-0.5-negative-evidence.json` — raw and independently derived 0.5 + records; and +- `ravel-0.5-source-and-execution-manifest.json` and + `ravel-0.5-assurance-case.json` — bound build/source identity and current + bounded non-promotion record. ## MNCS boundary @@ -138,11 +181,20 @@ Requirements: a C11 compiler, the C math library, and Make. - **Development-control plane:** fixed seeds, partitions, birth and retirement budgets, immutable thresholds, and non-promotion fields. - **Operational-control plane:** complete-scan fallback, checkpoint restoration, model identity, and replacement of maintained execution source. -The repository-visible studies record development `PASS`. Formal MNCS and MNCDS status remain `UNKNOWN`; promotion is unauthorized pending independent protected real-data evaluation, adversarial continual-learning studies, learned modality adapters, cross-host reproduction, accelerator and distributed evidence, and operational release controls. +Historical RAVEL 0.1–0.3 studies recorded favorable development observations. +RAVEL 0.4 records development `FAIL` with zero of eight trials passing. RAVEL +0.5 records development `FAIL` with 24 of 32 trials passing. Formal MNCS and +MNCDS status remain `UNKNOWN`; promotion is unauthorized pending independent +protected real-data evaluation, adversarial continual-learning studies, learned +modality adapters, cross-host reproduction, accelerator and distributed +evidence, and operational release controls. ## Claim boundary -RAVEL-U is a favorable deterministic mechanism proof. It does not establish general intelligence, foundation-model performance, language or multimodal generation, causal reasoning, real-data generalization, production safety, or formal conformance. +RAVEL is a bounded deterministic research study with both favorable and +unfavorable results. It does not establish general intelligence, +foundation-model performance, language or multimodal generation, causal +reasoning, real-data generalization, production safety, or formal conformance. ## Origin diff --git a/ravel-0.5-assurance-case.json b/ravel-0.5-assurance-case.json new file mode 100644 index 0000000..39e4505 --- /dev/null +++ b/ravel-0.5-assurance-case.json @@ -0,0 +1 @@ +{"assurance_case_id":"ravel.adaptive-mechanism-correction.epoch-1","claim_boundaries":["development evidence is not independent protected evidence","synthetic results do not establish real-data generalization","deterministic reproduction is not cross-organizational reproduction","routing equivalence is not overall model correctness","checkpoint reproducibility is not production rollback authorization","formal MNCS and MNCDS status remain UNKNOWN","promotion remains unauthorized"],"development_result":"FAIL","disposition":"NON_PROMOTION_RESEARCH_EVIDENCE","evaluator_authority":{"all_gates_independently_derived":true,"path":"case-studies/ravel/tools/ravel_0_5_evaluator.py","preregistration":"ravel-0.5-preregistration.json","raw_executable_verdicts_trusted":false},"evidence":{"deterministic_reproduction":true,"holdouts_used_for_adaptation_or_selection":false,"independent_custody":false,"negative_and_mutation_tests":true,"protected_custody":false,"records":[{"bytes":859770,"path":"ravel-0.5-raw-observations.json","sha256":"bb34d0292a9286ea321d50d31919dc43793a58b90b4c7a7892f91552b841f354"},{"bytes":607011,"path":"ravel-0.5-trial-evidence.json","sha256":"9ffefe97e5331b65e5b998f9c2d3aac91cdf9cca246a377ca421a3bef0ba0e80"},{"bytes":10150,"path":"ravel-0.5-negative-evidence.json","sha256":"3c18eb94e0a76019a7fa3f4d2a85972332705867174f5d694d278464fc07cdb9"}]},"execution_integrity":"PASS","formal_mncds_status":"UNKNOWN","formal_mncs_status":"UNKNOWN","implementation":{"build_configuration":{"canonical_compiler":"cc","canonical_flags":["-std=c11","-O3","-Wall","-Wextra","-Werror","-pedantic"],"language":"C","link_libraries":["m"],"standard":"C11"},"entrypoint":"case-studies/ravel/ravel_0_5.c","source_digest":"a182be923d77fb841905eb501e387440bcb64a3dee85ad4b60e65a1f881b816e","source_manifest":"ravel-0.5-source-and-execution-manifest.json","source_manifest_sha256":"82b372e43cc012b8b8d3aabe46eba57b8d6116f55cbeae21e98ce9525d1e22ee","source_provenance":{"classification":"maintained_source","generator":null,"statement":"RAVEL 0.5 is directly maintained C11 source. No higher-level generator or generated execution shard exists."}},"promotion_authorized":false,"schema":"ravel-assurance-case/0.5","trial_summary":{"declared":32,"failing":8,"minimum_passing_trials":32,"minimum_passing_trials_per_regime":4,"passing":24,"passing_by_regime":{"combined_observation_and_label_drift":3,"increased_observation_noise":4,"label_drift":1,"observation_drift":4,"partially_observed_ambiguous":1,"partially_overlapping_observations":4,"separated_state":4,"transition_drift":3}}} diff --git a/ravel-0.5-negative-evidence.json b/ravel-0.5-negative-evidence.json new file mode 100644 index 0000000..80f95d1 --- /dev/null +++ b/ravel-0.5-negative-evidence.json @@ -0,0 +1 @@ +{"all_negative_tests_pass":true,"formal_mncds_status":"UNKNOWN","formal_mncs_status":"UNKNOWN","promotion_authorized":false,"replay_observations":{"actions_covered":4,"assigned_experts_covered":63,"high_loss_cases_selected":13,"labels_covered":8,"rare_cases_selected":60,"selected":256,"selection_checksum":"d93af04d442bb390","states_covered":64,"transition_pairs_covered":253,"unique":256},"schema":"ravel-negative-evidence/0.5","self_test_observations_sha256":"25afab5f5faf41c38986c44649d8d0390a07be22859721ee0f3587b878735dd9","sparse_replay_observations":{"actions_covered":2,"assigned_experts_covered":2,"high_loss_cases_selected":16,"labels_covered":2,"rare_cases_selected":0,"selected":16,"selection_checksum":"088b84ce5271b343","states_covered":2,"transition_pairs_covered":2,"unique":16},"tests":{"action_coverage_residual_fixture":{"expected_disposition":"preserve_non_promotion","expected_observation":true,"observed":true,"pass":true,"rationale":"Missing action coverage changes the normalized birth score."},"aggregate_mutation":{"expected_disposition":"reject","expected_observation":true,"observed":true,"pass":true,"rationale":"Executable-emitted aggregate or global verdicts are unknown raw fields."},"artifact_mutation":{"expected_disposition":"reject","expected_observation":true,"observed":true,"pass":true,"rationale":"Changed declared bytes fail exact manifest equality."},"balanced_replay_coverage":{"expected_disposition":"preserve_non_promotion","expected_observation":true,"observed":true,"pass":true,"rationale":"Replay covers every label, action, and state in the fixture."},"balanced_replay_determinism":{"expected_disposition":"preserve_non_promotion","expected_observation":true,"observed":true,"pass":true,"rationale":"Repeated stratified selection is byte-for-byte deterministic."},"balanced_replay_no_duplicates":{"expected_disposition":"preserve_non_promotion","expected_observation":true,"observed":true,"pass":true,"rationale":"Replay selection contains no accidental duplicates."},"balanced_replay_sparse_strata":{"expected_disposition":"preserve_non_promotion","expected_observation":true,"observed":true,"pass":true,"rationale":"Sparse strata terminate without invented duplicates."},"birth_beyond_capacity":{"expected_disposition":"reject","expected_observation":true,"observed":true,"pass":true,"rationale":"A birth beyond capacity is rejected."},"build_configuration_mutation":{"expected_disposition":"reject","expected_observation":true,"observed":true,"pass":true,"rationale":"Compiler flags and build identity are manifest authority."},"catastrophic_forgetting_experiment":{"expected_disposition":"fail_a_gate","expected_observation":true,"observed":true,"pass":true,"rationale":"Repeated unprotected updates create a distinct forgetting condition."},"classification_residual_fixture":{"expected_disposition":"preserve_non_promotion","expected_observation":true,"observed":true,"pass":true,"rationale":"Classification residual changes the normalized birth score."},"degenerate_expert_assignment":{"expected_disposition":"reject","expected_observation":true,"observed":true,"pass":true,"rationale":"A split without two nonempty assignments is rejected."},"duplicate_expert":{"expected_disposition":"reject","expected_observation":true,"observed":true,"pass":true,"rationale":"Duplicate behaviorally identical experts violate topology uniqueness."},"empty_expert_assignment":{"expected_disposition":"reject","expected_observation":true,"observed":true,"pass":true,"rationale":"An empty model has no valid assignment."},"evidence_file_mutation":{"expected_disposition":"reject","expected_observation":true,"observed":true,"pass":true,"rationale":"Canonical evidence identity changes when evidence content changes."},"executable_gate_boolean_injection":{"expected_disposition":"reject","expected_observation":true,"observed":true,"pass":true,"rationale":"An executable-emitted hard gate is an unknown raw field."},"executable_trial_result_injection":{"expected_disposition":"reject","expected_observation":true,"observed":true,"pass":true,"rationale":"An executable-emitted trial result is an unknown raw field."},"inverse_support_residual_fixture":{"expected_disposition":"preserve_non_promotion","expected_observation":true,"observed":true,"pass":true,"rationale":"Inverse support changes the normalized birth score."},"malformed_observation":{"expected_disposition":"reject","expected_observation":true,"observed":true,"pass":true,"rationale":"Invalid action encoding is rejected."},"maximum_expert_capacity":{"expected_disposition":"preserve_non_promotion","expected_observation":true,"observed":true,"pass":true,"rationale":"The model preserves the declared maximum capacity."},"non_finite_serialization":{"expected_disposition":"reject","expected_observation":true,"observed":true,"pass":true,"rationale":"Non-finite model state cannot be serialized."},"nondeterministic_output_detection":{"expected_disposition":"reject","expected_observation":true,"observed":true,"pass":true,"rationale":"Each trial and self-test is executed twice and must be byte-identical."},"novelty_residual_fixture":{"expected_disposition":"preserve_non_promotion","expected_observation":true,"observed":true,"pass":true,"rationale":"Novelty residual changes the normalized birth score."},"omitted_file":{"expected_disposition":"reject","expected_observation":true,"observed":true,"pass":true,"rationale":"An omitted authority fails exact manifest equality."},"out_of_domain_value":{"expected_disposition":"fall_back","expected_observation":true,"observed":true,"pass":true,"rationale":"Out-of-domain routing cannot certify and uses complete scan."},"overflow_serialization":{"expected_disposition":"reject","expected_observation":true,"observed":true,"pass":true,"rationale":"Fixed-point overflow cannot be serialized."},"poisoned_adaptation_labels":{"expected_disposition":"fail_a_gate","expected_observation":true,"observed":true,"pass":true,"rationale":"Poisoned labels produce a retention failure condition."},"poisoned_transition_observations":{"expected_disposition":"fail_a_gate","expected_observation":true,"observed":true,"pass":true,"rationale":"Poisoned next observations produce a prediction failure condition."},"prediction_residual_fixture":{"expected_disposition":"preserve_non_promotion","expected_observation":true,"observed":true,"pass":true,"rationale":"Prediction residual changes the normalized birth score."},"raw_metric_mutation":{"expected_disposition":"reject","expected_observation":true,"observed":true,"pass":true,"rationale":"A changed raw metric changes canonical derived evidence and fails verification."},"reconstruction_residual_fixture":{"expected_disposition":"preserve_non_promotion","expected_observation":true,"observed":true,"pass":true,"rationale":"Reconstruction residual changes the normalized birth score."},"regime_mutation":{"expected_disposition":"reject","expected_observation":true,"observed":true,"pass":true,"rationale":"Trial regimes must match the frozen matrix."},"reordered_file":{"expected_disposition":"reject","expected_observation":true,"observed":true,"pass":true,"rationale":"Manifest file order is digest authority."},"replay_removal_experiment":{"expected_disposition":"fail_a_gate","expected_observation":true,"observed":true,"pass":true,"rationale":"A distinct no-replay experiment is worse than protected balanced replay."},"retention_risk_residual_fixture":{"expected_disposition":"preserve_non_promotion","expected_observation":true,"observed":true,"pass":true,"rationale":"Anchored retention risk changes the normalized birth score."},"retirement_checkpoint_remap":{"expected_disposition":"preserve_non_promotion","expected_observation":true,"observed":true,"pass":true,"rationale":"Transition target identities are remapped or invalidated after expert compaction and survive canonical roundtrip."},"retirement_unique_support_safety":{"expected_disposition":"reject","expected_observation":true,"observed":true,"pass":true,"rationale":"Retirement that destroys unique support is rejected."},"routing_lower_bound_equality":{"expected_disposition":"fall_back","expected_observation":true,"observed":true,"pass":true,"rationale":"Lower-bound equality cannot certify early return."},"seed_mutation":{"expected_disposition":"reject","expected_observation":true,"observed":true,"pass":true,"rationale":"Trial seeds must match the frozen derivation."},"stale_assurance":{"expected_disposition":"reject","expected_observation":true,"observed":true,"pass":true,"rationale":"Assurance must bind the exact manifest and source digest."},"stale_manifest":{"expected_disposition":"reject","expected_observation":true,"observed":true,"pass":true,"rationale":"A stale source digest cannot equal independent recalculation."},"substituted_source":{"expected_disposition":"reject","expected_observation":true,"observed":true,"pass":true,"rationale":"A substituted maintained source hash fails manifest equality."},"threshold_mutation":{"expected_disposition":"reject","expected_observation":true,"observed":true,"pass":true,"rationale":"A changed threshold invalidates the preregistration digest."},"tied_distance":{"expected_disposition":"fall_back","expected_observation":true,"observed":true,"pass":true,"rationale":"Ties resolve deterministically to the lower expert ID."},"top_k_transition_ambiguity":{"expected_disposition":"preserve_non_promotion","expected_observation":true,"observed":true,"pass":true,"rationale":"Two supported transition targets are retained deterministically."},"uncertainty_residual_fixture":{"expected_disposition":"preserve_non_promotion","expected_observation":true,"observed":true,"pass":true,"rationale":"Uncertainty changes the normalized birth score."},"unsupported_action_unknown":{"expected_disposition":"preserve_non_promotion","expected_observation":true,"observed":true,"pass":true,"rationale":"An unsupported action remains an unknown graph edge."},"wrong_lifecycle_retirement":{"expected_disposition":"reject","expected_observation":true,"observed":true,"pass":true,"rationale":"Anchored or wrong-class experts cannot be retired."}}} diff --git a/ravel-0.5-raw-observations.json b/ravel-0.5-raw-observations.json new file mode 100644 index 0000000..a0bd2ce --- /dev/null +++ b/ravel-0.5-raw-observations.json @@ -0,0 +1 @@ +{"preregistration":"ravel-0.5-preregistration.json","preregistration_sha256":"30386a8d0c7e9a15fd8cb907f55e74b46a319e1f17102654eceda18699dce12f","schema":"ravel-raw-observations/0.5","self_tests_sha256":"25afab5f5faf41c38986c44649d8d0390a07be22859721ee0f3587b878735dd9","trials":[{"candidate":{"adaptation_completed":true,"adaptation_training":{"classification_checksum":"58ae85ab4f5296f8","correct":512,"expert_evaluations":4096,"prediction_checksum":"5e86b9a830521e35","prediction_samples":468,"prediction_sse_q20":114789283715,"reconstruction_checksum":"488c2c3f0ad80c32","reconstruction_sse_q20":85395381675,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":512,"samples":512,"transition_checksum":"e9a292457768dc98","transition_correct":443,"transition_supported":468,"transition_unknown":44},"adaptation_training_evaluations":812544,"adapted_model_drift_holdout":{"classification_checksum":"5fa3ff5e56b8926e","correct":256,"expert_evaluations":2048,"prediction_checksum":"2addae80932b17b1","prediction_samples":237,"prediction_sse_q20":52136909489,"reconstruction_checksum":"09e2ceff4d6dc365","reconstruction_sse_q20":32808693212,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"c1908bad04889e46","transition_correct":220,"transition_supported":237,"transition_unknown":19},"base_holdout":{"classification_checksum":"25d086af645fe75a","correct":241,"expert_evaluations":2048,"prediction_checksum":"c715c29eec15b4d7","prediction_samples":237,"prediction_sse_q20":89793086605,"reconstruction_checksum":"423edda3e9633c70","reconstruction_sse_q20":82081451186,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"32cc841b517a5b4d","transition_correct":221,"transition_supported":237,"transition_unknown":19},"base_holdout_retention":{"classification_checksum":"def12f97e4e1e8ac","correct":256,"expert_evaluations":2048,"prediction_checksum":"e53e5ce3bbb48859","prediction_samples":235,"prediction_sse_q20":71114171399,"reconstruction_checksum":"6f1ccc0df5d20b52","reconstruction_sse_q20":45668797470,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"c686453153908b81","transition_correct":220,"transition_supported":235,"transition_unknown":21},"base_training_evaluations":562488,"behavior_identity":"4ba983bf744677ca19a40c2f1f209e2bf49ff57221b8a79b13fae95a097aa850","checkpoint_size_bytes":46064,"expert_count":69,"model_identity":"85509834738786ab183f7a4a32f6e7c16b35a02164b607b190fc8407a32a2100","planning":{"belief_set_target_reached":49,"cases":64,"checksum":"62f1814d9551f529","exact_world_state_target_reached":49,"executed_path_length":276,"expansions":2221,"goal_expert_reached":49,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":295,"path_found":64,"path_length_regret":12,"state_aliasing_failures":0,"transition_model_error_failures":15},"replay":{"actions_covered":4,"assigned_experts_covered":62,"high_loss_cases_selected":12,"labels_covered":8,"rare_cases_selected":63,"selected":256,"selection_checksum":"6787c6a90285c3e4","states_covered":64,"transition_pairs_covered":254,"unique":256},"static_model_drift_holdout":{"classification_checksum":"870e45f1a33bab53","correct":245,"expert_evaluations":2048,"prediction_checksum":"e103a91aa90f2991","prediction_samples":238,"prediction_sse_q20":76896120468,"reconstruction_checksum":"cce9abaadf941409","reconstruction_sse_q20":60614426760,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"3321cc580945569c","transition_correct":218,"transition_supported":238,"transition_unknown":18},"topology":{"accepted_births":5,"accepted_retirements":0,"births":[{"dominant_channel":0,"event_index":165,"normalized_score_q20":559212},{"dominant_channel":0,"event_index":97,"normalized_score_q20":518902},{"dominant_channel":0,"event_index":127,"normalized_score_q20":508542},{"dominant_channel":2,"event_index":304,"normalized_score_q20":374180},{"dominant_channel":2,"event_index":301,"normalized_score_q20":304703}],"objective_after_q20":906173,"objective_before_q20":889375,"rejected_births":11,"rejected_retirements":1,"retired_lineages":[],"training_observations":{"births":5,"certified":10752,"expert_evaluations":812544,"rejected_births":11,"rejected_retirements":1,"retired":0,"samples":10752}}},"checkpoint_format":{"byte_order":"big_endian","magic_hex":"524156454c303500","payload_digest":"sha256","real_encoding":"signed_q20_int64","schema_version":5,"transition_support_min":2,"transition_top_k":2},"comparisons":{"fixed_8_expert":{"checkpoint_size_bytes":11294,"drift_holdout":{"classification_checksum":"bd96d5ca031b1165","correct":59,"expert_evaluations":2048,"prediction_checksum":"2a89e5deb5930ad3","prediction_samples":256,"prediction_sse_q20":1942231716078,"reconstruction_checksum":"c1fcb99165bb532a","reconstruction_sse_q20":1753723391001,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"70fe482ccc5c7822","transition_correct":144,"transition_supported":256,"transition_unknown":0},"expert_count":8,"planning":{"belief_set_target_reached":13,"cases":64,"checksum":"d09d91757b3b30d6","exact_world_state_target_reached":0,"executed_path_length":26,"expansions":146,"goal_expert_reached":13,"graph_disconnection_failures":38,"no_supported_edge_failures":0,"optimal_path_length":295,"path_found":26,"path_length_regret":0,"state_aliasing_failures":13,"transition_model_error_failures":13},"retention_holdout":{"classification_checksum":"06a1345401cef251","correct":53,"expert_evaluations":2048,"prediction_checksum":"8bbe439d29a25213","prediction_samples":256,"prediction_sse_q20":2137623832654,"reconstruction_checksum":"105602cc021572f0","reconstruction_sse_q20":1851354058793,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"7be9956324d9ea00","transition_correct":123,"transition_supported":256,"transition_unknown":0},"training_evaluations":94208},"fixed_topology_64_expert_routed":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"e5edfb12c7a5f5e7","correct":256,"expert_evaluations":2048,"prediction_checksum":"66ef54c89b1587bd","prediction_samples":235,"prediction_sse_q20":24832483044,"reconstruction_checksum":"9d373611863d46ca","reconstruction_sse_q20":22385123166,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"dd8c7c825da7987d","transition_correct":235,"transition_supported":235,"transition_unknown":21},"expert_count":64,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"3a52e6a046b6b6cb","exact_world_state_target_reached":64,"executed_path_length":320,"expansions":2163,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":295,"path_found":64,"path_length_regret":25,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"280bc9bf0304594a","correct":256,"expert_evaluations":2048,"prediction_checksum":"a01202c035a8081f","prediction_samples":227,"prediction_sse_q20":25372315111,"reconstruction_checksum":"8b7fee9cbabcb908","reconstruction_sse_q20":21644962082,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"ef665ae9ff17800e","transition_correct":227,"transition_supported":227,"transition_unknown":29},"training_evaluations":2588672},"flat_64_expert_complete_scan":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"e5edfb12c7a5f5e7","correct":256,"expert_evaluations":16384,"prediction_checksum":"66ef54c89b1587bd","prediction_samples":235,"prediction_sse_q20":24832483044,"reconstruction_checksum":"9d373611863d46ca","reconstruction_sse_q20":22385123166,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"dd8c7c825da7987d","transition_correct":235,"transition_supported":235,"transition_unknown":21},"expert_count":64,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"3a52e6a046b6b6cb","exact_world_state_target_reached":64,"executed_path_length":320,"expansions":2163,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":295,"path_found":64,"path_length_regret":25,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"280bc9bf0304594a","correct":256,"expert_evaluations":16384,"prediction_checksum":"a01202c035a8081f","prediction_samples":227,"prediction_sse_q20":25372315111,"reconstruction_checksum":"8b7fee9cbabcb908","reconstruction_sse_q20":21644962082,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"ef665ae9ff17800e","transition_correct":227,"transition_supported":227,"transition_unknown":29},"training_evaluations":2588672},"matched_compute_fixed_topology":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"870e45f1a33bab53","correct":245,"expert_evaluations":2048,"prediction_checksum":"e103a91aa90f2991","prediction_samples":238,"prediction_sse_q20":76896120468,"reconstruction_checksum":"cce9abaadf941409","reconstruction_sse_q20":60614426760,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"3321cc580945569c","transition_correct":218,"transition_supported":238,"transition_unknown":18},"expert_count":64,"planning":{"belief_set_target_reached":45,"cases":64,"checksum":"b6fe4cd4e9951586","exact_world_state_target_reached":41,"executed_path_length":258,"expansions":2045,"goal_expert_reached":45,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":295,"path_found":64,"path_length_regret":10,"state_aliasing_failures":4,"transition_model_error_failures":19},"retention_holdout":{"classification_checksum":"8288639acb4366dd","correct":244,"expert_evaluations":2048,"prediction_checksum":"6123320769337ddb","prediction_samples":237,"prediction_sse_q20":97170764379,"reconstruction_checksum":"f14bb6f4b30269f3","reconstruction_sse_q20":74967406299,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"77d505b7e581c336","transition_correct":220,"transition_supported":237,"transition_unknown":19},"training_evaluations":1447224},"matched_expert_count_capacity":{"checkpoint_size_bytes":46064,"drift_holdout":{"classification_checksum":"cd81c0c1b0b95edc","correct":256,"expert_evaluations":2048,"prediction_checksum":"a59ff1bafce42c68","prediction_samples":231,"prediction_sse_q20":24489183027,"reconstruction_checksum":"527ecc06c32f4aa7","reconstruction_sse_q20":22336857477,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"6171e9e23578ef6f","transition_correct":223,"transition_supported":231,"transition_unknown":25},"expert_count":69,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"cc51f67ec85ff7f8","exact_world_state_target_reached":64,"executed_path_length":322,"expansions":2207,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":295,"path_found":64,"path_length_regret":27,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"b047c960ff2e4f75","correct":256,"expert_evaluations":2048,"prediction_checksum":"1bb58f3fef18db95","prediction_samples":221,"prediction_sse_q20":24858982074,"reconstruction_checksum":"7080676ce19411a9","reconstruction_sse_q20":21635644155,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"cf8141007c3c6721","transition_correct":211,"transition_supported":221,"transition_unknown":35},"training_evaluations":2967552},"nearest_centroid_16_no_recursive_births":{"checkpoint_size_bytes":15854,"drift_holdout":{"classification_checksum":"0b878c89146f0aa3","correct":64,"expert_evaluations":4096,"prediction_checksum":"5a9d840d9db9be12","prediction_samples":256,"prediction_sse_q20":1180340001693,"reconstruction_checksum":"8be04cb302e5be3a","reconstruction_sse_q20":1091418181917,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"3f0abb7085361779","transition_correct":190,"transition_supported":256,"transition_unknown":0},"expert_count":16,"planning":{"belief_set_target_reached":34,"cases":64,"checksum":"5f7252620f4ca99f","exact_world_state_target_reached":6,"executed_path_length":153,"expansions":528,"goal_expert_reached":34,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":295,"path_found":64,"path_length_regret":0,"state_aliasing_failures":28,"transition_model_error_failures":30},"retention_holdout":{"classification_checksum":"819544c17afdb121","correct":63,"expert_evaluations":4096,"prediction_checksum":"d6e820a0eb80b18b","prediction_samples":256,"prediction_sse_q20":1238365414741,"reconstruction_checksum":"3d3fb90790d83dc1","reconstruction_sse_q20":1172708690537,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"3f21b6a57268624e","transition_correct":160,"transition_supported":256,"transition_unknown":0},"training_evaluations":253952},"no_adaptation_static":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"870e45f1a33bab53","correct":245,"expert_evaluations":2048,"prediction_checksum":"e103a91aa90f2991","prediction_samples":238,"prediction_sse_q20":76896120468,"reconstruction_checksum":"cce9abaadf941409","reconstruction_sse_q20":60614426760,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"3321cc580945569c","transition_correct":218,"transition_supported":238,"transition_unknown":18},"expert_count":64,"planning":{"belief_set_target_reached":45,"cases":64,"checksum":"b6fe4cd4e9951586","exact_world_state_target_reached":41,"executed_path_length":258,"expansions":2045,"goal_expert_reached":45,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":295,"path_found":64,"path_length_regret":10,"state_aliasing_failures":4,"transition_model_error_failures":19},"retention_holdout":{"classification_checksum":"8288639acb4366dd","correct":244,"expert_evaluations":2048,"prediction_checksum":"6123320769337ddb","prediction_samples":237,"prediction_sse_q20":97170764379,"reconstruction_checksum":"f14bb6f4b30269f3","reconstruction_sse_q20":74967406299,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"77d505b7e581c336","transition_correct":220,"transition_supported":237,"transition_unknown":19},"training_evaluations":562488},"periodic_replay_policy":{"checkpoint_size_bytes":45494,"drift_holdout":{"classification_checksum":"cf1f4d7483eee25c","correct":256,"expert_evaluations":2048,"prediction_checksum":"6d565673c1b86931","prediction_samples":235,"prediction_sse_q20":51813134874,"reconstruction_checksum":"74f54fd1b0bfcae9","reconstruction_sse_q20":32784106651,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"d32baf10c4b7ace5","transition_correct":220,"transition_supported":235,"transition_unknown":21},"expert_count":68,"planning":{"belief_set_target_reached":48,"cases":64,"checksum":"0c47951408c73440","exact_world_state_target_reached":48,"executed_path_length":274,"expansions":2177,"goal_expert_reached":48,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":295,"path_found":64,"path_length_regret":10,"state_aliasing_failures":0,"transition_model_error_failures":16},"retention_holdout":{"classification_checksum":"def12f97e4e1e8ac","correct":256,"expert_evaluations":2048,"prediction_checksum":"5b549919334a7f14","prediction_samples":236,"prediction_sse_q20":71539266800,"reconstruction_checksum":"7a4eeb505ecb9586","reconstruction_sse_q20":45654691109,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"2eac8a893594acda","transition_correct":224,"transition_supported":236,"transition_unknown":20},"training_evaluations":1253688},"ravel_0_5_candidate":{"checkpoint_size_bytes":46064,"drift_holdout":{"classification_checksum":"5fa3ff5e56b8926e","correct":256,"expert_evaluations":2048,"prediction_checksum":"2addae80932b17b1","prediction_samples":237,"prediction_sse_q20":52136909489,"reconstruction_checksum":"09e2ceff4d6dc365","reconstruction_sse_q20":32808693212,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"c1908bad04889e46","transition_correct":220,"transition_supported":237,"transition_unknown":19},"expert_count":69,"planning":{"belief_set_target_reached":49,"cases":64,"checksum":"62f1814d9551f529","exact_world_state_target_reached":49,"executed_path_length":276,"expansions":2221,"goal_expert_reached":49,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":295,"path_found":64,"path_length_regret":12,"state_aliasing_failures":0,"transition_model_error_failures":15},"retention_holdout":{"classification_checksum":"def12f97e4e1e8ac","correct":256,"expert_evaluations":2048,"prediction_checksum":"e53e5ce3bbb48859","prediction_samples":235,"prediction_sse_q20":71114171399,"reconstruction_checksum":"6f1ccc0df5d20b52","reconstruction_sse_q20":45668797470,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"c686453153908b81","transition_correct":220,"transition_supported":235,"transition_unknown":21},"training_evaluations":1375032},"ravel_complete_scan_without_certification":{"checkpoint_size_bytes":46064,"drift_holdout":{"classification_checksum":"5fa3ff5e56b8926e","correct":256,"expert_evaluations":17664,"prediction_checksum":"2addae80932b17b1","prediction_samples":237,"prediction_sse_q20":52136909489,"reconstruction_checksum":"09e2ceff4d6dc365","reconstruction_sse_q20":32808693212,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"c1908bad04889e46","transition_correct":220,"transition_supported":237,"transition_unknown":19},"expert_count":69,"planning":{"belief_set_target_reached":49,"cases":64,"checksum":"62f1814d9551f529","exact_world_state_target_reached":49,"executed_path_length":276,"expansions":2221,"goal_expert_reached":49,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":295,"path_found":64,"path_length_regret":12,"state_aliasing_failures":0,"transition_model_error_failures":15},"retention_holdout":{"classification_checksum":"def12f97e4e1e8ac","correct":256,"expert_evaluations":17664,"prediction_checksum":"e53e5ce3bbb48859","prediction_samples":235,"prediction_sse_q20":71114171399,"reconstruction_checksum":"6f1ccc0df5d20b52","reconstruction_sse_q20":45668797470,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"c686453153908b81","transition_correct":220,"transition_supported":235,"transition_unknown":21},"training_evaluations":1562424},"ravel_no_birth_same_replay_iterations":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"870e45f1a33bab53","correct":245,"expert_evaluations":2048,"prediction_checksum":"e103a91aa90f2991","prediction_samples":238,"prediction_sse_q20":76896120468,"reconstruction_checksum":"cce9abaadf941409","reconstruction_sse_q20":60614426760,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"3321cc580945569c","transition_correct":218,"transition_supported":238,"transition_unknown":18},"expert_count":64,"planning":{"belief_set_target_reached":45,"cases":64,"checksum":"b6fe4cd4e9951586","exact_world_state_target_reached":41,"executed_path_length":258,"expansions":2045,"goal_expert_reached":45,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":295,"path_found":64,"path_length_regret":10,"state_aliasing_failures":4,"transition_model_error_failures":19},"retention_holdout":{"classification_checksum":"8288639acb4366dd","correct":244,"expert_evaluations":2048,"prediction_checksum":"6123320769337ddb","prediction_samples":237,"prediction_sse_q20":97170764379,"reconstruction_checksum":"f14bb6f4b30269f3","reconstruction_sse_q20":74967406299,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"77d505b7e581c336","transition_correct":220,"transition_supported":237,"transition_unknown":19},"training_evaluations":783672},"ravel_random_births":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"870e45f1a33bab53","correct":245,"expert_evaluations":2048,"prediction_checksum":"e103a91aa90f2991","prediction_samples":238,"prediction_sse_q20":76896120468,"reconstruction_checksum":"cce9abaadf941409","reconstruction_sse_q20":60614426760,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"3321cc580945569c","transition_correct":218,"transition_supported":238,"transition_unknown":18},"expert_count":64,"planning":{"belief_set_target_reached":45,"cases":64,"checksum":"b6fe4cd4e9951586","exact_world_state_target_reached":41,"executed_path_length":258,"expansions":2045,"goal_expert_reached":45,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":295,"path_found":64,"path_length_regret":10,"state_aliasing_failures":4,"transition_model_error_failures":19},"retention_holdout":{"classification_checksum":"8288639acb4366dd","correct":244,"expert_evaluations":2048,"prediction_checksum":"6123320769337ddb","prediction_samples":237,"prediction_sse_q20":97170764379,"reconstruction_checksum":"f14bb6f4b30269f3","reconstruction_sse_q20":74967406299,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"77d505b7e581c336","transition_correct":220,"transition_supported":237,"transition_unknown":19},"training_evaluations":783672},"ravel_without_replay":{"checkpoint_size_bytes":46064,"drift_holdout":{"classification_checksum":"cf1f4d7483eee25c","correct":256,"expert_evaluations":2048,"prediction_checksum":"74eaf1fead735c02","prediction_samples":232,"prediction_sse_q20":51592058063,"reconstruction_checksum":"e7a8e0268d6f9b07","reconstruction_sse_q20":32922757807,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"99aa4429bc116698","transition_correct":217,"transition_supported":232,"transition_unknown":24},"expert_count":69,"planning":{"belief_set_target_reached":48,"cases":64,"checksum":"47fabef4ba50a046","exact_world_state_target_reached":48,"executed_path_length":276,"expansions":2145,"goal_expert_reached":48,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":295,"path_found":64,"path_length_regret":10,"state_aliasing_failures":0,"transition_model_error_failures":16},"retention_holdout":{"classification_checksum":"7fb5406423960d22","correct":256,"expert_evaluations":2048,"prediction_checksum":"7389a1a7a09e90ab","prediction_samples":231,"prediction_sse_q20":70752984195,"reconstruction_checksum":"14cc44262c8a30ad","reconstruction_sse_q20":45706577455,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"99709b1e9c8d68f9","transition_correct":218,"transition_supported":231,"transition_unknown":25},"training_evaluations":951608},"ravel_without_retirement_matched_work":{"checkpoint_size_bytes":46064,"drift_holdout":{"classification_checksum":"5fa3ff5e56b8926e","correct":256,"expert_evaluations":2048,"prediction_checksum":"2addae80932b17b1","prediction_samples":237,"prediction_sse_q20":52136909489,"reconstruction_checksum":"09e2ceff4d6dc365","reconstruction_sse_q20":32808693212,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"c1908bad04889e46","transition_correct":220,"transition_supported":237,"transition_unknown":19},"expert_count":69,"planning":{"belief_set_target_reached":49,"cases":64,"checksum":"62f1814d9551f529","exact_world_state_target_reached":49,"executed_path_length":276,"expansions":2221,"goal_expert_reached":49,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":295,"path_found":64,"path_length_regret":12,"state_aliasing_failures":0,"transition_model_error_failures":15},"retention_holdout":{"classification_checksum":"def12f97e4e1e8ac","correct":256,"expert_evaluations":2048,"prediction_checksum":"e53e5ce3bbb48859","prediction_samples":235,"prediction_sse_q20":71114171399,"reconstruction_checksum":"6f1ccc0df5d20b52","reconstruction_sse_q20":45668797470,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"c686453153908b81","transition_correct":220,"transition_supported":235,"transition_unknown":21},"training_evaluations":1375032}},"dataset_seeds":{"base_holdout":"0x53dde4986813e339","base_training":"0x43d011e98bbe8b8b","drift_adaptation_training":"0x1cb35e0bbe7c3def","drift_holdout":"0x7654403138c685f8","original_task_retention_holdout":"0x80cd34d1b9304fe2","planning_cases":"0x85ae7ef5eb056f75"},"dataset_sizes":{"base_holdout":256,"base_training":1024,"drift_adaptation_training":512,"drift_holdout":256,"original_task_retention_holdout":256,"planning_cases":64},"integrity":{"checkpoint_behavior_match":true,"checkpoint_identity_match":true,"checkpoint_mutations":{"anchored_status":true,"appended_unexpected_byte":true,"checkpoint_substitution":true,"checkpoint_truncation":true,"incorrect_schema_version":true,"label":true,"label_count":true,"lineage":true,"next_observation_component":true,"payload_byte":true,"reconstruction_component":true,"retrieval_key_component":true,"transition_graph_edge":true,"transition_support":true},"checkpoint_roundtrip":true,"lineage_invariants":{"deterministic_topology_reproduction":true,"lineage_uniqueness":true,"no_accidental_lineage_reuse":true,"parent_child_generation_increment":true,"repeated_descendant_splitting":true,"sibling_generation_equality":true},"unsupported_graph_edge_violations":0},"regime":"separated_state","schema":"ravel-raw-trial/0.5","seed":"0xd61698008d192310","trial_id":"validation-separated-01"},{"candidate":{"adaptation_completed":true,"adaptation_training":{"classification_checksum":"4c0d50485685100a","correct":512,"expert_evaluations":4096,"prediction_checksum":"a925e92a0252f6be","prediction_samples":472,"prediction_sse_q20":50487576469,"reconstruction_checksum":"d63a6440e7bb859e","reconstruction_sse_q20":46358579894,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":512,"samples":512,"transition_checksum":"1cabbf6276f15719","transition_correct":470,"transition_supported":472,"transition_unknown":40},"adaptation_training_evaluations":336384,"adapted_model_drift_holdout":{"classification_checksum":"f386b4b173774216","correct":256,"expert_evaluations":2048,"prediction_checksum":"2f7b5ed3a3ae2e56","prediction_samples":230,"prediction_sse_q20":24866650103,"reconstruction_checksum":"245a90036d53936f","reconstruction_sse_q20":23182765250,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"781ec0990af5e6bb","transition_correct":226,"transition_supported":230,"transition_unknown":26},"base_holdout":{"classification_checksum":"98f8a4a32762f255","correct":256,"expert_evaluations":2048,"prediction_checksum":"0186e2efcedb0cc8","prediction_samples":234,"prediction_sse_q20":25784001560,"reconstruction_checksum":"433695abe5da701f","reconstruction_sse_q20":23032145585,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"65fd3a2d2a521220","transition_correct":234,"transition_supported":234,"transition_unknown":22},"base_holdout_retention":{"classification_checksum":"9a480923947127e4","correct":256,"expert_evaluations":2048,"prediction_checksum":"62e3d95d8921a447","prediction_samples":233,"prediction_sse_q20":25253282425,"reconstruction_checksum":"d9f4303f629ae82c","reconstruction_sse_q20":22458300885,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"344324d0c1817453","transition_correct":231,"transition_supported":233,"transition_unknown":23},"base_training_evaluations":551216,"behavior_identity":"7f75efec4a9ff0db442e13b3d88fcee2f4426eed48348568324c789cd0ed83be","checkpoint_size_bytes":43784,"expert_count":65,"model_identity":"c17742afc3df0b6b8c1d6b331e42e5446d7827ccdd8c8c00a6f897f7e7360e93","planning":{"belief_set_target_reached":64,"cases":64,"checksum":"f5627364f87670f5","exact_world_state_target_reached":64,"executed_path_length":295,"expansions":1922,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":274,"path_found":64,"path_length_regret":21,"state_aliasing_failures":0,"transition_model_error_failures":0},"replay":{"actions_covered":4,"assigned_experts_covered":64,"high_loss_cases_selected":24,"labels_covered":8,"rare_cases_selected":47,"selected":256,"selection_checksum":"997dcef28eaa1091","states_covered":64,"transition_pairs_covered":247,"unique":256},"static_model_drift_holdout":{"classification_checksum":"f386b4b173774216","correct":256,"expert_evaluations":2048,"prediction_checksum":"2f7b5ed3a3ae2e56","prediction_samples":230,"prediction_sse_q20":24866650103,"reconstruction_checksum":"245a90036d53936f","reconstruction_sse_q20":23182765250,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"6ec5d1920eedb316","transition_correct":230,"transition_supported":230,"transition_unknown":26},"topology":{"accepted_births":1,"accepted_retirements":0,"births":[{"dominant_channel":2,"event_index":351,"normalized_score_q20":324203}],"objective_after_q20":915785,"objective_before_q20":915453,"rejected_births":15,"rejected_retirements":1,"retired_lineages":[],"training_observations":{"births":1,"certified":4608,"expert_evaluations":336384,"rejected_births":15,"rejected_retirements":1,"retired":0,"samples":4608}}},"checkpoint_format":{"byte_order":"big_endian","magic_hex":"524156454c303500","payload_digest":"sha256","real_encoding":"signed_q20_int64","schema_version":5,"transition_support_min":2,"transition_top_k":2},"comparisons":{"fixed_8_expert":{"checkpoint_size_bytes":11294,"drift_holdout":{"classification_checksum":"39797428817cc4a7","correct":60,"expert_evaluations":2048,"prediction_checksum":"776c32a57c8a9514","prediction_samples":256,"prediction_sse_q20":1987808379445,"reconstruction_checksum":"ea890c0cf5a59645","reconstruction_sse_q20":1771877118564,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"44bf4db2389c0f6b","transition_correct":115,"transition_supported":256,"transition_unknown":0},"expert_count":8,"planning":{"belief_set_target_reached":15,"cases":64,"checksum":"6fb0392fc2236940","exact_world_state_target_reached":2,"executed_path_length":95,"expansions":266,"goal_expert_reached":15,"graph_disconnection_failures":18,"no_supported_edge_failures":0,"optimal_path_length":274,"path_found":46,"path_length_regret":0,"state_aliasing_failures":13,"transition_model_error_failures":31},"retention_holdout":{"classification_checksum":"55f3771c35bb9aeb","correct":50,"expert_evaluations":2048,"prediction_checksum":"af2da7cd04731afe","prediction_samples":256,"prediction_sse_q20":1938054652897,"reconstruction_checksum":"78259828fc21f409","reconstruction_sse_q20":1703755132665,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"755ebe5076947fca","transition_correct":135,"transition_supported":256,"transition_unknown":0},"training_evaluations":94208},"fixed_topology_64_expert_routed":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"f8625a3b79535fa2","correct":256,"expert_evaluations":2048,"prediction_checksum":"2f7b5ed3a3ae2e56","prediction_samples":230,"prediction_sse_q20":24866650103,"reconstruction_checksum":"245a90036d53936f","reconstruction_sse_q20":23182765250,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"56a9f7f65b40227b","transition_correct":230,"transition_supported":230,"transition_unknown":26},"expert_count":64,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"4387bf81c9ccc219","exact_world_state_target_reached":64,"executed_path_length":295,"expansions":1922,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":274,"path_found":64,"path_length_regret":21,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"bc8f3389fc86d433","correct":256,"expert_evaluations":2048,"prediction_checksum":"62e3d95d8921a447","prediction_samples":233,"prediction_sse_q20":25253282425,"reconstruction_checksum":"d9f4303f629ae82c","reconstruction_sse_q20":22458300885,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"9e3aa2e588b9e7e2","transition_correct":233,"transition_supported":233,"transition_unknown":23},"training_evaluations":2588672},"flat_64_expert_complete_scan":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"f8625a3b79535fa2","correct":256,"expert_evaluations":16384,"prediction_checksum":"2f7b5ed3a3ae2e56","prediction_samples":230,"prediction_sse_q20":24866650103,"reconstruction_checksum":"245a90036d53936f","reconstruction_sse_q20":23182765250,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"56a9f7f65b40227b","transition_correct":230,"transition_supported":230,"transition_unknown":26},"expert_count":64,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"4387bf81c9ccc219","exact_world_state_target_reached":64,"executed_path_length":295,"expansions":1922,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":274,"path_found":64,"path_length_regret":21,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"bc8f3389fc86d433","correct":256,"expert_evaluations":16384,"prediction_checksum":"62e3d95d8921a447","prediction_samples":233,"prediction_sse_q20":25253282425,"reconstruction_checksum":"d9f4303f629ae82c","reconstruction_sse_q20":22458300885,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"9e3aa2e588b9e7e2","transition_correct":233,"transition_supported":233,"transition_unknown":23},"training_evaluations":2588672},"matched_compute_fixed_topology":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"f386b4b173774216","correct":256,"expert_evaluations":2048,"prediction_checksum":"2f7b5ed3a3ae2e56","prediction_samples":230,"prediction_sse_q20":24866650103,"reconstruction_checksum":"245a90036d53936f","reconstruction_sse_q20":23182765250,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"6ec5d1920eedb316","transition_correct":230,"transition_supported":230,"transition_unknown":26},"expert_count":64,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"f5627364f87670f5","exact_world_state_target_reached":64,"executed_path_length":295,"expansions":1922,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":274,"path_found":64,"path_length_regret":21,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"9a480923947127e4","correct":256,"expert_evaluations":2048,"prediction_checksum":"62e3d95d8921a447","prediction_samples":233,"prediction_sse_q20":25253282425,"reconstruction_checksum":"d9f4303f629ae82c","reconstruction_sse_q20":22458300885,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"d40a692481eee38e","transition_correct":233,"transition_supported":233,"transition_unknown":23},"training_evaluations":993584},"matched_expert_count_capacity":{"checkpoint_size_bytes":43784,"drift_holdout":{"classification_checksum":"a27e26829c94ce00","correct":256,"expert_evaluations":2048,"prediction_checksum":"32ffa4c6a9c2e01c","prediction_samples":229,"prediction_sse_q20":24766984897,"reconstruction_checksum":"58dfa591d9b9ab80","reconstruction_sse_q20":23149229534,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"d6b226c110df5ed7","transition_correct":229,"transition_supported":229,"transition_unknown":27},"expert_count":65,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"047e377277178b34","exact_world_state_target_reached":64,"executed_path_length":295,"expansions":1922,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":274,"path_found":64,"path_length_regret":21,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"6a8cd3689bdce902","correct":256,"expert_evaluations":2048,"prediction_checksum":"5bdf712925637dde","prediction_samples":232,"prediction_sse_q20":25158364448,"reconstruction_checksum":"34f7e3ce888f3c0c","reconstruction_sse_q20":22451072337,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"51998af0584b8f94","transition_correct":232,"transition_supported":232,"transition_unknown":24},"training_evaluations":2662400},"nearest_centroid_16_no_recursive_births":{"checkpoint_size_bytes":15854,"drift_holdout":{"classification_checksum":"aa6bf19cb739b1f4","correct":66,"expert_evaluations":4096,"prediction_checksum":"b0b0294f315a5ef9","prediction_samples":256,"prediction_sse_q20":1410396725882,"reconstruction_checksum":"872a92257fde4bf3","reconstruction_sse_q20":1125948509954,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"03b0900d8c7d65a2","transition_correct":153,"transition_supported":256,"transition_unknown":0},"expert_count":16,"planning":{"belief_set_target_reached":35,"cases":64,"checksum":"83f00a49735f9caa","exact_world_state_target_reached":9,"executed_path_length":159,"expansions":541,"goal_expert_reached":35,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":274,"path_found":64,"path_length_regret":2,"state_aliasing_failures":26,"transition_model_error_failures":29},"retention_holdout":{"classification_checksum":"e47327a5767a5a55","correct":63,"expert_evaluations":4096,"prediction_checksum":"828c465da8da08fd","prediction_samples":256,"prediction_sse_q20":1361160364746,"reconstruction_checksum":"9234e1534533eb34","reconstruction_sse_q20":1100269323999,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"665f240e40e9ebac","transition_correct":165,"transition_supported":256,"transition_unknown":0},"training_evaluations":253952},"no_adaptation_static":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"f386b4b173774216","correct":256,"expert_evaluations":2048,"prediction_checksum":"2f7b5ed3a3ae2e56","prediction_samples":230,"prediction_sse_q20":24866650103,"reconstruction_checksum":"245a90036d53936f","reconstruction_sse_q20":23182765250,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"6ec5d1920eedb316","transition_correct":230,"transition_supported":230,"transition_unknown":26},"expert_count":64,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"f5627364f87670f5","exact_world_state_target_reached":64,"executed_path_length":295,"expansions":1922,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":274,"path_found":64,"path_length_regret":21,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"9a480923947127e4","correct":256,"expert_evaluations":2048,"prediction_checksum":"62e3d95d8921a447","prediction_samples":233,"prediction_sse_q20":25253282425,"reconstruction_checksum":"d9f4303f629ae82c","reconstruction_sse_q20":22458300885,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"d40a692481eee38e","transition_correct":233,"transition_supported":233,"transition_unknown":23},"training_evaluations":551216},"periodic_replay_policy":{"checkpoint_size_bytes":43784,"drift_holdout":{"classification_checksum":"f386b4b173774216","correct":256,"expert_evaluations":2048,"prediction_checksum":"2f7b5ed3a3ae2e56","prediction_samples":230,"prediction_sse_q20":24866650103,"reconstruction_checksum":"245a90036d53936f","reconstruction_sse_q20":23182765250,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"781ec0990af5e6bb","transition_correct":226,"transition_supported":230,"transition_unknown":26},"expert_count":65,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"f5627364f87670f5","exact_world_state_target_reached":64,"executed_path_length":295,"expansions":1922,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":274,"path_found":64,"path_length_regret":21,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"9a480923947127e4","correct":256,"expert_evaluations":2048,"prediction_checksum":"62e3d95d8921a447","prediction_samples":233,"prediction_sse_q20":25253282425,"reconstruction_checksum":"d9f4303f629ae82c","reconstruction_sse_q20":22458300885,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"344324d0c1817453","transition_correct":231,"transition_supported":233,"transition_unknown":23},"training_evaluations":887600},"ravel_0_5_candidate":{"checkpoint_size_bytes":43784,"drift_holdout":{"classification_checksum":"f386b4b173774216","correct":256,"expert_evaluations":2048,"prediction_checksum":"2f7b5ed3a3ae2e56","prediction_samples":230,"prediction_sse_q20":24866650103,"reconstruction_checksum":"245a90036d53936f","reconstruction_sse_q20":23182765250,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"781ec0990af5e6bb","transition_correct":226,"transition_supported":230,"transition_unknown":26},"expert_count":65,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"f5627364f87670f5","exact_world_state_target_reached":64,"executed_path_length":295,"expansions":1922,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":274,"path_found":64,"path_length_regret":21,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"9a480923947127e4","correct":256,"expert_evaluations":2048,"prediction_checksum":"62e3d95d8921a447","prediction_samples":233,"prediction_sse_q20":25253282425,"reconstruction_checksum":"d9f4303f629ae82c","reconstruction_sse_q20":22458300885,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"344324d0c1817453","transition_correct":231,"transition_supported":233,"transition_unknown":23},"training_evaluations":887600},"ravel_complete_scan_without_certification":{"checkpoint_size_bytes":43784,"drift_holdout":{"classification_checksum":"f386b4b173774216","correct":256,"expert_evaluations":16640,"prediction_checksum":"2f7b5ed3a3ae2e56","prediction_samples":230,"prediction_sse_q20":24866650103,"reconstruction_checksum":"245a90036d53936f","reconstruction_sse_q20":23182765250,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"781ec0990af5e6bb","transition_correct":226,"transition_supported":230,"transition_unknown":26},"expert_count":65,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"f5627364f87670f5","exact_world_state_target_reached":64,"executed_path_length":295,"expansions":1922,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":274,"path_found":64,"path_length_regret":21,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"9a480923947127e4","correct":256,"expert_evaluations":16640,"prediction_checksum":"62e3d95d8921a447","prediction_samples":233,"prediction_sse_q20":25253282425,"reconstruction_checksum":"d9f4303f629ae82c","reconstruction_sse_q20":22458300885,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"344324d0c1817453","transition_correct":231,"transition_supported":233,"transition_unknown":23},"training_evaluations":1062704},"ravel_no_birth_same_replay_iterations":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"f386b4b173774216","correct":256,"expert_evaluations":2048,"prediction_checksum":"2f7b5ed3a3ae2e56","prediction_samples":230,"prediction_sse_q20":24866650103,"reconstruction_checksum":"245a90036d53936f","reconstruction_sse_q20":23182765250,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"6ec5d1920eedb316","transition_correct":230,"transition_supported":230,"transition_unknown":26},"expert_count":64,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"f5627364f87670f5","exact_world_state_target_reached":64,"executed_path_length":295,"expansions":1922,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":274,"path_found":64,"path_length_regret":21,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"9a480923947127e4","correct":256,"expert_evaluations":2048,"prediction_checksum":"62e3d95d8921a447","prediction_samples":233,"prediction_sse_q20":25253282425,"reconstruction_checksum":"d9f4303f629ae82c","reconstruction_sse_q20":22458300885,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"d40a692481eee38e","transition_correct":233,"transition_supported":233,"transition_unknown":23},"training_evaluations":772400},"ravel_random_births":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"f386b4b173774216","correct":256,"expert_evaluations":2048,"prediction_checksum":"2f7b5ed3a3ae2e56","prediction_samples":230,"prediction_sse_q20":24866650103,"reconstruction_checksum":"245a90036d53936f","reconstruction_sse_q20":23182765250,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"6ec5d1920eedb316","transition_correct":230,"transition_supported":230,"transition_unknown":26},"expert_count":64,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"f5627364f87670f5","exact_world_state_target_reached":64,"executed_path_length":295,"expansions":1922,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":274,"path_found":64,"path_length_regret":21,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"9a480923947127e4","correct":256,"expert_evaluations":2048,"prediction_checksum":"62e3d95d8921a447","prediction_samples":233,"prediction_sse_q20":25253282425,"reconstruction_checksum":"d9f4303f629ae82c","reconstruction_sse_q20":22458300885,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"d40a692481eee38e","transition_correct":233,"transition_supported":233,"transition_unknown":23},"training_evaluations":772400},"ravel_without_replay":{"checkpoint_size_bytes":44924,"drift_holdout":{"classification_checksum":"9604cc22af0b69f8","correct":256,"expert_evaluations":2048,"prediction_checksum":"34dc2b19259a4f64","prediction_samples":231,"prediction_sse_q20":25074006007,"reconstruction_checksum":"dc0f63d113d0c66c","reconstruction_sse_q20":23106741888,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"5b52728b2245f880","transition_correct":226,"transition_supported":231,"transition_unknown":25},"expert_count":67,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"88c52f34e0eaf903","exact_world_state_target_reached":64,"executed_path_length":297,"expansions":1964,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":274,"path_found":64,"path_length_regret":23,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"9a480923947127e4","correct":256,"expert_evaluations":2048,"prediction_checksum":"62e3d95d8921a447","prediction_samples":233,"prediction_sse_q20":25253282425,"reconstruction_checksum":"d9f4303f629ae82c","reconstruction_sse_q20":22458300885,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"61e6e5f0e4c8e8cc","transition_correct":229,"transition_supported":233,"transition_unknown":23},"training_evaluations":932144},"ravel_without_retirement_matched_work":{"checkpoint_size_bytes":43784,"drift_holdout":{"classification_checksum":"f386b4b173774216","correct":256,"expert_evaluations":2048,"prediction_checksum":"2f7b5ed3a3ae2e56","prediction_samples":230,"prediction_sse_q20":24866650103,"reconstruction_checksum":"245a90036d53936f","reconstruction_sse_q20":23182765250,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"781ec0990af5e6bb","transition_correct":226,"transition_supported":230,"transition_unknown":26},"expert_count":65,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"f5627364f87670f5","exact_world_state_target_reached":64,"executed_path_length":295,"expansions":1922,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":274,"path_found":64,"path_length_regret":21,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"9a480923947127e4","correct":256,"expert_evaluations":2048,"prediction_checksum":"62e3d95d8921a447","prediction_samples":233,"prediction_sse_q20":25253282425,"reconstruction_checksum":"d9f4303f629ae82c","reconstruction_sse_q20":22458300885,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"344324d0c1817453","transition_correct":231,"transition_supported":233,"transition_unknown":23},"training_evaluations":887600}},"dataset_seeds":{"base_holdout":"0xbe5ac42cfe386970","base_training":"0x7423acb4b3f33170","drift_adaptation_training":"0x935d39c1aa0c9d35","drift_holdout":"0x523433576fd6e4b3","original_task_retention_holdout":"0xac9db937b6d3bf4d","planning_cases":"0xef5b8b627f68ea07"},"dataset_sizes":{"base_holdout":256,"base_training":1024,"drift_adaptation_training":512,"drift_holdout":256,"original_task_retention_holdout":256,"planning_cases":64},"integrity":{"checkpoint_behavior_match":true,"checkpoint_identity_match":true,"checkpoint_mutations":{"anchored_status":true,"appended_unexpected_byte":true,"checkpoint_substitution":true,"checkpoint_truncation":true,"incorrect_schema_version":true,"label":true,"label_count":true,"lineage":true,"next_observation_component":true,"payload_byte":true,"reconstruction_component":true,"retrieval_key_component":true,"transition_graph_edge":true,"transition_support":true},"checkpoint_roundtrip":true,"lineage_invariants":{"deterministic_topology_reproduction":true,"lineage_uniqueness":true,"no_accidental_lineage_reuse":true,"parent_child_generation_increment":true,"repeated_descendant_splitting":true,"sibling_generation_equality":true},"unsupported_graph_edge_violations":0},"regime":"separated_state","schema":"ravel-raw-trial/0.5","seed":"0xaf704736a9144c08","trial_id":"validation-separated-02"},{"candidate":{"adaptation_completed":true,"adaptation_training":{"classification_checksum":"3f9affc42365e323","correct":512,"expert_evaluations":4096,"prediction_checksum":"719581f92f3a5056","prediction_samples":475,"prediction_sse_q20":66939250889,"reconstruction_checksum":"972fef24c672ba4c","reconstruction_sse_q20":56037295413,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":512,"samples":512,"transition_checksum":"6c0b2d2d691b2aa5","transition_correct":467,"transition_supported":475,"transition_unknown":37},"adaptation_training_evaluations":340992,"adapted_model_drift_holdout":{"classification_checksum":"25ba2a02dd81bf86","correct":256,"expert_evaluations":2048,"prediction_checksum":"b73961267bdd0a5b","prediction_samples":229,"prediction_sse_q20":35536255054,"reconstruction_checksum":"dbfa72c960c43d5f","reconstruction_sse_q20":31983847324,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"a0a5088923223461","transition_correct":222,"transition_supported":229,"transition_unknown":27},"base_holdout":{"classification_checksum":"ea581479d70d24f5","correct":248,"expert_evaluations":2048,"prediction_checksum":"51f205704ec8c49f","prediction_samples":236,"prediction_sse_q20":56645719429,"reconstruction_checksum":"3d072a45e4210496","reconstruction_sse_q20":52105270042,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"881df7e50f312879","transition_correct":233,"transition_supported":236,"transition_unknown":20},"base_holdout_retention":{"classification_checksum":"6c8f45362eb0b7f9","correct":256,"expert_evaluations":2048,"prediction_checksum":"55119f3ecf267653","prediction_samples":234,"prediction_sse_q20":29569851160,"reconstruction_checksum":"8bee113ffa07a7d9","reconstruction_sse_q20":27576149876,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"a040ed5abc8511cf","transition_correct":233,"transition_supported":234,"transition_unknown":22},"base_training_evaluations":556440,"behavior_identity":"937ffd16fb627f8baf2a2bb9770447af6af50393b789014096af5a7e1726707c","checkpoint_size_bytes":44354,"expert_count":66,"model_identity":"35f685a4fa14b1971fd3b8bf2c723f86290366d0c0951f2a8dbc9f4dbee554e5","planning":{"belief_set_target_reached":64,"cases":64,"checksum":"ff957f14ebd8fe34","exact_world_state_target_reached":64,"executed_path_length":334,"expansions":2118,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":282,"path_found":64,"path_length_regret":52,"state_aliasing_failures":0,"transition_model_error_failures":0},"replay":{"actions_covered":4,"assigned_experts_covered":63,"high_loss_cases_selected":21,"labels_covered":8,"rare_cases_selected":52,"selected":256,"selection_checksum":"3258c96452bf86b0","states_covered":64,"transition_pairs_covered":255,"unique":256},"static_model_drift_holdout":{"classification_checksum":"3962bf175d99472c","correct":248,"expert_evaluations":2048,"prediction_checksum":"0264705ccd4d8abd","prediction_samples":231,"prediction_sse_q20":66620942877,"reconstruction_checksum":"17b1545a2b3cbcac","reconstruction_sse_q20":61352999992,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"9cea13a4f0d8a22a","transition_correct":220,"transition_supported":231,"transition_unknown":25},"topology":{"accepted_births":2,"accepted_retirements":0,"births":[{"dominant_channel":0,"event_index":274,"normalized_score_q20":514224},{"dominant_channel":0,"event_index":278,"normalized_score_q20":480423}],"objective_after_q20":911409,"objective_before_q20":902494,"rejected_births":14,"rejected_retirements":1,"retired_lineages":[],"training_observations":{"births":2,"certified":4608,"expert_evaluations":340992,"rejected_births":14,"rejected_retirements":1,"retired":0,"samples":4608}}},"checkpoint_format":{"byte_order":"big_endian","magic_hex":"524156454c303500","payload_digest":"sha256","real_encoding":"signed_q20_int64","schema_version":5,"transition_support_min":2,"transition_top_k":2},"comparisons":{"fixed_8_expert":{"checkpoint_size_bytes":11294,"drift_holdout":{"classification_checksum":"f4f8909b0c1ae023","correct":63,"expert_evaluations":2048,"prediction_checksum":"b0c29017b9cdff74","prediction_samples":256,"prediction_sse_q20":2093206270984,"reconstruction_checksum":"b3522ef7759957be","reconstruction_sse_q20":1792191304224,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"02d0893a73b4563f","transition_correct":121,"transition_supported":256,"transition_unknown":0},"expert_count":8,"planning":{"belief_set_target_reached":17,"cases":64,"checksum":"a3cae90bb782a9cb","exact_world_state_target_reached":3,"executed_path_length":19,"expansions":142,"goal_expert_reached":17,"graph_disconnection_failures":44,"no_supported_edge_failures":0,"optimal_path_length":282,"path_found":20,"path_length_regret":0,"state_aliasing_failures":14,"transition_model_error_failures":3},"retention_holdout":{"classification_checksum":"78eba342c144860c","correct":65,"expert_evaluations":2048,"prediction_checksum":"9d74b28d9ad0c8c4","prediction_samples":256,"prediction_sse_q20":2073655364216,"reconstruction_checksum":"7fdd494fc6774bc9","reconstruction_sse_q20":1775261923326,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"3a25467970a9712c","transition_correct":114,"transition_supported":256,"transition_unknown":0},"training_evaluations":94208},"fixed_topology_64_expert_routed":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"3ccb53223067f68e","correct":256,"expert_evaluations":2048,"prediction_checksum":"3b55735240be45a4","prediction_samples":228,"prediction_sse_q20":25175165066,"reconstruction_checksum":"ae7ebb3503d3d563","reconstruction_sse_q20":23581844807,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"d353577fedacd137","transition_correct":228,"transition_supported":228,"transition_unknown":28},"expert_count":64,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"aef93289620b372d","exact_world_state_target_reached":64,"executed_path_length":330,"expansions":2093,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":282,"path_found":64,"path_length_regret":48,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"b2b52756f708a6b5","correct":256,"expert_evaluations":2048,"prediction_checksum":"cb08a1704cff427d","prediction_samples":238,"prediction_sse_q20":25084961697,"reconstruction_checksum":"b909c0364aaf7157","reconstruction_sse_q20":23259276817,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"9f011ba491e6a2eb","transition_correct":238,"transition_supported":238,"transition_unknown":18},"training_evaluations":2588672},"flat_64_expert_complete_scan":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"3ccb53223067f68e","correct":256,"expert_evaluations":16384,"prediction_checksum":"3b55735240be45a4","prediction_samples":228,"prediction_sse_q20":25175165066,"reconstruction_checksum":"ae7ebb3503d3d563","reconstruction_sse_q20":23581844807,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"d353577fedacd137","transition_correct":228,"transition_supported":228,"transition_unknown":28},"expert_count":64,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"aef93289620b372d","exact_world_state_target_reached":64,"executed_path_length":330,"expansions":2093,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":282,"path_found":64,"path_length_regret":48,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"b2b52756f708a6b5","correct":256,"expert_evaluations":16384,"prediction_checksum":"cb08a1704cff427d","prediction_samples":238,"prediction_sse_q20":25084961697,"reconstruction_checksum":"b909c0364aaf7157","reconstruction_sse_q20":23259276817,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"9f011ba491e6a2eb","transition_correct":238,"transition_supported":238,"transition_unknown":18},"training_evaluations":2588672},"matched_compute_fixed_topology":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"3962bf175d99472c","correct":248,"expert_evaluations":2048,"prediction_checksum":"0264705ccd4d8abd","prediction_samples":231,"prediction_sse_q20":66620942877,"reconstruction_checksum":"17b1545a2b3cbcac","reconstruction_sse_q20":61352999992,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"9cea13a4f0d8a22a","transition_correct":220,"transition_supported":231,"transition_unknown":25},"expert_count":64,"planning":{"belief_set_target_reached":51,"cases":64,"checksum":"51b85cfdd26e9d01","exact_world_state_target_reached":51,"executed_path_length":293,"expansions":1953,"goal_expert_reached":51,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":282,"path_found":64,"path_length_regret":42,"state_aliasing_failures":0,"transition_model_error_failures":13},"retention_holdout":{"classification_checksum":"5a98f7df8cdd2b5c","correct":251,"expert_evaluations":2048,"prediction_checksum":"8e2f08e1def5b473","prediction_samples":236,"prediction_sse_q20":49431631175,"reconstruction_checksum":"22291389def61387","reconstruction_sse_q20":46873849396,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"b3095b1072341a46","transition_correct":231,"transition_supported":236,"transition_unknown":20},"training_evaluations":998808},"matched_expert_count_capacity":{"checkpoint_size_bytes":44354,"drift_holdout":{"classification_checksum":"04b4d64a09d8a511","correct":256,"expert_evaluations":2048,"prediction_checksum":"08d53536e4dca84d","prediction_samples":223,"prediction_sse_q20":24773365012,"reconstruction_checksum":"89b8c97279cde432","reconstruction_sse_q20":23413355258,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"c4509099bc380814","transition_correct":217,"transition_supported":223,"transition_unknown":33},"expert_count":66,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"1f431293876fdd0a","exact_world_state_target_reached":64,"executed_path_length":330,"expansions":2135,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":282,"path_found":64,"path_length_regret":48,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"fe4ef5ca127f2cb3","correct":256,"expert_evaluations":2048,"prediction_checksum":"50823b2643513b15","prediction_samples":236,"prediction_sse_q20":24918629542,"reconstruction_checksum":"7957f2579ed6e7d7","reconstruction_sse_q20":23202693099,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"445a8eea5f423585","transition_correct":231,"transition_supported":236,"transition_unknown":20},"training_evaluations":2737152},"nearest_centroid_16_no_recursive_births":{"checkpoint_size_bytes":15854,"drift_holdout":{"classification_checksum":"b6d8f6a0ee7510be","correct":75,"expert_evaluations":4096,"prediction_checksum":"ab13c3c167070cbe","prediction_samples":256,"prediction_sse_q20":1415368198425,"reconstruction_checksum":"b3fe6bc5e776f4b4","reconstruction_sse_q20":1221492660414,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"5f2f5abfab994583","transition_correct":145,"transition_supported":256,"transition_unknown":0},"expert_count":16,"planning":{"belief_set_target_reached":29,"cases":64,"checksum":"6f45928653fe8638","exact_world_state_target_reached":8,"executed_path_length":122,"expansions":439,"goal_expert_reached":29,"graph_disconnection_failures":8,"no_supported_edge_failures":0,"optimal_path_length":282,"path_found":56,"path_length_regret":0,"state_aliasing_failures":21,"transition_model_error_failures":27},"retention_holdout":{"classification_checksum":"ccaa1a95a9919dcb","correct":76,"expert_evaluations":4096,"prediction_checksum":"2e0bfc101960a73a","prediction_samples":256,"prediction_sse_q20":1419705350208,"reconstruction_checksum":"919ee38c2d70266d","reconstruction_sse_q20":1248291678154,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"5f3d48d669db42cb","transition_correct":127,"transition_supported":256,"transition_unknown":0},"training_evaluations":253952},"no_adaptation_static":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"3962bf175d99472c","correct":248,"expert_evaluations":2048,"prediction_checksum":"0264705ccd4d8abd","prediction_samples":231,"prediction_sse_q20":66620942877,"reconstruction_checksum":"17b1545a2b3cbcac","reconstruction_sse_q20":61352999992,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"9cea13a4f0d8a22a","transition_correct":220,"transition_supported":231,"transition_unknown":25},"expert_count":64,"planning":{"belief_set_target_reached":51,"cases":64,"checksum":"51b85cfdd26e9d01","exact_world_state_target_reached":51,"executed_path_length":293,"expansions":1953,"goal_expert_reached":51,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":282,"path_found":64,"path_length_regret":42,"state_aliasing_failures":0,"transition_model_error_failures":13},"retention_holdout":{"classification_checksum":"5a98f7df8cdd2b5c","correct":251,"expert_evaluations":2048,"prediction_checksum":"8e2f08e1def5b473","prediction_samples":236,"prediction_sse_q20":49431631175,"reconstruction_checksum":"22291389def61387","reconstruction_sse_q20":46873849396,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"b3095b1072341a46","transition_correct":231,"transition_supported":236,"transition_unknown":20},"training_evaluations":556440},"periodic_replay_policy":{"checkpoint_size_bytes":44354,"drift_holdout":{"classification_checksum":"25ba2a02dd81bf86","correct":256,"expert_evaluations":2048,"prediction_checksum":"07deed0a6a85ed3b","prediction_samples":229,"prediction_sse_q20":35525777844,"reconstruction_checksum":"f2077a3f43fc657d","reconstruction_sse_q20":32009533057,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"a0a5088923223461","transition_correct":222,"transition_supported":229,"transition_unknown":27},"expert_count":66,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"ff957f14ebd8fe34","exact_world_state_target_reached":64,"executed_path_length":334,"expansions":2118,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":282,"path_found":64,"path_length_regret":52,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"6c8f45362eb0b7f9","correct":256,"expert_evaluations":2048,"prediction_checksum":"fb9b1a61268b7fb1","prediction_samples":234,"prediction_sse_q20":29673252400,"reconstruction_checksum":"7cf5926426c8f8d0","reconstruction_sse_q20":27569231004,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"a040ed5abc8511cf","transition_correct":233,"transition_supported":234,"transition_unknown":22},"training_evaluations":1009560},"ravel_0_5_candidate":{"checkpoint_size_bytes":44354,"drift_holdout":{"classification_checksum":"25ba2a02dd81bf86","correct":256,"expert_evaluations":2048,"prediction_checksum":"b73961267bdd0a5b","prediction_samples":229,"prediction_sse_q20":35536255054,"reconstruction_checksum":"dbfa72c960c43d5f","reconstruction_sse_q20":31983847324,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"a0a5088923223461","transition_correct":222,"transition_supported":229,"transition_unknown":27},"expert_count":66,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"ff957f14ebd8fe34","exact_world_state_target_reached":64,"executed_path_length":334,"expansions":2118,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":282,"path_found":64,"path_length_regret":52,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"6c8f45362eb0b7f9","correct":256,"expert_evaluations":2048,"prediction_checksum":"55119f3ecf267653","prediction_samples":234,"prediction_sse_q20":29569851160,"reconstruction_checksum":"8bee113ffa07a7d9","reconstruction_sse_q20":27576149876,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"a040ed5abc8511cf","transition_correct":233,"transition_supported":234,"transition_unknown":22},"training_evaluations":897432},"ravel_complete_scan_without_certification":{"checkpoint_size_bytes":44354,"drift_holdout":{"classification_checksum":"25ba2a02dd81bf86","correct":256,"expert_evaluations":16896,"prediction_checksum":"b73961267bdd0a5b","prediction_samples":229,"prediction_sse_q20":35536255054,"reconstruction_checksum":"dbfa72c960c43d5f","reconstruction_sse_q20":31983847324,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"a0a5088923223461","transition_correct":222,"transition_supported":229,"transition_unknown":27},"expert_count":66,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"ff957f14ebd8fe34","exact_world_state_target_reached":64,"executed_path_length":334,"expansions":2118,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":282,"path_found":64,"path_length_regret":52,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"6c8f45362eb0b7f9","correct":256,"expert_evaluations":16896,"prediction_checksum":"55119f3ecf267653","prediction_samples":234,"prediction_sse_q20":29569851160,"reconstruction_checksum":"8bee113ffa07a7d9","reconstruction_sse_q20":27576149876,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"a040ed5abc8511cf","transition_correct":233,"transition_supported":234,"transition_unknown":22},"training_evaluations":1075608},"ravel_no_birth_same_replay_iterations":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"3962bf175d99472c","correct":248,"expert_evaluations":2048,"prediction_checksum":"0264705ccd4d8abd","prediction_samples":231,"prediction_sse_q20":66620942877,"reconstruction_checksum":"17b1545a2b3cbcac","reconstruction_sse_q20":61352999992,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"9cea13a4f0d8a22a","transition_correct":220,"transition_supported":231,"transition_unknown":25},"expert_count":64,"planning":{"belief_set_target_reached":51,"cases":64,"checksum":"51b85cfdd26e9d01","exact_world_state_target_reached":51,"executed_path_length":293,"expansions":1953,"goal_expert_reached":51,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":282,"path_found":64,"path_length_regret":42,"state_aliasing_failures":0,"transition_model_error_failures":13},"retention_holdout":{"classification_checksum":"5a98f7df8cdd2b5c","correct":251,"expert_evaluations":2048,"prediction_checksum":"8e2f08e1def5b473","prediction_samples":236,"prediction_sse_q20":49431631175,"reconstruction_checksum":"22291389def61387","reconstruction_sse_q20":46873849396,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"b3095b1072341a46","transition_correct":231,"transition_supported":236,"transition_unknown":20},"training_evaluations":777624},"ravel_random_births":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"3962bf175d99472c","correct":248,"expert_evaluations":2048,"prediction_checksum":"0264705ccd4d8abd","prediction_samples":231,"prediction_sse_q20":66620942877,"reconstruction_checksum":"17b1545a2b3cbcac","reconstruction_sse_q20":61352999992,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"9cea13a4f0d8a22a","transition_correct":220,"transition_supported":231,"transition_unknown":25},"expert_count":64,"planning":{"belief_set_target_reached":51,"cases":64,"checksum":"51b85cfdd26e9d01","exact_world_state_target_reached":51,"executed_path_length":293,"expansions":1953,"goal_expert_reached":51,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":282,"path_found":64,"path_length_regret":42,"state_aliasing_failures":0,"transition_model_error_failures":13},"retention_holdout":{"classification_checksum":"5a98f7df8cdd2b5c","correct":251,"expert_evaluations":2048,"prediction_checksum":"8e2f08e1def5b473","prediction_samples":236,"prediction_sse_q20":49431631175,"reconstruction_checksum":"22291389def61387","reconstruction_sse_q20":46873849396,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"b3095b1072341a46","transition_correct":231,"transition_supported":236,"transition_unknown":20},"training_evaluations":777624},"ravel_without_replay":{"checkpoint_size_bytes":44354,"drift_holdout":{"classification_checksum":"25ba2a02dd81bf86","correct":256,"expert_evaluations":2048,"prediction_checksum":"7e07c797d0de658e","prediction_samples":229,"prediction_sse_q20":35539681570,"reconstruction_checksum":"f107278e5427d7e1","reconstruction_sse_q20":32159470670,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"a0a5088923223461","transition_correct":222,"transition_supported":229,"transition_unknown":27},"expert_count":66,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"ff957f14ebd8fe34","exact_world_state_target_reached":64,"executed_path_length":334,"expansions":2118,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":282,"path_found":64,"path_length_regret":52,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"6c8f45362eb0b7f9","correct":256,"expert_evaluations":2048,"prediction_checksum":"fb9b1a61268b7fb1","prediction_samples":234,"prediction_sse_q20":29673252400,"reconstruction_checksum":"d552688d30bd79a1","reconstruction_sse_q20":27607906837,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"a040ed5abc8511cf","transition_correct":233,"transition_supported":234,"transition_unknown":22},"training_evaluations":858520},"ravel_without_retirement_matched_work":{"checkpoint_size_bytes":44354,"drift_holdout":{"classification_checksum":"25ba2a02dd81bf86","correct":256,"expert_evaluations":2048,"prediction_checksum":"b73961267bdd0a5b","prediction_samples":229,"prediction_sse_q20":35536255054,"reconstruction_checksum":"dbfa72c960c43d5f","reconstruction_sse_q20":31983847324,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"a0a5088923223461","transition_correct":222,"transition_supported":229,"transition_unknown":27},"expert_count":66,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"ff957f14ebd8fe34","exact_world_state_target_reached":64,"executed_path_length":334,"expansions":2118,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":282,"path_found":64,"path_length_regret":52,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"6c8f45362eb0b7f9","correct":256,"expert_evaluations":2048,"prediction_checksum":"55119f3ecf267653","prediction_samples":234,"prediction_sse_q20":29569851160,"reconstruction_checksum":"8bee113ffa07a7d9","reconstruction_sse_q20":27576149876,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"a040ed5abc8511cf","transition_correct":233,"transition_supported":234,"transition_unknown":22},"training_evaluations":897432}},"dataset_seeds":{"base_holdout":"0xee4df5916f5ace67","base_training":"0x67baee3b8cdb916f","drift_adaptation_training":"0x61c8825d2abdbb7e","drift_holdout":"0x7fea3cb941b55b2b","original_task_retention_holdout":"0x7d14a6f1588d6760","planning_cases":"0x869f15fbfa0e01fd"},"dataset_sizes":{"base_holdout":256,"base_training":1024,"drift_adaptation_training":512,"drift_holdout":256,"original_task_retention_holdout":256,"planning_cases":64},"integrity":{"checkpoint_behavior_match":true,"checkpoint_identity_match":true,"checkpoint_mutations":{"anchored_status":true,"appended_unexpected_byte":true,"checkpoint_substitution":true,"checkpoint_truncation":true,"incorrect_schema_version":true,"label":true,"label_count":true,"lineage":true,"next_observation_component":true,"payload_byte":true,"reconstruction_component":true,"retrieval_key_component":true,"transition_graph_edge":true,"transition_support":true},"checkpoint_roundtrip":true,"lineage_invariants":{"deterministic_topology_reproduction":true,"lineage_uniqueness":true,"no_accidental_lineage_reuse":true,"parent_child_generation_increment":true,"repeated_descendant_splitting":true,"sibling_generation_equality":true},"unsupported_graph_edge_violations":0},"regime":"separated_state","schema":"ravel-raw-trial/0.5","seed":"0x45894249803b385a","trial_id":"validation-separated-03"},{"candidate":{"adaptation_completed":true,"adaptation_training":{"classification_checksum":"6cbd0b2e6e2a4743","correct":512,"expert_evaluations":4096,"prediction_checksum":"b07f73b7035e01d6","prediction_samples":465,"prediction_sse_q20":94191929903,"reconstruction_checksum":"109710837bd4c9e6","reconstruction_sse_q20":84011018713,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":512,"samples":512,"transition_checksum":"9eeaf4ea5e7f0cac","transition_correct":438,"transition_supported":465,"transition_unknown":47},"adaptation_training_evaluations":1059840,"adapted_model_drift_holdout":{"classification_checksum":"090649007d3dcaa7","correct":256,"expert_evaluations":2048,"prediction_checksum":"2d86da892e88437e","prediction_samples":229,"prediction_sse_q20":42772540753,"reconstruction_checksum":"351c79b81eb362b2","reconstruction_sse_q20":38211686567,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"822a13e56af2ce64","transition_correct":214,"transition_supported":229,"transition_unknown":27},"base_holdout":{"classification_checksum":"e475f150ee34cfc8","correct":233,"expert_evaluations":2048,"prediction_checksum":"a580f2a1a685a02c","prediction_samples":230,"prediction_sse_q20":128708072650,"reconstruction_checksum":"48bac7d092f1d419","reconstruction_sse_q20":128998380979,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"e5f0f5efe49a2d7d","transition_correct":202,"transition_supported":230,"transition_unknown":26},"base_holdout_retention":{"classification_checksum":"b40381d096df39e0","correct":256,"expert_evaluations":2048,"prediction_checksum":"6ae58115a2957a3e","prediction_samples":221,"prediction_sse_q20":55579819712,"reconstruction_checksum":"609a908a751a662d","reconstruction_sse_q20":47965197563,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"29b151b5151d3634","transition_correct":204,"transition_supported":221,"transition_unknown":35},"base_training_evaluations":554336,"behavior_identity":"9d3a70b24ac80f770227389e8eef7bf1b0a4f0b443ce86459d9b37916fdfda4c","checkpoint_size_bytes":47204,"expert_count":71,"model_identity":"4bdccadb4aa9c59d4f153451e6a387bc89192f64ca62936793f0365e3fb02f08","planning":{"belief_set_target_reached":59,"cases":64,"checksum":"59fee08789bed518","exact_world_state_target_reached":59,"executed_path_length":304,"expansions":2141,"goal_expert_reached":59,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":295,"path_found":64,"path_length_regret":12,"state_aliasing_failures":0,"transition_model_error_failures":5},"replay":{"actions_covered":4,"assigned_experts_covered":64,"high_loss_cases_selected":13,"labels_covered":8,"rare_cases_selected":53,"selected":256,"selection_checksum":"84bd9167493e998b","states_covered":64,"transition_pairs_covered":250,"unique":256},"static_model_drift_holdout":{"classification_checksum":"89948d59511995bf","correct":236,"expert_evaluations":2048,"prediction_checksum":"7d315b31c7e541f0","prediction_samples":232,"prediction_sse_q20":112453592569,"reconstruction_checksum":"ef508541a0a25a55","reconstruction_sse_q20":110556539797,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"5d20363f0615ce17","transition_correct":208,"transition_supported":232,"transition_unknown":24},"topology":{"accepted_births":7,"accepted_retirements":0,"births":[{"dominant_channel":0,"event_index":156,"normalized_score_q20":694832},{"dominant_channel":0,"event_index":457,"normalized_score_q20":511104},{"dominant_channel":0,"event_index":231,"normalized_score_q20":510825},{"dominant_channel":0,"event_index":189,"normalized_score_q20":509513},{"dominant_channel":0,"event_index":465,"normalized_score_q20":505777},{"dominant_channel":2,"event_index":431,"normalized_score_q20":433573},{"dominant_channel":2,"event_index":308,"normalized_score_q20":343611}],"objective_after_q20":904494,"objective_before_q20":870276,"rejected_births":9,"rejected_retirements":1,"retired_lineages":[],"training_observations":{"births":7,"certified":13824,"expert_evaluations":1059840,"rejected_births":9,"rejected_retirements":1,"retired":0,"samples":13824}}},"checkpoint_format":{"byte_order":"big_endian","magic_hex":"524156454c303500","payload_digest":"sha256","real_encoding":"signed_q20_int64","schema_version":5,"transition_support_min":2,"transition_top_k":2},"comparisons":{"fixed_8_expert":{"checkpoint_size_bytes":11294,"drift_holdout":{"classification_checksum":"1de8dd365b402d02","correct":70,"expert_evaluations":2048,"prediction_checksum":"59126a3785cfc622","prediction_samples":256,"prediction_sse_q20":2121435872918,"reconstruction_checksum":"dc018436584d3650","reconstruction_sse_q20":1866863363951,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"e5604886b54e1568","transition_correct":100,"transition_supported":256,"transition_unknown":0},"expert_count":8,"planning":{"belief_set_target_reached":25,"cases":64,"checksum":"4096fcd993dd1ca0","exact_world_state_target_reached":6,"executed_path_length":99,"expansions":269,"goal_expert_reached":25,"graph_disconnection_failures":12,"no_supported_edge_failures":0,"optimal_path_length":295,"path_found":52,"path_length_regret":2,"state_aliasing_failures":19,"transition_model_error_failures":27},"retention_holdout":{"classification_checksum":"e46514fa23ea4f38","correct":63,"expert_evaluations":2048,"prediction_checksum":"2be1c58e0dfcf128","prediction_samples":256,"prediction_sse_q20":2093292342224,"reconstruction_checksum":"658594606dea5fd6","reconstruction_sse_q20":1715535594662,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"11684631561af07e","transition_correct":109,"transition_supported":256,"transition_unknown":0},"training_evaluations":94208},"fixed_topology_64_expert_routed":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"4a040d6d3a4ec23c","correct":256,"expert_evaluations":2048,"prediction_checksum":"0212119837313723","prediction_samples":234,"prediction_sse_q20":24302719165,"reconstruction_checksum":"ee6421f87845b0f6","reconstruction_sse_q20":23606764888,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"40b27cfa99e8803c","transition_correct":234,"transition_supported":234,"transition_unknown":22},"expert_count":64,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"e6bf526da272c07c","exact_world_state_target_reached":64,"executed_path_length":305,"expansions":2113,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":295,"path_found":64,"path_length_regret":10,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"8f921c92b33acec7","correct":256,"expert_evaluations":2048,"prediction_checksum":"3104cc4c1e0bad4b","prediction_samples":230,"prediction_sse_q20":24765612872,"reconstruction_checksum":"738eb1d0b34e45ae","reconstruction_sse_q20":22390688249,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"f7013fff087cf671","transition_correct":230,"transition_supported":230,"transition_unknown":26},"training_evaluations":2588672},"flat_64_expert_complete_scan":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"4a040d6d3a4ec23c","correct":256,"expert_evaluations":16384,"prediction_checksum":"0212119837313723","prediction_samples":234,"prediction_sse_q20":24302719165,"reconstruction_checksum":"ee6421f87845b0f6","reconstruction_sse_q20":23606764888,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"40b27cfa99e8803c","transition_correct":234,"transition_supported":234,"transition_unknown":22},"expert_count":64,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"e6bf526da272c07c","exact_world_state_target_reached":64,"executed_path_length":305,"expansions":2113,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":295,"path_found":64,"path_length_regret":10,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"8f921c92b33acec7","correct":256,"expert_evaluations":16384,"prediction_checksum":"3104cc4c1e0bad4b","prediction_samples":230,"prediction_sse_q20":24765612872,"reconstruction_checksum":"738eb1d0b34e45ae","reconstruction_sse_q20":22390688249,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"f7013fff087cf671","transition_correct":230,"transition_supported":230,"transition_unknown":26},"training_evaluations":2588672},"matched_compute_fixed_topology":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"89948d59511995bf","correct":236,"expert_evaluations":2048,"prediction_checksum":"7d315b31c7e541f0","prediction_samples":232,"prediction_sse_q20":112453592569,"reconstruction_checksum":"ef508541a0a25a55","reconstruction_sse_q20":110556539797,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"5d20363f0615ce17","transition_correct":208,"transition_supported":232,"transition_unknown":24},"expert_count":64,"planning":{"belief_set_target_reached":33,"cases":64,"checksum":"6f979d7274aad1fa","exact_world_state_target_reached":32,"executed_path_length":273,"expansions":2107,"goal_expert_reached":33,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":295,"path_found":64,"path_length_regret":11,"state_aliasing_failures":1,"transition_model_error_failures":31},"retention_holdout":{"classification_checksum":"21739cd1c1a849b1","correct":240,"expert_evaluations":2048,"prediction_checksum":"10104087b27694d5","prediction_samples":228,"prediction_sse_q20":118258442363,"reconstruction_checksum":"47bb6acb854a4227","reconstruction_sse_q20":100869146888,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"f5ee93dafa06632b","transition_correct":201,"transition_supported":228,"transition_unknown":28},"training_evaluations":1660256},"matched_expert_count_capacity":{"checkpoint_size_bytes":47204,"drift_holdout":{"classification_checksum":"594cbf39b1b8341e","correct":256,"expert_evaluations":2048,"prediction_checksum":"86b5322e8b787579","prediction_samples":230,"prediction_sse_q20":24063426706,"reconstruction_checksum":"ee79073334d541a8","reconstruction_sse_q20":23525730307,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"9e0554e3183e92ab","transition_correct":217,"transition_supported":230,"transition_unknown":26},"expert_count":71,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"e727816a973784bc","exact_world_state_target_reached":64,"executed_path_length":311,"expansions":2233,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":295,"path_found":64,"path_length_regret":16,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"39b1d3838361a0c5","correct":256,"expert_evaluations":2048,"prediction_checksum":"8030e62b162820c7","prediction_samples":224,"prediction_sse_q20":24427526746,"reconstruction_checksum":"97931abb94cf942b","reconstruction_sse_q20":22320970783,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"cd86412d3db16cf0","transition_correct":215,"transition_supported":224,"transition_unknown":32},"training_evaluations":3126272},"nearest_centroid_16_no_recursive_births":{"checkpoint_size_bytes":15854,"drift_holdout":{"classification_checksum":"00451d8c6d4b6fad","correct":73,"expert_evaluations":4096,"prediction_checksum":"c7121a798538dc4a","prediction_samples":256,"prediction_sse_q20":1488785133487,"reconstruction_checksum":"eac8441e8d8c8506","reconstruction_sse_q20":1253652168556,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"1b6338ef622d8b99","transition_correct":122,"transition_supported":256,"transition_unknown":0},"expert_count":16,"planning":{"belief_set_target_reached":20,"cases":64,"checksum":"b31c3bcac3022ae0","exact_world_state_target_reached":5,"executed_path_length":148,"expansions":485,"goal_expert_reached":20,"graph_disconnection_failures":5,"no_supported_edge_failures":0,"optimal_path_length":295,"path_found":59,"path_length_regret":0,"state_aliasing_failures":15,"transition_model_error_failures":39},"retention_holdout":{"classification_checksum":"84ddbc164da2d031","correct":78,"expert_evaluations":4096,"prediction_checksum":"4adbf4b4d956da4d","prediction_samples":256,"prediction_sse_q20":1450412156728,"reconstruction_checksum":"adba4cb5f102362b","reconstruction_sse_q20":1165974688589,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"2026971d7cc16731","transition_correct":128,"transition_supported":256,"transition_unknown":0},"training_evaluations":253952},"no_adaptation_static":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"89948d59511995bf","correct":236,"expert_evaluations":2048,"prediction_checksum":"7d315b31c7e541f0","prediction_samples":232,"prediction_sse_q20":112453592569,"reconstruction_checksum":"ef508541a0a25a55","reconstruction_sse_q20":110556539797,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"5d20363f0615ce17","transition_correct":208,"transition_supported":232,"transition_unknown":24},"expert_count":64,"planning":{"belief_set_target_reached":33,"cases":64,"checksum":"6f979d7274aad1fa","exact_world_state_target_reached":32,"executed_path_length":273,"expansions":2107,"goal_expert_reached":33,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":295,"path_found":64,"path_length_regret":11,"state_aliasing_failures":1,"transition_model_error_failures":31},"retention_holdout":{"classification_checksum":"21739cd1c1a849b1","correct":240,"expert_evaluations":2048,"prediction_checksum":"10104087b27694d5","prediction_samples":228,"prediction_sse_q20":118258442363,"reconstruction_checksum":"47bb6acb854a4227","reconstruction_sse_q20":100869146888,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"f5ee93dafa06632b","transition_correct":201,"transition_supported":228,"transition_unknown":28},"training_evaluations":554336},"periodic_replay_policy":{"checkpoint_size_bytes":47774,"drift_holdout":{"classification_checksum":"090649007d3dcaa7","correct":256,"expert_evaluations":2048,"prediction_checksum":"0c47bce1e40e4ed5","prediction_samples":227,"prediction_sse_q20":42432504735,"reconstruction_checksum":"a50e1f072ca2f312","reconstruction_sse_q20":38296703781,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"cc84b4d754a591fc","transition_correct":212,"transition_supported":227,"transition_unknown":29},"expert_count":72,"planning":{"belief_set_target_reached":59,"cases":64,"checksum":"59fee08789bed518","exact_world_state_target_reached":59,"executed_path_length":304,"expansions":2153,"goal_expert_reached":59,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":295,"path_found":64,"path_length_regret":12,"state_aliasing_failures":0,"transition_model_error_failures":5},"retention_holdout":{"classification_checksum":"66a64f011d86e54a","correct":256,"expert_evaluations":2048,"prediction_checksum":"f45f45469a2c0823","prediction_samples":222,"prediction_sse_q20":55564137189,"reconstruction_checksum":"215353bf975c5914","reconstruction_sse_q20":48016385027,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"886922498c858fdc","transition_correct":206,"transition_supported":222,"transition_unknown":34},"training_evaluations":1867616},"ravel_0_5_candidate":{"checkpoint_size_bytes":47204,"drift_holdout":{"classification_checksum":"090649007d3dcaa7","correct":256,"expert_evaluations":2048,"prediction_checksum":"2d86da892e88437e","prediction_samples":229,"prediction_sse_q20":42772540753,"reconstruction_checksum":"351c79b81eb362b2","reconstruction_sse_q20":38211686567,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"822a13e56af2ce64","transition_correct":214,"transition_supported":229,"transition_unknown":27},"expert_count":71,"planning":{"belief_set_target_reached":59,"cases":64,"checksum":"59fee08789bed518","exact_world_state_target_reached":59,"executed_path_length":304,"expansions":2141,"goal_expert_reached":59,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":295,"path_found":64,"path_length_regret":12,"state_aliasing_failures":0,"transition_model_error_failures":5},"retention_holdout":{"classification_checksum":"b40381d096df39e0","correct":256,"expert_evaluations":2048,"prediction_checksum":"6ae58115a2957a3e","prediction_samples":221,"prediction_sse_q20":55579819712,"reconstruction_checksum":"609a908a751a662d","reconstruction_sse_q20":47965197563,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"29b151b5151d3634","transition_correct":204,"transition_supported":221,"transition_unknown":35},"training_evaluations":1614176},"ravel_complete_scan_without_certification":{"checkpoint_size_bytes":47204,"drift_holdout":{"classification_checksum":"090649007d3dcaa7","correct":256,"expert_evaluations":18176,"prediction_checksum":"2d86da892e88437e","prediction_samples":229,"prediction_sse_q20":42772540753,"reconstruction_checksum":"351c79b81eb362b2","reconstruction_sse_q20":38211686567,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"822a13e56af2ce64","transition_correct":214,"transition_supported":229,"transition_unknown":27},"expert_count":71,"planning":{"belief_set_target_reached":59,"cases":64,"checksum":"59fee08789bed518","exact_world_state_target_reached":59,"executed_path_length":304,"expansions":2141,"goal_expert_reached":59,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":295,"path_found":64,"path_length_regret":12,"state_aliasing_failures":0,"transition_model_error_failures":5},"retention_holdout":{"classification_checksum":"b40381d096df39e0","correct":256,"expert_evaluations":18176,"prediction_checksum":"6ae58115a2957a3e","prediction_samples":221,"prediction_sse_q20":55579819712,"reconstruction_checksum":"609a908a751a662d","reconstruction_sse_q20":47965197563,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"29b151b5151d3634","transition_correct":204,"transition_supported":221,"transition_unknown":35},"training_evaluations":1807712},"ravel_no_birth_same_replay_iterations":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"89948d59511995bf","correct":236,"expert_evaluations":2048,"prediction_checksum":"7d315b31c7e541f0","prediction_samples":232,"prediction_sse_q20":112453592569,"reconstruction_checksum":"ef508541a0a25a55","reconstruction_sse_q20":110556539797,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"5d20363f0615ce17","transition_correct":208,"transition_supported":232,"transition_unknown":24},"expert_count":64,"planning":{"belief_set_target_reached":33,"cases":64,"checksum":"6f979d7274aad1fa","exact_world_state_target_reached":32,"executed_path_length":273,"expansions":2107,"goal_expert_reached":33,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":295,"path_found":64,"path_length_regret":11,"state_aliasing_failures":1,"transition_model_error_failures":31},"retention_holdout":{"classification_checksum":"21739cd1c1a849b1","correct":240,"expert_evaluations":2048,"prediction_checksum":"10104087b27694d5","prediction_samples":228,"prediction_sse_q20":118258442363,"reconstruction_checksum":"47bb6acb854a4227","reconstruction_sse_q20":100869146888,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"f5ee93dafa06632b","transition_correct":201,"transition_supported":228,"transition_unknown":28},"training_evaluations":775520},"ravel_random_births":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"89948d59511995bf","correct":236,"expert_evaluations":2048,"prediction_checksum":"7d315b31c7e541f0","prediction_samples":232,"prediction_sse_q20":112453592569,"reconstruction_checksum":"ef508541a0a25a55","reconstruction_sse_q20":110556539797,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"5d20363f0615ce17","transition_correct":208,"transition_supported":232,"transition_unknown":24},"expert_count":64,"planning":{"belief_set_target_reached":33,"cases":64,"checksum":"6f979d7274aad1fa","exact_world_state_target_reached":32,"executed_path_length":273,"expansions":2107,"goal_expert_reached":33,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":295,"path_found":64,"path_length_regret":11,"state_aliasing_failures":1,"transition_model_error_failures":31},"retention_holdout":{"classification_checksum":"21739cd1c1a849b1","correct":240,"expert_evaluations":2048,"prediction_checksum":"10104087b27694d5","prediction_samples":228,"prediction_sse_q20":118258442363,"reconstruction_checksum":"47bb6acb854a4227","reconstruction_sse_q20":100869146888,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"f5ee93dafa06632b","transition_correct":201,"transition_supported":228,"transition_unknown":28},"training_evaluations":775520},"ravel_without_replay":{"checkpoint_size_bytes":47774,"drift_holdout":{"classification_checksum":"090649007d3dcaa7","correct":256,"expert_evaluations":2048,"prediction_checksum":"b10ef608b8906fda","prediction_samples":221,"prediction_sse_q20":41945413236,"reconstruction_checksum":"9c6cc9668317aecb","reconstruction_sse_q20":38351366716,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"adbcfbbf259a4e85","transition_correct":207,"transition_supported":221,"transition_unknown":35},"expert_count":72,"planning":{"belief_set_target_reached":59,"cases":64,"checksum":"c7224d0b0222d423","exact_world_state_target_reached":59,"executed_path_length":308,"expansions":2126,"goal_expert_reached":59,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":295,"path_found":64,"path_length_regret":16,"state_aliasing_failures":0,"transition_model_error_failures":5},"retention_holdout":{"classification_checksum":"b40381d096df39e0","correct":256,"expert_evaluations":2048,"prediction_checksum":"3a57f7bd903df6ab","prediction_samples":219,"prediction_sse_q20":55254811247,"reconstruction_checksum":"043a0e6122e7cee8","reconstruction_sse_q20":48070964801,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"be0e6bfe3d6171df","transition_correct":204,"transition_supported":219,"transition_unknown":37},"training_evaluations":1344864},"ravel_without_retirement_matched_work":{"checkpoint_size_bytes":47204,"drift_holdout":{"classification_checksum":"090649007d3dcaa7","correct":256,"expert_evaluations":2048,"prediction_checksum":"2d86da892e88437e","prediction_samples":229,"prediction_sse_q20":42772540753,"reconstruction_checksum":"351c79b81eb362b2","reconstruction_sse_q20":38211686567,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"822a13e56af2ce64","transition_correct":214,"transition_supported":229,"transition_unknown":27},"expert_count":71,"planning":{"belief_set_target_reached":59,"cases":64,"checksum":"59fee08789bed518","exact_world_state_target_reached":59,"executed_path_length":304,"expansions":2141,"goal_expert_reached":59,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":295,"path_found":64,"path_length_regret":12,"state_aliasing_failures":0,"transition_model_error_failures":5},"retention_holdout":{"classification_checksum":"b40381d096df39e0","correct":256,"expert_evaluations":2048,"prediction_checksum":"6ae58115a2957a3e","prediction_samples":221,"prediction_sse_q20":55579819712,"reconstruction_checksum":"609a908a751a662d","reconstruction_sse_q20":47965197563,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"29b151b5151d3634","transition_correct":204,"transition_supported":221,"transition_unknown":35},"training_evaluations":1614176}},"dataset_seeds":{"base_holdout":"0x2ae5e28925f2e956","base_training":"0x00da2ba73963c488","drift_adaptation_training":"0x19f5baaaa2c543cd","drift_holdout":"0xdd324acf6f99fc15","original_task_retention_holdout":"0x02b7bbd7237bf4cb","planning_cases":"0x0c94b3dcdb2cb64d"},"dataset_sizes":{"base_holdout":256,"base_training":1024,"drift_adaptation_training":512,"drift_holdout":256,"original_task_retention_holdout":256,"planning_cases":64},"integrity":{"checkpoint_behavior_match":true,"checkpoint_identity_match":true,"checkpoint_mutations":{"anchored_status":true,"appended_unexpected_byte":true,"checkpoint_substitution":true,"checkpoint_truncation":true,"incorrect_schema_version":true,"label":true,"label_count":true,"lineage":true,"next_observation_component":true,"payload_byte":true,"reconstruction_component":true,"retrieval_key_component":true,"transition_graph_edge":true,"transition_support":true},"checkpoint_roundtrip":true,"lineage_invariants":{"deterministic_topology_reproduction":true,"lineage_uniqueness":true,"no_accidental_lineage_reuse":true,"parent_child_generation_increment":true,"repeated_descendant_splitting":true,"sibling_generation_equality":true},"unsupported_graph_edge_violations":0},"regime":"separated_state","schema":"ravel-raw-trial/0.5","seed":"0x6b14192d06857894","trial_id":"validation-separated-04"},{"candidate":{"adaptation_completed":true,"adaptation_training":{"classification_checksum":"2829748c26b522f0","correct":512,"expert_evaluations":5230,"prediction_checksum":"5b9c530b7419b0d6","prediction_samples":487,"prediction_sse_q20":108857885339,"reconstruction_checksum":"087d329259160bab","reconstruction_sse_q20":93234927940,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":494,"samples":512,"transition_checksum":"35f6dd5b6475555c","transition_correct":460,"transition_supported":487,"transition_unknown":25},"adaptation_training_evaluations":1097800,"adapted_model_drift_holdout":{"classification_checksum":"408b6d4f8775f976","correct":256,"expert_evaluations":2741,"prediction_checksum":"5a677ce50f3996f8","prediction_samples":234,"prediction_sse_q20":60273692687,"reconstruction_checksum":"10a3d782ffa01f1a","reconstruction_sse_q20":51437496539,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":245,"samples":256,"transition_checksum":"8184031bd3013780","transition_correct":221,"transition_supported":234,"transition_unknown":22},"base_holdout":{"classification_checksum":"016933dc2f9ca9bb","correct":242,"expert_evaluations":3112,"prediction_checksum":"ee4835e1b5ed2c24","prediction_samples":239,"prediction_sse_q20":68871126435,"reconstruction_checksum":"5b7d68e289b4fd27","reconstruction_sse_q20":62804528971,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":237,"samples":256,"transition_checksum":"16558f298970fec8","transition_correct":225,"transition_supported":239,"transition_unknown":17},"base_holdout_retention":{"classification_checksum":"7c175ab030ec453a","correct":256,"expert_evaluations":2489,"prediction_checksum":"e96daf3db60a17f6","prediction_samples":234,"prediction_sse_q20":56886638569,"reconstruction_checksum":"6c5c03316e32ffb6","reconstruction_sse_q20":47038859799,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":249,"samples":256,"transition_checksum":"3a7607c9b1295788","transition_correct":226,"transition_supported":234,"transition_unknown":22},"base_training_evaluations":623528,"behavior_identity":"dceb300dd13fc29b55965af9e4f8096180b8e672d48355aa986e5cea4592fd19","checkpoint_size_bytes":47204,"expert_count":71,"model_identity":"c178927f8abdf322f8d0223e7739b92cfa5182147dcc84ad39b91fe78de2aac8","planning":{"belief_set_target_reached":64,"cases":64,"checksum":"1c5fd022e7f437f5","exact_world_state_target_reached":64,"executed_path_length":307,"expansions":2099,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":281,"path_found":64,"path_length_regret":26,"state_aliasing_failures":0,"transition_model_error_failures":0},"replay":{"actions_covered":4,"assigned_experts_covered":64,"high_loss_cases_selected":12,"labels_covered":8,"rare_cases_selected":51,"selected":256,"selection_checksum":"83d37ff9361ce68c","states_covered":64,"transition_pairs_covered":247,"unique":256},"static_model_drift_holdout":{"classification_checksum":"cb2dd42455d0e182","correct":241,"expert_evaluations":3504,"prediction_checksum":"b7b9be380404552d","prediction_samples":239,"prediction_sse_q20":83126358915,"reconstruction_checksum":"ece03a62b01a8ccc","reconstruction_sse_q20":64253780802,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":230,"samples":256,"transition_checksum":"060c17eec275e7fe","transition_correct":217,"transition_supported":239,"transition_unknown":17},"topology":{"accepted_births":7,"accepted_retirements":0,"births":[{"dominant_channel":0,"event_index":200,"normalized_score_q20":522490},{"dominant_channel":0,"event_index":367,"normalized_score_q20":506897},{"dominant_channel":0,"event_index":443,"normalized_score_q20":503719},{"dominant_channel":0,"event_index":444,"normalized_score_q20":436339},{"dominant_channel":2,"event_index":402,"normalized_score_q20":359880},{"dominant_channel":2,"event_index":123,"normalized_score_q20":336488},{"dominant_channel":2,"event_index":206,"normalized_score_q20":318959}],"objective_after_q20":908451,"objective_before_q20":891357,"rejected_births":9,"rejected_retirements":1,"retired_lineages":[],"training_observations":{"births":7,"certified":13192,"expert_evaluations":1097800,"rejected_births":9,"rejected_retirements":1,"retired":0,"samples":13824}}},"checkpoint_format":{"byte_order":"big_endian","magic_hex":"524156454c303500","payload_digest":"sha256","real_encoding":"signed_q20_int64","schema_version":5,"transition_support_min":2,"transition_top_k":2},"comparisons":{"fixed_8_expert":{"checkpoint_size_bytes":11294,"drift_holdout":{"classification_checksum":"53eba8c2432f0631","correct":45,"expert_evaluations":2048,"prediction_checksum":"b033b49f6c18d838","prediction_samples":256,"prediction_sse_q20":656881323222,"reconstruction_checksum":"fe8c0b6c175aeb25","reconstruction_sse_q20":569588060407,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"8c85f90ba9817fd3","transition_correct":169,"transition_supported":256,"transition_unknown":0},"expert_count":8,"planning":{"belief_set_target_reached":39,"cases":64,"checksum":"6ff6b613f984527e","exact_world_state_target_reached":2,"executed_path_length":113,"expansions":283,"goal_expert_reached":39,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":281,"path_found":64,"path_length_regret":0,"state_aliasing_failures":37,"transition_model_error_failures":25},"retention_holdout":{"classification_checksum":"e13d4b00cfd12764","correct":35,"expert_evaluations":2048,"prediction_checksum":"13e350967c9eb850","prediction_samples":256,"prediction_sse_q20":640924327368,"reconstruction_checksum":"9a0a4602934c0483","reconstruction_sse_q20":556491720086,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"cb4458b39c03f29f","transition_correct":175,"transition_supported":256,"transition_unknown":0},"training_evaluations":94208},"fixed_topology_64_expert_routed":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"3ea86237bcf051ca","correct":256,"expert_evaluations":2048,"prediction_checksum":"fb74ae0e7853df97","prediction_samples":234,"prediction_sse_q20":45043076544,"reconstruction_checksum":"9b2bd9d78632c6f0","reconstruction_sse_q20":42564663857,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"1e7072f50e5ded30","transition_correct":234,"transition_supported":234,"transition_unknown":22},"expert_count":64,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"3c75b95da4e6cd42","exact_world_state_target_reached":64,"executed_path_length":301,"expansions":2014,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":281,"path_found":64,"path_length_regret":20,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"2b7d78b0f1493316","correct":256,"expert_evaluations":2048,"prediction_checksum":"4ecbe19f91cabad3","prediction_samples":236,"prediction_sse_q20":48876641452,"reconstruction_checksum":"8e377391cb5a7403","reconstruction_sse_q20":41819020967,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"39f2b8943b5a65c9","transition_correct":236,"transition_supported":236,"transition_unknown":20},"training_evaluations":2588672},"flat_64_expert_complete_scan":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"3ea86237bcf051ca","correct":256,"expert_evaluations":16384,"prediction_checksum":"fb74ae0e7853df97","prediction_samples":234,"prediction_sse_q20":45043076544,"reconstruction_checksum":"9b2bd9d78632c6f0","reconstruction_sse_q20":42564663857,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"1e7072f50e5ded30","transition_correct":234,"transition_supported":234,"transition_unknown":22},"expert_count":64,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"3c75b95da4e6cd42","exact_world_state_target_reached":64,"executed_path_length":301,"expansions":2014,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":281,"path_found":64,"path_length_regret":20,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"2b7d78b0f1493316","correct":256,"expert_evaluations":16384,"prediction_checksum":"4ecbe19f91cabad3","prediction_samples":236,"prediction_sse_q20":48876641452,"reconstruction_checksum":"8e377391cb5a7403","reconstruction_sse_q20":41819020967,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"39f2b8943b5a65c9","transition_correct":236,"transition_supported":236,"transition_unknown":20},"training_evaluations":2588672},"matched_compute_fixed_topology":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"cb2dd42455d0e182","correct":241,"expert_evaluations":3504,"prediction_checksum":"b7b9be380404552d","prediction_samples":239,"prediction_sse_q20":83126358915,"reconstruction_checksum":"ece03a62b01a8ccc","reconstruction_sse_q20":64253780802,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":230,"samples":256,"transition_checksum":"060c17eec275e7fe","transition_correct":217,"transition_supported":239,"transition_unknown":17},"expert_count":64,"planning":{"belief_set_target_reached":44,"cases":64,"checksum":"b20a315f53df8df4","exact_world_state_target_reached":42,"executed_path_length":274,"expansions":1933,"goal_expert_reached":44,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":281,"path_found":64,"path_length_regret":9,"state_aliasing_failures":2,"transition_model_error_failures":20},"retention_holdout":{"classification_checksum":"d80287bcdc8870a8","correct":239,"expert_evaluations":3336,"prediction_checksum":"ef381d30408b5f04","prediction_samples":240,"prediction_sse_q20":85615136117,"reconstruction_checksum":"2b1e08aaca6df462","reconstruction_sse_q20":59088350933,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":233,"samples":256,"transition_checksum":"3c3b753962e18414","transition_correct":219,"transition_supported":240,"transition_unknown":16},"training_evaluations":1805608},"matched_expert_count_capacity":{"checkpoint_size_bytes":47204,"drift_holdout":{"classification_checksum":"a8ed49c81576cf16","correct":256,"expert_evaluations":2048,"prediction_checksum":"270c0a1240f3f283","prediction_samples":230,"prediction_sse_q20":44982535704,"reconstruction_checksum":"7abf539fb5a20857","reconstruction_sse_q20":42572929897,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"df51ddc0fd574202","transition_correct":221,"transition_supported":230,"transition_unknown":26},"expert_count":71,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"a78811f6a9100773","exact_world_state_target_reached":64,"executed_path_length":314,"expansions":2150,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":281,"path_found":64,"path_length_regret":33,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"b91ddd9eead70300","correct":256,"expert_evaluations":2048,"prediction_checksum":"d65e641e3a7c1e31","prediction_samples":228,"prediction_sse_q20":47346565664,"reconstruction_checksum":"434c3ef1c2cbc6ab","reconstruction_sse_q20":41320125698,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"862318c996fc4883","transition_correct":220,"transition_supported":228,"transition_unknown":28},"training_evaluations":3126272},"nearest_centroid_16_no_recursive_births":{"checkpoint_size_bytes":15854,"drift_holdout":{"classification_checksum":"d78fde3d7ba9e931","correct":73,"expert_evaluations":4096,"prediction_checksum":"b792c05dba9f9443","prediction_samples":256,"prediction_sse_q20":312669713941,"reconstruction_checksum":"de0f419d13865245","reconstruction_sse_q20":301951627834,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"fc8a519126f2dfe8","transition_correct":256,"transition_supported":256,"transition_unknown":0},"expert_count":16,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"4420e84cfc147164","exact_world_state_target_reached":20,"executed_path_length":157,"expansions":547,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":281,"path_found":64,"path_length_regret":0,"state_aliasing_failures":44,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"5a722dcde561244f","correct":57,"expert_evaluations":4096,"prediction_checksum":"50f970ee39cc7a1e","prediction_samples":256,"prediction_sse_q20":321139091469,"reconstruction_checksum":"6fb653097ed5707f","reconstruction_sse_q20":298394143941,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"cc6c6fd89ca7f067","transition_correct":256,"transition_supported":256,"transition_unknown":0},"training_evaluations":253952},"no_adaptation_static":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"cb2dd42455d0e182","correct":241,"expert_evaluations":3504,"prediction_checksum":"b7b9be380404552d","prediction_samples":239,"prediction_sse_q20":83126358915,"reconstruction_checksum":"ece03a62b01a8ccc","reconstruction_sse_q20":64253780802,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":230,"samples":256,"transition_checksum":"060c17eec275e7fe","transition_correct":217,"transition_supported":239,"transition_unknown":17},"expert_count":64,"planning":{"belief_set_target_reached":44,"cases":64,"checksum":"b20a315f53df8df4","exact_world_state_target_reached":42,"executed_path_length":274,"expansions":1933,"goal_expert_reached":44,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":281,"path_found":64,"path_length_regret":9,"state_aliasing_failures":2,"transition_model_error_failures":20},"retention_holdout":{"classification_checksum":"d80287bcdc8870a8","correct":239,"expert_evaluations":3336,"prediction_checksum":"ef381d30408b5f04","prediction_samples":240,"prediction_sse_q20":85615136117,"reconstruction_checksum":"2b1e08aaca6df462","reconstruction_sse_q20":59088350933,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":233,"samples":256,"transition_checksum":"3c3b753962e18414","transition_correct":219,"transition_supported":240,"transition_unknown":16},"training_evaluations":623528},"periodic_replay_policy":{"checkpoint_size_bytes":47204,"drift_holdout":{"classification_checksum":"408b6d4f8775f976","correct":256,"expert_evaluations":2741,"prediction_checksum":"340e82a4bdc49a4c","prediction_samples":233,"prediction_sse_q20":60048312773,"reconstruction_checksum":"c70e9c659a9da0cd","reconstruction_sse_q20":51335907430,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":245,"samples":256,"transition_checksum":"c0fb1d38776785d7","transition_correct":220,"transition_supported":233,"transition_unknown":23},"expert_count":71,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"1c5fd022e7f437f5","exact_world_state_target_reached":64,"executed_path_length":307,"expansions":2111,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":281,"path_found":64,"path_length_regret":26,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"7c175ab030ec453a","correct":256,"expert_evaluations":2489,"prediction_checksum":"85e8c6cc20b9ee29","prediction_samples":234,"prediction_sse_q20":56892027091,"reconstruction_checksum":"660a1b94ca9250b1","reconstruction_sse_q20":47161166025,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":249,"samples":256,"transition_checksum":"505eac7d12dc7ea3","transition_correct":225,"transition_supported":234,"transition_unknown":22},"training_evaluations":1719610},"ravel_0_5_candidate":{"checkpoint_size_bytes":47204,"drift_holdout":{"classification_checksum":"408b6d4f8775f976","correct":256,"expert_evaluations":2741,"prediction_checksum":"5a677ce50f3996f8","prediction_samples":234,"prediction_sse_q20":60273692687,"reconstruction_checksum":"10a3d782ffa01f1a","reconstruction_sse_q20":51437496539,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":245,"samples":256,"transition_checksum":"8184031bd3013780","transition_correct":221,"transition_supported":234,"transition_unknown":22},"expert_count":71,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"1c5fd022e7f437f5","exact_world_state_target_reached":64,"executed_path_length":307,"expansions":2099,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":281,"path_found":64,"path_length_regret":26,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"7c175ab030ec453a","correct":256,"expert_evaluations":2489,"prediction_checksum":"e96daf3db60a17f6","prediction_samples":234,"prediction_sse_q20":56886638569,"reconstruction_checksum":"6c5c03316e32ffb6","reconstruction_sse_q20":47038859799,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":249,"samples":256,"transition_checksum":"3a7607c9b1295788","transition_correct":226,"transition_supported":234,"transition_unknown":22},"training_evaluations":1721328},"ravel_complete_scan_without_certification":{"checkpoint_size_bytes":47204,"drift_holdout":{"classification_checksum":"408b6d4f8775f976","correct":256,"expert_evaluations":18176,"prediction_checksum":"5a677ce50f3996f8","prediction_samples":234,"prediction_sse_q20":60273692687,"reconstruction_checksum":"10a3d782ffa01f1a","reconstruction_sse_q20":51437496539,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"8184031bd3013780","transition_correct":221,"transition_supported":234,"transition_unknown":22},"expert_count":71,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"1c5fd022e7f437f5","exact_world_state_target_reached":64,"executed_path_length":307,"expansions":2099,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":281,"path_found":64,"path_length_regret":26,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"7c175ab030ec453a","correct":256,"expert_evaluations":18176,"prediction_checksum":"e96daf3db60a17f6","prediction_samples":234,"prediction_sse_q20":56886638569,"reconstruction_checksum":"6c5c03316e32ffb6","reconstruction_sse_q20":47038859799,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"3a7607c9b1295788","transition_correct":226,"transition_supported":234,"transition_unknown":22},"training_evaluations":1907808},"ravel_no_birth_same_replay_iterations":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"cb2dd42455d0e182","correct":241,"expert_evaluations":3504,"prediction_checksum":"b7b9be380404552d","prediction_samples":239,"prediction_sse_q20":83126358915,"reconstruction_checksum":"ece03a62b01a8ccc","reconstruction_sse_q20":64253780802,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":230,"samples":256,"transition_checksum":"060c17eec275e7fe","transition_correct":217,"transition_supported":239,"transition_unknown":17},"expert_count":64,"planning":{"belief_set_target_reached":44,"cases":64,"checksum":"b20a315f53df8df4","exact_world_state_target_reached":42,"executed_path_length":274,"expansions":1933,"goal_expert_reached":44,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":281,"path_found":64,"path_length_regret":9,"state_aliasing_failures":2,"transition_model_error_failures":20},"retention_holdout":{"classification_checksum":"d80287bcdc8870a8","correct":239,"expert_evaluations":3336,"prediction_checksum":"ef381d30408b5f04","prediction_samples":240,"prediction_sse_q20":85615136117,"reconstruction_checksum":"2b1e08aaca6df462","reconstruction_sse_q20":59088350933,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":233,"samples":256,"transition_checksum":"3c3b753962e18414","transition_correct":219,"transition_supported":240,"transition_unknown":16},"training_evaluations":859944},"ravel_random_births":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"cb2dd42455d0e182","correct":241,"expert_evaluations":3504,"prediction_checksum":"b7b9be380404552d","prediction_samples":239,"prediction_sse_q20":83126358915,"reconstruction_checksum":"ece03a62b01a8ccc","reconstruction_sse_q20":64253780802,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":230,"samples":256,"transition_checksum":"060c17eec275e7fe","transition_correct":217,"transition_supported":239,"transition_unknown":17},"expert_count":64,"planning":{"belief_set_target_reached":44,"cases":64,"checksum":"b20a315f53df8df4","exact_world_state_target_reached":42,"executed_path_length":274,"expansions":1933,"goal_expert_reached":44,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":281,"path_found":64,"path_length_regret":9,"state_aliasing_failures":2,"transition_model_error_failures":20},"retention_holdout":{"classification_checksum":"d80287bcdc8870a8","correct":239,"expert_evaluations":3336,"prediction_checksum":"ef381d30408b5f04","prediction_samples":240,"prediction_sse_q20":85615136117,"reconstruction_checksum":"2b1e08aaca6df462","reconstruction_sse_q20":59088350933,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":233,"samples":256,"transition_checksum":"3c3b753962e18414","transition_correct":219,"transition_supported":240,"transition_unknown":16},"training_evaluations":859944},"ravel_without_replay":{"checkpoint_size_bytes":47204,"drift_holdout":{"classification_checksum":"408b6d4f8775f976","correct":256,"expert_evaluations":2741,"prediction_checksum":"1c476c8bc8fee03d","prediction_samples":230,"prediction_sse_q20":59252718477,"reconstruction_checksum":"0d924029b743fe74","reconstruction_sse_q20":51499993327,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":245,"samples":256,"transition_checksum":"93f6931236d2032a","transition_correct":217,"transition_supported":230,"transition_unknown":26},"expert_count":71,"planning":{"belief_set_target_reached":63,"cases":64,"checksum":"7b5e84ee2be530bb","exact_world_state_target_reached":63,"executed_path_length":309,"expansions":2082,"goal_expert_reached":63,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":281,"path_found":64,"path_length_regret":28,"state_aliasing_failures":0,"transition_model_error_failures":1},"retention_holdout":{"classification_checksum":"7c175ab030ec453a","correct":256,"expert_evaluations":2489,"prediction_checksum":"ed75990c517b6dad","prediction_samples":229,"prediction_sse_q20":55879918239,"reconstruction_checksum":"fd5fcf32f57bca00","reconstruction_sse_q20":47182218519,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":249,"samples":256,"transition_checksum":"5ea4e1e5f7709ddf","transition_correct":220,"transition_supported":229,"transition_unknown":27},"training_evaluations":1355172},"ravel_without_retirement_matched_work":{"checkpoint_size_bytes":47204,"drift_holdout":{"classification_checksum":"408b6d4f8775f976","correct":256,"expert_evaluations":2741,"prediction_checksum":"5a677ce50f3996f8","prediction_samples":234,"prediction_sse_q20":60273692687,"reconstruction_checksum":"10a3d782ffa01f1a","reconstruction_sse_q20":51437496539,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":245,"samples":256,"transition_checksum":"8184031bd3013780","transition_correct":221,"transition_supported":234,"transition_unknown":22},"expert_count":71,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"1c5fd022e7f437f5","exact_world_state_target_reached":64,"executed_path_length":307,"expansions":2099,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":281,"path_found":64,"path_length_regret":26,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"7c175ab030ec453a","correct":256,"expert_evaluations":2489,"prediction_checksum":"e96daf3db60a17f6","prediction_samples":234,"prediction_sse_q20":56886638569,"reconstruction_checksum":"6c5c03316e32ffb6","reconstruction_sse_q20":47038859799,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":249,"samples":256,"transition_checksum":"3a7607c9b1295788","transition_correct":226,"transition_supported":234,"transition_unknown":22},"training_evaluations":1721328}},"dataset_seeds":{"base_holdout":"0x1ec2da030c4249c4","base_training":"0xef6c61b40943c1d3","drift_adaptation_training":"0x842b8ee5921afea3","drift_holdout":"0xd8cf24b8077e8425","original_task_retention_holdout":"0x0ba013d972fd8207","planning_cases":"0xf70169b9209005e4"},"dataset_sizes":{"base_holdout":256,"base_training":1024,"drift_adaptation_training":512,"drift_holdout":256,"original_task_retention_holdout":256,"planning_cases":64},"integrity":{"checkpoint_behavior_match":true,"checkpoint_identity_match":true,"checkpoint_mutations":{"anchored_status":true,"appended_unexpected_byte":true,"checkpoint_substitution":true,"checkpoint_truncation":true,"incorrect_schema_version":true,"label":true,"label_count":true,"lineage":true,"next_observation_component":true,"payload_byte":true,"reconstruction_component":true,"retrieval_key_component":true,"transition_graph_edge":true,"transition_support":true},"checkpoint_roundtrip":true,"lineage_invariants":{"deterministic_topology_reproduction":true,"lineage_uniqueness":true,"no_accidental_lineage_reuse":true,"parent_child_generation_increment":true,"repeated_descendant_splitting":true,"sibling_generation_equality":true},"unsupported_graph_edge_violations":0},"regime":"partially_overlapping_observations","schema":"ravel-raw-trial/0.5","seed":"0xb8c7841518d48d8c","trial_id":"validation-overlap-01"},{"candidate":{"adaptation_completed":true,"adaptation_training":{"classification_checksum":"4e0a72d11e07ad5b","correct":512,"expert_evaluations":5150,"prediction_checksum":"feac80f6bd0afd68","prediction_samples":469,"prediction_sse_q20":101811183418,"reconstruction_checksum":"eb1d972e1f3db05a","reconstruction_sse_q20":96588919336,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":495,"samples":512,"transition_checksum":"9a6953b019a02eae","transition_correct":436,"transition_supported":469,"transition_unknown":43},"adaptation_training_evaluations":1097316,"adapted_model_drift_holdout":{"classification_checksum":"2a5599e4af9d025a","correct":256,"expert_evaluations":2172,"prediction_checksum":"5e1630d5b3821582","prediction_samples":228,"prediction_sse_q20":52091950703,"reconstruction_checksum":"cf81f7034e627cea","reconstruction_sse_q20":46526919995,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":254,"samples":256,"transition_checksum":"6c23d1b7b1dfc8a2","transition_correct":214,"transition_supported":228,"transition_unknown":28},"base_holdout":{"classification_checksum":"4b9d4208d4f5bd4d","correct":245,"expert_evaluations":2944,"prediction_checksum":"d635345213064144","prediction_samples":231,"prediction_sse_q20":56942650876,"reconstruction_checksum":"186fe705c5e888c7","reconstruction_sse_q20":53654434444,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":240,"samples":256,"transition_checksum":"57df09ae77c9d3cc","transition_correct":218,"transition_supported":231,"transition_unknown":25},"base_holdout_retention":{"classification_checksum":"7b3cf1e37955f3ce","correct":256,"expert_evaluations":2420,"prediction_checksum":"7915e6cecd628a6d","prediction_samples":235,"prediction_sse_q20":50071832528,"reconstruction_checksum":"54578e8632a16579","reconstruction_sse_q20":48457426987,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":250,"samples":256,"transition_checksum":"a4af50d8839dbe42","transition_correct":218,"transition_supported":235,"transition_unknown":21},"base_training_evaluations":620920,"behavior_identity":"595f23268960926156dae552d8664a2811cf6e85fd24e8bdb1925a831b696e56","checkpoint_size_bytes":46634,"expert_count":70,"model_identity":"542a9d3b6c8c7077de324706e17855f198db8d07a905255f8b398c1fd1d133e8","planning":{"belief_set_target_reached":48,"cases":64,"checksum":"7987de04f8f5082e","exact_world_state_target_reached":48,"executed_path_length":255,"expansions":2037,"goal_expert_reached":48,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":272,"path_found":64,"path_length_regret":7,"state_aliasing_failures":0,"transition_model_error_failures":16},"replay":{"actions_covered":4,"assigned_experts_covered":64,"high_loss_cases_selected":12,"labels_covered":8,"rare_cases_selected":56,"selected":256,"selection_checksum":"144d5566141ab76c","states_covered":64,"transition_pairs_covered":252,"unique":256},"static_model_drift_holdout":{"classification_checksum":"fd420442ef6cbf16","correct":237,"expert_evaluations":3168,"prediction_checksum":"cef6f75668820d60","prediction_samples":230,"prediction_sse_q20":70199388014,"reconstruction_checksum":"a9e8a9b61b1d10a2","reconstruction_sse_q20":62194464796,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":236,"samples":256,"transition_checksum":"ca665a578217e949","transition_correct":208,"transition_supported":230,"transition_unknown":26},"topology":{"accepted_births":7,"accepted_retirements":1,"births":[{"dominant_channel":0,"event_index":249,"normalized_score_q20":520658},{"dominant_channel":0,"event_index":458,"normalized_score_q20":497485},{"dominant_channel":0,"event_index":238,"normalized_score_q20":482230},{"dominant_channel":0,"event_index":426,"normalized_score_q20":453148},{"dominant_channel":2,"event_index":373,"normalized_score_q20":333459},{"dominant_channel":2,"event_index":112,"normalized_score_q20":325040},{"dominant_channel":2,"event_index":92,"normalized_score_q20":311001}],"objective_after_q20":902185,"objective_before_q20":878130,"rejected_births":9,"rejected_retirements":1,"retired_lineages":["bae569ccdfaa44f6"],"training_observations":{"births":7,"certified":13200,"expert_evaluations":1097316,"rejected_births":9,"rejected_retirements":1,"retired":1,"samples":13824}}},"checkpoint_format":{"byte_order":"big_endian","magic_hex":"524156454c303500","payload_digest":"sha256","real_encoding":"signed_q20_int64","schema_version":5,"transition_support_min":2,"transition_top_k":2},"comparisons":{"fixed_8_expert":{"checkpoint_size_bytes":11294,"drift_holdout":{"classification_checksum":"5db05dfa6b107d7a","correct":32,"expert_evaluations":2048,"prediction_checksum":"443054ca7afe5ff2","prediction_samples":256,"prediction_sse_q20":665564572827,"reconstruction_checksum":"f88eea9d09360970","reconstruction_sse_q20":577438340573,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"ba54d36bd8e7996c","transition_correct":177,"transition_supported":256,"transition_unknown":0},"expert_count":8,"planning":{"belief_set_target_reached":34,"cases":64,"checksum":"7ce3210c596eb84d","exact_world_state_target_reached":4,"executed_path_length":121,"expansions":263,"goal_expert_reached":34,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":272,"path_found":64,"path_length_regret":0,"state_aliasing_failures":30,"transition_model_error_failures":30},"retention_holdout":{"classification_checksum":"7aed184cb107161a","correct":42,"expert_evaluations":2048,"prediction_checksum":"3f54eb1e248a91c5","prediction_samples":256,"prediction_sse_q20":679435572877,"reconstruction_checksum":"a6627984ee830932","reconstruction_sse_q20":577030498159,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"c11195dabdeae6b6","transition_correct":170,"transition_supported":256,"transition_unknown":0},"training_evaluations":94208},"fixed_topology_64_expert_routed":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"a6e515433810d37a","correct":256,"expert_evaluations":2048,"prediction_checksum":"2c6f7a8c9397f715","prediction_samples":228,"prediction_sse_q20":44153779800,"reconstruction_checksum":"829dcb71049c8755","reconstruction_sse_q20":44070644954,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"4d889d84024dfc7d","transition_correct":228,"transition_supported":228,"transition_unknown":28},"expert_count":64,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"527982c924b2bf0b","exact_world_state_target_reached":64,"executed_path_length":280,"expansions":2046,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":272,"path_found":64,"path_length_regret":8,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"39a1a69bafe1c900","correct":256,"expert_evaluations":2048,"prediction_checksum":"fd7f39cb05c2911c","prediction_samples":235,"prediction_sse_q20":45685219749,"reconstruction_checksum":"34a1fd98700f2980","reconstruction_sse_q20":44015689852,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"152f63ce04b24660","transition_correct":235,"transition_supported":235,"transition_unknown":21},"training_evaluations":2588672},"flat_64_expert_complete_scan":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"a6e515433810d37a","correct":256,"expert_evaluations":16384,"prediction_checksum":"2c6f7a8c9397f715","prediction_samples":228,"prediction_sse_q20":44153779800,"reconstruction_checksum":"829dcb71049c8755","reconstruction_sse_q20":44070644954,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"4d889d84024dfc7d","transition_correct":228,"transition_supported":228,"transition_unknown":28},"expert_count":64,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"527982c924b2bf0b","exact_world_state_target_reached":64,"executed_path_length":280,"expansions":2046,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":272,"path_found":64,"path_length_regret":8,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"39a1a69bafe1c900","correct":256,"expert_evaluations":16384,"prediction_checksum":"fd7f39cb05c2911c","prediction_samples":235,"prediction_sse_q20":45685219749,"reconstruction_checksum":"34a1fd98700f2980","reconstruction_sse_q20":44015689852,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"152f63ce04b24660","transition_correct":235,"transition_supported":235,"transition_unknown":21},"training_evaluations":2588672},"matched_compute_fixed_topology":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"fd420442ef6cbf16","correct":237,"expert_evaluations":3168,"prediction_checksum":"cef6f75668820d60","prediction_samples":230,"prediction_sse_q20":70199388014,"reconstruction_checksum":"a9e8a9b61b1d10a2","reconstruction_sse_q20":62194464796,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":236,"samples":256,"transition_checksum":"ca665a578217e949","transition_correct":208,"transition_supported":230,"transition_unknown":26},"expert_count":64,"planning":{"belief_set_target_reached":42,"cases":64,"checksum":"e3bf64503cfdd520","exact_world_state_target_reached":41,"executed_path_length":245,"expansions":1980,"goal_expert_reached":42,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":272,"path_found":64,"path_length_regret":5,"state_aliasing_failures":1,"transition_model_error_failures":22},"retention_holdout":{"classification_checksum":"badc580cc3ba8f26","correct":242,"expert_evaluations":3112,"prediction_checksum":"1aba7e81819bc994","prediction_samples":235,"prediction_sse_q20":66735540972,"reconstruction_checksum":"3292af88df82df8b","reconstruction_sse_q20":59813196313,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":237,"samples":256,"transition_checksum":"36d5dcbae165a3d4","transition_correct":210,"transition_supported":235,"transition_unknown":21},"training_evaluations":1811960},"matched_expert_count_capacity":{"checkpoint_size_bytes":46634,"drift_holdout":{"classification_checksum":"1b54206be73c5f91","correct":256,"expert_evaluations":2048,"prediction_checksum":"19b2e2dbea721db9","prediction_samples":217,"prediction_sse_q20":42503268701,"reconstruction_checksum":"d650f9e647c2adc9","reconstruction_sse_q20":43735512202,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"e85b804de7cbf057","transition_correct":201,"transition_supported":217,"transition_unknown":39},"expert_count":70,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"21ab4bc60eb23df1","exact_world_state_target_reached":64,"executed_path_length":295,"expansions":2250,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":272,"path_found":64,"path_length_regret":23,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"a63a1add82fc614d","correct":256,"expert_evaluations":2048,"prediction_checksum":"b692eaa41c9b2c02","prediction_samples":228,"prediction_sse_q20":44435236394,"reconstruction_checksum":"037f3eeec654068a","reconstruction_sse_q20":43838192796,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"f383ff1905151c67","transition_correct":219,"transition_supported":228,"transition_unknown":28},"training_evaluations":3046400},"nearest_centroid_16_no_recursive_births":{"checkpoint_size_bytes":15854,"drift_holdout":{"classification_checksum":"21bfe82a5854f65d","correct":64,"expert_evaluations":4096,"prediction_checksum":"3f6d18b5bb6753c2","prediction_samples":256,"prediction_sse_q20":393838037078,"reconstruction_checksum":"79f9fd6ba29a3661","reconstruction_sse_q20":346456821096,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"72106dcad88222e3","transition_correct":213,"transition_supported":256,"transition_unknown":0},"expert_count":16,"planning":{"belief_set_target_reached":42,"cases":64,"checksum":"b1e93792043ee160","exact_world_state_target_reached":12,"executed_path_length":150,"expansions":494,"goal_expert_reached":42,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":272,"path_found":64,"path_length_regret":0,"state_aliasing_failures":30,"transition_model_error_failures":22},"retention_holdout":{"classification_checksum":"d59eb6d5a02910d8","correct":64,"expert_evaluations":4096,"prediction_checksum":"6f8b37bcef608dac","prediction_samples":256,"prediction_sse_q20":422711967182,"reconstruction_checksum":"664921e2d5cf48d4","reconstruction_sse_q20":360189386190,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"aafcb70574247b97","transition_correct":201,"transition_supported":256,"transition_unknown":0},"training_evaluations":253952},"no_adaptation_static":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"fd420442ef6cbf16","correct":237,"expert_evaluations":3168,"prediction_checksum":"cef6f75668820d60","prediction_samples":230,"prediction_sse_q20":70199388014,"reconstruction_checksum":"a9e8a9b61b1d10a2","reconstruction_sse_q20":62194464796,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":236,"samples":256,"transition_checksum":"ca665a578217e949","transition_correct":208,"transition_supported":230,"transition_unknown":26},"expert_count":64,"planning":{"belief_set_target_reached":42,"cases":64,"checksum":"e3bf64503cfdd520","exact_world_state_target_reached":41,"executed_path_length":245,"expansions":1980,"goal_expert_reached":42,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":272,"path_found":64,"path_length_regret":5,"state_aliasing_failures":1,"transition_model_error_failures":22},"retention_holdout":{"classification_checksum":"badc580cc3ba8f26","correct":242,"expert_evaluations":3112,"prediction_checksum":"1aba7e81819bc994","prediction_samples":235,"prediction_sse_q20":66735540972,"reconstruction_checksum":"3292af88df82df8b","reconstruction_sse_q20":59813196313,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":237,"samples":256,"transition_checksum":"36d5dcbae165a3d4","transition_correct":210,"transition_supported":235,"transition_unknown":21},"training_evaluations":620920},"periodic_replay_policy":{"checkpoint_size_bytes":47204,"drift_holdout":{"classification_checksum":"2a5599e4af9d025a","correct":256,"expert_evaluations":2174,"prediction_checksum":"6b074574f2263a50","prediction_samples":224,"prediction_sse_q20":51635817840,"reconstruction_checksum":"8b07d5d67cf3f99e","reconstruction_sse_q20":46734091924,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":254,"samples":256,"transition_checksum":"55a2d44f347db72d","transition_correct":209,"transition_supported":224,"transition_unknown":32},"expert_count":71,"planning":{"belief_set_target_reached":48,"cases":64,"checksum":"3121f67a6ff46f16","exact_world_state_target_reached":48,"executed_path_length":254,"expansions":2014,"goal_expert_reached":48,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":272,"path_found":64,"path_length_regret":8,"state_aliasing_failures":0,"transition_model_error_failures":16},"retention_holdout":{"classification_checksum":"7b3cf1e37955f3ce","correct":256,"expert_evaluations":2426,"prediction_checksum":"b0f33defc34be977","prediction_samples":235,"prediction_sse_q20":50226459650,"reconstruction_checksum":"4ac6c832f4380c75","reconstruction_sse_q20":48500681915,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":250,"samples":256,"transition_checksum":"f47c1726cddf725f","transition_correct":218,"transition_supported":235,"transition_unknown":21},"training_evaluations":1714426},"ravel_0_5_candidate":{"checkpoint_size_bytes":46634,"drift_holdout":{"classification_checksum":"2a5599e4af9d025a","correct":256,"expert_evaluations":2172,"prediction_checksum":"5e1630d5b3821582","prediction_samples":228,"prediction_sse_q20":52091950703,"reconstruction_checksum":"cf81f7034e627cea","reconstruction_sse_q20":46526919995,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":254,"samples":256,"transition_checksum":"6c23d1b7b1dfc8a2","transition_correct":214,"transition_supported":228,"transition_unknown":28},"expert_count":70,"planning":{"belief_set_target_reached":48,"cases":64,"checksum":"7987de04f8f5082e","exact_world_state_target_reached":48,"executed_path_length":255,"expansions":2037,"goal_expert_reached":48,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":272,"path_found":64,"path_length_regret":7,"state_aliasing_failures":0,"transition_model_error_failures":16},"retention_holdout":{"classification_checksum":"7b3cf1e37955f3ce","correct":256,"expert_evaluations":2420,"prediction_checksum":"7915e6cecd628a6d","prediction_samples":235,"prediction_sse_q20":50071832528,"reconstruction_checksum":"54578e8632a16579","reconstruction_sse_q20":48457426987,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":250,"samples":256,"transition_checksum":"a4af50d8839dbe42","transition_correct":218,"transition_supported":235,"transition_unknown":21},"training_evaluations":1718236},"ravel_complete_scan_without_certification":{"checkpoint_size_bytes":46634,"drift_holdout":{"classification_checksum":"2a5599e4af9d025a","correct":256,"expert_evaluations":17920,"prediction_checksum":"5e1630d5b3821582","prediction_samples":228,"prediction_sse_q20":52091950703,"reconstruction_checksum":"cf81f7034e627cea","reconstruction_sse_q20":46526919995,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"6c23d1b7b1dfc8a2","transition_correct":214,"transition_supported":228,"transition_unknown":28},"expert_count":70,"planning":{"belief_set_target_reached":48,"cases":64,"checksum":"7987de04f8f5082e","exact_world_state_target_reached":48,"executed_path_length":255,"expansions":2037,"goal_expert_reached":48,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":272,"path_found":64,"path_length_regret":7,"state_aliasing_failures":0,"transition_model_error_failures":16},"retention_holdout":{"classification_checksum":"7b3cf1e37955f3ce","correct":256,"expert_evaluations":17920,"prediction_checksum":"7915e6cecd628a6d","prediction_samples":235,"prediction_sse_q20":50071832528,"reconstruction_checksum":"54578e8632a16579","reconstruction_sse_q20":48457426987,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"a4af50d8839dbe42","transition_correct":218,"transition_supported":235,"transition_unknown":21},"training_evaluations":1904716},"ravel_no_birth_same_replay_iterations":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"fd420442ef6cbf16","correct":237,"expert_evaluations":3168,"prediction_checksum":"cef6f75668820d60","prediction_samples":230,"prediction_sse_q20":70199388014,"reconstruction_checksum":"a9e8a9b61b1d10a2","reconstruction_sse_q20":62194464796,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":236,"samples":256,"transition_checksum":"ca665a578217e949","transition_correct":208,"transition_supported":230,"transition_unknown":26},"expert_count":64,"planning":{"belief_set_target_reached":42,"cases":64,"checksum":"e3bf64503cfdd520","exact_world_state_target_reached":41,"executed_path_length":245,"expansions":1980,"goal_expert_reached":42,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":272,"path_found":64,"path_length_regret":5,"state_aliasing_failures":1,"transition_model_error_failures":22},"retention_holdout":{"classification_checksum":"badc580cc3ba8f26","correct":242,"expert_evaluations":3112,"prediction_checksum":"1aba7e81819bc994","prediction_samples":235,"prediction_sse_q20":66735540972,"reconstruction_checksum":"3292af88df82df8b","reconstruction_sse_q20":59813196313,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":237,"samples":256,"transition_checksum":"36d5dcbae165a3d4","transition_correct":210,"transition_supported":235,"transition_unknown":21},"training_evaluations":859128},"ravel_random_births":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"fd420442ef6cbf16","correct":237,"expert_evaluations":3168,"prediction_checksum":"cef6f75668820d60","prediction_samples":230,"prediction_sse_q20":70199388014,"reconstruction_checksum":"a9e8a9b61b1d10a2","reconstruction_sse_q20":62194464796,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":236,"samples":256,"transition_checksum":"ca665a578217e949","transition_correct":208,"transition_supported":230,"transition_unknown":26},"expert_count":64,"planning":{"belief_set_target_reached":42,"cases":64,"checksum":"e3bf64503cfdd520","exact_world_state_target_reached":41,"executed_path_length":245,"expansions":1980,"goal_expert_reached":42,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":272,"path_found":64,"path_length_regret":5,"state_aliasing_failures":1,"transition_model_error_failures":22},"retention_holdout":{"classification_checksum":"badc580cc3ba8f26","correct":242,"expert_evaluations":3112,"prediction_checksum":"1aba7e81819bc994","prediction_samples":235,"prediction_sse_q20":66735540972,"reconstruction_checksum":"3292af88df82df8b","reconstruction_sse_q20":59813196313,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":237,"samples":256,"transition_checksum":"36d5dcbae165a3d4","transition_correct":210,"transition_supported":235,"transition_unknown":21},"training_evaluations":859128},"ravel_without_replay":{"checkpoint_size_bytes":46634,"drift_holdout":{"classification_checksum":"2a5599e4af9d025a","correct":256,"expert_evaluations":2172,"prediction_checksum":"588261e53544603c","prediction_samples":220,"prediction_sse_q20":51062563665,"reconstruction_checksum":"e28a216e75c127db","reconstruction_sse_q20":46754013230,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":254,"samples":256,"transition_checksum":"96a4d17c97f34776","transition_correct":205,"transition_supported":220,"transition_unknown":36},"expert_count":70,"planning":{"belief_set_target_reached":48,"cases":64,"checksum":"3121f67a6ff46f16","exact_world_state_target_reached":48,"executed_path_length":254,"expansions":2013,"goal_expert_reached":48,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":272,"path_found":64,"path_length_regret":8,"state_aliasing_failures":0,"transition_model_error_failures":16},"retention_holdout":{"classification_checksum":"7b3cf1e37955f3ce","correct":256,"expert_evaluations":2420,"prediction_checksum":"2a0078011c996455","prediction_samples":232,"prediction_sse_q20":49785942682,"reconstruction_checksum":"e7a9730310342eb7","reconstruction_sse_q20":48631494271,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":250,"samples":256,"transition_checksum":"fb8ae776d31881bc","transition_correct":215,"transition_supported":232,"transition_unknown":24},"training_evaluations":1266507},"ravel_without_retirement_matched_work":{"checkpoint_size_bytes":47204,"drift_holdout":{"classification_checksum":"2a5599e4af9d025a","correct":256,"expert_evaluations":2174,"prediction_checksum":"5e1630d5b3821582","prediction_samples":228,"prediction_sse_q20":52091950703,"reconstruction_checksum":"cf81f7034e627cea","reconstruction_sse_q20":46526919995,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":254,"samples":256,"transition_checksum":"6c23d1b7b1dfc8a2","transition_correct":214,"transition_supported":228,"transition_unknown":28},"expert_count":71,"planning":{"belief_set_target_reached":48,"cases":64,"checksum":"7987de04f8f5082e","exact_world_state_target_reached":48,"executed_path_length":255,"expansions":2037,"goal_expert_reached":48,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":272,"path_found":64,"path_length_regret":7,"state_aliasing_failures":0,"transition_model_error_failures":16},"retention_holdout":{"classification_checksum":"7b3cf1e37955f3ce","correct":256,"expert_evaluations":2426,"prediction_checksum":"7915e6cecd628a6d","prediction_samples":235,"prediction_sse_q20":50071832528,"reconstruction_checksum":"54578e8632a16579","reconstruction_sse_q20":48457426987,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":250,"samples":256,"transition_checksum":"a4af50d8839dbe42","transition_correct":218,"transition_supported":235,"transition_unknown":21},"training_evaluations":1718236}},"dataset_seeds":{"base_holdout":"0x97524a27d8b31672","base_training":"0xf6ae3e816186b418","drift_adaptation_training":"0x8a4b7443ca0c4f33","drift_holdout":"0xbcdc07edf174a6df","original_task_retention_holdout":"0x1eb587cad32207ac","planning_cases":"0x5fe4128613b0e87f"},"dataset_sizes":{"base_holdout":256,"base_training":1024,"drift_adaptation_training":512,"drift_holdout":256,"original_task_retention_holdout":256,"planning_cases":64},"integrity":{"checkpoint_behavior_match":true,"checkpoint_identity_match":true,"checkpoint_mutations":{"anchored_status":true,"appended_unexpected_byte":true,"checkpoint_substitution":true,"checkpoint_truncation":true,"incorrect_schema_version":true,"label":true,"label_count":true,"lineage":true,"next_observation_component":true,"payload_byte":true,"reconstruction_component":true,"retrieval_key_component":true,"transition_graph_edge":true,"transition_support":true},"checkpoint_roundtrip":true,"lineage_invariants":{"deterministic_topology_reproduction":true,"lineage_uniqueness":true,"no_accidental_lineage_reuse":true,"parent_child_generation_increment":true,"repeated_descendant_splitting":true,"sibling_generation_equality":true},"unsupported_graph_edge_violations":0},"regime":"partially_overlapping_observations","schema":"ravel-raw-trial/0.5","seed":"0x3cfbef3be50fce38","trial_id":"validation-overlap-02"},{"candidate":{"adaptation_completed":true,"adaptation_training":{"classification_checksum":"ccbff66db3e9a142","correct":512,"expert_evaluations":4273,"prediction_checksum":"52ce2d41a38e3430","prediction_samples":476,"prediction_sse_q20":100278431356,"reconstruction_checksum":"269ee4f78871e258","reconstruction_sse_q20":88768666392,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":509,"samples":512,"transition_checksum":"eddbe9345e03fff9","transition_correct":468,"transition_supported":476,"transition_unknown":36},"adaptation_training_evaluations":577489,"adapted_model_drift_holdout":{"classification_checksum":"cc86778a658762ee","correct":256,"expert_evaluations":2284,"prediction_checksum":"3b60fd8d48bfa684","prediction_samples":237,"prediction_sse_q20":50348392519,"reconstruction_checksum":"3e6c53d9feb92df9","reconstruction_sse_q20":43819711257,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":252,"samples":256,"transition_checksum":"018a6fadb7e8c925","transition_correct":229,"transition_supported":237,"transition_unknown":19},"base_holdout":{"classification_checksum":"12600f16fafb199e","correct":250,"expert_evaluations":2552,"prediction_checksum":"b8aa3c28850f17d5","prediction_samples":241,"prediction_sse_q20":58848536212,"reconstruction_checksum":"bc2e16065af00fa3","reconstruction_sse_q20":48449505551,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":247,"samples":256,"transition_checksum":"0d62c807a4e0be87","transition_correct":236,"transition_supported":241,"transition_unknown":15},"base_holdout_retention":{"classification_checksum":"f9fd8a07e199fbec","correct":256,"expert_evaluations":2166,"prediction_checksum":"0163712eb28c4f2b","prediction_samples":244,"prediction_sse_q20":54275535004,"reconstruction_checksum":"9dfc8545bf0bf460","reconstruction_sse_q20":45070553939,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":254,"samples":256,"transition_checksum":"b262cdcbd93650dd","transition_correct":237,"transition_supported":244,"transition_unknown":12},"base_training_evaluations":617344,"behavior_identity":"7a0fd382397800de653494ae02c06d9a16205abc47f037ac52dfd0fe71066d51","checkpoint_size_bytes":44924,"expert_count":67,"model_identity":"b088cf2dbe74826097636b060750839e37b21f96677a876b8dc5d97b80b8184a","planning":{"belief_set_target_reached":54,"cases":64,"checksum":"f416909b4bfb11ac","exact_world_state_target_reached":54,"executed_path_length":323,"expansions":2386,"goal_expert_reached":54,"graph_disconnection_failures":0,"no_supported_edge_failures":1,"optimal_path_length":323,"path_found":63,"path_length_regret":8,"state_aliasing_failures":0,"transition_model_error_failures":9},"replay":{"actions_covered":4,"assigned_experts_covered":63,"high_loss_cases_selected":22,"labels_covered":8,"rare_cases_selected":48,"selected":256,"selection_checksum":"42b49ada77be463c","states_covered":64,"transition_pairs_covered":248,"unique":256},"static_model_drift_holdout":{"classification_checksum":"20d9ef4aa7706113","correct":248,"expert_evaluations":2720,"prediction_checksum":"4493f0dc7adb4a40","prediction_samples":237,"prediction_sse_q20":55983877694,"reconstruction_checksum":"c73a13176ded7b62","reconstruction_sse_q20":49919464735,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":244,"samples":256,"transition_checksum":"42562ca55f11009d","transition_correct":226,"transition_supported":237,"transition_unknown":19},"topology":{"accepted_births":3,"accepted_retirements":0,"births":[{"dominant_channel":0,"event_index":355,"normalized_score_q20":516841},{"dominant_channel":0,"event_index":44,"normalized_score_q20":493643},{"dominant_channel":2,"event_index":342,"normalized_score_q20":331659}],"objective_after_q20":909364,"objective_before_q20":898233,"rejected_births":13,"rejected_retirements":1,"retired_lineages":[],"training_observations":{"births":3,"certified":7575,"expert_evaluations":577489,"rejected_births":13,"rejected_retirements":1,"retired":0,"samples":7680}}},"checkpoint_format":{"byte_order":"big_endian","magic_hex":"524156454c303500","payload_digest":"sha256","real_encoding":"signed_q20_int64","schema_version":5,"transition_support_min":2,"transition_top_k":2},"comparisons":{"fixed_8_expert":{"checkpoint_size_bytes":11294,"drift_holdout":{"classification_checksum":"97e80f44736d1a23","correct":48,"expert_evaluations":2048,"prediction_checksum":"0101fc654617273e","prediction_samples":256,"prediction_sse_q20":675572656866,"reconstruction_checksum":"ed6d7c92d7fc96df","reconstruction_sse_q20":551981738644,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"6b908224f49ffefe","transition_correct":152,"transition_supported":256,"transition_unknown":0},"expert_count":8,"planning":{"belief_set_target_reached":33,"cases":64,"checksum":"9ff80ff062f5cf4e","exact_world_state_target_reached":3,"executed_path_length":76,"expansions":227,"goal_expert_reached":33,"graph_disconnection_failures":15,"no_supported_edge_failures":0,"optimal_path_length":323,"path_found":49,"path_length_regret":0,"state_aliasing_failures":30,"transition_model_error_failures":16},"retention_holdout":{"classification_checksum":"c032d387f47a766b","correct":53,"expert_evaluations":2048,"prediction_checksum":"ea01e7517fc2b285","prediction_samples":256,"prediction_sse_q20":668287477238,"reconstruction_checksum":"7f41366f90508b2c","reconstruction_sse_q20":588713102674,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"59147cf0ce108273","transition_correct":159,"transition_supported":256,"transition_unknown":0},"training_evaluations":94208},"fixed_topology_64_expert_routed":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"52af853054227b46","correct":256,"expert_evaluations":2048,"prediction_checksum":"355fb688c661def1","prediction_samples":235,"prediction_sse_q20":45765408318,"reconstruction_checksum":"7f67faf05ea7d33a","reconstruction_sse_q20":41679115921,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"f12db05b16fe7ac3","transition_correct":235,"transition_supported":235,"transition_unknown":21},"expert_count":64,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"8c667a856ce9d051","exact_world_state_target_reached":64,"executed_path_length":335,"expansions":2287,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":323,"path_found":64,"path_length_regret":12,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"e509a06f5f33b4f8","correct":256,"expert_evaluations":2048,"prediction_checksum":"8121e219a394567f","prediction_samples":238,"prediction_sse_q20":47013494636,"reconstruction_checksum":"0101677a3631db31","reconstruction_sse_q20":42237864267,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"2770a6abbde2e9c1","transition_correct":238,"transition_supported":238,"transition_unknown":18},"training_evaluations":2588672},"flat_64_expert_complete_scan":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"52af853054227b46","correct":256,"expert_evaluations":16384,"prediction_checksum":"355fb688c661def1","prediction_samples":235,"prediction_sse_q20":45765408318,"reconstruction_checksum":"7f67faf05ea7d33a","reconstruction_sse_q20":41679115921,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"f12db05b16fe7ac3","transition_correct":235,"transition_supported":235,"transition_unknown":21},"expert_count":64,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"8c667a856ce9d051","exact_world_state_target_reached":64,"executed_path_length":335,"expansions":2287,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":323,"path_found":64,"path_length_regret":12,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"e509a06f5f33b4f8","correct":256,"expert_evaluations":16384,"prediction_checksum":"8121e219a394567f","prediction_samples":238,"prediction_sse_q20":47013494636,"reconstruction_checksum":"0101677a3631db31","reconstruction_sse_q20":42237864267,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"2770a6abbde2e9c1","transition_correct":238,"transition_supported":238,"transition_unknown":18},"training_evaluations":2588672},"matched_compute_fixed_topology":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"20d9ef4aa7706113","correct":248,"expert_evaluations":2720,"prediction_checksum":"4493f0dc7adb4a40","prediction_samples":237,"prediction_sse_q20":55983877694,"reconstruction_checksum":"c73a13176ded7b62","reconstruction_sse_q20":49919464735,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":244,"samples":256,"transition_checksum":"42562ca55f11009d","transition_correct":226,"transition_supported":237,"transition_unknown":19},"expert_count":64,"planning":{"belief_set_target_reached":47,"cases":64,"checksum":"886cb1f192fd45bf","exact_world_state_target_reached":44,"executed_path_length":311,"expansions":2240,"goal_expert_reached":47,"graph_disconnection_failures":0,"no_supported_edge_failures":1,"optimal_path_length":323,"path_found":63,"path_length_regret":6,"state_aliasing_failures":3,"transition_model_error_failures":16},"retention_holdout":{"classification_checksum":"5f0b3871655ce3c8","correct":244,"expert_evaluations":2776,"prediction_checksum":"e767d6697354c275","prediction_samples":243,"prediction_sse_q20":64217820592,"reconstruction_checksum":"204c757fcac1de13","reconstruction_sse_q20":54536654777,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":243,"samples":256,"transition_checksum":"2641477fdcd470a4","transition_correct":231,"transition_supported":243,"transition_unknown":13},"training_evaluations":1302400},"matched_expert_count_capacity":{"checkpoint_size_bytes":44924,"drift_holdout":{"classification_checksum":"3e05aa48507869ed","correct":256,"expert_evaluations":2048,"prediction_checksum":"56053895014cdff6","prediction_samples":228,"prediction_sse_q20":45056491194,"reconstruction_checksum":"4d1dd2b67d92e822","reconstruction_sse_q20":41689985745,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"edf2bacc21ec4365","transition_correct":226,"transition_supported":228,"transition_unknown":28},"expert_count":67,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"5d5f253ecdea3b4d","exact_world_state_target_reached":64,"executed_path_length":337,"expansions":2312,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":323,"path_found":64,"path_length_regret":14,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"85941ff116d74472","correct":256,"expert_evaluations":2048,"prediction_checksum":"4326c59ad9d7848e","prediction_samples":237,"prediction_sse_q20":46944565257,"reconstruction_checksum":"2bcfb8ee885e1f56","reconstruction_sse_q20":42186746134,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"3e34c47f2720590d","transition_correct":228,"transition_supported":237,"transition_unknown":19},"training_evaluations":2812928},"nearest_centroid_16_no_recursive_births":{"checkpoint_size_bytes":15854,"drift_holdout":{"classification_checksum":"21b9e4fa5389ba8b","correct":63,"expert_evaluations":4096,"prediction_checksum":"ca4ffe4d55d44455","prediction_samples":256,"prediction_sse_q20":378893393108,"reconstruction_checksum":"5463c6d692eb96ef","reconstruction_sse_q20":315946611171,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"344f7fe21da3cb50","transition_correct":237,"transition_supported":256,"transition_unknown":0},"expert_count":16,"planning":{"belief_set_target_reached":58,"cases":64,"checksum":"8d7954daa0acb75b","exact_world_state_target_reached":12,"executed_path_length":171,"expansions":566,"goal_expert_reached":58,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":323,"path_found":64,"path_length_regret":0,"state_aliasing_failures":46,"transition_model_error_failures":6},"retention_holdout":{"classification_checksum":"e0eab96bbf7c1376","correct":72,"expert_evaluations":4096,"prediction_checksum":"ac329d85467a0e64","prediction_samples":256,"prediction_sse_q20":342386173244,"reconstruction_checksum":"334b1d0ceb450c57","reconstruction_sse_q20":317750945970,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"faa2e349568e9fee","transition_correct":237,"transition_supported":256,"transition_unknown":0},"training_evaluations":253952},"no_adaptation_static":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"20d9ef4aa7706113","correct":248,"expert_evaluations":2720,"prediction_checksum":"4493f0dc7adb4a40","prediction_samples":237,"prediction_sse_q20":55983877694,"reconstruction_checksum":"c73a13176ded7b62","reconstruction_sse_q20":49919464735,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":244,"samples":256,"transition_checksum":"42562ca55f11009d","transition_correct":226,"transition_supported":237,"transition_unknown":19},"expert_count":64,"planning":{"belief_set_target_reached":47,"cases":64,"checksum":"886cb1f192fd45bf","exact_world_state_target_reached":44,"executed_path_length":311,"expansions":2240,"goal_expert_reached":47,"graph_disconnection_failures":0,"no_supported_edge_failures":1,"optimal_path_length":323,"path_found":63,"path_length_regret":6,"state_aliasing_failures":3,"transition_model_error_failures":16},"retention_holdout":{"classification_checksum":"5f0b3871655ce3c8","correct":244,"expert_evaluations":2776,"prediction_checksum":"e767d6697354c275","prediction_samples":243,"prediction_sse_q20":64217820592,"reconstruction_checksum":"204c757fcac1de13","reconstruction_sse_q20":54536654777,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":243,"samples":256,"transition_checksum":"2641477fdcd470a4","transition_correct":231,"transition_supported":243,"transition_unknown":13},"training_evaluations":617344},"periodic_replay_policy":{"checkpoint_size_bytes":44924,"drift_holdout":{"classification_checksum":"2bd746222abe53e7","correct":256,"expert_evaluations":2284,"prediction_checksum":"a65287ca8023c881","prediction_samples":235,"prediction_sse_q20":49276922606,"reconstruction_checksum":"ec29eddad3aed337","reconstruction_sse_q20":43711287189,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":252,"samples":256,"transition_checksum":"f1c2146e8d1e86ed","transition_correct":228,"transition_supported":235,"transition_unknown":21},"expert_count":67,"planning":{"belief_set_target_reached":54,"cases":64,"checksum":"00214d67256c5607","exact_world_state_target_reached":54,"executed_path_length":325,"expansions":2360,"goal_expert_reached":54,"graph_disconnection_failures":0,"no_supported_edge_failures":1,"optimal_path_length":323,"path_found":63,"path_length_regret":10,"state_aliasing_failures":0,"transition_model_error_failures":9},"retention_holdout":{"classification_checksum":"b8dc1e2d4da1808a","correct":256,"expert_evaluations":2166,"prediction_checksum":"6ba6a39f74f139a4","prediction_samples":240,"prediction_sse_q20":53511507539,"reconstruction_checksum":"ca87f25f718d87d7","reconstruction_sse_q20":44932148409,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":254,"samples":256,"transition_checksum":"b94bb4b972c45bfa","transition_correct":235,"transition_supported":240,"transition_unknown":16},"training_evaluations":1193850},"ravel_0_5_candidate":{"checkpoint_size_bytes":44924,"drift_holdout":{"classification_checksum":"cc86778a658762ee","correct":256,"expert_evaluations":2284,"prediction_checksum":"3b60fd8d48bfa684","prediction_samples":237,"prediction_sse_q20":50348392519,"reconstruction_checksum":"3e6c53d9feb92df9","reconstruction_sse_q20":43819711257,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":252,"samples":256,"transition_checksum":"018a6fadb7e8c925","transition_correct":229,"transition_supported":237,"transition_unknown":19},"expert_count":67,"planning":{"belief_set_target_reached":54,"cases":64,"checksum":"f416909b4bfb11ac","exact_world_state_target_reached":54,"executed_path_length":323,"expansions":2386,"goal_expert_reached":54,"graph_disconnection_failures":0,"no_supported_edge_failures":1,"optimal_path_length":323,"path_found":63,"path_length_regret":8,"state_aliasing_failures":0,"transition_model_error_failures":9},"retention_holdout":{"classification_checksum":"f9fd8a07e199fbec","correct":256,"expert_evaluations":2166,"prediction_checksum":"0163712eb28c4f2b","prediction_samples":244,"prediction_sse_q20":54275535004,"reconstruction_checksum":"9dfc8545bf0bf460","reconstruction_sse_q20":45070553939,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":254,"samples":256,"transition_checksum":"b262cdcbd93650dd","transition_correct":237,"transition_supported":244,"transition_unknown":12},"training_evaluations":1194833},"ravel_complete_scan_without_certification":{"checkpoint_size_bytes":44924,"drift_holdout":{"classification_checksum":"cc86778a658762ee","correct":256,"expert_evaluations":17152,"prediction_checksum":"3b60fd8d48bfa684","prediction_samples":237,"prediction_sse_q20":50348392519,"reconstruction_checksum":"3e6c53d9feb92df9","reconstruction_sse_q20":43819711257,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"018a6fadb7e8c925","transition_correct":229,"transition_supported":237,"transition_unknown":19},"expert_count":67,"planning":{"belief_set_target_reached":54,"cases":64,"checksum":"f416909b4bfb11ac","exact_world_state_target_reached":54,"executed_path_length":323,"expansions":2386,"goal_expert_reached":54,"graph_disconnection_failures":0,"no_supported_edge_failures":1,"optimal_path_length":323,"path_found":63,"path_length_regret":8,"state_aliasing_failures":0,"transition_model_error_failures":9},"retention_holdout":{"classification_checksum":"f9fd8a07e199fbec","correct":256,"expert_evaluations":17152,"prediction_checksum":"0163712eb28c4f2b","prediction_samples":244,"prediction_sse_q20":54275535004,"reconstruction_checksum":"9dfc8545bf0bf460","reconstruction_sse_q20":45070553939,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"b262cdcbd93650dd","transition_correct":237,"transition_supported":244,"transition_unknown":12},"training_evaluations":1374193},"ravel_no_birth_same_replay_iterations":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"20d9ef4aa7706113","correct":248,"expert_evaluations":2720,"prediction_checksum":"4493f0dc7adb4a40","prediction_samples":237,"prediction_sse_q20":55983877694,"reconstruction_checksum":"c73a13176ded7b62","reconstruction_sse_q20":49919464735,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":244,"samples":256,"transition_checksum":"42562ca55f11009d","transition_correct":226,"transition_supported":237,"transition_unknown":19},"expert_count":64,"planning":{"belief_set_target_reached":47,"cases":64,"checksum":"886cb1f192fd45bf","exact_world_state_target_reached":44,"executed_path_length":311,"expansions":2240,"goal_expert_reached":47,"graph_disconnection_failures":0,"no_supported_edge_failures":1,"optimal_path_length":323,"path_found":63,"path_length_regret":6,"state_aliasing_failures":3,"transition_model_error_failures":16},"retention_holdout":{"classification_checksum":"5f0b3871655ce3c8","correct":244,"expert_evaluations":2776,"prediction_checksum":"e767d6697354c275","prediction_samples":243,"prediction_sse_q20":64217820592,"reconstruction_checksum":"204c757fcac1de13","reconstruction_sse_q20":54536654777,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":243,"samples":256,"transition_checksum":"2641477fdcd470a4","transition_correct":231,"transition_supported":243,"transition_unknown":13},"training_evaluations":845696},"ravel_random_births":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"20d9ef4aa7706113","correct":248,"expert_evaluations":2720,"prediction_checksum":"4493f0dc7adb4a40","prediction_samples":237,"prediction_sse_q20":55983877694,"reconstruction_checksum":"c73a13176ded7b62","reconstruction_sse_q20":49919464735,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":244,"samples":256,"transition_checksum":"42562ca55f11009d","transition_correct":226,"transition_supported":237,"transition_unknown":19},"expert_count":64,"planning":{"belief_set_target_reached":47,"cases":64,"checksum":"886cb1f192fd45bf","exact_world_state_target_reached":44,"executed_path_length":311,"expansions":2240,"goal_expert_reached":47,"graph_disconnection_failures":0,"no_supported_edge_failures":1,"optimal_path_length":323,"path_found":63,"path_length_regret":6,"state_aliasing_failures":3,"transition_model_error_failures":16},"retention_holdout":{"classification_checksum":"5f0b3871655ce3c8","correct":244,"expert_evaluations":2776,"prediction_checksum":"e767d6697354c275","prediction_samples":243,"prediction_sse_q20":64217820592,"reconstruction_checksum":"204c757fcac1de13","reconstruction_sse_q20":54536654777,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":243,"samples":256,"transition_checksum":"2641477fdcd470a4","transition_correct":231,"transition_supported":243,"transition_unknown":13},"training_evaluations":845696},"ravel_without_replay":{"checkpoint_size_bytes":45494,"drift_holdout":{"classification_checksum":"2bd746222abe53e7","correct":256,"expert_evaluations":2288,"prediction_checksum":"24b4ae6aea8d3c8e","prediction_samples":231,"prediction_sse_q20":48649349866,"reconstruction_checksum":"d10add1c3b46cd31","reconstruction_sse_q20":43672058845,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":252,"samples":256,"transition_checksum":"815b2b19d62de416","transition_correct":222,"transition_supported":231,"transition_unknown":25},"expert_count":68,"planning":{"belief_set_target_reached":54,"cases":64,"checksum":"00214d67256c5607","exact_world_state_target_reached":54,"executed_path_length":325,"expansions":2351,"goal_expert_reached":54,"graph_disconnection_failures":0,"no_supported_edge_failures":1,"optimal_path_length":323,"path_found":63,"path_length_regret":10,"state_aliasing_failures":0,"transition_model_error_failures":9},"retention_holdout":{"classification_checksum":"b8dc1e2d4da1808a","correct":256,"expert_evaluations":2168,"prediction_checksum":"34eb45f1339f6920","prediction_samples":236,"prediction_sse_q20":52457216805,"reconstruction_checksum":"19559065c2b7481b","reconstruction_sse_q20":44944865703,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":254,"samples":256,"transition_checksum":"df065db70b08b975","transition_correct":231,"transition_supported":236,"transition_unknown":20},"training_evaluations":1081066},"ravel_without_retirement_matched_work":{"checkpoint_size_bytes":44924,"drift_holdout":{"classification_checksum":"cc86778a658762ee","correct":256,"expert_evaluations":2284,"prediction_checksum":"3b60fd8d48bfa684","prediction_samples":237,"prediction_sse_q20":50348392519,"reconstruction_checksum":"3e6c53d9feb92df9","reconstruction_sse_q20":43819711257,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":252,"samples":256,"transition_checksum":"018a6fadb7e8c925","transition_correct":229,"transition_supported":237,"transition_unknown":19},"expert_count":67,"planning":{"belief_set_target_reached":54,"cases":64,"checksum":"f416909b4bfb11ac","exact_world_state_target_reached":54,"executed_path_length":323,"expansions":2386,"goal_expert_reached":54,"graph_disconnection_failures":0,"no_supported_edge_failures":1,"optimal_path_length":323,"path_found":63,"path_length_regret":8,"state_aliasing_failures":0,"transition_model_error_failures":9},"retention_holdout":{"classification_checksum":"f9fd8a07e199fbec","correct":256,"expert_evaluations":2166,"prediction_checksum":"0163712eb28c4f2b","prediction_samples":244,"prediction_sse_q20":54275535004,"reconstruction_checksum":"9dfc8545bf0bf460","reconstruction_sse_q20":45070553939,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":254,"samples":256,"transition_checksum":"b262cdcbd93650dd","transition_correct":237,"transition_supported":244,"transition_unknown":12},"training_evaluations":1194833}},"dataset_seeds":{"base_holdout":"0xd7c0b91a18484529","base_training":"0x70890d917a6be9c2","drift_adaptation_training":"0xfda0a3e5706b6813","drift_holdout":"0x9e0c808ed160e40e","original_task_retention_holdout":"0x10e5a441b9d357d9","planning_cases":"0x0a8c16557f863b79"},"dataset_sizes":{"base_holdout":256,"base_training":1024,"drift_adaptation_training":512,"drift_holdout":256,"original_task_retention_holdout":256,"planning_cases":64},"integrity":{"checkpoint_behavior_match":true,"checkpoint_identity_match":true,"checkpoint_mutations":{"anchored_status":true,"appended_unexpected_byte":true,"checkpoint_substitution":true,"checkpoint_truncation":true,"incorrect_schema_version":true,"label":true,"label_count":true,"lineage":true,"next_observation_component":true,"payload_byte":true,"reconstruction_component":true,"retrieval_key_component":true,"transition_graph_edge":true,"transition_support":true},"checkpoint_roundtrip":true,"lineage_invariants":{"deterministic_topology_reproduction":true,"lineage_uniqueness":true,"no_accidental_lineage_reuse":true,"parent_child_generation_increment":true,"repeated_descendant_splitting":true,"sibling_generation_equality":true},"unsupported_graph_edge_violations":0},"regime":"partially_overlapping_observations","schema":"ravel-raw-trial/0.5","seed":"0xe38c303e80ef16a9","trial_id":"validation-overlap-03"},{"candidate":{"adaptation_completed":true,"adaptation_training":{"classification_checksum":"a8d014be43007971","correct":512,"expert_evaluations":4816,"prediction_checksum":"c055256189c3a52c","prediction_samples":470,"prediction_sse_q20":96882035803,"reconstruction_checksum":"22584553065addc4","reconstruction_sse_q20":90961385556,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":500,"samples":512,"transition_checksum":"63f8a5f55c298c34","transition_correct":457,"transition_supported":470,"transition_unknown":42},"adaptation_training_evaluations":707482,"adapted_model_drift_holdout":{"classification_checksum":"f3a1ff82743b2a98","correct":256,"expert_evaluations":2408,"prediction_checksum":"e55e4fd7be0abb61","prediction_samples":221,"prediction_sse_q20":47562667009,"reconstruction_checksum":"fda1840197018dfe","reconstruction_sse_q20":47004073806,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":250,"samples":256,"transition_checksum":"9c1ccd344d5d2329","transition_correct":213,"transition_supported":221,"transition_unknown":35},"base_holdout":{"classification_checksum":"5c47e8d182d3830e","correct":242,"expert_evaluations":3112,"prediction_checksum":"c947fe8aaf28cb7b","prediction_samples":239,"prediction_sse_q20":68785510730,"reconstruction_checksum":"b2c8c1b5bd0cca62","reconstruction_sse_q20":57605957941,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":237,"samples":256,"transition_checksum":"962dbf376e0c1956","transition_correct":221,"transition_supported":239,"transition_unknown":17},"base_holdout_retention":{"classification_checksum":"31013341db7e5178","correct":256,"expert_evaluations":2408,"prediction_checksum":"c4d549bc96c845f3","prediction_samples":236,"prediction_sse_q20":52543020106,"reconstruction_checksum":"9627f3d6e7616704","reconstruction_sse_q20":46504776364,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":250,"samples":256,"transition_checksum":"20b15e3923061e03","transition_correct":227,"transition_supported":236,"transition_unknown":20},"base_training_evaluations":624016,"behavior_identity":"93255d1dcef35a6e62165ca877297b4199f6b1d87fdfd89552230faef5731ede","checkpoint_size_bytes":45494,"expert_count":68,"model_identity":"24eb758d8a5ac02f5e59193b46d089695f7f735b907be235212e151b1bb54251","planning":{"belief_set_target_reached":59,"cases":64,"checksum":"1db155237871678e","exact_world_state_target_reached":59,"executed_path_length":278,"expansions":1957,"goal_expert_reached":59,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":273,"path_found":64,"path_length_regret":7,"state_aliasing_failures":0,"transition_model_error_failures":5},"replay":{"actions_covered":4,"assigned_experts_covered":64,"high_loss_cases_selected":13,"labels_covered":8,"rare_cases_selected":55,"selected":256,"selection_checksum":"65bad9cc9d27eaa8","states_covered":64,"transition_pairs_covered":252,"unique":256},"static_model_drift_holdout":{"classification_checksum":"88ad352a6b8ff7ce","correct":233,"expert_evaluations":3616,"prediction_checksum":"5a098298ac8978ff","prediction_samples":227,"prediction_sse_q20":69607939146,"reconstruction_checksum":"cd10359424c040e1","reconstruction_sse_q20":62678969528,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":228,"samples":256,"transition_checksum":"b40635989faea5e7","transition_correct":207,"transition_supported":227,"transition_unknown":29},"topology":{"accepted_births":4,"accepted_retirements":0,"births":[{"dominant_channel":0,"event_index":347,"normalized_score_q20":657247},{"dominant_channel":0,"event_index":374,"normalized_score_q20":531242},{"dominant_channel":0,"event_index":511,"normalized_score_q20":502901},{"dominant_channel":2,"event_index":33,"normalized_score_q20":305619}],"objective_after_q20":905710,"objective_before_q20":887728,"rejected_births":12,"rejected_retirements":1,"retired_lineages":[],"training_observations":{"births":4,"certified":8938,"expert_evaluations":707482,"rejected_births":12,"rejected_retirements":1,"retired":0,"samples":9216}}},"checkpoint_format":{"byte_order":"big_endian","magic_hex":"524156454c303500","payload_digest":"sha256","real_encoding":"signed_q20_int64","schema_version":5,"transition_support_min":2,"transition_top_k":2},"comparisons":{"fixed_8_expert":{"checkpoint_size_bytes":11294,"drift_holdout":{"classification_checksum":"fe69be40088073fe","correct":45,"expert_evaluations":2048,"prediction_checksum":"8e69513c6ac0d9f6","prediction_samples":256,"prediction_sse_q20":630452199579,"reconstruction_checksum":"3974b8fae3c05d66","reconstruction_sse_q20":543321812770,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"f74fb6b5688b4b04","transition_correct":180,"transition_supported":256,"transition_unknown":0},"expert_count":8,"planning":{"belief_set_target_reached":33,"cases":64,"checksum":"efb37aef79a24859","exact_world_state_target_reached":1,"executed_path_length":145,"expansions":320,"goal_expert_reached":33,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":273,"path_found":64,"path_length_regret":0,"state_aliasing_failures":32,"transition_model_error_failures":31},"retention_holdout":{"classification_checksum":"0c17af8cd87b78cb","correct":58,"expert_evaluations":2048,"prediction_checksum":"91ed7c7997887be9","prediction_samples":256,"prediction_sse_q20":650302895609,"reconstruction_checksum":"d9aa5d2d394be51d","reconstruction_sse_q20":547965543293,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"48c19288abd608bd","transition_correct":176,"transition_supported":256,"transition_unknown":0},"training_evaluations":94208},"fixed_topology_64_expert_routed":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"169a67b782a3c1dd","correct":256,"expert_evaluations":2048,"prediction_checksum":"922af6cfa22bd59e","prediction_samples":219,"prediction_sse_q20":44340033723,"reconstruction_checksum":"1eaf5350176bcbe2","reconstruction_sse_q20":43625443473,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"1d8dfa12a8f8b2c9","transition_correct":219,"transition_supported":219,"transition_unknown":37},"expert_count":64,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"358c12495208a293","exact_world_state_target_reached":64,"executed_path_length":285,"expansions":1912,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":273,"path_found":64,"path_length_regret":12,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"b88e0a4edc39ff18","correct":256,"expert_evaluations":2048,"prediction_checksum":"35fafb3a07f38f6b","prediction_samples":229,"prediction_sse_q20":47152877675,"reconstruction_checksum":"9a5883ffde51da7b","reconstruction_sse_q20":42114303332,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"8711ff8a8b94393e","transition_correct":229,"transition_supported":229,"transition_unknown":27},"training_evaluations":2588672},"flat_64_expert_complete_scan":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"169a67b782a3c1dd","correct":256,"expert_evaluations":16384,"prediction_checksum":"922af6cfa22bd59e","prediction_samples":219,"prediction_sse_q20":44340033723,"reconstruction_checksum":"1eaf5350176bcbe2","reconstruction_sse_q20":43625443473,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"1d8dfa12a8f8b2c9","transition_correct":219,"transition_supported":219,"transition_unknown":37},"expert_count":64,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"358c12495208a293","exact_world_state_target_reached":64,"executed_path_length":285,"expansions":1912,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":273,"path_found":64,"path_length_regret":12,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"b88e0a4edc39ff18","correct":256,"expert_evaluations":16384,"prediction_checksum":"35fafb3a07f38f6b","prediction_samples":229,"prediction_sse_q20":47152877675,"reconstruction_checksum":"9a5883ffde51da7b","reconstruction_sse_q20":42114303332,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"8711ff8a8b94393e","transition_correct":229,"transition_supported":229,"transition_unknown":27},"training_evaluations":2588672},"matched_compute_fixed_topology":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"88ad352a6b8ff7ce","correct":233,"expert_evaluations":3616,"prediction_checksum":"5a098298ac8978ff","prediction_samples":227,"prediction_sse_q20":69607939146,"reconstruction_checksum":"cd10359424c040e1","reconstruction_sse_q20":62678969528,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":228,"samples":256,"transition_checksum":"b40635989faea5e7","transition_correct":207,"transition_supported":227,"transition_unknown":29},"expert_count":64,"planning":{"belief_set_target_reached":52,"cases":64,"checksum":"21cb29298dc46c2e","exact_world_state_target_reached":49,"executed_path_length":259,"expansions":1872,"goal_expert_reached":52,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":273,"path_found":64,"path_length_regret":8,"state_aliasing_failures":3,"transition_model_error_failures":12},"retention_holdout":{"classification_checksum":"7d3f86722d07e51d","correct":245,"expert_evaluations":2888,"prediction_checksum":"884e6723e63b47be","prediction_samples":236,"prediction_sse_q20":60048519994,"reconstruction_checksum":"4f2474c9c8f4d6db","reconstruction_sse_q20":55042005632,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":241,"samples":256,"transition_checksum":"ad8b6bec13d867ed","transition_correct":224,"transition_supported":236,"transition_unknown":20},"training_evaluations":1553552},"matched_expert_count_capacity":{"checkpoint_size_bytes":45494,"drift_holdout":{"classification_checksum":"1b3011409f8256c2","correct":256,"expert_evaluations":2048,"prediction_checksum":"7d4e31ebac855b68","prediction_samples":212,"prediction_sse_q20":43361533199,"reconstruction_checksum":"2934f5d48bc156ae","reconstruction_sse_q20":43348235647,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"7b744128eb5f0342","transition_correct":204,"transition_supported":212,"transition_unknown":44},"expert_count":68,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"3e8eadf524bb6629","exact_world_state_target_reached":64,"executed_path_length":298,"expansions":2053,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":273,"path_found":64,"path_length_regret":25,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"c38f74131d1834d4","correct":256,"expert_evaluations":2048,"prediction_checksum":"23f1d205b4ff1e2f","prediction_samples":225,"prediction_sse_q20":46323248127,"reconstruction_checksum":"b7cc1e9e01066662","reconstruction_sse_q20":42080099743,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"cd5ab26d707dbe46","transition_correct":218,"transition_supported":225,"transition_unknown":31},"training_evaluations":2889728},"nearest_centroid_16_no_recursive_births":{"checkpoint_size_bytes":15854,"drift_holdout":{"classification_checksum":"6c84fdd068d5e8a0","correct":48,"expert_evaluations":4096,"prediction_checksum":"d7ce4b03270ac9a9","prediction_samples":256,"prediction_sse_q20":337441598478,"reconstruction_checksum":"d500627fae4ba9ca","reconstruction_sse_q20":310997682644,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"a6962559183abe53","transition_correct":256,"transition_supported":256,"transition_unknown":0},"expert_count":16,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"572dfe9de4ba431f","exact_world_state_target_reached":22,"executed_path_length":170,"expansions":606,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":273,"path_found":64,"path_length_regret":0,"state_aliasing_failures":42,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"de9456676d68f572","correct":58,"expert_evaluations":4096,"prediction_checksum":"9642277c429f7cb1","prediction_samples":256,"prediction_sse_q20":321828123206,"reconstruction_checksum":"c49714ce8fd17019","reconstruction_sse_q20":301619230014,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"96bf956778a06333","transition_correct":256,"transition_supported":256,"transition_unknown":0},"training_evaluations":253952},"no_adaptation_static":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"88ad352a6b8ff7ce","correct":233,"expert_evaluations":3616,"prediction_checksum":"5a098298ac8978ff","prediction_samples":227,"prediction_sse_q20":69607939146,"reconstruction_checksum":"cd10359424c040e1","reconstruction_sse_q20":62678969528,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":228,"samples":256,"transition_checksum":"b40635989faea5e7","transition_correct":207,"transition_supported":227,"transition_unknown":29},"expert_count":64,"planning":{"belief_set_target_reached":52,"cases":64,"checksum":"21cb29298dc46c2e","exact_world_state_target_reached":49,"executed_path_length":259,"expansions":1872,"goal_expert_reached":52,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":273,"path_found":64,"path_length_regret":8,"state_aliasing_failures":3,"transition_model_error_failures":12},"retention_holdout":{"classification_checksum":"7d3f86722d07e51d","correct":245,"expert_evaluations":2888,"prediction_checksum":"884e6723e63b47be","prediction_samples":236,"prediction_sse_q20":60048519994,"reconstruction_checksum":"4f2474c9c8f4d6db","reconstruction_sse_q20":55042005632,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":241,"samples":256,"transition_checksum":"ad8b6bec13d867ed","transition_correct":224,"transition_supported":236,"transition_unknown":20},"training_evaluations":624016},"periodic_replay_policy":{"checkpoint_size_bytes":44924,"drift_holdout":{"classification_checksum":"7f47a2f1646c21dc","correct":256,"expert_evaluations":2402,"prediction_checksum":"c295e86812f13cbc","prediction_samples":225,"prediction_sse_q20":48715669777,"reconstruction_checksum":"daeb587f2d2bc541","reconstruction_sse_q20":47396251508,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":250,"samples":256,"transition_checksum":"b04c5872045ee7d4","transition_correct":218,"transition_supported":225,"transition_unknown":31},"expert_count":67,"planning":{"belief_set_target_reached":60,"cases":64,"checksum":"3febf04293de6c58","exact_world_state_target_reached":60,"executed_path_length":277,"expansions":1937,"goal_expert_reached":60,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":273,"path_found":64,"path_length_regret":7,"state_aliasing_failures":0,"transition_model_error_failures":4},"retention_holdout":{"classification_checksum":"31013341db7e5178","correct":256,"expert_evaluations":2402,"prediction_checksum":"fb5614bf79d090cf","prediction_samples":236,"prediction_sse_q20":52754945432,"reconstruction_checksum":"e0a1737a9222c7cf","reconstruction_sse_q20":46501045268,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":250,"samples":256,"transition_checksum":"97ad1f9a1fda860d","transition_correct":230,"transition_supported":236,"transition_unknown":20},"training_evaluations":1207370},"ravel_0_5_candidate":{"checkpoint_size_bytes":45494,"drift_holdout":{"classification_checksum":"f3a1ff82743b2a98","correct":256,"expert_evaluations":2408,"prediction_checksum":"e55e4fd7be0abb61","prediction_samples":221,"prediction_sse_q20":47562667009,"reconstruction_checksum":"fda1840197018dfe","reconstruction_sse_q20":47004073806,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":250,"samples":256,"transition_checksum":"9c1ccd344d5d2329","transition_correct":213,"transition_supported":221,"transition_unknown":35},"expert_count":68,"planning":{"belief_set_target_reached":59,"cases":64,"checksum":"1db155237871678e","exact_world_state_target_reached":59,"executed_path_length":278,"expansions":1957,"goal_expert_reached":59,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":273,"path_found":64,"path_length_regret":7,"state_aliasing_failures":0,"transition_model_error_failures":5},"retention_holdout":{"classification_checksum":"31013341db7e5178","correct":256,"expert_evaluations":2408,"prediction_checksum":"c4d549bc96c845f3","prediction_samples":236,"prediction_sse_q20":52543020106,"reconstruction_checksum":"9627f3d6e7616704","reconstruction_sse_q20":46504776364,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":250,"samples":256,"transition_checksum":"20b15e3923061e03","transition_correct":227,"transition_supported":236,"transition_unknown":20},"training_evaluations":1331498},"ravel_complete_scan_without_certification":{"checkpoint_size_bytes":45494,"drift_holdout":{"classification_checksum":"f3a1ff82743b2a98","correct":256,"expert_evaluations":17408,"prediction_checksum":"e55e4fd7be0abb61","prediction_samples":221,"prediction_sse_q20":47562667009,"reconstruction_checksum":"fda1840197018dfe","reconstruction_sse_q20":47004073806,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"9c1ccd344d5d2329","transition_correct":213,"transition_supported":221,"transition_unknown":35},"expert_count":68,"planning":{"belief_set_target_reached":59,"cases":64,"checksum":"1db155237871678e","exact_world_state_target_reached":59,"executed_path_length":278,"expansions":1957,"goal_expert_reached":59,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":273,"path_found":64,"path_length_regret":7,"state_aliasing_failures":0,"transition_model_error_failures":5},"retention_holdout":{"classification_checksum":"31013341db7e5178","correct":256,"expert_evaluations":17408,"prediction_checksum":"c4d549bc96c845f3","prediction_samples":236,"prediction_sse_q20":52543020106,"reconstruction_checksum":"9627f3d6e7616704","reconstruction_sse_q20":46504776364,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"20b15e3923061e03","transition_correct":227,"transition_supported":236,"transition_unknown":20},"training_evaluations":1511738},"ravel_no_birth_same_replay_iterations":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"88ad352a6b8ff7ce","correct":233,"expert_evaluations":3616,"prediction_checksum":"5a098298ac8978ff","prediction_samples":227,"prediction_sse_q20":69607939146,"reconstruction_checksum":"cd10359424c040e1","reconstruction_sse_q20":62678969528,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":228,"samples":256,"transition_checksum":"b40635989faea5e7","transition_correct":207,"transition_supported":227,"transition_unknown":29},"expert_count":64,"planning":{"belief_set_target_reached":52,"cases":64,"checksum":"21cb29298dc46c2e","exact_world_state_target_reached":49,"executed_path_length":259,"expansions":1872,"goal_expert_reached":52,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":273,"path_found":64,"path_length_regret":8,"state_aliasing_failures":3,"transition_model_error_failures":12},"retention_holdout":{"classification_checksum":"7d3f86722d07e51d","correct":245,"expert_evaluations":2888,"prediction_checksum":"884e6723e63b47be","prediction_samples":236,"prediction_sse_q20":60048519994,"reconstruction_checksum":"4f2474c9c8f4d6db","reconstruction_sse_q20":55042005632,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":241,"samples":256,"transition_checksum":"ad8b6bec13d867ed","transition_correct":224,"transition_supported":236,"transition_unknown":20},"training_evaluations":856400},"ravel_random_births":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"88ad352a6b8ff7ce","correct":233,"expert_evaluations":3616,"prediction_checksum":"5a098298ac8978ff","prediction_samples":227,"prediction_sse_q20":69607939146,"reconstruction_checksum":"cd10359424c040e1","reconstruction_sse_q20":62678969528,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":228,"samples":256,"transition_checksum":"b40635989faea5e7","transition_correct":207,"transition_supported":227,"transition_unknown":29},"expert_count":64,"planning":{"belief_set_target_reached":52,"cases":64,"checksum":"21cb29298dc46c2e","exact_world_state_target_reached":49,"executed_path_length":259,"expansions":1872,"goal_expert_reached":52,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":273,"path_found":64,"path_length_regret":8,"state_aliasing_failures":3,"transition_model_error_failures":12},"retention_holdout":{"classification_checksum":"7d3f86722d07e51d","correct":245,"expert_evaluations":2888,"prediction_checksum":"884e6723e63b47be","prediction_samples":236,"prediction_sse_q20":60048519994,"reconstruction_checksum":"4f2474c9c8f4d6db","reconstruction_sse_q20":55042005632,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":241,"samples":256,"transition_checksum":"ad8b6bec13d867ed","transition_correct":224,"transition_supported":236,"transition_unknown":20},"training_evaluations":856400},"ravel_without_replay":{"checkpoint_size_bytes":45494,"drift_holdout":{"classification_checksum":"f3a1ff82743b2a98","correct":256,"expert_evaluations":2408,"prediction_checksum":"0aecf6202833d44f","prediction_samples":217,"prediction_sse_q20":47239966579,"reconstruction_checksum":"8063fd864f919224","reconstruction_sse_q20":47001243570,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":250,"samples":256,"transition_checksum":"8c1fff96e5f8eead","transition_correct":209,"transition_supported":217,"transition_unknown":39},"expert_count":68,"planning":{"belief_set_target_reached":59,"cases":64,"checksum":"1db155237871678e","exact_world_state_target_reached":59,"executed_path_length":278,"expansions":1949,"goal_expert_reached":59,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":273,"path_found":64,"path_length_regret":7,"state_aliasing_failures":0,"transition_model_error_failures":5},"retention_holdout":{"classification_checksum":"31013341db7e5178","correct":256,"expert_evaluations":2408,"prediction_checksum":"1bebd2ab7fcecec0","prediction_samples":236,"prediction_sse_q20":53034592240,"reconstruction_checksum":"2db8fa59bb90b64c","reconstruction_sse_q20":46505185542,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":250,"samples":256,"transition_checksum":"20b15e3923061e03","transition_correct":227,"transition_supported":236,"transition_unknown":20},"training_evaluations":1095940},"ravel_without_retirement_matched_work":{"checkpoint_size_bytes":45494,"drift_holdout":{"classification_checksum":"f3a1ff82743b2a98","correct":256,"expert_evaluations":2408,"prediction_checksum":"e55e4fd7be0abb61","prediction_samples":221,"prediction_sse_q20":47562667009,"reconstruction_checksum":"fda1840197018dfe","reconstruction_sse_q20":47004073806,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":250,"samples":256,"transition_checksum":"9c1ccd344d5d2329","transition_correct":213,"transition_supported":221,"transition_unknown":35},"expert_count":68,"planning":{"belief_set_target_reached":59,"cases":64,"checksum":"1db155237871678e","exact_world_state_target_reached":59,"executed_path_length":278,"expansions":1957,"goal_expert_reached":59,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":273,"path_found":64,"path_length_regret":7,"state_aliasing_failures":0,"transition_model_error_failures":5},"retention_holdout":{"classification_checksum":"31013341db7e5178","correct":256,"expert_evaluations":2408,"prediction_checksum":"c4d549bc96c845f3","prediction_samples":236,"prediction_sse_q20":52543020106,"reconstruction_checksum":"9627f3d6e7616704","reconstruction_sse_q20":46504776364,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":250,"samples":256,"transition_checksum":"20b15e3923061e03","transition_correct":227,"transition_supported":236,"transition_unknown":20},"training_evaluations":1331498}},"dataset_seeds":{"base_holdout":"0xd0e52c923e596462","base_training":"0x1b0e2c07203e5d05","drift_adaptation_training":"0x66a8a29e830bf766","drift_holdout":"0x93539a2150c7c975","original_task_retention_holdout":"0xf731ee2aa463eb47","planning_cases":"0x2f279b47af034483"},"dataset_sizes":{"base_holdout":256,"base_training":1024,"drift_adaptation_training":512,"drift_holdout":256,"original_task_retention_holdout":256,"planning_cases":64},"integrity":{"checkpoint_behavior_match":true,"checkpoint_identity_match":true,"checkpoint_mutations":{"anchored_status":true,"appended_unexpected_byte":true,"checkpoint_substitution":true,"checkpoint_truncation":true,"incorrect_schema_version":true,"label":true,"label_count":true,"lineage":true,"next_observation_component":true,"payload_byte":true,"reconstruction_component":true,"retrieval_key_component":true,"transition_graph_edge":true,"transition_support":true},"checkpoint_roundtrip":true,"lineage_invariants":{"deterministic_topology_reproduction":true,"lineage_uniqueness":true,"no_accidental_lineage_reuse":true,"parent_child_generation_increment":true,"repeated_descendant_splitting":true,"sibling_generation_equality":true},"unsupported_graph_edge_violations":0},"regime":"partially_overlapping_observations","schema":"ravel-raw-trial/0.5","seed":"0xb240684596a68108","trial_id":"validation-overlap-04"},{"candidate":{"adaptation_completed":true,"adaptation_training":{"classification_checksum":"d9de51e356903cec","correct":512,"expert_evaluations":4523,"prediction_checksum":"b8612109ebb605a3","prediction_samples":477,"prediction_sse_q20":613669009163,"reconstruction_checksum":"9086f1c506f96dab","reconstruction_sse_q20":596551713517,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":505,"samples":512,"transition_checksum":"c9d7243aa3678e5f","transition_correct":451,"transition_supported":477,"transition_unknown":35},"adaptation_training_evaluations":821688,"adapted_model_drift_holdout":{"classification_checksum":"152b7bc00d4827fe","correct":256,"expert_evaluations":2353,"prediction_checksum":"a1ccbc8b9ae33cc6","prediction_samples":239,"prediction_sse_q20":318074681753,"reconstruction_checksum":"fb07617de6ee3709","reconstruction_sse_q20":295325372570,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":251,"samples":256,"transition_checksum":"57ab5aa6a0983e05","transition_correct":222,"transition_supported":239,"transition_unknown":17},"base_holdout":{"classification_checksum":"75987469a5594e2b","correct":238,"expert_evaluations":2272,"prediction_checksum":"760306ad17f45f1d","prediction_samples":240,"prediction_sse_q20":219383397971,"reconstruction_checksum":"b73f63710d09006a","reconstruction_sse_q20":187926249918,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":252,"samples":256,"transition_checksum":"6a887fcb7bdc60b8","transition_correct":218,"transition_supported":240,"transition_unknown":16},"base_holdout_retention":{"classification_checksum":"ae9556bb0e9fb459","correct":256,"expert_evaluations":2170,"prediction_checksum":"2b861979649349c3","prediction_samples":241,"prediction_sse_q20":197757306496,"reconstruction_checksum":"b5fd2a79108abdd0","reconstruction_sse_q20":168418598285,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":254,"samples":256,"transition_checksum":"bc28cf1fe12c93e0","transition_correct":227,"transition_supported":241,"transition_unknown":15},"base_training_evaluations":565216,"behavior_identity":"d10269e5acdb11ea4458a83f59b8f34c432a7604f38bccbf46df4491708ca6bc","checkpoint_size_bytes":46064,"expert_count":69,"model_identity":"097dd98e995a73edd586a3cba51e06f5079c1b723992720b3262f7c619d709e4","planning":{"belief_set_target_reached":46,"cases":64,"checksum":"af23b1f6b6e48a93","exact_world_state_target_reached":46,"executed_path_length":261,"expansions":2162,"goal_expert_reached":46,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":285,"path_found":64,"path_length_regret":11,"state_aliasing_failures":0,"transition_model_error_failures":18},"replay":{"actions_covered":4,"assigned_experts_covered":63,"high_loss_cases_selected":14,"labels_covered":8,"rare_cases_selected":54,"selected":256,"selection_checksum":"4590cb241ebf4483","states_covered":64,"transition_pairs_covered":252,"unique":256},"static_model_drift_holdout":{"classification_checksum":"3b0564ff8ba29b52","correct":231,"expert_evaluations":2608,"prediction_checksum":"bfdea4ac2cf57dd3","prediction_samples":239,"prediction_sse_q20":385107874252,"reconstruction_checksum":"72f0f80c75094f8b","reconstruction_sse_q20":358091478050,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":246,"samples":256,"transition_checksum":"a100fc28b292837b","transition_correct":213,"transition_supported":239,"transition_unknown":17},"topology":{"accepted_births":5,"accepted_retirements":0,"births":[{"dominant_channel":0,"event_index":370,"normalized_score_q20":546848},{"dominant_channel":0,"event_index":176,"normalized_score_q20":526347},{"dominant_channel":0,"event_index":71,"normalized_score_q20":522302},{"dominant_channel":0,"event_index":123,"normalized_score_q20":522199},{"dominant_channel":2,"event_index":183,"normalized_score_q20":319078}],"objective_after_q20":887897,"objective_before_q20":866626,"rejected_births":11,"rejected_retirements":1,"retired_lineages":[],"training_observations":{"births":5,"certified":10598,"expert_evaluations":821688,"rejected_births":11,"rejected_retirements":1,"retired":0,"samples":10752}}},"checkpoint_format":{"byte_order":"big_endian","magic_hex":"524156454c303500","payload_digest":"sha256","real_encoding":"signed_q20_int64","schema_version":5,"transition_support_min":2,"transition_top_k":2},"comparisons":{"fixed_8_expert":{"checkpoint_size_bytes":11294,"drift_holdout":{"classification_checksum":"70cb782b6829af9f","correct":48,"expert_evaluations":2048,"prediction_checksum":"3a3ba000fbc3e7c9","prediction_samples":256,"prediction_sse_q20":2301031124649,"reconstruction_checksum":"fff4f693abbd3a50","reconstruction_sse_q20":1914560054643,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"ac938876aeb4c315","transition_correct":123,"transition_supported":256,"transition_unknown":0},"expert_count":8,"planning":{"belief_set_target_reached":22,"cases":64,"checksum":"216c0e48a557f368","exact_world_state_target_reached":3,"executed_path_length":57,"expansions":220,"goal_expert_reached":22,"graph_disconnection_failures":24,"no_supported_edge_failures":0,"optimal_path_length":285,"path_found":40,"path_length_regret":2,"state_aliasing_failures":19,"transition_model_error_failures":18},"retention_holdout":{"classification_checksum":"fb334e54f702e516","correct":56,"expert_evaluations":2048,"prediction_checksum":"ad1506e4a42f7b9d","prediction_samples":256,"prediction_sse_q20":2141119944390,"reconstruction_checksum":"713c71d597ba5131","reconstruction_sse_q20":1905304735398,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"2b05e54fc051ebec","transition_correct":124,"transition_supported":256,"transition_unknown":0},"training_evaluations":94208},"fixed_topology_64_expert_routed":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"c812e6882cdc04b9","correct":256,"expert_evaluations":2160,"prediction_checksum":"8c0c7afa092d8e10","prediction_samples":241,"prediction_sse_q20":291562777430,"reconstruction_checksum":"a862c80dfcea4a0c","reconstruction_sse_q20":277831142669,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":254,"samples":256,"transition_checksum":"f983cbc36be5ef34","transition_correct":241,"transition_supported":241,"transition_unknown":15},"expert_count":64,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"e6201b24c8569c2d","exact_world_state_target_reached":64,"executed_path_length":297,"expansions":2099,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":285,"path_found":64,"path_length_regret":12,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"140e4d81fa7c11bd","correct":256,"expert_evaluations":2048,"prediction_checksum":"60a8b18e23d728b4","prediction_samples":241,"prediction_sse_q20":154082639269,"reconstruction_checksum":"d304794ddd70bac0","reconstruction_sse_q20":145213088458,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"cdbedc18650f726c","transition_correct":241,"transition_supported":241,"transition_unknown":15},"training_evaluations":2588672},"flat_64_expert_complete_scan":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"c812e6882cdc04b9","correct":256,"expert_evaluations":16384,"prediction_checksum":"8c0c7afa092d8e10","prediction_samples":241,"prediction_sse_q20":291562777430,"reconstruction_checksum":"a862c80dfcea4a0c","reconstruction_sse_q20":277831142669,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"f983cbc36be5ef34","transition_correct":241,"transition_supported":241,"transition_unknown":15},"expert_count":64,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"e6201b24c8569c2d","exact_world_state_target_reached":64,"executed_path_length":297,"expansions":2099,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":285,"path_found":64,"path_length_regret":12,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"140e4d81fa7c11bd","correct":256,"expert_evaluations":16384,"prediction_checksum":"60a8b18e23d728b4","prediction_samples":241,"prediction_sse_q20":154082639269,"reconstruction_checksum":"d304794ddd70bac0","reconstruction_sse_q20":145213088458,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"cdbedc18650f726c","transition_correct":241,"transition_supported":241,"transition_unknown":15},"training_evaluations":2588672},"matched_compute_fixed_topology":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"3b0564ff8ba29b52","correct":231,"expert_evaluations":2608,"prediction_checksum":"bfdea4ac2cf57dd3","prediction_samples":239,"prediction_sse_q20":385107874252,"reconstruction_checksum":"72f0f80c75094f8b","reconstruction_sse_q20":358091478050,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":246,"samples":256,"transition_checksum":"a100fc28b292837b","transition_correct":213,"transition_supported":239,"transition_unknown":17},"expert_count":64,"planning":{"belief_set_target_reached":42,"cases":64,"checksum":"e318a868428fecfa","exact_world_state_target_reached":37,"executed_path_length":241,"expansions":1978,"goal_expert_reached":42,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":285,"path_found":64,"path_length_regret":12,"state_aliasing_failures":5,"transition_model_error_failures":22},"retention_holdout":{"classification_checksum":"0b25a95feb25d541","correct":237,"expert_evaluations":2216,"prediction_checksum":"6e5115b0cb3bf646","prediction_samples":241,"prediction_sse_q20":239214536605,"reconstruction_checksum":"8d0c5f95c9418fff","reconstruction_sse_q20":220261553623,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":253,"samples":256,"transition_checksum":"5a712ffc54252237","transition_correct":222,"transition_supported":241,"transition_unknown":15},"training_evaluations":1465184},"matched_expert_count_capacity":{"checkpoint_size_bytes":46064,"drift_holdout":{"classification_checksum":"ca62ecb38e784f92","correct":256,"expert_evaluations":2231,"prediction_checksum":"df82957633cc8e5a","prediction_samples":228,"prediction_sse_q20":277227057488,"reconstruction_checksum":"0dfc46cf55b7925a","reconstruction_sse_q20":274862452453,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":253,"samples":256,"transition_checksum":"bd0d34e040a916c1","transition_correct":220,"transition_supported":228,"transition_unknown":28},"expert_count":69,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"7462c9de70ffeb33","exact_world_state_target_reached":64,"executed_path_length":298,"expansions":2175,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":285,"path_found":64,"path_length_regret":13,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"fc0df55fc6a2d747","correct":256,"expert_evaluations":2048,"prediction_checksum":"13ce5b89bda2de5b","prediction_samples":237,"prediction_sse_q20":152367835500,"reconstruction_checksum":"65921281e25bf9e2","reconstruction_sse_q20":144709802798,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"03c6bdd5e5dc30d8","transition_correct":230,"transition_supported":237,"transition_unknown":19},"training_evaluations":2967552},"nearest_centroid_16_no_recursive_births":{"checkpoint_size_bytes":15854,"drift_holdout":{"classification_checksum":"4e6cfb81ae0f2a72","correct":80,"expert_evaluations":4096,"prediction_checksum":"2729a780a577ea83","prediction_samples":256,"prediction_sse_q20":1623933214716,"reconstruction_checksum":"259a46a6b98e7c93","reconstruction_sse_q20":1337678748275,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"cd0e47b5e1de1488","transition_correct":148,"transition_supported":256,"transition_unknown":0},"expert_count":16,"planning":{"belief_set_target_reached":27,"cases":64,"checksum":"faf8ae57db8f245e","exact_world_state_target_reached":9,"executed_path_length":188,"expansions":524,"goal_expert_reached":27,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":285,"path_found":64,"path_length_regret":3,"state_aliasing_failures":18,"transition_model_error_failures":37},"retention_holdout":{"classification_checksum":"84fb7bd3f5633840","correct":78,"expert_evaluations":4096,"prediction_checksum":"9952ad3e5d066bb7","prediction_samples":256,"prediction_sse_q20":1504581453969,"reconstruction_checksum":"9ec5a4a5d84a9db5","reconstruction_sse_q20":1281074666595,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"e49a4e5074c951c7","transition_correct":150,"transition_supported":256,"transition_unknown":0},"training_evaluations":253952},"no_adaptation_static":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"3b0564ff8ba29b52","correct":231,"expert_evaluations":2608,"prediction_checksum":"bfdea4ac2cf57dd3","prediction_samples":239,"prediction_sse_q20":385107874252,"reconstruction_checksum":"72f0f80c75094f8b","reconstruction_sse_q20":358091478050,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":246,"samples":256,"transition_checksum":"a100fc28b292837b","transition_correct":213,"transition_supported":239,"transition_unknown":17},"expert_count":64,"planning":{"belief_set_target_reached":42,"cases":64,"checksum":"e318a868428fecfa","exact_world_state_target_reached":37,"executed_path_length":241,"expansions":1978,"goal_expert_reached":42,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":285,"path_found":64,"path_length_regret":12,"state_aliasing_failures":5,"transition_model_error_failures":22},"retention_holdout":{"classification_checksum":"0b25a95feb25d541","correct":237,"expert_evaluations":2216,"prediction_checksum":"6e5115b0cb3bf646","prediction_samples":241,"prediction_sse_q20":239214536605,"reconstruction_checksum":"8d0c5f95c9418fff","reconstruction_sse_q20":220261553623,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":253,"samples":256,"transition_checksum":"5a712ffc54252237","transition_correct":222,"transition_supported":241,"transition_unknown":15},"training_evaluations":565216},"periodic_replay_policy":{"checkpoint_size_bytes":45494,"drift_holdout":{"classification_checksum":"152b7bc00d4827fe","correct":256,"expert_evaluations":2348,"prediction_checksum":"d53b3ea179371aa9","prediction_samples":234,"prediction_sse_q20":311475143967,"reconstruction_checksum":"597d56ee7e70767b","reconstruction_sse_q20":295985315545,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":251,"samples":256,"transition_checksum":"7a2c525ed178b46b","transition_correct":217,"transition_supported":234,"transition_unknown":22},"expert_count":68,"planning":{"belief_set_target_reached":46,"cases":64,"checksum":"af23b1f6b6e48a93","exact_world_state_target_reached":46,"executed_path_length":261,"expansions":2136,"goal_expert_reached":46,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":285,"path_found":64,"path_length_regret":11,"state_aliasing_failures":0,"transition_model_error_failures":18},"retention_holdout":{"classification_checksum":"ae9556bb0e9fb459","correct":256,"expert_evaluations":2168,"prediction_checksum":"02f144beda33d818","prediction_samples":236,"prediction_sse_q20":193077489896,"reconstruction_checksum":"0394cef5814fbfae","reconstruction_sse_q20":169674274718,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":254,"samples":256,"transition_checksum":"4761879185a996cd","transition_correct":222,"transition_supported":236,"transition_unknown":20},"training_evaluations":1146264},"ravel_0_5_candidate":{"checkpoint_size_bytes":46064,"drift_holdout":{"classification_checksum":"152b7bc00d4827fe","correct":256,"expert_evaluations":2353,"prediction_checksum":"a1ccbc8b9ae33cc6","prediction_samples":239,"prediction_sse_q20":318074681753,"reconstruction_checksum":"fb07617de6ee3709","reconstruction_sse_q20":295325372570,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":251,"samples":256,"transition_checksum":"57ab5aa6a0983e05","transition_correct":222,"transition_supported":239,"transition_unknown":17},"expert_count":69,"planning":{"belief_set_target_reached":46,"cases":64,"checksum":"af23b1f6b6e48a93","exact_world_state_target_reached":46,"executed_path_length":261,"expansions":2162,"goal_expert_reached":46,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":285,"path_found":64,"path_length_regret":11,"state_aliasing_failures":0,"transition_model_error_failures":18},"retention_holdout":{"classification_checksum":"ae9556bb0e9fb459","correct":256,"expert_evaluations":2170,"prediction_checksum":"2b861979649349c3","prediction_samples":241,"prediction_sse_q20":197757306496,"reconstruction_checksum":"b5fd2a79108abdd0","reconstruction_sse_q20":168418598285,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":254,"samples":256,"transition_checksum":"bc28cf1fe12c93e0","transition_correct":227,"transition_supported":241,"transition_unknown":15},"training_evaluations":1386904},"ravel_complete_scan_without_certification":{"checkpoint_size_bytes":46064,"drift_holdout":{"classification_checksum":"152b7bc00d4827fe","correct":256,"expert_evaluations":17664,"prediction_checksum":"a1ccbc8b9ae33cc6","prediction_samples":239,"prediction_sse_q20":318074681753,"reconstruction_checksum":"fb07617de6ee3709","reconstruction_sse_q20":295325372570,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"57ab5aa6a0983e05","transition_correct":222,"transition_supported":239,"transition_unknown":17},"expert_count":69,"planning":{"belief_set_target_reached":46,"cases":64,"checksum":"af23b1f6b6e48a93","exact_world_state_target_reached":46,"executed_path_length":261,"expansions":2162,"goal_expert_reached":46,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":285,"path_found":64,"path_length_regret":11,"state_aliasing_failures":0,"transition_model_error_failures":18},"retention_holdout":{"classification_checksum":"ae9556bb0e9fb459","correct":256,"expert_evaluations":17664,"prediction_checksum":"2b861979649349c3","prediction_samples":241,"prediction_sse_q20":197757306496,"reconstruction_checksum":"b5fd2a79108abdd0","reconstruction_sse_q20":168418598285,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"bc28cf1fe12c93e0","transition_correct":227,"transition_supported":241,"transition_unknown":15},"training_evaluations":1571856},"ravel_no_birth_same_replay_iterations":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"3b0564ff8ba29b52","correct":231,"expert_evaluations":2608,"prediction_checksum":"bfdea4ac2cf57dd3","prediction_samples":239,"prediction_sse_q20":385107874252,"reconstruction_checksum":"72f0f80c75094f8b","reconstruction_sse_q20":358091478050,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":246,"samples":256,"transition_checksum":"a100fc28b292837b","transition_correct":213,"transition_supported":239,"transition_unknown":17},"expert_count":64,"planning":{"belief_set_target_reached":42,"cases":64,"checksum":"e318a868428fecfa","exact_world_state_target_reached":37,"executed_path_length":241,"expansions":1978,"goal_expert_reached":42,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":285,"path_found":64,"path_length_regret":12,"state_aliasing_failures":5,"transition_model_error_failures":22},"retention_holdout":{"classification_checksum":"0b25a95feb25d541","correct":237,"expert_evaluations":2216,"prediction_checksum":"6e5115b0cb3bf646","prediction_samples":241,"prediction_sse_q20":239214536605,"reconstruction_checksum":"8d0c5f95c9418fff","reconstruction_sse_q20":220261553623,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":253,"samples":256,"transition_checksum":"5a712ffc54252237","transition_correct":222,"transition_supported":241,"transition_unknown":15},"training_evaluations":790208},"ravel_random_births":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"3b0564ff8ba29b52","correct":231,"expert_evaluations":2608,"prediction_checksum":"bfdea4ac2cf57dd3","prediction_samples":239,"prediction_sse_q20":385107874252,"reconstruction_checksum":"72f0f80c75094f8b","reconstruction_sse_q20":358091478050,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":246,"samples":256,"transition_checksum":"a100fc28b292837b","transition_correct":213,"transition_supported":239,"transition_unknown":17},"expert_count":64,"planning":{"belief_set_target_reached":42,"cases":64,"checksum":"e318a868428fecfa","exact_world_state_target_reached":37,"executed_path_length":241,"expansions":1978,"goal_expert_reached":42,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":285,"path_found":64,"path_length_regret":12,"state_aliasing_failures":5,"transition_model_error_failures":22},"retention_holdout":{"classification_checksum":"0b25a95feb25d541","correct":237,"expert_evaluations":2216,"prediction_checksum":"6e5115b0cb3bf646","prediction_samples":241,"prediction_sse_q20":239214536605,"reconstruction_checksum":"8d0c5f95c9418fff","reconstruction_sse_q20":220261553623,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":253,"samples":256,"transition_checksum":"5a712ffc54252237","transition_correct":222,"transition_supported":241,"transition_unknown":15},"training_evaluations":790208},"ravel_without_replay":{"checkpoint_size_bytes":46064,"drift_holdout":{"classification_checksum":"f2d968b26ab5d74a","correct":256,"expert_evaluations":2414,"prediction_checksum":"5c75a7eb7082cee8","prediction_samples":229,"prediction_sse_q20":303388321983,"reconstruction_checksum":"fdcfaae9bccf87d9","reconstruction_sse_q20":295900114079,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":250,"samples":256,"transition_checksum":"5d04471e974ece2a","transition_correct":210,"transition_supported":229,"transition_unknown":27},"expert_count":69,"planning":{"belief_set_target_reached":46,"cases":64,"checksum":"af23b1f6b6e48a93","exact_world_state_target_reached":46,"executed_path_length":261,"expansions":2115,"goal_expert_reached":46,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":285,"path_found":64,"path_length_regret":11,"state_aliasing_failures":0,"transition_model_error_failures":18},"retention_holdout":{"classification_checksum":"ae9556bb0e9fb459","correct":256,"expert_evaluations":2170,"prediction_checksum":"34ff32a6b69ee410","prediction_samples":234,"prediction_sse_q20":192578760994,"reconstruction_checksum":"2b770f49cc10b3a5","reconstruction_sse_q20":169687985191,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":254,"samples":256,"transition_checksum":"cef941fd7ee120f9","transition_correct":220,"transition_supported":234,"transition_unknown":22},"training_evaluations":1035812},"ravel_without_retirement_matched_work":{"checkpoint_size_bytes":46064,"drift_holdout":{"classification_checksum":"152b7bc00d4827fe","correct":256,"expert_evaluations":2353,"prediction_checksum":"a1ccbc8b9ae33cc6","prediction_samples":239,"prediction_sse_q20":318074681753,"reconstruction_checksum":"fb07617de6ee3709","reconstruction_sse_q20":295325372570,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":251,"samples":256,"transition_checksum":"57ab5aa6a0983e05","transition_correct":222,"transition_supported":239,"transition_unknown":17},"expert_count":69,"planning":{"belief_set_target_reached":46,"cases":64,"checksum":"af23b1f6b6e48a93","exact_world_state_target_reached":46,"executed_path_length":261,"expansions":2162,"goal_expert_reached":46,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":285,"path_found":64,"path_length_regret":11,"state_aliasing_failures":0,"transition_model_error_failures":18},"retention_holdout":{"classification_checksum":"ae9556bb0e9fb459","correct":256,"expert_evaluations":2170,"prediction_checksum":"2b861979649349c3","prediction_samples":241,"prediction_sse_q20":197757306496,"reconstruction_checksum":"b5fd2a79108abdd0","reconstruction_sse_q20":168418598285,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":254,"samples":256,"transition_checksum":"bc28cf1fe12c93e0","transition_correct":227,"transition_supported":241,"transition_unknown":15},"training_evaluations":1386904}},"dataset_seeds":{"base_holdout":"0x550afcb6fe3de0c5","base_training":"0x27d5badcc6fd50e4","drift_adaptation_training":"0xc7691a7eabaf945f","drift_holdout":"0x128830bfc2bb2c7b","original_task_retention_holdout":"0x013eda3b78e16d10","planning_cases":"0xeccf17d264ce6792"},"dataset_sizes":{"base_holdout":256,"base_training":1024,"drift_adaptation_training":512,"drift_holdout":256,"original_task_retention_holdout":256,"planning_cases":64},"integrity":{"checkpoint_behavior_match":true,"checkpoint_identity_match":true,"checkpoint_mutations":{"anchored_status":true,"appended_unexpected_byte":true,"checkpoint_substitution":true,"checkpoint_truncation":true,"incorrect_schema_version":true,"label":true,"label_count":true,"lineage":true,"next_observation_component":true,"payload_byte":true,"reconstruction_component":true,"retrieval_key_component":true,"transition_graph_edge":true,"transition_support":true},"checkpoint_roundtrip":true,"lineage_invariants":{"deterministic_topology_reproduction":true,"lineage_uniqueness":true,"no_accidental_lineage_reuse":true,"parent_child_generation_increment":true,"repeated_descendant_splitting":true,"sibling_generation_equality":true},"unsupported_graph_edge_violations":0},"regime":"increased_observation_noise","schema":"ravel-raw-trial/0.5","seed":"0x44ed3e5b3038b65f","trial_id":"validation-noise-01"},{"candidate":{"adaptation_completed":true,"adaptation_training":{"classification_checksum":"6d7ab986ef32684f","correct":512,"expert_evaluations":4401,"prediction_checksum":"fedda123d7d359c3","prediction_samples":468,"prediction_sse_q20":586533244790,"reconstruction_checksum":"f8674a3fbd6a066e","reconstruction_sse_q20":581547061000,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":507,"samples":512,"transition_checksum":"70fae016da8b0f05","transition_correct":454,"transition_supported":468,"transition_unknown":44},"adaptation_training_evaluations":946691,"adapted_model_drift_holdout":{"classification_checksum":"9ef609297ba9505f","correct":256,"expert_evaluations":2292,"prediction_checksum":"0cb586269290d7ab","prediction_samples":222,"prediction_sse_q20":288223392969,"reconstruction_checksum":"062554c10d8b6ac1","reconstruction_sse_q20":298785018940,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":252,"samples":256,"transition_checksum":"4f35394804924a61","transition_correct":213,"transition_supported":222,"transition_unknown":34},"base_holdout":{"classification_checksum":"80d44f941e07ec04","correct":243,"expert_evaluations":2160,"prediction_checksum":"6455bb77c6b52e06","prediction_samples":233,"prediction_sse_q20":217725843531,"reconstruction_checksum":"9b98dce2b6495a48","reconstruction_sse_q20":200610352555,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":254,"samples":256,"transition_checksum":"4de05636d364230f","transition_correct":215,"transition_supported":233,"transition_unknown":23},"base_holdout_retention":{"classification_checksum":"67a1f756aeb45f9f","correct":256,"expert_evaluations":2048,"prediction_checksum":"08fea061e276f101","prediction_samples":228,"prediction_sse_q20":163394518710,"reconstruction_checksum":"1fbe15a54f11b783","reconstruction_sse_q20":156652587951,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"4272c9b26ad575a9","transition_correct":226,"transition_supported":228,"transition_unknown":28},"base_training_evaluations":574648,"behavior_identity":"58c8ad35c1c744254070095d40c468672c89efc7d54fc158a0cfa339906e0933","checkpoint_size_bytes":46064,"expert_count":69,"model_identity":"6bba2b9e5e27e23286712e238002ac7f557d8616c4f9b8bebff698723b34173f","planning":{"belief_set_target_reached":59,"cases":64,"checksum":"401c3af0bae99b90","exact_world_state_target_reached":59,"executed_path_length":307,"expansions":2168,"goal_expert_reached":59,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":299,"path_found":64,"path_length_regret":10,"state_aliasing_failures":0,"transition_model_error_failures":5},"replay":{"actions_covered":4,"assigned_experts_covered":64,"high_loss_cases_selected":14,"labels_covered":8,"rare_cases_selected":52,"selected":256,"selection_checksum":"c28fd4108b7a4c2a","states_covered":64,"transition_pairs_covered":251,"unique":256},"static_model_drift_holdout":{"classification_checksum":"79f2c691ff938e56","correct":247,"expert_evaluations":2440,"prediction_checksum":"e18ba55a6e9cef2e","prediction_samples":226,"prediction_sse_q20":327372976437,"reconstruction_checksum":"489905598e910d8d","reconstruction_sse_q20":330877936085,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":249,"samples":256,"transition_checksum":"bbccdbc98a4271bf","transition_correct":211,"transition_supported":226,"transition_unknown":30},"topology":{"accepted_births":6,"accepted_retirements":1,"births":[{"dominant_channel":0,"event_index":336,"normalized_score_q20":572008},{"dominant_channel":0,"event_index":499,"normalized_score_q20":521513},{"dominant_channel":0,"event_index":208,"normalized_score_q20":519823},{"dominant_channel":0,"event_index":7,"normalized_score_q20":516055},{"dominant_channel":2,"event_index":444,"normalized_score_q20":421602},{"dominant_channel":2,"event_index":45,"normalized_score_q20":367744}],"objective_after_q20":885639,"objective_before_q20":864806,"rejected_births":10,"rejected_retirements":1,"retired_lineages":["b572a3d327f3a1cd"],"training_observations":{"births":6,"certified":12099,"expert_evaluations":946691,"rejected_births":10,"rejected_retirements":1,"retired":1,"samples":12288}}},"checkpoint_format":{"byte_order":"big_endian","magic_hex":"524156454c303500","payload_digest":"sha256","real_encoding":"signed_q20_int64","schema_version":5,"transition_support_min":2,"transition_top_k":2},"comparisons":{"fixed_8_expert":{"checkpoint_size_bytes":11294,"drift_holdout":{"classification_checksum":"c5a3877adf5e7a64","correct":50,"expert_evaluations":2048,"prediction_checksum":"2ee79961843a43c9","prediction_samples":256,"prediction_sse_q20":2245251198476,"reconstruction_checksum":"ed766d5adbbabb2a","reconstruction_sse_q20":2006201595476,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"8969df5bfdcc312a","transition_correct":119,"transition_supported":256,"transition_unknown":0},"expert_count":8,"planning":{"belief_set_target_reached":16,"cases":64,"checksum":"c2cc0236b6d45950","exact_world_state_target_reached":0,"executed_path_length":95,"expansions":246,"goal_expert_reached":16,"graph_disconnection_failures":21,"no_supported_edge_failures":0,"optimal_path_length":299,"path_found":43,"path_length_regret":0,"state_aliasing_failures":16,"transition_model_error_failures":27},"retention_holdout":{"classification_checksum":"b3390b393e136966","correct":43,"expert_evaluations":2048,"prediction_checksum":"676800af3775ded6","prediction_samples":256,"prediction_sse_q20":2153872762302,"reconstruction_checksum":"67709dd90f6a912a","reconstruction_sse_q20":1933445929283,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"8de45db3f91c2934","transition_correct":127,"transition_supported":256,"transition_unknown":0},"training_evaluations":94208},"fixed_topology_64_expert_routed":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"db7c131bf4717fcf","correct":256,"expert_evaluations":2216,"prediction_checksum":"8a77daed1004eaad","prediction_samples":231,"prediction_sse_q20":279424473355,"reconstruction_checksum":"4bc14b6075b92a97","reconstruction_sse_q20":290780568612,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":253,"samples":256,"transition_checksum":"086bbfe524e9e7cc","transition_correct":231,"transition_supported":231,"transition_unknown":25},"expert_count":64,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"cf6072bf615ecb89","exact_world_state_target_reached":64,"executed_path_length":305,"expansions":2169,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":299,"path_found":64,"path_length_regret":6,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"04441800ae934eff","correct":256,"expert_evaluations":2048,"prediction_checksum":"f01f0734ec281d0f","prediction_samples":227,"prediction_sse_q20":145289723045,"reconstruction_checksum":"a667a9e0cc8d4fba","reconstruction_sse_q20":137112256437,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"cb67149e13b72448","transition_correct":227,"transition_supported":227,"transition_unknown":29},"training_evaluations":2588672},"flat_64_expert_complete_scan":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"db7c131bf4717fcf","correct":256,"expert_evaluations":16384,"prediction_checksum":"8a77daed1004eaad","prediction_samples":231,"prediction_sse_q20":279424473355,"reconstruction_checksum":"4bc14b6075b92a97","reconstruction_sse_q20":290780568612,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"086bbfe524e9e7cc","transition_correct":231,"transition_supported":231,"transition_unknown":25},"expert_count":64,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"cf6072bf615ecb89","exact_world_state_target_reached":64,"executed_path_length":305,"expansions":2169,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":299,"path_found":64,"path_length_regret":6,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"04441800ae934eff","correct":256,"expert_evaluations":16384,"prediction_checksum":"f01f0734ec281d0f","prediction_samples":227,"prediction_sse_q20":145289723045,"reconstruction_checksum":"a667a9e0cc8d4fba","reconstruction_sse_q20":137112256437,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"cb67149e13b72448","transition_correct":227,"transition_supported":227,"transition_unknown":29},"training_evaluations":2588672},"matched_compute_fixed_topology":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"79f2c691ff938e56","correct":247,"expert_evaluations":2440,"prediction_checksum":"e18ba55a6e9cef2e","prediction_samples":226,"prediction_sse_q20":327372976437,"reconstruction_checksum":"489905598e910d8d","reconstruction_sse_q20":330877936085,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":249,"samples":256,"transition_checksum":"bbccdbc98a4271bf","transition_correct":211,"transition_supported":226,"transition_unknown":30},"expert_count":64,"planning":{"belief_set_target_reached":46,"cases":64,"checksum":"d777d0d0fc983846","exact_world_state_target_reached":42,"executed_path_length":263,"expansions":1949,"goal_expert_reached":46,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":299,"path_found":64,"path_length_regret":6,"state_aliasing_failures":4,"transition_model_error_failures":18},"retention_holdout":{"classification_checksum":"1649eb913830729a","correct":246,"expert_evaluations":2216,"prediction_checksum":"62deac156a74c0f2","prediction_samples":230,"prediction_sse_q20":217087168466,"reconstruction_checksum":"3696414dfb165bb9","reconstruction_sse_q20":188704654143,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":253,"samples":256,"transition_checksum":"9d7e9f5a17b90c10","transition_correct":218,"transition_supported":230,"transition_unknown":26},"training_evaluations":1704088},"matched_expert_count_capacity":{"checkpoint_size_bytes":46064,"drift_holdout":{"classification_checksum":"97ec84e1f15984bd","correct":256,"expert_evaluations":2231,"prediction_checksum":"b8dbd8ebac992bd7","prediction_samples":226,"prediction_sse_q20":274784634875,"reconstruction_checksum":"4210b796504089ea","reconstruction_sse_q20":287982737641,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":253,"samples":256,"transition_checksum":"209ddcc27069bfd7","transition_correct":216,"transition_supported":226,"transition_unknown":30},"expert_count":69,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"8ff0a09a708791c7","exact_world_state_target_reached":64,"executed_path_length":306,"expansions":2232,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":299,"path_found":64,"path_length_regret":7,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"5b50f4d61ca50e9d","correct":256,"expert_evaluations":2048,"prediction_checksum":"fdd2b2930a1a8b08","prediction_samples":216,"prediction_sse_q20":136821215656,"reconstruction_checksum":"425674604a1fd66e","reconstruction_sse_q20":136877076825,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"c804a6ac53537416","transition_correct":211,"transition_supported":216,"transition_unknown":40},"training_evaluations":2967552},"nearest_centroid_16_no_recursive_births":{"checkpoint_size_bytes":15854,"drift_holdout":{"classification_checksum":"e16bd7308e85949b","correct":62,"expert_evaluations":4096,"prediction_checksum":"0f62a59397fa27d9","prediction_samples":256,"prediction_sse_q20":1617116933426,"reconstruction_checksum":"2dfb201b6765ecee","reconstruction_sse_q20":1412218421460,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"6854850f013f2c94","transition_correct":147,"transition_supported":256,"transition_unknown":0},"expert_count":16,"planning":{"belief_set_target_reached":27,"cases":64,"checksum":"e263b034cb238a87","exact_world_state_target_reached":3,"executed_path_length":184,"expansions":539,"goal_expert_reached":27,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":299,"path_found":64,"path_length_regret":0,"state_aliasing_failures":24,"transition_model_error_failures":37},"retention_holdout":{"classification_checksum":"97c46b4506677390","correct":56,"expert_evaluations":4096,"prediction_checksum":"5628a3f739288aaf","prediction_samples":256,"prediction_sse_q20":1492611444650,"reconstruction_checksum":"59161db030257692","reconstruction_sse_q20":1298027439105,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"3c76c5709a1a26a1","transition_correct":146,"transition_supported":256,"transition_unknown":0},"training_evaluations":253952},"no_adaptation_static":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"79f2c691ff938e56","correct":247,"expert_evaluations":2440,"prediction_checksum":"e18ba55a6e9cef2e","prediction_samples":226,"prediction_sse_q20":327372976437,"reconstruction_checksum":"489905598e910d8d","reconstruction_sse_q20":330877936085,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":249,"samples":256,"transition_checksum":"bbccdbc98a4271bf","transition_correct":211,"transition_supported":226,"transition_unknown":30},"expert_count":64,"planning":{"belief_set_target_reached":46,"cases":64,"checksum":"d777d0d0fc983846","exact_world_state_target_reached":42,"executed_path_length":263,"expansions":1949,"goal_expert_reached":46,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":299,"path_found":64,"path_length_regret":6,"state_aliasing_failures":4,"transition_model_error_failures":18},"retention_holdout":{"classification_checksum":"1649eb913830729a","correct":246,"expert_evaluations":2216,"prediction_checksum":"62deac156a74c0f2","prediction_samples":230,"prediction_sse_q20":217087168466,"reconstruction_checksum":"3696414dfb165bb9","reconstruction_sse_q20":188704654143,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":253,"samples":256,"transition_checksum":"9d7e9f5a17b90c10","transition_correct":218,"transition_supported":230,"transition_unknown":26},"training_evaluations":574648},"periodic_replay_policy":{"checkpoint_size_bytes":45494,"drift_holdout":{"classification_checksum":"7b84ca501b231252","correct":256,"expert_evaluations":2288,"prediction_checksum":"f2c419b1edb3b7fd","prediction_samples":225,"prediction_sse_q20":298061394231,"reconstruction_checksum":"3107581b9fd6393f","reconstruction_sse_q20":301938786975,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":252,"samples":256,"transition_checksum":"9a84b4c0ad540295","transition_correct":217,"transition_supported":225,"transition_unknown":31},"expert_count":68,"planning":{"belief_set_target_reached":59,"cases":64,"checksum":"ec562c11e46e4bf3","exact_world_state_target_reached":59,"executed_path_length":302,"expansions":2155,"goal_expert_reached":59,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":299,"path_found":64,"path_length_regret":5,"state_aliasing_failures":0,"transition_model_error_failures":5},"retention_holdout":{"classification_checksum":"38c9753db6108330","correct":256,"expert_evaluations":2048,"prediction_checksum":"b23e90c6a7951ed7","prediction_samples":226,"prediction_sse_q20":162314240788,"reconstruction_checksum":"57f37380cbd3a54a","reconstruction_sse_q20":156520871044,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"21067dfc7e148426","transition_correct":224,"transition_supported":226,"transition_unknown":30},"training_evaluations":1273398},"ravel_0_5_candidate":{"checkpoint_size_bytes":46064,"drift_holdout":{"classification_checksum":"9ef609297ba9505f","correct":256,"expert_evaluations":2292,"prediction_checksum":"0cb586269290d7ab","prediction_samples":222,"prediction_sse_q20":288223392969,"reconstruction_checksum":"062554c10d8b6ac1","reconstruction_sse_q20":298785018940,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":252,"samples":256,"transition_checksum":"4f35394804924a61","transition_correct":213,"transition_supported":222,"transition_unknown":34},"expert_count":69,"planning":{"belief_set_target_reached":59,"cases":64,"checksum":"401c3af0bae99b90","exact_world_state_target_reached":59,"executed_path_length":307,"expansions":2168,"goal_expert_reached":59,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":299,"path_found":64,"path_length_regret":10,"state_aliasing_failures":0,"transition_model_error_failures":5},"retention_holdout":{"classification_checksum":"67a1f756aeb45f9f","correct":256,"expert_evaluations":2048,"prediction_checksum":"08fea061e276f101","prediction_samples":228,"prediction_sse_q20":163394518710,"reconstruction_checksum":"1fbe15a54f11b783","reconstruction_sse_q20":156652587951,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"4272c9b26ad575a9","transition_correct":226,"transition_supported":228,"transition_unknown":28},"training_evaluations":1521339},"ravel_complete_scan_without_certification":{"checkpoint_size_bytes":46064,"drift_holdout":{"classification_checksum":"9ef609297ba9505f","correct":256,"expert_evaluations":17664,"prediction_checksum":"0cb586269290d7ab","prediction_samples":222,"prediction_sse_q20":288223392969,"reconstruction_checksum":"062554c10d8b6ac1","reconstruction_sse_q20":298785018940,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"4f35394804924a61","transition_correct":213,"transition_supported":222,"transition_unknown":34},"expert_count":69,"planning":{"belief_set_target_reached":59,"cases":64,"checksum":"401c3af0bae99b90","exact_world_state_target_reached":59,"executed_path_length":307,"expansions":2168,"goal_expert_reached":59,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":299,"path_found":64,"path_length_regret":10,"state_aliasing_failures":0,"transition_model_error_failures":5},"retention_holdout":{"classification_checksum":"67a1f756aeb45f9f","correct":256,"expert_evaluations":17664,"prediction_checksum":"08fea061e276f101","prediction_samples":228,"prediction_sse_q20":163394518710,"reconstruction_checksum":"1fbe15a54f11b783","reconstruction_sse_q20":156652587951,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"4272c9b26ad575a9","transition_correct":226,"transition_supported":228,"transition_unknown":28},"training_evaluations":1709571},"ravel_no_birth_same_replay_iterations":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"79f2c691ff938e56","correct":247,"expert_evaluations":2440,"prediction_checksum":"e18ba55a6e9cef2e","prediction_samples":226,"prediction_sse_q20":327372976437,"reconstruction_checksum":"489905598e910d8d","reconstruction_sse_q20":330877936085,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":249,"samples":256,"transition_checksum":"bbccdbc98a4271bf","transition_correct":211,"transition_supported":226,"transition_unknown":30},"expert_count":64,"planning":{"belief_set_target_reached":46,"cases":64,"checksum":"d777d0d0fc983846","exact_world_state_target_reached":42,"executed_path_length":263,"expansions":1949,"goal_expert_reached":46,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":299,"path_found":64,"path_length_regret":6,"state_aliasing_failures":4,"transition_model_error_failures":18},"retention_holdout":{"classification_checksum":"1649eb913830729a","correct":246,"expert_evaluations":2216,"prediction_checksum":"62deac156a74c0f2","prediction_samples":230,"prediction_sse_q20":217087168466,"reconstruction_checksum":"3696414dfb165bb9","reconstruction_sse_q20":188704654143,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":253,"samples":256,"transition_checksum":"9d7e9f5a17b90c10","transition_correct":218,"transition_supported":230,"transition_unknown":26},"training_evaluations":800536},"ravel_random_births":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"79f2c691ff938e56","correct":247,"expert_evaluations":2440,"prediction_checksum":"e18ba55a6e9cef2e","prediction_samples":226,"prediction_sse_q20":327372976437,"reconstruction_checksum":"489905598e910d8d","reconstruction_sse_q20":330877936085,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":249,"samples":256,"transition_checksum":"bbccdbc98a4271bf","transition_correct":211,"transition_supported":226,"transition_unknown":30},"expert_count":64,"planning":{"belief_set_target_reached":46,"cases":64,"checksum":"d777d0d0fc983846","exact_world_state_target_reached":42,"executed_path_length":263,"expansions":1949,"goal_expert_reached":46,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":299,"path_found":64,"path_length_regret":6,"state_aliasing_failures":4,"transition_model_error_failures":18},"retention_holdout":{"classification_checksum":"1649eb913830729a","correct":246,"expert_evaluations":2216,"prediction_checksum":"62deac156a74c0f2","prediction_samples":230,"prediction_sse_q20":217087168466,"reconstruction_checksum":"3696414dfb165bb9","reconstruction_sse_q20":188704654143,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":253,"samples":256,"transition_checksum":"9d7e9f5a17b90c10","transition_correct":218,"transition_supported":230,"transition_unknown":26},"training_evaluations":800536},"ravel_without_replay":{"checkpoint_size_bytes":45494,"drift_holdout":{"classification_checksum":"7b84ca501b231252","correct":256,"expert_evaluations":2348,"prediction_checksum":"35b950ab677c3b13","prediction_samples":222,"prediction_sse_q20":294644297153,"reconstruction_checksum":"27e6fd2e7e99dde1","reconstruction_sse_q20":302126670666,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":251,"samples":256,"transition_checksum":"a3ea6a492f213aad","transition_correct":214,"transition_supported":222,"transition_unknown":34},"expert_count":68,"planning":{"belief_set_target_reached":60,"cases":64,"checksum":"260e0c7b110a8f95","exact_world_state_target_reached":60,"executed_path_length":310,"expansions":2170,"goal_expert_reached":60,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":299,"path_found":64,"path_length_regret":13,"state_aliasing_failures":0,"transition_model_error_failures":4},"retention_holdout":{"classification_checksum":"38c9753db6108330","correct":256,"expert_evaluations":2048,"prediction_checksum":"106315d95c2a81bc","prediction_samples":225,"prediction_sse_q20":162668964740,"reconstruction_checksum":"3d6479f8258856c8","reconstruction_sse_q20":157319634309,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"a1140ef427b4bfb5","transition_correct":223,"transition_supported":225,"transition_unknown":31},"training_evaluations":1041833},"ravel_without_retirement_matched_work":{"checkpoint_size_bytes":46634,"drift_holdout":{"classification_checksum":"e5d645063bb60dd9","correct":256,"expert_evaluations":2296,"prediction_checksum":"0cb586269290d7ab","prediction_samples":222,"prediction_sse_q20":288223392969,"reconstruction_checksum":"b255dc439d2644e4","reconstruction_sse_q20":298628781116,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":252,"samples":256,"transition_checksum":"4f35394804924a61","transition_correct":213,"transition_supported":222,"transition_unknown":34},"expert_count":70,"planning":{"belief_set_target_reached":59,"cases":64,"checksum":"401c3af0bae99b90","exact_world_state_target_reached":59,"executed_path_length":307,"expansions":2168,"goal_expert_reached":59,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":299,"path_found":64,"path_length_regret":10,"state_aliasing_failures":0,"transition_model_error_failures":5},"retention_holdout":{"classification_checksum":"67a1f756aeb45f9f","correct":256,"expert_evaluations":2048,"prediction_checksum":"08fea061e276f101","prediction_samples":228,"prediction_sse_q20":163394518710,"reconstruction_checksum":"1fbe15a54f11b783","reconstruction_sse_q20":156652587951,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"4272c9b26ad575a9","transition_correct":226,"transition_supported":228,"transition_unknown":28},"training_evaluations":1521339}},"dataset_seeds":{"base_holdout":"0x83178a8f04d4159f","base_training":"0xaafea6eea38b9ea5","drift_adaptation_training":"0xce40d516b6c29737","drift_holdout":"0x5c6f4689f0389908","original_task_retention_holdout":"0x578b1a89897d8540","planning_cases":"0x840eeb9797be214b"},"dataset_sizes":{"base_holdout":256,"base_training":1024,"drift_adaptation_training":512,"drift_holdout":256,"original_task_retention_holdout":256,"planning_cases":64},"integrity":{"checkpoint_behavior_match":true,"checkpoint_identity_match":true,"checkpoint_mutations":{"anchored_status":true,"appended_unexpected_byte":true,"checkpoint_substitution":true,"checkpoint_truncation":true,"incorrect_schema_version":true,"label":true,"label_count":true,"lineage":true,"next_observation_component":true,"payload_byte":true,"reconstruction_component":true,"retrieval_key_component":true,"transition_graph_edge":true,"transition_support":true},"checkpoint_roundtrip":true,"lineage_invariants":{"deterministic_topology_reproduction":true,"lineage_uniqueness":true,"no_accidental_lineage_reuse":true,"parent_child_generation_increment":true,"repeated_descendant_splitting":true,"sibling_generation_equality":true},"unsupported_graph_edge_violations":0},"regime":"increased_observation_noise","schema":"ravel-raw-trial/0.5","seed":"0xe8de8b800dc18a66","trial_id":"validation-noise-02"},{"candidate":{"adaptation_completed":true,"adaptation_training":{"classification_checksum":"a0b446e1d6f3f67e","correct":512,"expert_evaluations":4340,"prediction_checksum":"e3ca00e7b764b02f","prediction_samples":470,"prediction_sse_q20":583561662103,"reconstruction_checksum":"c25635159e357254","reconstruction_sse_q20":555055431655,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":508,"samples":512,"transition_checksum":"9b9ff40e313bc649","transition_correct":460,"transition_supported":470,"transition_unknown":42},"adaptation_training_evaluations":818871,"adapted_model_drift_holdout":{"classification_checksum":"20bd6073dde45404","correct":254,"expert_evaluations":2536,"prediction_checksum":"3d2166a15b531737","prediction_samples":224,"prediction_sse_q20":298726905064,"reconstruction_checksum":"8174eef7ffd6f3e6","reconstruction_sse_q20":307642084018,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":248,"samples":256,"transition_checksum":"babf6665c52780d2","transition_correct":218,"transition_supported":224,"transition_unknown":32},"base_holdout":{"classification_checksum":"e4d55c44d4016069","correct":245,"expert_evaluations":2272,"prediction_checksum":"f7528aecbfa7ae0d","prediction_samples":240,"prediction_sse_q20":209088950871,"reconstruction_checksum":"090a9472be5bfb76","reconstruction_sse_q20":190440320738,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":252,"samples":256,"transition_checksum":"289a2a8075d463d0","transition_correct":229,"transition_supported":240,"transition_unknown":16},"base_holdout_retention":{"classification_checksum":"9e2b6dfcfebe8300","correct":256,"expert_evaluations":2048,"prediction_checksum":"9f281c2b83565169","prediction_samples":221,"prediction_sse_q20":159567023253,"reconstruction_checksum":"b929055e49619405","reconstruction_sse_q20":150311020026,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"834e53f502ab01c3","transition_correct":218,"transition_supported":221,"transition_unknown":35},"base_training_evaluations":568608,"behavior_identity":"8c878a76992cab0494bc67610a3a2afcdb238c53ad1e5fd8973bdbc89db65710","checkpoint_size_bytes":46064,"expert_count":69,"model_identity":"9e250f25ea8f5f3df7e7fef4c807347a51b92a97b4a14a159db2dd13c0234dea","planning":{"belief_set_target_reached":61,"cases":64,"checksum":"62d04cb2234fa337","exact_world_state_target_reached":61,"executed_path_length":312,"expansions":2313,"goal_expert_reached":61,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":301,"path_found":64,"path_length_regret":12,"state_aliasing_failures":0,"transition_model_error_failures":3},"replay":{"actions_covered":4,"assigned_experts_covered":62,"high_loss_cases_selected":18,"labels_covered":8,"rare_cases_selected":60,"selected":256,"selection_checksum":"e0232e11329f948b","states_covered":64,"transition_pairs_covered":252,"unique":256},"static_model_drift_holdout":{"classification_checksum":"1f9237efade3d829","correct":248,"expert_evaluations":2608,"prediction_checksum":"64d28c0131f36e1b","prediction_samples":224,"prediction_sse_q20":311229249722,"reconstruction_checksum":"72878eba014af8e4","reconstruction_sse_q20":324591392246,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":246,"samples":256,"transition_checksum":"964dd667d45d98e5","transition_correct":216,"transition_supported":224,"transition_unknown":32},"topology":{"accepted_births":5,"accepted_retirements":0,"births":[{"dominant_channel":0,"event_index":143,"normalized_score_q20":552339},{"dominant_channel":2,"event_index":96,"normalized_score_q20":548957},{"dominant_channel":0,"event_index":333,"normalized_score_q20":526090},{"dominant_channel":2,"event_index":345,"normalized_score_q20":365413},{"dominant_channel":2,"event_index":346,"normalized_score_q20":322995}],"objective_after_q20":891048,"objective_before_q20":883141,"rejected_births":11,"rejected_retirements":1,"retired_lineages":[],"training_observations":{"births":5,"certified":10645,"expert_evaluations":818871,"rejected_births":11,"rejected_retirements":1,"retired":0,"samples":10752}}},"checkpoint_format":{"byte_order":"big_endian","magic_hex":"524156454c303500","payload_digest":"sha256","real_encoding":"signed_q20_int64","schema_version":5,"transition_support_min":2,"transition_top_k":2},"comparisons":{"fixed_8_expert":{"checkpoint_size_bytes":11294,"drift_holdout":{"classification_checksum":"53e54bcd855dd1e2","correct":44,"expert_evaluations":2048,"prediction_checksum":"1129b67a5b93b30a","prediction_samples":256,"prediction_sse_q20":2337789693227,"reconstruction_checksum":"2da7bea511375561","reconstruction_sse_q20":2003917585775,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"e5aa89722bdd393d","transition_correct":141,"transition_supported":256,"transition_unknown":0},"expert_count":8,"planning":{"belief_set_target_reached":17,"cases":64,"checksum":"de6b70de6b9e02b8","exact_world_state_target_reached":1,"executed_path_length":19,"expansions":146,"goal_expert_reached":17,"graph_disconnection_failures":37,"no_supported_edge_failures":0,"optimal_path_length":301,"path_found":27,"path_length_regret":0,"state_aliasing_failures":16,"transition_model_error_failures":10},"retention_holdout":{"classification_checksum":"6992b1b3973aa7ca","correct":43,"expert_evaluations":2048,"prediction_checksum":"b77efcb591244df2","prediction_samples":256,"prediction_sse_q20":2133343359241,"reconstruction_checksum":"dfa0afa85ea24d9c","reconstruction_sse_q20":1847617042755,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"4258c3d941e2c1ab","transition_correct":131,"transition_supported":256,"transition_unknown":0},"training_evaluations":94208},"fixed_topology_64_expert_routed":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"a2f9127a9f99ed3d","correct":256,"expert_evaluations":2272,"prediction_checksum":"1f885ffe3e09e450","prediction_samples":221,"prediction_sse_q20":279939286038,"reconstruction_checksum":"0d981a37341888cf","reconstruction_sse_q20":292901424986,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":252,"samples":256,"transition_checksum":"25e964d75192acc8","transition_correct":221,"transition_supported":221,"transition_unknown":35},"expert_count":64,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"47fae24a3bef7aeb","exact_world_state_target_reached":64,"executed_path_length":313,"expansions":2312,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":301,"path_found":64,"path_length_regret":12,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"ec68cd4be51e63b5","correct":256,"expert_evaluations":2048,"prediction_checksum":"8d84c1879d9e5b12","prediction_samples":221,"prediction_sse_q20":145106284727,"reconstruction_checksum":"dae691def7d3fbc5","reconstruction_sse_q20":137212537732,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"043af2f801b8eec7","transition_correct":221,"transition_supported":221,"transition_unknown":35},"training_evaluations":2588672},"flat_64_expert_complete_scan":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"a2f9127a9f99ed3d","correct":256,"expert_evaluations":16384,"prediction_checksum":"1f885ffe3e09e450","prediction_samples":221,"prediction_sse_q20":279939286038,"reconstruction_checksum":"0d981a37341888cf","reconstruction_sse_q20":292901424986,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"25e964d75192acc8","transition_correct":221,"transition_supported":221,"transition_unknown":35},"expert_count":64,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"47fae24a3bef7aeb","exact_world_state_target_reached":64,"executed_path_length":313,"expansions":2312,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":301,"path_found":64,"path_length_regret":12,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"ec68cd4be51e63b5","correct":256,"expert_evaluations":16384,"prediction_checksum":"8d84c1879d9e5b12","prediction_samples":221,"prediction_sse_q20":145106284727,"reconstruction_checksum":"dae691def7d3fbc5","reconstruction_sse_q20":137212537732,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"043af2f801b8eec7","transition_correct":221,"transition_supported":221,"transition_unknown":35},"training_evaluations":2588672},"matched_compute_fixed_topology":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"1f9237efade3d829","correct":248,"expert_evaluations":2608,"prediction_checksum":"64d28c0131f36e1b","prediction_samples":224,"prediction_sse_q20":311229249722,"reconstruction_checksum":"72878eba014af8e4","reconstruction_sse_q20":324591392246,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":246,"samples":256,"transition_checksum":"964dd667d45d98e5","transition_correct":216,"transition_supported":224,"transition_unknown":32},"expert_count":64,"planning":{"belief_set_target_reached":52,"cases":64,"checksum":"e88ee1d6589e8931","exact_world_state_target_reached":50,"executed_path_length":296,"expansions":2206,"goal_expert_reached":52,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":301,"path_found":64,"path_length_regret":8,"state_aliasing_failures":2,"transition_model_error_failures":12},"retention_holdout":{"classification_checksum":"7118e93522c1eeda","correct":248,"expert_evaluations":2048,"prediction_checksum":"d4cfa2f764058394","prediction_samples":224,"prediction_sse_q20":185463602258,"reconstruction_checksum":"14a217eed2ab331e","reconstruction_sse_q20":164578195721,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"55eaecff7dd82e5e","transition_correct":217,"transition_supported":224,"transition_unknown":32},"training_evaluations":1462304},"matched_expert_count_capacity":{"checkpoint_size_bytes":46064,"drift_holdout":{"classification_checksum":"ce45e24e60d2fa8c","correct":256,"expert_evaluations":2353,"prediction_checksum":"0dfbbb376beffd04","prediction_samples":216,"prediction_sse_q20":275743961376,"reconstruction_checksum":"53602ba2b944b80b","reconstruction_sse_q20":291679471344,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":251,"samples":256,"transition_checksum":"38002e1e669e9f8a","transition_correct":207,"transition_supported":216,"transition_unknown":40},"expert_count":69,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"628f895ae4abd2a4","exact_world_state_target_reached":64,"executed_path_length":315,"expansions":2375,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":301,"path_found":64,"path_length_regret":14,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"cd138884403d47cc","correct":256,"expert_evaluations":2048,"prediction_checksum":"5e98f4608accd60a","prediction_samples":214,"prediction_sse_q20":141439662016,"reconstruction_checksum":"ea3e5dba91bfbdb1","reconstruction_sse_q20":136358419826,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"4e8b6e4de081d61d","transition_correct":202,"transition_supported":214,"transition_unknown":42},"training_evaluations":2967552},"nearest_centroid_16_no_recursive_births":{"checkpoint_size_bytes":15854,"drift_holdout":{"classification_checksum":"3c712ff7f286572a","correct":67,"expert_evaluations":4096,"prediction_checksum":"362421d6e2ecb139","prediction_samples":256,"prediction_sse_q20":1699519659999,"reconstruction_checksum":"c690ba4664653c6b","reconstruction_sse_q20":1397799307047,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"21041801a61e1b5c","transition_correct":157,"transition_supported":256,"transition_unknown":0},"expert_count":16,"planning":{"belief_set_target_reached":35,"cases":64,"checksum":"3a7e59af1f0e75cf","exact_world_state_target_reached":7,"executed_path_length":200,"expansions":565,"goal_expert_reached":35,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":301,"path_found":64,"path_length_regret":3,"state_aliasing_failures":28,"transition_model_error_failures":29},"retention_holdout":{"classification_checksum":"3a1fd7816d557eeb","correct":71,"expert_evaluations":4096,"prediction_checksum":"84e91b8c18b83244","prediction_samples":256,"prediction_sse_q20":1535758744296,"reconstruction_checksum":"372101e3bfdebc22","reconstruction_sse_q20":1295786018565,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"70a6dbdca25d440c","transition_correct":165,"transition_supported":256,"transition_unknown":0},"training_evaluations":253952},"no_adaptation_static":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"1f9237efade3d829","correct":248,"expert_evaluations":2608,"prediction_checksum":"64d28c0131f36e1b","prediction_samples":224,"prediction_sse_q20":311229249722,"reconstruction_checksum":"72878eba014af8e4","reconstruction_sse_q20":324591392246,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":246,"samples":256,"transition_checksum":"964dd667d45d98e5","transition_correct":216,"transition_supported":224,"transition_unknown":32},"expert_count":64,"planning":{"belief_set_target_reached":52,"cases":64,"checksum":"e88ee1d6589e8931","exact_world_state_target_reached":50,"executed_path_length":296,"expansions":2206,"goal_expert_reached":52,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":301,"path_found":64,"path_length_regret":8,"state_aliasing_failures":2,"transition_model_error_failures":12},"retention_holdout":{"classification_checksum":"7118e93522c1eeda","correct":248,"expert_evaluations":2048,"prediction_checksum":"d4cfa2f764058394","prediction_samples":224,"prediction_sse_q20":185463602258,"reconstruction_checksum":"14a217eed2ab331e","reconstruction_sse_q20":164578195721,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"55eaecff7dd82e5e","transition_correct":217,"transition_supported":224,"transition_unknown":32},"training_evaluations":568608},"periodic_replay_policy":{"checkpoint_size_bytes":45494,"drift_holdout":{"classification_checksum":"ca9ed6e07eb21b7c","correct":254,"expert_evaluations":2528,"prediction_checksum":"5d7eb0e34cf5e832","prediction_samples":221,"prediction_sse_q20":294315108894,"reconstruction_checksum":"bbb0d468934b8c04","reconstruction_sse_q20":308477620954,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":248,"samples":256,"transition_checksum":"17e38ac55374f376","transition_correct":216,"transition_supported":221,"transition_unknown":35},"expert_count":68,"planning":{"belief_set_target_reached":59,"cases":64,"checksum":"ee6d8635aab64d6e","exact_world_state_target_reached":59,"executed_path_length":293,"expansions":2187,"goal_expert_reached":59,"graph_disconnection_failures":0,"no_supported_edge_failures":2,"optimal_path_length":301,"path_found":62,"path_length_regret":10,"state_aliasing_failures":0,"transition_model_error_failures":3},"retention_holdout":{"classification_checksum":"c84b0e0824397ff4","correct":256,"expert_evaluations":2048,"prediction_checksum":"806f257b3c834f9c","prediction_samples":217,"prediction_sse_q20":156603878549,"reconstruction_checksum":"7f6acaa0ff275061","reconstruction_sse_q20":150900136218,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"f0956c356cfb51f3","transition_correct":214,"transition_supported":217,"transition_unknown":39},"training_evaluations":1150766},"ravel_0_5_candidate":{"checkpoint_size_bytes":46064,"drift_holdout":{"classification_checksum":"20bd6073dde45404","correct":254,"expert_evaluations":2536,"prediction_checksum":"3d2166a15b531737","prediction_samples":224,"prediction_sse_q20":298726905064,"reconstruction_checksum":"8174eef7ffd6f3e6","reconstruction_sse_q20":307642084018,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":248,"samples":256,"transition_checksum":"babf6665c52780d2","transition_correct":218,"transition_supported":224,"transition_unknown":32},"expert_count":69,"planning":{"belief_set_target_reached":61,"cases":64,"checksum":"62d04cb2234fa337","exact_world_state_target_reached":61,"executed_path_length":312,"expansions":2313,"goal_expert_reached":61,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":301,"path_found":64,"path_length_regret":12,"state_aliasing_failures":0,"transition_model_error_failures":3},"retention_holdout":{"classification_checksum":"9e2b6dfcfebe8300","correct":256,"expert_evaluations":2048,"prediction_checksum":"9f281c2b83565169","prediction_samples":221,"prediction_sse_q20":159567023253,"reconstruction_checksum":"b929055e49619405","reconstruction_sse_q20":150311020026,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"834e53f502ab01c3","transition_correct":218,"transition_supported":221,"transition_unknown":35},"training_evaluations":1387479},"ravel_complete_scan_without_certification":{"checkpoint_size_bytes":46064,"drift_holdout":{"classification_checksum":"20bd6073dde45404","correct":254,"expert_evaluations":17664,"prediction_checksum":"3d2166a15b531737","prediction_samples":224,"prediction_sse_q20":298726905064,"reconstruction_checksum":"8174eef7ffd6f3e6","reconstruction_sse_q20":307642084018,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"babf6665c52780d2","transition_correct":218,"transition_supported":224,"transition_unknown":32},"expert_count":69,"planning":{"belief_set_target_reached":61,"cases":64,"checksum":"62d04cb2234fa337","exact_world_state_target_reached":61,"executed_path_length":312,"expansions":2313,"goal_expert_reached":61,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":301,"path_found":64,"path_length_regret":12,"state_aliasing_failures":0,"transition_model_error_failures":3},"retention_holdout":{"classification_checksum":"9e2b6dfcfebe8300","correct":256,"expert_evaluations":17664,"prediction_checksum":"9f281c2b83565169","prediction_samples":221,"prediction_sse_q20":159567023253,"reconstruction_checksum":"b929055e49619405","reconstruction_sse_q20":150311020026,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"834e53f502ab01c3","transition_correct":218,"transition_supported":221,"transition_unknown":35},"training_evaluations":1573407},"ravel_no_birth_same_replay_iterations":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"1f9237efade3d829","correct":248,"expert_evaluations":2608,"prediction_checksum":"64d28c0131f36e1b","prediction_samples":224,"prediction_sse_q20":311229249722,"reconstruction_checksum":"72878eba014af8e4","reconstruction_sse_q20":324591392246,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":246,"samples":256,"transition_checksum":"964dd667d45d98e5","transition_correct":216,"transition_supported":224,"transition_unknown":32},"expert_count":64,"planning":{"belief_set_target_reached":52,"cases":64,"checksum":"e88ee1d6589e8931","exact_world_state_target_reached":50,"executed_path_length":296,"expansions":2206,"goal_expert_reached":52,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":301,"path_found":64,"path_length_regret":8,"state_aliasing_failures":2,"transition_model_error_failures":12},"retention_holdout":{"classification_checksum":"7118e93522c1eeda","correct":248,"expert_evaluations":2048,"prediction_checksum":"d4cfa2f764058394","prediction_samples":224,"prediction_sse_q20":185463602258,"reconstruction_checksum":"14a217eed2ab331e","reconstruction_sse_q20":164578195721,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"55eaecff7dd82e5e","transition_correct":217,"transition_supported":224,"transition_unknown":32},"training_evaluations":792032},"ravel_random_births":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"1f9237efade3d829","correct":248,"expert_evaluations":2608,"prediction_checksum":"64d28c0131f36e1b","prediction_samples":224,"prediction_sse_q20":311229249722,"reconstruction_checksum":"72878eba014af8e4","reconstruction_sse_q20":324591392246,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":246,"samples":256,"transition_checksum":"964dd667d45d98e5","transition_correct":216,"transition_supported":224,"transition_unknown":32},"expert_count":64,"planning":{"belief_set_target_reached":52,"cases":64,"checksum":"e88ee1d6589e8931","exact_world_state_target_reached":50,"executed_path_length":296,"expansions":2206,"goal_expert_reached":52,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":301,"path_found":64,"path_length_regret":8,"state_aliasing_failures":2,"transition_model_error_failures":12},"retention_holdout":{"classification_checksum":"7118e93522c1eeda","correct":248,"expert_evaluations":2048,"prediction_checksum":"d4cfa2f764058394","prediction_samples":224,"prediction_sse_q20":185463602258,"reconstruction_checksum":"14a217eed2ab331e","reconstruction_sse_q20":164578195721,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"55eaecff7dd82e5e","transition_correct":217,"transition_supported":224,"transition_unknown":32},"training_evaluations":792032},"ravel_without_replay":{"checkpoint_size_bytes":46064,"drift_holdout":{"classification_checksum":"20bd6073dde45404","correct":254,"expert_evaluations":2597,"prediction_checksum":"11787e17476639bb","prediction_samples":220,"prediction_sse_q20":292772915742,"reconstruction_checksum":"5925ab17a87173a9","reconstruction_sse_q20":308937937245,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":247,"samples":256,"transition_checksum":"615b1b306d91e092","transition_correct":215,"transition_supported":220,"transition_unknown":36},"expert_count":69,"planning":{"belief_set_target_reached":59,"cases":64,"checksum":"125ea1662c874cf0","exact_world_state_target_reached":59,"executed_path_length":293,"expansions":2186,"goal_expert_reached":59,"graph_disconnection_failures":0,"no_supported_edge_failures":2,"optimal_path_length":301,"path_found":62,"path_length_regret":10,"state_aliasing_failures":0,"transition_model_error_failures":3},"retention_holdout":{"classification_checksum":"9e2b6dfcfebe8300","correct":256,"expert_evaluations":2048,"prediction_checksum":"7d48e16290d26c18","prediction_samples":217,"prediction_sse_q20":156931150809,"reconstruction_checksum":"b8fc8e59140d7fcd","reconstruction_sse_q20":151963994330,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"bfa9a4f30a3dc7ef","transition_correct":214,"transition_supported":217,"transition_unknown":39},"training_evaluations":1039012},"ravel_without_retirement_matched_work":{"checkpoint_size_bytes":46064,"drift_holdout":{"classification_checksum":"20bd6073dde45404","correct":254,"expert_evaluations":2536,"prediction_checksum":"3d2166a15b531737","prediction_samples":224,"prediction_sse_q20":298726905064,"reconstruction_checksum":"8174eef7ffd6f3e6","reconstruction_sse_q20":307642084018,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":248,"samples":256,"transition_checksum":"babf6665c52780d2","transition_correct":218,"transition_supported":224,"transition_unknown":32},"expert_count":69,"planning":{"belief_set_target_reached":61,"cases":64,"checksum":"62d04cb2234fa337","exact_world_state_target_reached":61,"executed_path_length":312,"expansions":2313,"goal_expert_reached":61,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":301,"path_found":64,"path_length_regret":12,"state_aliasing_failures":0,"transition_model_error_failures":3},"retention_holdout":{"classification_checksum":"9e2b6dfcfebe8300","correct":256,"expert_evaluations":2048,"prediction_checksum":"9f281c2b83565169","prediction_samples":221,"prediction_sse_q20":159567023253,"reconstruction_checksum":"b929055e49619405","reconstruction_sse_q20":150311020026,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"834e53f502ab01c3","transition_correct":218,"transition_supported":221,"transition_unknown":35},"training_evaluations":1387479}},"dataset_seeds":{"base_holdout":"0xdac51a674c51c99d","base_training":"0x6e86a85de6c94072","drift_adaptation_training":"0x1c916b1b0c7b97cd","drift_holdout":"0xfdc37204feac2017","original_task_retention_holdout":"0xb7f0a8f33fb21e00","planning_cases":"0x1fc750694c49f417"},"dataset_sizes":{"base_holdout":256,"base_training":1024,"drift_adaptation_training":512,"drift_holdout":256,"original_task_retention_holdout":256,"planning_cases":64},"integrity":{"checkpoint_behavior_match":true,"checkpoint_identity_match":true,"checkpoint_mutations":{"anchored_status":true,"appended_unexpected_byte":true,"checkpoint_substitution":true,"checkpoint_truncation":true,"incorrect_schema_version":true,"label":true,"label_count":true,"lineage":true,"next_observation_component":true,"payload_byte":true,"reconstruction_component":true,"retrieval_key_component":true,"transition_graph_edge":true,"transition_support":true},"checkpoint_roundtrip":true,"lineage_invariants":{"deterministic_topology_reproduction":true,"lineage_uniqueness":true,"no_accidental_lineage_reuse":true,"parent_child_generation_increment":true,"repeated_descendant_splitting":true,"sibling_generation_equality":true},"unsupported_graph_edge_violations":0},"regime":"increased_observation_noise","schema":"ravel-raw-trial/0.5","seed":"0x0f5d03772bddb16f","trial_id":"validation-noise-03"},{"candidate":{"adaptation_completed":true,"adaptation_training":{"classification_checksum":"68861eb347d5f672","correct":512,"expert_evaluations":4706,"prediction_checksum":"34919e882043750f","prediction_samples":476,"prediction_sse_q20":592243506903,"reconstruction_checksum":"9a676d09c2438892","reconstruction_sse_q20":595791453860,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":502,"samples":512,"transition_checksum":"ef4142579c4dba1c","transition_correct":463,"transition_supported":476,"transition_unknown":36},"adaptation_training_evaluations":826770,"adapted_model_drift_holdout":{"classification_checksum":"9dff3863e880adaf","correct":256,"expert_evaluations":2414,"prediction_checksum":"b91cf8fbaa0fe363","prediction_samples":236,"prediction_sse_q20":308562073079,"reconstruction_checksum":"20509a2940e1deb6","reconstruction_sse_q20":297952404668,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":250,"samples":256,"transition_checksum":"b779aca4e05604d0","transition_correct":229,"transition_supported":236,"transition_unknown":20},"base_holdout":{"classification_checksum":"04d9e039723a8385","correct":243,"expert_evaluations":2216,"prediction_checksum":"07201e9098f4f603","prediction_samples":235,"prediction_sse_q20":240183456821,"reconstruction_checksum":"cd3a697aa3287c0a","reconstruction_sse_q20":205491495061,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":253,"samples":256,"transition_checksum":"761097f7bdb7394f","transition_correct":210,"transition_supported":235,"transition_unknown":21},"base_holdout_retention":{"classification_checksum":"439d545162cf7d3b","correct":256,"expert_evaluations":2048,"prediction_checksum":"c197beaa59190034","prediction_samples":233,"prediction_sse_q20":183598343647,"reconstruction_checksum":"bd642c34b09fd330","reconstruction_sse_q20":159519095379,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"c238276d9892c7b6","transition_correct":225,"transition_supported":233,"transition_unknown":23},"base_training_evaluations":572448,"behavior_identity":"75fcee9e746b9937058a146845a86dafe1afef4335484ae51d0c1ffecfe05d7a","checkpoint_size_bytes":46064,"expert_count":69,"model_identity":"e3596a92fe0b1558a6021bc73bbe66221cc1a45f4c851653bbb77c4bb8580c01","planning":{"belief_set_target_reached":44,"cases":64,"checksum":"c5341ca190ce45a0","exact_world_state_target_reached":44,"executed_path_length":246,"expansions":1945,"goal_expert_reached":44,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":287,"path_found":64,"path_length_regret":1,"state_aliasing_failures":0,"transition_model_error_failures":20},"replay":{"actions_covered":4,"assigned_experts_covered":63,"high_loss_cases_selected":12,"labels_covered":8,"rare_cases_selected":49,"selected":256,"selection_checksum":"2e5f9e129500d054","states_covered":64,"transition_pairs_covered":251,"unique":256},"static_model_drift_holdout":{"classification_checksum":"06bb10f6a8e752ed","correct":238,"expert_evaluations":2944,"prediction_checksum":"d7b932fd6560a076","prediction_samples":239,"prediction_sse_q20":386396354589,"reconstruction_checksum":"0182141d0bcc4bf0","reconstruction_sse_q20":345652470433,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":240,"samples":256,"transition_checksum":"56996b3c17c37ff0","transition_correct":216,"transition_supported":239,"transition_unknown":17},"topology":{"accepted_births":5,"accepted_retirements":0,"births":[{"dominant_channel":0,"event_index":474,"normalized_score_q20":576116},{"dominant_channel":0,"event_index":119,"normalized_score_q20":541041},{"dominant_channel":0,"event_index":318,"normalized_score_q20":529791},{"dominant_channel":0,"event_index":505,"normalized_score_q20":523871},{"dominant_channel":2,"event_index":104,"normalized_score_q20":392875}],"objective_after_q20":886036,"objective_before_q20":857210,"rejected_births":11,"rejected_retirements":1,"retired_lineages":[],"training_observations":{"births":5,"certified":10511,"expert_evaluations":826770,"rejected_births":11,"rejected_retirements":1,"retired":0,"samples":10752}}},"checkpoint_format":{"byte_order":"big_endian","magic_hex":"524156454c303500","payload_digest":"sha256","real_encoding":"signed_q20_int64","schema_version":5,"transition_support_min":2,"transition_top_k":2},"comparisons":{"fixed_8_expert":{"checkpoint_size_bytes":11294,"drift_holdout":{"classification_checksum":"7c7492de6dc61596","correct":61,"expert_evaluations":2048,"prediction_checksum":"60161331d4a4ab8b","prediction_samples":256,"prediction_sse_q20":2356667654360,"reconstruction_checksum":"205528e2c2a746d8","reconstruction_sse_q20":2061229310682,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"b42f14af2c07352a","transition_correct":91,"transition_supported":256,"transition_unknown":0},"expert_count":8,"planning":{"belief_set_target_reached":18,"cases":64,"checksum":"61098e2c2b7e795f","exact_world_state_target_reached":2,"executed_path_length":69,"expansions":229,"goal_expert_reached":18,"graph_disconnection_failures":20,"no_supported_edge_failures":0,"optimal_path_length":287,"path_found":44,"path_length_regret":0,"state_aliasing_failures":16,"transition_model_error_failures":26},"retention_holdout":{"classification_checksum":"6a9cb252f2e987d0","correct":50,"expert_evaluations":2048,"prediction_checksum":"b76803d181ac71b8","prediction_samples":256,"prediction_sse_q20":2123654324997,"reconstruction_checksum":"3f61e29e3a93f3be","reconstruction_sse_q20":1900731400130,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"87f81272593002aa","transition_correct":122,"transition_supported":256,"transition_unknown":0},"training_evaluations":94208},"fixed_topology_64_expert_routed":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"6b04dba4d4affb2a","correct":256,"expert_evaluations":2216,"prediction_checksum":"082417545b43bcf9","prediction_samples":238,"prediction_sse_q20":287538647366,"reconstruction_checksum":"54c55f8a264a148c","reconstruction_sse_q20":284230034884,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":253,"samples":256,"transition_checksum":"669f4bd9ce13faaf","transition_correct":238,"transition_supported":238,"transition_unknown":18},"expert_count":64,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"cf80f4162c924778","exact_world_state_target_reached":64,"executed_path_length":295,"expansions":2056,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":287,"path_found":64,"path_length_regret":8,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"3c41fbd89bc7e94c","correct":256,"expert_evaluations":2048,"prediction_checksum":"63e06dc253181f58","prediction_samples":223,"prediction_sse_q20":146424980188,"reconstruction_checksum":"6aae47aeb150bf66","reconstruction_sse_q20":137223719360,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"19a4f60e2f02b42b","transition_correct":223,"transition_supported":223,"transition_unknown":33},"training_evaluations":2588672},"flat_64_expert_complete_scan":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"6b04dba4d4affb2a","correct":256,"expert_evaluations":16384,"prediction_checksum":"082417545b43bcf9","prediction_samples":238,"prediction_sse_q20":287538647366,"reconstruction_checksum":"54c55f8a264a148c","reconstruction_sse_q20":284230034884,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"669f4bd9ce13faaf","transition_correct":238,"transition_supported":238,"transition_unknown":18},"expert_count":64,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"cf80f4162c924778","exact_world_state_target_reached":64,"executed_path_length":295,"expansions":2056,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":287,"path_found":64,"path_length_regret":8,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"3c41fbd89bc7e94c","correct":256,"expert_evaluations":16384,"prediction_checksum":"63e06dc253181f58","prediction_samples":223,"prediction_sse_q20":146424980188,"reconstruction_checksum":"6aae47aeb150bf66","reconstruction_sse_q20":137223719360,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"19a4f60e2f02b42b","transition_correct":223,"transition_supported":223,"transition_unknown":33},"training_evaluations":2588672},"matched_compute_fixed_topology":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"06bb10f6a8e752ed","correct":238,"expert_evaluations":2944,"prediction_checksum":"d7b932fd6560a076","prediction_samples":239,"prediction_sse_q20":386396354589,"reconstruction_checksum":"0182141d0bcc4bf0","reconstruction_sse_q20":345652470433,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":240,"samples":256,"transition_checksum":"56996b3c17c37ff0","transition_correct":216,"transition_supported":239,"transition_unknown":17},"expert_count":64,"planning":{"belief_set_target_reached":40,"cases":64,"checksum":"1cd1b8de14b59d99","exact_world_state_target_reached":36,"executed_path_length":239,"expansions":1925,"goal_expert_reached":40,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":287,"path_found":64,"path_length_regret":4,"state_aliasing_failures":4,"transition_model_error_failures":24},"retention_holdout":{"classification_checksum":"8a6508c41469a6ce","correct":243,"expert_evaluations":2272,"prediction_checksum":"7b827a84c2d50242","prediction_samples":233,"prediction_sse_q20":252189565085,"reconstruction_checksum":"7eced7a62625196b","reconstruction_sse_q20":199148458786,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":252,"samples":256,"transition_checksum":"7c032494c0c65ca0","transition_correct":212,"transition_supported":233,"transition_unknown":23},"training_evaluations":1484960},"matched_expert_count_capacity":{"checkpoint_size_bytes":46064,"drift_holdout":{"classification_checksum":"34fa0eaeb61d1f69","correct":256,"expert_evaluations":2231,"prediction_checksum":"b7428cd1a7593d82","prediction_samples":228,"prediction_sse_q20":277048956147,"reconstruction_checksum":"f2addab2243adf18","reconstruction_sse_q20":282417472006,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":253,"samples":256,"transition_checksum":"d7f8eb524ad99157","transition_correct":224,"transition_supported":228,"transition_unknown":28},"expert_count":69,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"3e89e8bdddd99cfb","exact_world_state_target_reached":64,"executed_path_length":299,"expansions":2143,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":287,"path_found":64,"path_length_regret":12,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"0afd092455398334","correct":256,"expert_evaluations":2048,"prediction_checksum":"bee54ae95ee1a21c","prediction_samples":216,"prediction_sse_q20":141853378008,"reconstruction_checksum":"86c913b96f2d43b5","reconstruction_sse_q20":136682023513,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"3020e955b809c284","transition_correct":208,"transition_supported":216,"transition_unknown":40},"training_evaluations":2967552},"nearest_centroid_16_no_recursive_births":{"checkpoint_size_bytes":15854,"drift_holdout":{"classification_checksum":"b4f787da28208bf4","correct":69,"expert_evaluations":4096,"prediction_checksum":"de7d124270672a30","prediction_samples":256,"prediction_sse_q20":1552369461540,"reconstruction_checksum":"fde98fadf6d3d82e","reconstruction_sse_q20":1374755129884,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"33c05ab802572e26","transition_correct":159,"transition_supported":256,"transition_unknown":0},"expert_count":16,"planning":{"belief_set_target_reached":33,"cases":64,"checksum":"f5707b006b7bec7c","exact_world_state_target_reached":14,"executed_path_length":169,"expansions":573,"goal_expert_reached":33,"graph_disconnection_failures":4,"no_supported_edge_failures":0,"optimal_path_length":287,"path_found":60,"path_length_regret":5,"state_aliasing_failures":19,"transition_model_error_failures":27},"retention_holdout":{"classification_checksum":"7e319212ccd9125e","correct":67,"expert_evaluations":4096,"prediction_checksum":"dcd04fee1ea9278c","prediction_samples":256,"prediction_sse_q20":1485277900072,"reconstruction_checksum":"2f1336afb966e723","reconstruction_sse_q20":1259025177980,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"0d2763375b6e9f14","transition_correct":160,"transition_supported":256,"transition_unknown":0},"training_evaluations":253952},"no_adaptation_static":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"06bb10f6a8e752ed","correct":238,"expert_evaluations":2944,"prediction_checksum":"d7b932fd6560a076","prediction_samples":239,"prediction_sse_q20":386396354589,"reconstruction_checksum":"0182141d0bcc4bf0","reconstruction_sse_q20":345652470433,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":240,"samples":256,"transition_checksum":"56996b3c17c37ff0","transition_correct":216,"transition_supported":239,"transition_unknown":17},"expert_count":64,"planning":{"belief_set_target_reached":40,"cases":64,"checksum":"1cd1b8de14b59d99","exact_world_state_target_reached":36,"executed_path_length":239,"expansions":1925,"goal_expert_reached":40,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":287,"path_found":64,"path_length_regret":4,"state_aliasing_failures":4,"transition_model_error_failures":24},"retention_holdout":{"classification_checksum":"8a6508c41469a6ce","correct":243,"expert_evaluations":2272,"prediction_checksum":"7b827a84c2d50242","prediction_samples":233,"prediction_sse_q20":252189565085,"reconstruction_checksum":"7eced7a62625196b","reconstruction_sse_q20":199148458786,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":252,"samples":256,"transition_checksum":"7c032494c0c65ca0","transition_correct":212,"transition_supported":233,"transition_unknown":23},"training_evaluations":572448},"periodic_replay_policy":{"checkpoint_size_bytes":46064,"drift_holdout":{"classification_checksum":"9dff3863e880adaf","correct":256,"expert_evaluations":2414,"prediction_checksum":"6808143eca1ef4be","prediction_samples":233,"prediction_sse_q20":304880073885,"reconstruction_checksum":"17b7bba0569794a0","reconstruction_sse_q20":297716687048,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":250,"samples":256,"transition_checksum":"8f006ca186e07fe8","transition_correct":226,"transition_supported":233,"transition_unknown":23},"expert_count":69,"planning":{"belief_set_target_reached":44,"cases":64,"checksum":"c5341ca190ce45a0","exact_world_state_target_reached":44,"executed_path_length":246,"expansions":1944,"goal_expert_reached":44,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":287,"path_found":64,"path_length_regret":1,"state_aliasing_failures":0,"transition_model_error_failures":20},"retention_holdout":{"classification_checksum":"439d545162cf7d3b","correct":256,"expert_evaluations":2048,"prediction_checksum":"ae4a2457604c5645","prediction_samples":232,"prediction_sse_q20":183005739843,"reconstruction_checksum":"2a9941a47160de9f","reconstruction_sse_q20":159620760166,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"24b5d352f11b5e08","transition_correct":224,"transition_supported":232,"transition_unknown":24},"training_evaluations":1398326},"ravel_0_5_candidate":{"checkpoint_size_bytes":46064,"drift_holdout":{"classification_checksum":"9dff3863e880adaf","correct":256,"expert_evaluations":2414,"prediction_checksum":"b91cf8fbaa0fe363","prediction_samples":236,"prediction_sse_q20":308562073079,"reconstruction_checksum":"20509a2940e1deb6","reconstruction_sse_q20":297952404668,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":250,"samples":256,"transition_checksum":"b779aca4e05604d0","transition_correct":229,"transition_supported":236,"transition_unknown":20},"expert_count":69,"planning":{"belief_set_target_reached":44,"cases":64,"checksum":"c5341ca190ce45a0","exact_world_state_target_reached":44,"executed_path_length":246,"expansions":1945,"goal_expert_reached":44,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":287,"path_found":64,"path_length_regret":1,"state_aliasing_failures":0,"transition_model_error_failures":20},"retention_holdout":{"classification_checksum":"439d545162cf7d3b","correct":256,"expert_evaluations":2048,"prediction_checksum":"c197beaa59190034","prediction_samples":233,"prediction_sse_q20":183598343647,"reconstruction_checksum":"bd642c34b09fd330","reconstruction_sse_q20":159519095379,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"c238276d9892c7b6","transition_correct":225,"transition_supported":233,"transition_unknown":23},"training_evaluations":1399218},"ravel_complete_scan_without_certification":{"checkpoint_size_bytes":46064,"drift_holdout":{"classification_checksum":"9dff3863e880adaf","correct":256,"expert_evaluations":17664,"prediction_checksum":"b91cf8fbaa0fe363","prediction_samples":236,"prediction_sse_q20":308562073079,"reconstruction_checksum":"20509a2940e1deb6","reconstruction_sse_q20":297952404668,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"b779aca4e05604d0","transition_correct":229,"transition_supported":236,"transition_unknown":20},"expert_count":69,"planning":{"belief_set_target_reached":44,"cases":64,"checksum":"c5341ca190ce45a0","exact_world_state_target_reached":44,"executed_path_length":246,"expansions":1945,"goal_expert_reached":44,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":287,"path_found":64,"path_length_regret":1,"state_aliasing_failures":0,"transition_model_error_failures":20},"retention_holdout":{"classification_checksum":"439d545162cf7d3b","correct":256,"expert_evaluations":17664,"prediction_checksum":"c197beaa59190034","prediction_samples":233,"prediction_sse_q20":183598343647,"reconstruction_checksum":"bd642c34b09fd330","reconstruction_sse_q20":159519095379,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"c238276d9892c7b6","transition_correct":225,"transition_supported":233,"transition_unknown":23},"training_evaluations":1583682},"ravel_no_birth_same_replay_iterations":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"06bb10f6a8e752ed","correct":238,"expert_evaluations":2944,"prediction_checksum":"d7b932fd6560a076","prediction_samples":239,"prediction_sse_q20":386396354589,"reconstruction_checksum":"0182141d0bcc4bf0","reconstruction_sse_q20":345652470433,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":240,"samples":256,"transition_checksum":"56996b3c17c37ff0","transition_correct":216,"transition_supported":239,"transition_unknown":17},"expert_count":64,"planning":{"belief_set_target_reached":40,"cases":64,"checksum":"1cd1b8de14b59d99","exact_world_state_target_reached":36,"executed_path_length":239,"expansions":1925,"goal_expert_reached":40,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":287,"path_found":64,"path_length_regret":4,"state_aliasing_failures":4,"transition_model_error_failures":24},"retention_holdout":{"classification_checksum":"8a6508c41469a6ce","correct":243,"expert_evaluations":2272,"prediction_checksum":"7b827a84c2d50242","prediction_samples":233,"prediction_sse_q20":252189565085,"reconstruction_checksum":"7eced7a62625196b","reconstruction_sse_q20":199148458786,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":252,"samples":256,"transition_checksum":"7c032494c0c65ca0","transition_correct":212,"transition_supported":233,"transition_unknown":23},"training_evaluations":800576},"ravel_random_births":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"06bb10f6a8e752ed","correct":238,"expert_evaluations":2944,"prediction_checksum":"d7b932fd6560a076","prediction_samples":239,"prediction_sse_q20":386396354589,"reconstruction_checksum":"0182141d0bcc4bf0","reconstruction_sse_q20":345652470433,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":240,"samples":256,"transition_checksum":"56996b3c17c37ff0","transition_correct":216,"transition_supported":239,"transition_unknown":17},"expert_count":64,"planning":{"belief_set_target_reached":40,"cases":64,"checksum":"1cd1b8de14b59d99","exact_world_state_target_reached":36,"executed_path_length":239,"expansions":1925,"goal_expert_reached":40,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":287,"path_found":64,"path_length_regret":4,"state_aliasing_failures":4,"transition_model_error_failures":24},"retention_holdout":{"classification_checksum":"8a6508c41469a6ce","correct":243,"expert_evaluations":2272,"prediction_checksum":"7b827a84c2d50242","prediction_samples":233,"prediction_sse_q20":252189565085,"reconstruction_checksum":"7eced7a62625196b","reconstruction_sse_q20":199148458786,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":252,"samples":256,"transition_checksum":"7c032494c0c65ca0","transition_correct":212,"transition_supported":233,"transition_unknown":23},"training_evaluations":800576},"ravel_without_replay":{"checkpoint_size_bytes":46064,"drift_holdout":{"classification_checksum":"9dff3863e880adaf","correct":256,"expert_evaluations":2414,"prediction_checksum":"a6f76def9bcfbc81","prediction_samples":233,"prediction_sse_q20":305740691421,"reconstruction_checksum":"69567775041ab7e3","reconstruction_sse_q20":297832555103,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":250,"samples":256,"transition_checksum":"8f006ca186e07fe8","transition_correct":226,"transition_supported":233,"transition_unknown":23},"expert_count":69,"planning":{"belief_set_target_reached":44,"cases":64,"checksum":"c5341ca190ce45a0","exact_world_state_target_reached":44,"executed_path_length":246,"expansions":1944,"goal_expert_reached":44,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":287,"path_found":64,"path_length_regret":1,"state_aliasing_failures":0,"transition_model_error_failures":20},"retention_holdout":{"classification_checksum":"439d545162cf7d3b","correct":256,"expert_evaluations":2048,"prediction_checksum":"ef9770944007e490","prediction_samples":232,"prediction_sse_q20":183899539948,"reconstruction_checksum":"6c60a115bce8e040","reconstruction_sse_q20":159780749171,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"24b5d352f11b5e08","transition_correct":224,"transition_supported":232,"transition_unknown":24},"training_evaluations":1126182},"ravel_without_retirement_matched_work":{"checkpoint_size_bytes":46064,"drift_holdout":{"classification_checksum":"9dff3863e880adaf","correct":256,"expert_evaluations":2414,"prediction_checksum":"b91cf8fbaa0fe363","prediction_samples":236,"prediction_sse_q20":308562073079,"reconstruction_checksum":"20509a2940e1deb6","reconstruction_sse_q20":297952404668,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":250,"samples":256,"transition_checksum":"b779aca4e05604d0","transition_correct":229,"transition_supported":236,"transition_unknown":20},"expert_count":69,"planning":{"belief_set_target_reached":44,"cases":64,"checksum":"c5341ca190ce45a0","exact_world_state_target_reached":44,"executed_path_length":246,"expansions":1945,"goal_expert_reached":44,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":287,"path_found":64,"path_length_regret":1,"state_aliasing_failures":0,"transition_model_error_failures":20},"retention_holdout":{"classification_checksum":"439d545162cf7d3b","correct":256,"expert_evaluations":2048,"prediction_checksum":"c197beaa59190034","prediction_samples":233,"prediction_sse_q20":183598343647,"reconstruction_checksum":"bd642c34b09fd330","reconstruction_sse_q20":159519095379,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"c238276d9892c7b6","transition_correct":225,"transition_supported":233,"transition_unknown":23},"training_evaluations":1399218}},"dataset_seeds":{"base_holdout":"0xed45b2ed70847451","base_training":"0x39b22b662712a7ef","drift_adaptation_training":"0x41441b5c3dbcf046","drift_holdout":"0xdf66d5866f3134d1","original_task_retention_holdout":"0x7afea0d2c8ed07b8","planning_cases":"0xcd4a5f12b694d7ea"},"dataset_sizes":{"base_holdout":256,"base_training":1024,"drift_adaptation_training":512,"drift_holdout":256,"original_task_retention_holdout":256,"planning_cases":64},"integrity":{"checkpoint_behavior_match":true,"checkpoint_identity_match":true,"checkpoint_mutations":{"anchored_status":true,"appended_unexpected_byte":true,"checkpoint_substitution":true,"checkpoint_truncation":true,"incorrect_schema_version":true,"label":true,"label_count":true,"lineage":true,"next_observation_component":true,"payload_byte":true,"reconstruction_component":true,"retrieval_key_component":true,"transition_graph_edge":true,"transition_support":true},"checkpoint_roundtrip":true,"lineage_invariants":{"deterministic_topology_reproduction":true,"lineage_uniqueness":true,"no_accidental_lineage_reuse":true,"parent_child_generation_increment":true,"repeated_descendant_splitting":true,"sibling_generation_equality":true},"unsupported_graph_edge_violations":0},"regime":"increased_observation_noise","schema":"ravel-raw-trial/0.5","seed":"0x8737c70577b4fdf1","trial_id":"validation-noise-04"},{"candidate":{"adaptation_completed":true,"adaptation_training":{"classification_checksum":"ec8020a7088319d3","correct":323,"expert_evaluations":4096,"prediction_checksum":"c303695895e929de","prediction_samples":484,"prediction_sse_q20":92207795534,"reconstruction_checksum":"1f5bfe7c3ffec461","reconstruction_sse_q20":63075668378,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":512,"samples":512,"transition_checksum":"37f414779d24596d","transition_correct":464,"transition_supported":484,"transition_unknown":28},"adaptation_training_evaluations":1336320,"adapted_model_drift_holdout":{"classification_checksum":"83fa78bf4863d8d8","correct":178,"expert_evaluations":2048,"prediction_checksum":"0cf93850d72c1536","prediction_samples":228,"prediction_sse_q20":28333839807,"reconstruction_checksum":"9cc9d522d0f3085d","reconstruction_sse_q20":26588154261,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"c79b5e06d9167f0b","transition_correct":221,"transition_supported":228,"transition_unknown":28},"base_holdout":{"classification_checksum":"adf0df6af8b7edc8","correct":243,"expert_evaluations":2048,"prediction_checksum":"7f79e781f79b7f7e","prediction_samples":236,"prediction_sse_q20":107053154228,"reconstruction_checksum":"88977a38d937ad44","reconstruction_sse_q20":84620904370,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"6850176725d56c76","transition_correct":224,"transition_supported":236,"transition_unknown":20},"base_holdout_retention":{"classification_checksum":"ad7204489e011fde","correct":248,"expert_evaluations":2048,"prediction_checksum":"6fbc1bb23f97635c","prediction_samples":237,"prediction_sse_q20":53472093920,"reconstruction_checksum":"73877c625d792322","reconstruction_sse_q20":33731086475,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"5bd9aea4adf5621d","transition_correct":228,"transition_supported":237,"transition_unknown":19},"base_training_evaluations":557768,"behavior_identity":"aad0d3f24c09117e48206684ef912cba005f1656aee6cfdd2c6bf4c30f680514","checkpoint_size_bytes":49484,"expert_count":75,"model_identity":"db02e751ec287bbdfa39dc6e616db5be91b5343f9fc2bca059200eb39770c8fa","planning":{"belief_set_target_reached":56,"cases":64,"checksum":"75375cf917443fc3","exact_world_state_target_reached":56,"executed_path_length":271,"expansions":2054,"goal_expert_reached":56,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":282,"path_found":64,"path_length_regret":16,"state_aliasing_failures":0,"transition_model_error_failures":8},"replay":{"actions_covered":4,"assigned_experts_covered":61,"high_loss_cases_selected":13,"labels_covered":8,"rare_cases_selected":62,"selected":256,"selection_checksum":"514c4b36ebf906a5","states_covered":64,"transition_pairs_covered":253,"unique":256},"static_model_drift_holdout":{"classification_checksum":"6b0ffb881518c595","correct":141,"expert_evaluations":2048,"prediction_checksum":"fbbce90d6e85cc91","prediction_samples":235,"prediction_sse_q20":84584590047,"reconstruction_checksum":"203ba78d5061017b","reconstruction_sse_q20":90742769367,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"d20cdd3fd5e747c1","transition_correct":224,"transition_supported":235,"transition_unknown":21},"topology":{"accepted_births":12,"accepted_retirements":1,"births":[{"dominant_channel":0,"event_index":75,"normalized_score_q20":592803},{"dominant_channel":0,"event_index":28,"normalized_score_q20":590254},{"dominant_channel":0,"event_index":153,"normalized_score_q20":564170},{"dominant_channel":0,"event_index":384,"normalized_score_q20":555683},{"dominant_channel":0,"event_index":124,"normalized_score_q20":554532},{"dominant_channel":0,"event_index":111,"normalized_score_q20":521165},{"dominant_channel":0,"event_index":150,"normalized_score_q20":511697},{"dominant_channel":0,"event_index":372,"normalized_score_q20":507317},{"dominant_channel":0,"event_index":470,"normalized_score_q20":502180},{"dominant_channel":0,"event_index":203,"normalized_score_q20":498310},{"dominant_channel":0,"event_index":96,"normalized_score_q20":487713},{"dominant_channel":0,"event_index":460,"normalized_score_q20":413678}],"objective_after_q20":841819,"objective_before_q20":816976,"rejected_births":4,"rejected_retirements":1,"retired_lineages":["f308c6a88c2a6dd9"],"training_observations":{"births":12,"certified":16896,"expert_evaluations":1336320,"rejected_births":4,"rejected_retirements":1,"retired":1,"samples":16896}}},"checkpoint_format":{"byte_order":"big_endian","magic_hex":"524156454c303500","payload_digest":"sha256","real_encoding":"signed_q20_int64","schema_version":5,"transition_support_min":2,"transition_top_k":2},"comparisons":{"fixed_8_expert":{"checkpoint_size_bytes":11294,"drift_holdout":{"classification_checksum":"2e49400b8f307c27","correct":46,"expert_evaluations":2048,"prediction_checksum":"26c58d8748a846ac","prediction_samples":256,"prediction_sse_q20":1912189163582,"reconstruction_checksum":"3bb5eb3328d04f50","reconstruction_sse_q20":1768816299082,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"1da1ec5b6d4f7bfe","transition_correct":133,"transition_supported":256,"transition_unknown":0},"expert_count":8,"planning":{"belief_set_target_reached":30,"cases":64,"checksum":"346af446e40dd7a0","exact_world_state_target_reached":3,"executed_path_length":139,"expansions":291,"goal_expert_reached":30,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":282,"path_found":64,"path_length_regret":0,"state_aliasing_failures":27,"transition_model_error_failures":34},"retention_holdout":{"classification_checksum":"1a95bbd136b97d08","correct":47,"expert_evaluations":2048,"prediction_checksum":"2952fc1ab3b769bf","prediction_samples":256,"prediction_sse_q20":1952117914333,"reconstruction_checksum":"ee12a2e1fbcd00d6","reconstruction_sse_q20":1758914669139,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"1c0fbd254a8c034d","transition_correct":133,"transition_supported":256,"transition_unknown":0},"training_evaluations":94208},"fixed_topology_64_expert_routed":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"ae6e4e5b76004b12","correct":160,"expert_evaluations":2048,"prediction_checksum":"e67ddec69560c5ce","prediction_samples":232,"prediction_sse_q20":24344858259,"reconstruction_checksum":"fce515c51306b073","reconstruction_sse_q20":22968345993,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"412f715a8f9a70bf","transition_correct":232,"transition_supported":232,"transition_unknown":24},"expert_count":64,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"c03f9991bf8f7125","exact_world_state_target_reached":64,"executed_path_length":296,"expansions":1986,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":282,"path_found":64,"path_length_regret":14,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"253fd361b87942b7","correct":256,"expert_evaluations":2048,"prediction_checksum":"78dbebbc3e018b84","prediction_samples":239,"prediction_sse_q20":26577464292,"reconstruction_checksum":"c3975b53bbd8ccc9","reconstruction_sse_q20":22618809565,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"1ad837ec652157b2","transition_correct":239,"transition_supported":239,"transition_unknown":17},"training_evaluations":2588672},"flat_64_expert_complete_scan":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"ae6e4e5b76004b12","correct":160,"expert_evaluations":16384,"prediction_checksum":"e67ddec69560c5ce","prediction_samples":232,"prediction_sse_q20":24344858259,"reconstruction_checksum":"fce515c51306b073","reconstruction_sse_q20":22968345993,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"412f715a8f9a70bf","transition_correct":232,"transition_supported":232,"transition_unknown":24},"expert_count":64,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"c03f9991bf8f7125","exact_world_state_target_reached":64,"executed_path_length":296,"expansions":1986,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":282,"path_found":64,"path_length_regret":14,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"253fd361b87942b7","correct":256,"expert_evaluations":16384,"prediction_checksum":"78dbebbc3e018b84","prediction_samples":239,"prediction_sse_q20":26577464292,"reconstruction_checksum":"c3975b53bbd8ccc9","reconstruction_sse_q20":22618809565,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"1ad837ec652157b2","transition_correct":239,"transition_supported":239,"transition_unknown":17},"training_evaluations":2588672},"matched_compute_fixed_topology":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"6b0ffb881518c595","correct":141,"expert_evaluations":2048,"prediction_checksum":"fbbce90d6e85cc91","prediction_samples":235,"prediction_sse_q20":84584590047,"reconstruction_checksum":"203ba78d5061017b","reconstruction_sse_q20":90742769367,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"d20cdd3fd5e747c1","transition_correct":224,"transition_supported":235,"transition_unknown":21},"expert_count":64,"planning":{"belief_set_target_reached":45,"cases":64,"checksum":"dff235658944581d","exact_world_state_target_reached":43,"executed_path_length":244,"expansions":1779,"goal_expert_reached":45,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":282,"path_found":64,"path_length_regret":10,"state_aliasing_failures":2,"transition_model_error_failures":19},"retention_holdout":{"classification_checksum":"2a33b4eb9b241602","correct":232,"expert_evaluations":2048,"prediction_checksum":"7dac1cb2cf0cfc5b","prediction_samples":242,"prediction_sse_q20":115623861775,"reconstruction_checksum":"d0aced8b43a2cc45","reconstruction_sse_q20":102162001984,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"a0bafd4ac50aa628","transition_correct":219,"transition_supported":242,"transition_unknown":14},"training_evaluations":2106056},"matched_expert_count_capacity":{"checkpoint_size_bytes":49484,"drift_holdout":{"classification_checksum":"51e6968775f153fd","correct":160,"expert_evaluations":2048,"prediction_checksum":"49dcae0587b5e46d","prediction_samples":222,"prediction_sse_q20":23438753123,"reconstruction_checksum":"381416a3ebcbb582","reconstruction_sse_q20":22795561121,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"d97855686d5edef5","transition_correct":209,"transition_supported":222,"transition_unknown":34},"expert_count":75,"planning":{"belief_set_target_reached":63,"cases":64,"checksum":"0feb2cb83f6ac928","exact_world_state_target_reached":63,"executed_path_length":306,"expansions":2120,"goal_expert_reached":63,"graph_disconnection_failures":0,"no_supported_edge_failures":1,"optimal_path_length":282,"path_found":63,"path_length_regret":27,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"738c2e43dadb49a9","correct":256,"expert_evaluations":2048,"prediction_checksum":"592d41a6e4fc6b6c","prediction_samples":231,"prediction_sse_q20":26104591999,"reconstruction_checksum":"36bf0d31d806c42b","reconstruction_sse_q20":22588532447,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"255bc1d166ce616c","transition_correct":214,"transition_supported":231,"transition_unknown":25},"training_evaluations":3456000},"nearest_centroid_16_no_recursive_births":{"checkpoint_size_bytes":15854,"drift_holdout":{"classification_checksum":"633af584dfd16932","correct":56,"expert_evaluations":4096,"prediction_checksum":"f5d9a79fdba8f270","prediction_samples":256,"prediction_sse_q20":1291304099715,"reconstruction_checksum":"b11963b0d98d86e1","reconstruction_sse_q20":1124621656026,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"582e183ebf8204b5","transition_correct":172,"transition_supported":256,"transition_unknown":0},"expert_count":16,"planning":{"belief_set_target_reached":40,"cases":64,"checksum":"c978f1d88b3fc6b9","exact_world_state_target_reached":11,"executed_path_length":134,"expansions":391,"goal_expert_reached":40,"graph_disconnection_failures":8,"no_supported_edge_failures":0,"optimal_path_length":282,"path_found":56,"path_length_regret":0,"state_aliasing_failures":29,"transition_model_error_failures":16},"retention_holdout":{"classification_checksum":"49316f86117e5cae","correct":81,"expert_evaluations":4096,"prediction_checksum":"195faa89aeb38afe","prediction_samples":256,"prediction_sse_q20":1359347643573,"reconstruction_checksum":"c04216f599721a45","reconstruction_sse_q20":1167035230833,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"b3e9fc6b2e87d1c3","transition_correct":172,"transition_supported":256,"transition_unknown":0},"training_evaluations":253952},"no_adaptation_static":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"6b0ffb881518c595","correct":141,"expert_evaluations":2048,"prediction_checksum":"fbbce90d6e85cc91","prediction_samples":235,"prediction_sse_q20":84584590047,"reconstruction_checksum":"203ba78d5061017b","reconstruction_sse_q20":90742769367,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"d20cdd3fd5e747c1","transition_correct":224,"transition_supported":235,"transition_unknown":21},"expert_count":64,"planning":{"belief_set_target_reached":45,"cases":64,"checksum":"dff235658944581d","exact_world_state_target_reached":43,"executed_path_length":244,"expansions":1779,"goal_expert_reached":45,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":282,"path_found":64,"path_length_regret":10,"state_aliasing_failures":2,"transition_model_error_failures":19},"retention_holdout":{"classification_checksum":"2a33b4eb9b241602","correct":232,"expert_evaluations":2048,"prediction_checksum":"7dac1cb2cf0cfc5b","prediction_samples":242,"prediction_sse_q20":115623861775,"reconstruction_checksum":"d0aced8b43a2cc45","reconstruction_sse_q20":102162001984,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"a0bafd4ac50aa628","transition_correct":219,"transition_supported":242,"transition_unknown":14},"training_evaluations":557768},"periodic_replay_policy":{"checkpoint_size_bytes":51764,"drift_holdout":{"classification_checksum":"c0148f777700b216","correct":180,"expert_evaluations":3113,"prediction_checksum":"7a6483843dcaacd5","prediction_samples":226,"prediction_sse_q20":27985144536,"reconstruction_checksum":"c0f4587d60ece55f","reconstruction_sse_q20":26355771166,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":241,"samples":256,"transition_checksum":"0c3c900100b7c483","transition_correct":219,"transition_supported":226,"transition_unknown":30},"expert_count":79,"planning":{"belief_set_target_reached":56,"cases":64,"checksum":"840ce15a2e6c5741","exact_world_state_target_reached":56,"executed_path_length":273,"expansions":2052,"goal_expert_reached":56,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":282,"path_found":64,"path_length_regret":14,"state_aliasing_failures":0,"transition_model_error_failures":8},"retention_holdout":{"classification_checksum":"0ba0e03f2f20ff3b","correct":248,"expert_evaluations":3255,"prediction_checksum":"e163d7179bb488cd","prediction_samples":235,"prediction_sse_q20":53269580372,"reconstruction_checksum":"8fd69b9945e089df","reconstruction_sse_q20":33620050878,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":239,"samples":256,"transition_checksum":"f591db8a225a545f","transition_correct":223,"transition_supported":235,"transition_unknown":21},"training_evaluations":2168388},"ravel_0_5_candidate":{"checkpoint_size_bytes":49484,"drift_holdout":{"classification_checksum":"83fa78bf4863d8d8","correct":178,"expert_evaluations":2048,"prediction_checksum":"0cf93850d72c1536","prediction_samples":228,"prediction_sse_q20":28333839807,"reconstruction_checksum":"9cc9d522d0f3085d","reconstruction_sse_q20":26588154261,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"c79b5e06d9167f0b","transition_correct":221,"transition_supported":228,"transition_unknown":28},"expert_count":75,"planning":{"belief_set_target_reached":56,"cases":64,"checksum":"75375cf917443fc3","exact_world_state_target_reached":56,"executed_path_length":271,"expansions":2054,"goal_expert_reached":56,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":282,"path_found":64,"path_length_regret":16,"state_aliasing_failures":0,"transition_model_error_failures":8},"retention_holdout":{"classification_checksum":"ad7204489e011fde","correct":248,"expert_evaluations":2048,"prediction_checksum":"6fbc1bb23f97635c","prediction_samples":237,"prediction_sse_q20":53472093920,"reconstruction_checksum":"73877c625d792322","reconstruction_sse_q20":33731086475,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"5bd9aea4adf5621d","transition_correct":228,"transition_supported":237,"transition_unknown":19},"training_evaluations":1894088},"ravel_complete_scan_without_certification":{"checkpoint_size_bytes":49484,"drift_holdout":{"classification_checksum":"83fa78bf4863d8d8","correct":178,"expert_evaluations":19200,"prediction_checksum":"0cf93850d72c1536","prediction_samples":228,"prediction_sse_q20":28333839807,"reconstruction_checksum":"9cc9d522d0f3085d","reconstruction_sse_q20":26588154261,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"c79b5e06d9167f0b","transition_correct":221,"transition_supported":228,"transition_unknown":28},"expert_count":75,"planning":{"belief_set_target_reached":56,"cases":64,"checksum":"75375cf917443fc3","exact_world_state_target_reached":56,"executed_path_length":271,"expansions":2054,"goal_expert_reached":56,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":282,"path_found":64,"path_length_regret":16,"state_aliasing_failures":0,"transition_model_error_failures":8},"retention_holdout":{"classification_checksum":"ad7204489e011fde","correct":248,"expert_evaluations":19200,"prediction_checksum":"6fbc1bb23f97635c","prediction_samples":237,"prediction_sse_q20":53472093920,"reconstruction_checksum":"73877c625d792322","reconstruction_sse_q20":33731086475,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"5bd9aea4adf5621d","transition_correct":228,"transition_supported":237,"transition_unknown":19},"training_evaluations":2102984},"ravel_no_birth_same_replay_iterations":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"6b0ffb881518c595","correct":141,"expert_evaluations":2048,"prediction_checksum":"fbbce90d6e85cc91","prediction_samples":235,"prediction_sse_q20":84584590047,"reconstruction_checksum":"203ba78d5061017b","reconstruction_sse_q20":90742769367,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"d20cdd3fd5e747c1","transition_correct":224,"transition_supported":235,"transition_unknown":21},"expert_count":64,"planning":{"belief_set_target_reached":45,"cases":64,"checksum":"dff235658944581d","exact_world_state_target_reached":43,"executed_path_length":244,"expansions":1779,"goal_expert_reached":45,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":282,"path_found":64,"path_length_regret":10,"state_aliasing_failures":2,"transition_model_error_failures":19},"retention_holdout":{"classification_checksum":"2a33b4eb9b241602","correct":232,"expert_evaluations":2048,"prediction_checksum":"7dac1cb2cf0cfc5b","prediction_samples":242,"prediction_sse_q20":115623861775,"reconstruction_checksum":"d0aced8b43a2cc45","reconstruction_sse_q20":102162001984,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"a0bafd4ac50aa628","transition_correct":219,"transition_supported":242,"transition_unknown":14},"training_evaluations":778952},"ravel_random_births":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"6b0ffb881518c595","correct":141,"expert_evaluations":2048,"prediction_checksum":"fbbce90d6e85cc91","prediction_samples":235,"prediction_sse_q20":84584590047,"reconstruction_checksum":"203ba78d5061017b","reconstruction_sse_q20":90742769367,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"d20cdd3fd5e747c1","transition_correct":224,"transition_supported":235,"transition_unknown":21},"expert_count":64,"planning":{"belief_set_target_reached":45,"cases":64,"checksum":"dff235658944581d","exact_world_state_target_reached":43,"executed_path_length":244,"expansions":1779,"goal_expert_reached":45,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":282,"path_found":64,"path_length_regret":10,"state_aliasing_failures":2,"transition_model_error_failures":19},"retention_holdout":{"classification_checksum":"2a33b4eb9b241602","correct":232,"expert_evaluations":2048,"prediction_checksum":"7dac1cb2cf0cfc5b","prediction_samples":242,"prediction_sse_q20":115623861775,"reconstruction_checksum":"d0aced8b43a2cc45","reconstruction_sse_q20":102162001984,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"a0bafd4ac50aa628","transition_correct":219,"transition_supported":242,"transition_unknown":14},"training_evaluations":778952},"ravel_without_replay":{"checkpoint_size_bytes":52334,"drift_holdout":{"classification_checksum":"61fc5558e5fe7618","correct":180,"expert_evaluations":3128,"prediction_checksum":"f4b641d66256a981","prediction_samples":217,"prediction_sse_q20":27222391438,"reconstruction_checksum":"95d4c194271fd824","reconstruction_sse_q20":26808734962,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":241,"samples":256,"transition_checksum":"ce108d1bdfb456e7","transition_correct":210,"transition_supported":217,"transition_unknown":39},"expert_count":80,"planning":{"belief_set_target_reached":57,"cases":64,"checksum":"0d5227fa0441e3b5","exact_world_state_target_reached":57,"executed_path_length":276,"expansions":2069,"goal_expert_reached":57,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":282,"path_found":64,"path_length_regret":16,"state_aliasing_failures":0,"transition_model_error_failures":7},"retention_holdout":{"classification_checksum":"8dd1b5fd7739ea69","correct":247,"expert_evaluations":3272,"prediction_checksum":"ff8ed028a089af3c","prediction_samples":222,"prediction_sse_q20":51774157246,"reconstruction_checksum":"26f6f642ab33c796","reconstruction_sse_q20":33707878454,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":239,"samples":256,"transition_checksum":"3f3a4bab8c73777d","transition_correct":210,"transition_supported":222,"transition_unknown":34},"training_evaluations":1751560},"ravel_without_retirement_matched_work":{"checkpoint_size_bytes":50054,"drift_holdout":{"classification_checksum":"83fa78bf4863d8d8","correct":178,"expert_evaluations":2048,"prediction_checksum":"0cf93850d72c1536","prediction_samples":228,"prediction_sse_q20":28333839807,"reconstruction_checksum":"9cc9d522d0f3085d","reconstruction_sse_q20":26588154261,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"c79b5e06d9167f0b","transition_correct":221,"transition_supported":228,"transition_unknown":28},"expert_count":76,"planning":{"belief_set_target_reached":56,"cases":64,"checksum":"75375cf917443fc3","exact_world_state_target_reached":56,"executed_path_length":271,"expansions":2054,"goal_expert_reached":56,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":282,"path_found":64,"path_length_regret":16,"state_aliasing_failures":0,"transition_model_error_failures":8},"retention_holdout":{"classification_checksum":"ad7204489e011fde","correct":248,"expert_evaluations":2048,"prediction_checksum":"6fbc1bb23f97635c","prediction_samples":237,"prediction_sse_q20":53472093920,"reconstruction_checksum":"73877c625d792322","reconstruction_sse_q20":33731086475,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"5bd9aea4adf5621d","transition_correct":228,"transition_supported":237,"transition_unknown":19},"training_evaluations":1894088}},"dataset_seeds":{"base_holdout":"0xa356444d54b55cd0","base_training":"0x85fbbd093bec8b02","drift_adaptation_training":"0x519fa5200be02df4","drift_holdout":"0x0b36002fe92ab194","original_task_retention_holdout":"0x48fcfd7d254aa1de","planning_cases":"0x335f81edd3c091e0"},"dataset_sizes":{"base_holdout":256,"base_training":1024,"drift_adaptation_training":512,"drift_holdout":256,"original_task_retention_holdout":256,"planning_cases":64},"integrity":{"checkpoint_behavior_match":true,"checkpoint_identity_match":true,"checkpoint_mutations":{"anchored_status":true,"appended_unexpected_byte":true,"checkpoint_substitution":true,"checkpoint_truncation":true,"incorrect_schema_version":true,"label":true,"label_count":true,"lineage":true,"next_observation_component":true,"payload_byte":true,"reconstruction_component":true,"retrieval_key_component":true,"transition_graph_edge":true,"transition_support":true},"checkpoint_roundtrip":true,"lineage_invariants":{"deterministic_topology_reproduction":true,"lineage_uniqueness":true,"no_accidental_lineage_reuse":true,"parent_child_generation_increment":true,"repeated_descendant_splitting":true,"sibling_generation_equality":true},"unsupported_graph_edge_violations":0},"regime":"label_drift","schema":"ravel-raw-trial/0.5","seed":"0xc5c651d456b06744","trial_id":"validation-label-01"},{"candidate":{"adaptation_completed":true,"adaptation_training":{"classification_checksum":"9316ab38abb09ae0","correct":342,"expert_evaluations":4096,"prediction_checksum":"5e180dd35f8e45bf","prediction_samples":453,"prediction_sse_q20":178266859390,"reconstruction_checksum":"a549b9e9c7c36560","reconstruction_sse_q20":141402530572,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":512,"samples":512,"transition_checksum":"848b82ecbfc4d1a8","transition_correct":416,"transition_supported":453,"transition_unknown":59},"adaptation_training_evaluations":1244160,"adapted_model_drift_holdout":{"classification_checksum":"f031b432f243bd68","correct":168,"expert_evaluations":2048,"prediction_checksum":"3962300b389ed4c4","prediction_samples":213,"prediction_sse_q20":64964840368,"reconstruction_checksum":"5d62aeb2bba9e6f8","reconstruction_sse_q20":66375376056,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"32fe63d943688491","transition_correct":195,"transition_supported":213,"transition_unknown":43},"base_holdout":{"classification_checksum":"a83f1b8db06c0594","correct":236,"expert_evaluations":2048,"prediction_checksum":"bdd41f4c5a0200cb","prediction_samples":230,"prediction_sse_q20":95706906583,"reconstruction_checksum":"8820b82bdab187b3","reconstruction_sse_q20":101438110070,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"5d72036b84aea617","transition_correct":215,"transition_supported":230,"transition_unknown":26},"base_holdout_retention":{"classification_checksum":"47c66ba187631313","correct":233,"expert_evaluations":2048,"prediction_checksum":"0535c8258b144666","prediction_samples":228,"prediction_sse_q20":90326724509,"reconstruction_checksum":"18bbbe8bcdcf50ab","reconstruction_sse_q20":89933842317,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"7eeb744a938a33cb","transition_correct":211,"transition_supported":228,"transition_unknown":28},"base_training_evaluations":552728,"behavior_identity":"37406004683da7d0021b6a7b84ca6503d1691fbc17b4acfb8d36909b3fde2113","checkpoint_size_bytes":50624,"expert_count":77,"model_identity":"e527e20059af60d3cf247ae4bca8ef4eafe5b19366e9127032e347cd7e0821a7","planning":{"belief_set_target_reached":57,"cases":64,"checksum":"67cadf31b8f3441d","exact_world_state_target_reached":56,"executed_path_length":297,"expansions":2052,"goal_expert_reached":57,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":281,"path_found":64,"path_length_regret":15,"state_aliasing_failures":1,"transition_model_error_failures":7},"replay":{"actions_covered":4,"assigned_experts_covered":63,"high_loss_cases_selected":14,"labels_covered":8,"rare_cases_selected":59,"selected":256,"selection_checksum":"2676e266b427c58d","states_covered":64,"transition_pairs_covered":252,"unique":256},"static_model_drift_holdout":{"classification_checksum":"d8bed2f656d33bd9","correct":159,"expert_evaluations":2048,"prediction_checksum":"717ae7aebfe810fd","prediction_samples":220,"prediction_sse_q20":65631749290,"reconstruction_checksum":"fd2b9af1664a9713","reconstruction_sse_q20":66749712695,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"69b474ae80f1aaef","transition_correct":207,"transition_supported":220,"transition_unknown":36},"topology":{"accepted_births":13,"accepted_retirements":0,"births":[{"dominant_channel":0,"event_index":33,"normalized_score_q20":587488},{"dominant_channel":0,"event_index":379,"normalized_score_q20":564462},{"dominant_channel":0,"event_index":412,"normalized_score_q20":564067},{"dominant_channel":0,"event_index":363,"normalized_score_q20":563620},{"dominant_channel":0,"event_index":446,"normalized_score_q20":563584},{"dominant_channel":0,"event_index":73,"normalized_score_q20":560424},{"dominant_channel":0,"event_index":95,"normalized_score_q20":559952},{"dominant_channel":0,"event_index":9,"normalized_score_q20":558676},{"dominant_channel":0,"event_index":136,"normalized_score_q20":553023},{"dominant_channel":0,"event_index":258,"normalized_score_q20":552946},{"dominant_channel":0,"event_index":52,"normalized_score_q20":551906},{"dominant_channel":0,"event_index":54,"normalized_score_q20":551660},{"dominant_channel":0,"event_index":419,"normalized_score_q20":550539}],"objective_after_q20":833587,"objective_before_q20":828015,"rejected_births":3,"rejected_retirements":1,"retired_lineages":[],"training_observations":{"births":13,"certified":15360,"expert_evaluations":1244160,"rejected_births":3,"rejected_retirements":1,"retired":0,"samples":15360}}},"checkpoint_format":{"byte_order":"big_endian","magic_hex":"524156454c303500","payload_digest":"sha256","real_encoding":"signed_q20_int64","schema_version":5,"transition_support_min":2,"transition_top_k":2},"comparisons":{"fixed_8_expert":{"checkpoint_size_bytes":11294,"drift_holdout":{"classification_checksum":"c780814dc8f50a94","correct":52,"expert_evaluations":2048,"prediction_checksum":"cce740bd7f47408c","prediction_samples":256,"prediction_sse_q20":2013314152000,"reconstruction_checksum":"44932739223eb933","reconstruction_sse_q20":1746281056616,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"cc5868d42498d9a1","transition_correct":91,"transition_supported":256,"transition_unknown":0},"expert_count":8,"planning":{"belief_set_target_reached":27,"cases":64,"checksum":"407e5b100e5231cf","exact_world_state_target_reached":3,"executed_path_length":118,"expansions":258,"goal_expert_reached":27,"graph_disconnection_failures":9,"no_supported_edge_failures":0,"optimal_path_length":281,"path_found":55,"path_length_regret":0,"state_aliasing_failures":24,"transition_model_error_failures":28},"retention_holdout":{"classification_checksum":"9fe1b380c045dc87","correct":54,"expert_evaluations":2048,"prediction_checksum":"05823889f8d56cf8","prediction_samples":256,"prediction_sse_q20":2021854428684,"reconstruction_checksum":"0ebba7901072109e","reconstruction_sse_q20":1802514818974,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"ce2ef09f3f44020e","transition_correct":92,"transition_supported":256,"transition_unknown":0},"training_evaluations":94208},"fixed_topology_64_expert_routed":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"798b0d25473a4eeb","correct":168,"expert_evaluations":2048,"prediction_checksum":"943bb5e810618c3e","prediction_samples":220,"prediction_sse_q20":24932656454,"reconstruction_checksum":"5a90d578501f4b19","reconstruction_sse_q20":22739540579,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"9f6805232ce6c48a","transition_correct":220,"transition_supported":220,"transition_unknown":36},"expert_count":64,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"8045d58e33e9d80b","exact_world_state_target_reached":64,"executed_path_length":292,"expansions":2077,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":281,"path_found":64,"path_length_regret":11,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"81e08ab0ff052f9d","correct":256,"expert_evaluations":2048,"prediction_checksum":"b431f3a30655de85","prediction_samples":228,"prediction_sse_q20":23709294322,"reconstruction_checksum":"fc34c48f8f96b78a","reconstruction_sse_q20":23028753639,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"36487a799e53c918","transition_correct":228,"transition_supported":228,"transition_unknown":28},"training_evaluations":2588672},"flat_64_expert_complete_scan":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"798b0d25473a4eeb","correct":168,"expert_evaluations":16384,"prediction_checksum":"943bb5e810618c3e","prediction_samples":220,"prediction_sse_q20":24932656454,"reconstruction_checksum":"5a90d578501f4b19","reconstruction_sse_q20":22739540579,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"9f6805232ce6c48a","transition_correct":220,"transition_supported":220,"transition_unknown":36},"expert_count":64,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"8045d58e33e9d80b","exact_world_state_target_reached":64,"executed_path_length":292,"expansions":2077,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":281,"path_found":64,"path_length_regret":11,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"81e08ab0ff052f9d","correct":256,"expert_evaluations":16384,"prediction_checksum":"b431f3a30655de85","prediction_samples":228,"prediction_sse_q20":23709294322,"reconstruction_checksum":"fc34c48f8f96b78a","reconstruction_sse_q20":23028753639,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"36487a799e53c918","transition_correct":228,"transition_supported":228,"transition_unknown":28},"training_evaluations":2588672},"matched_compute_fixed_topology":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"d8bed2f656d33bd9","correct":159,"expert_evaluations":2048,"prediction_checksum":"717ae7aebfe810fd","prediction_samples":220,"prediction_sse_q20":65631749290,"reconstruction_checksum":"fd2b9af1664a9713","reconstruction_sse_q20":66749712695,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"69b474ae80f1aaef","transition_correct":207,"transition_supported":220,"transition_unknown":36},"expert_count":64,"planning":{"belief_set_target_reached":56,"cases":64,"checksum":"7d4b24bc494052fa","exact_world_state_target_reached":55,"executed_path_length":294,"expansions":2001,"goal_expert_reached":56,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":281,"path_found":64,"path_length_regret":15,"state_aliasing_failures":1,"transition_model_error_failures":8},"retention_holdout":{"classification_checksum":"5b16148e570f87b1","correct":237,"expert_evaluations":2048,"prediction_checksum":"2f005643c36f02fc","prediction_samples":229,"prediction_sse_q20":90455298287,"reconstruction_checksum":"e5a613f47e18df79","reconstruction_sse_q20":90067939312,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"c80dd51801de85c3","transition_correct":216,"transition_supported":229,"transition_unknown":27},"training_evaluations":1879832},"matched_expert_count_capacity":{"checkpoint_size_bytes":50624,"drift_holdout":{"classification_checksum":"42821ce331c42de3","correct":168,"expert_evaluations":2048,"prediction_checksum":"eb2e7d00cffb3a11","prediction_samples":212,"prediction_sse_q20":24317605799,"reconstruction_checksum":"71fcce8b0df4b932","reconstruction_sse_q20":22251337079,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"165c5940b290785c","transition_correct":194,"transition_supported":212,"transition_unknown":44},"expert_count":77,"planning":{"belief_set_target_reached":63,"cases":64,"checksum":"8af0c168fedcd3a8","exact_world_state_target_reached":63,"executed_path_length":302,"expansions":2380,"goal_expert_reached":63,"graph_disconnection_failures":0,"no_supported_edge_failures":1,"optimal_path_length":281,"path_found":63,"path_length_regret":26,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"7a180204f4731af8","correct":256,"expert_evaluations":2048,"prediction_checksum":"74b26e6f9b5ed95c","prediction_samples":213,"prediction_sse_q20":22273185550,"reconstruction_checksum":"752b336a44f5b78e","reconstruction_sse_q20":22755384666,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"f89835722140b979","transition_correct":185,"transition_supported":213,"transition_unknown":43},"training_evaluations":3627008},"nearest_centroid_16_no_recursive_births":{"checkpoint_size_bytes":15854,"drift_holdout":{"classification_checksum":"d090777ed2c95461","correct":69,"expert_evaluations":4096,"prediction_checksum":"a26c3134a8460332","prediction_samples":256,"prediction_sse_q20":1413900708885,"reconstruction_checksum":"32dd8e95154ef812","reconstruction_sse_q20":1110568678417,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"76df34e3fc4fcd7f","transition_correct":153,"transition_supported":256,"transition_unknown":0},"expert_count":16,"planning":{"belief_set_target_reached":30,"cases":64,"checksum":"9f7a31a9780de58e","exact_world_state_target_reached":9,"executed_path_length":171,"expansions":547,"goal_expert_reached":30,"graph_disconnection_failures":5,"no_supported_edge_failures":0,"optimal_path_length":281,"path_found":59,"path_length_regret":0,"state_aliasing_failures":21,"transition_model_error_failures":29},"retention_holdout":{"classification_checksum":"73f47fa876640528","correct":67,"expert_evaluations":4096,"prediction_checksum":"7a92de70772e7338","prediction_samples":256,"prediction_sse_q20":1297597708329,"reconstruction_checksum":"1bd63f9c23463e65","reconstruction_sse_q20":1104200922821,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"11e6708e83ef3ad8","transition_correct":156,"transition_supported":256,"transition_unknown":0},"training_evaluations":253952},"no_adaptation_static":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"d8bed2f656d33bd9","correct":159,"expert_evaluations":2048,"prediction_checksum":"717ae7aebfe810fd","prediction_samples":220,"prediction_sse_q20":65631749290,"reconstruction_checksum":"fd2b9af1664a9713","reconstruction_sse_q20":66749712695,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"69b474ae80f1aaef","transition_correct":207,"transition_supported":220,"transition_unknown":36},"expert_count":64,"planning":{"belief_set_target_reached":56,"cases":64,"checksum":"7d4b24bc494052fa","exact_world_state_target_reached":55,"executed_path_length":294,"expansions":2001,"goal_expert_reached":56,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":281,"path_found":64,"path_length_regret":15,"state_aliasing_failures":1,"transition_model_error_failures":8},"retention_holdout":{"classification_checksum":"5b16148e570f87b1","correct":237,"expert_evaluations":2048,"prediction_checksum":"2f005643c36f02fc","prediction_samples":229,"prediction_sse_q20":90455298287,"reconstruction_checksum":"e5a613f47e18df79","reconstruction_sse_q20":90067939312,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"c80dd51801de85c3","transition_correct":216,"transition_supported":229,"transition_unknown":27},"training_evaluations":552728},"periodic_replay_policy":{"checkpoint_size_bytes":51194,"drift_holdout":{"classification_checksum":"d138ed816553c9ee","correct":168,"expert_evaluations":2048,"prediction_checksum":"3962300b389ed4c4","prediction_samples":213,"prediction_sse_q20":64964840368,"reconstruction_checksum":"2b97612d07d9db7c","reconstruction_sse_q20":66441619594,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"6b6d776c484ee86b","transition_correct":195,"transition_supported":213,"transition_unknown":43},"expert_count":78,"planning":{"belief_set_target_reached":57,"cases":64,"checksum":"67cadf31b8f3441d","exact_world_state_target_reached":56,"executed_path_length":297,"expansions":2054,"goal_expert_reached":57,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":281,"path_found":64,"path_length_regret":15,"state_aliasing_failures":1,"transition_model_error_failures":7},"retention_holdout":{"classification_checksum":"b0af312e617f3877","correct":233,"expert_evaluations":2048,"prediction_checksum":"0535c8258b144666","prediction_samples":228,"prediction_sse_q20":90326724509,"reconstruction_checksum":"8b5ea839dd0ac827","reconstruction_sse_q20":89935178603,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"def07404ec0d1291","transition_correct":211,"transition_supported":228,"transition_unknown":28},"training_evaluations":1893656},"ravel_0_5_candidate":{"checkpoint_size_bytes":50624,"drift_holdout":{"classification_checksum":"f031b432f243bd68","correct":168,"expert_evaluations":2048,"prediction_checksum":"3962300b389ed4c4","prediction_samples":213,"prediction_sse_q20":64964840368,"reconstruction_checksum":"5d62aeb2bba9e6f8","reconstruction_sse_q20":66375376056,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"32fe63d943688491","transition_correct":195,"transition_supported":213,"transition_unknown":43},"expert_count":77,"planning":{"belief_set_target_reached":57,"cases":64,"checksum":"67cadf31b8f3441d","exact_world_state_target_reached":56,"executed_path_length":297,"expansions":2052,"goal_expert_reached":57,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":281,"path_found":64,"path_length_regret":15,"state_aliasing_failures":1,"transition_model_error_failures":7},"retention_holdout":{"classification_checksum":"47c66ba187631313","correct":233,"expert_evaluations":2048,"prediction_checksum":"0535c8258b144666","prediction_samples":228,"prediction_sse_q20":90326724509,"reconstruction_checksum":"18bbbe8bcdcf50ab","reconstruction_sse_q20":89933842317,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"7eeb744a938a33cb","transition_correct":211,"transition_supported":228,"transition_unknown":28},"training_evaluations":1796888},"ravel_complete_scan_without_certification":{"checkpoint_size_bytes":50624,"drift_holdout":{"classification_checksum":"f031b432f243bd68","correct":168,"expert_evaluations":19712,"prediction_checksum":"3962300b389ed4c4","prediction_samples":213,"prediction_sse_q20":64964840368,"reconstruction_checksum":"5d62aeb2bba9e6f8","reconstruction_sse_q20":66375376056,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"32fe63d943688491","transition_correct":195,"transition_supported":213,"transition_unknown":43},"expert_count":77,"planning":{"belief_set_target_reached":57,"cases":64,"checksum":"67cadf31b8f3441d","exact_world_state_target_reached":56,"executed_path_length":297,"expansions":2052,"goal_expert_reached":57,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":281,"path_found":64,"path_length_regret":15,"state_aliasing_failures":1,"transition_model_error_failures":7},"retention_holdout":{"classification_checksum":"47c66ba187631313","correct":233,"expert_evaluations":19712,"prediction_checksum":"0535c8258b144666","prediction_samples":228,"prediction_sse_q20":90326724509,"reconstruction_checksum":"18bbbe8bcdcf50ab","reconstruction_sse_q20":89933842317,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"7eeb744a938a33cb","transition_correct":211,"transition_supported":228,"transition_unknown":28},"training_evaluations":2008856},"ravel_no_birth_same_replay_iterations":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"d8bed2f656d33bd9","correct":159,"expert_evaluations":2048,"prediction_checksum":"717ae7aebfe810fd","prediction_samples":220,"prediction_sse_q20":65631749290,"reconstruction_checksum":"fd2b9af1664a9713","reconstruction_sse_q20":66749712695,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"69b474ae80f1aaef","transition_correct":207,"transition_supported":220,"transition_unknown":36},"expert_count":64,"planning":{"belief_set_target_reached":56,"cases":64,"checksum":"7d4b24bc494052fa","exact_world_state_target_reached":55,"executed_path_length":294,"expansions":2001,"goal_expert_reached":56,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":281,"path_found":64,"path_length_regret":15,"state_aliasing_failures":1,"transition_model_error_failures":8},"retention_holdout":{"classification_checksum":"5b16148e570f87b1","correct":237,"expert_evaluations":2048,"prediction_checksum":"2f005643c36f02fc","prediction_samples":229,"prediction_sse_q20":90455298287,"reconstruction_checksum":"e5a613f47e18df79","reconstruction_sse_q20":90067939312,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"c80dd51801de85c3","transition_correct":216,"transition_supported":229,"transition_unknown":27},"training_evaluations":773912},"ravel_random_births":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"d8bed2f656d33bd9","correct":159,"expert_evaluations":2048,"prediction_checksum":"717ae7aebfe810fd","prediction_samples":220,"prediction_sse_q20":65631749290,"reconstruction_checksum":"fd2b9af1664a9713","reconstruction_sse_q20":66749712695,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"69b474ae80f1aaef","transition_correct":207,"transition_supported":220,"transition_unknown":36},"expert_count":64,"planning":{"belief_set_target_reached":56,"cases":64,"checksum":"7d4b24bc494052fa","exact_world_state_target_reached":55,"executed_path_length":294,"expansions":2001,"goal_expert_reached":56,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":281,"path_found":64,"path_length_regret":15,"state_aliasing_failures":1,"transition_model_error_failures":8},"retention_holdout":{"classification_checksum":"5b16148e570f87b1","correct":237,"expert_evaluations":2048,"prediction_checksum":"2f005643c36f02fc","prediction_samples":229,"prediction_sse_q20":90455298287,"reconstruction_checksum":"e5a613f47e18df79","reconstruction_sse_q20":90067939312,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"c80dd51801de85c3","transition_correct":216,"transition_supported":229,"transition_unknown":27},"training_evaluations":773912},"ravel_without_replay":{"checkpoint_size_bytes":52334,"drift_holdout":{"classification_checksum":"956c2709be69c0f9","correct":168,"expert_evaluations":3848,"prediction_checksum":"3962300b389ed4c4","prediction_samples":213,"prediction_sse_q20":64964840368,"reconstruction_checksum":"f7a491a99e9080f4","reconstruction_sse_q20":66381907814,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":231,"samples":256,"transition_checksum":"62d6679683f10ae4","transition_correct":192,"transition_supported":213,"transition_unknown":43},"expert_count":80,"planning":{"belief_set_target_reached":57,"cases":64,"checksum":"67cadf31b8f3441d","exact_world_state_target_reached":56,"executed_path_length":297,"expansions":2074,"goal_expert_reached":57,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":281,"path_found":64,"path_length_regret":15,"state_aliasing_failures":1,"transition_model_error_failures":7},"retention_holdout":{"classification_checksum":"95625b2a123811c4","correct":231,"expert_evaluations":2912,"prediction_checksum":"2ef74160671f12eb","prediction_samples":227,"prediction_sse_q20":90238178095,"reconstruction_checksum":"1c324237f6129bdb","reconstruction_sse_q20":89859987033,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":244,"samples":256,"transition_checksum":"a80cbf33ecfb54aa","transition_correct":207,"transition_supported":227,"transition_unknown":29},"training_evaluations":1583848},"ravel_without_retirement_matched_work":{"checkpoint_size_bytes":50624,"drift_holdout":{"classification_checksum":"f031b432f243bd68","correct":168,"expert_evaluations":2048,"prediction_checksum":"3962300b389ed4c4","prediction_samples":213,"prediction_sse_q20":64964840368,"reconstruction_checksum":"5d62aeb2bba9e6f8","reconstruction_sse_q20":66375376056,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"32fe63d943688491","transition_correct":195,"transition_supported":213,"transition_unknown":43},"expert_count":77,"planning":{"belief_set_target_reached":57,"cases":64,"checksum":"67cadf31b8f3441d","exact_world_state_target_reached":56,"executed_path_length":297,"expansions":2052,"goal_expert_reached":57,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":281,"path_found":64,"path_length_regret":15,"state_aliasing_failures":1,"transition_model_error_failures":7},"retention_holdout":{"classification_checksum":"47c66ba187631313","correct":233,"expert_evaluations":2048,"prediction_checksum":"0535c8258b144666","prediction_samples":228,"prediction_sse_q20":90326724509,"reconstruction_checksum":"18bbbe8bcdcf50ab","reconstruction_sse_q20":89933842317,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"7eeb744a938a33cb","transition_correct":211,"transition_supported":228,"transition_unknown":28},"training_evaluations":1796888}},"dataset_seeds":{"base_holdout":"0x532e0d82320d919f","base_training":"0xb5f3f5d5601ca538","drift_adaptation_training":"0x4306aa9194d027a7","drift_holdout":"0x2c16df0f9080418c","original_task_retention_holdout":"0xd5abe0ddc088e1b8","planning_cases":"0xa4edce040d297f82"},"dataset_sizes":{"base_holdout":256,"base_training":1024,"drift_adaptation_training":512,"drift_holdout":256,"original_task_retention_holdout":256,"planning_cases":64},"integrity":{"checkpoint_behavior_match":true,"checkpoint_identity_match":true,"checkpoint_mutations":{"anchored_status":true,"appended_unexpected_byte":true,"checkpoint_substitution":true,"checkpoint_truncation":true,"incorrect_schema_version":true,"label":true,"label_count":true,"lineage":true,"next_observation_component":true,"payload_byte":true,"reconstruction_component":true,"retrieval_key_component":true,"transition_graph_edge":true,"transition_support":true},"checkpoint_roundtrip":true,"lineage_invariants":{"deterministic_topology_reproduction":true,"lineage_uniqueness":true,"no_accidental_lineage_reuse":true,"parent_child_generation_increment":true,"repeated_descendant_splitting":true,"sibling_generation_equality":true},"unsupported_graph_edge_violations":0},"regime":"label_drift","schema":"ravel-raw-trial/0.5","seed":"0xbca063ccfee7e743","trial_id":"validation-label-02"},{"candidate":{"adaptation_completed":true,"adaptation_training":{"classification_checksum":"dcfdc49e3e5b7257","correct":305,"expert_evaluations":4096,"prediction_checksum":"a2ee4540607fdcbf","prediction_samples":461,"prediction_sse_q20":205237679015,"reconstruction_checksum":"694d714bb9a218b8","reconstruction_sse_q20":199181244260,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":512,"samples":512,"transition_checksum":"30be645e90cfc032","transition_correct":413,"transition_supported":461,"transition_unknown":51},"adaptation_training_evaluations":1245696,"adapted_model_drift_holdout":{"classification_checksum":"1c4c8b237ad58eb2","correct":158,"expert_evaluations":2048,"prediction_checksum":"684af22e23144680","prediction_samples":227,"prediction_sse_q20":95658064903,"reconstruction_checksum":"2925d01a75be640b","reconstruction_sse_q20":91603571115,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"d86ed3ff0c28105b","transition_correct":205,"transition_supported":227,"transition_unknown":29},"base_holdout":{"classification_checksum":"2b889fa747c038a5","correct":246,"expert_evaluations":2048,"prediction_checksum":"1c18fc3d4ec17ba0","prediction_samples":237,"prediction_sse_q20":77922242381,"reconstruction_checksum":"c3f381e9a0f2b8dd","reconstruction_sse_q20":74165584924,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"84dfb644e58260c6","transition_correct":225,"transition_supported":237,"transition_unknown":19},"base_holdout_retention":{"classification_checksum":"03694ac639b1a5cb","correct":232,"expert_evaluations":2048,"prediction_checksum":"bbf6f9b3b67859e4","prediction_samples":230,"prediction_sse_q20":93563349613,"reconstruction_checksum":"5fc387e8de02e30e","reconstruction_sse_q20":86963821783,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"a6f73fbcdf25a4bd","transition_correct":208,"transition_supported":230,"transition_unknown":26},"base_training_evaluations":555256,"behavior_identity":"b38bfded4645c50636ee21dc10a3fc0028d44996b71ec0c0a7209bd1bc5d88d8","checkpoint_size_bytes":51764,"expert_count":79,"model_identity":"9fd072cea937c7793cab9bc5091ae0d46a8fccd2dbe6b52175412e5fa8597fce","planning":{"belief_set_target_reached":40,"cases":64,"checksum":"d65fdb7c6d0ae898","exact_world_state_target_reached":32,"executed_path_length":244,"expansions":1902,"goal_expert_reached":40,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":308,"path_found":64,"path_length_regret":3,"state_aliasing_failures":8,"transition_model_error_failures":24},"replay":{"actions_covered":4,"assigned_experts_covered":63,"high_loss_cases_selected":14,"labels_covered":8,"rare_cases_selected":60,"selected":256,"selection_checksum":"fb5fa7b49ab6dfdc","states_covered":64,"transition_pairs_covered":251,"unique":256},"static_model_drift_holdout":{"classification_checksum":"c79fd434316db624","correct":150,"expert_evaluations":2048,"prediction_checksum":"39e36c3b3810cfb7","prediction_samples":232,"prediction_sse_q20":96233726644,"reconstruction_checksum":"95c30e4e70203b80","reconstruction_sse_q20":91808430073,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"435d071735a8b522","transition_correct":215,"transition_supported":232,"transition_unknown":24},"topology":{"accepted_births":15,"accepted_retirements":0,"births":[{"dominant_channel":0,"event_index":334,"normalized_score_q20":582428},{"dominant_channel":0,"event_index":461,"normalized_score_q20":581431},{"dominant_channel":0,"event_index":45,"normalized_score_q20":581141},{"dominant_channel":0,"event_index":510,"normalized_score_q20":580935},{"dominant_channel":0,"event_index":31,"normalized_score_q20":580513},{"dominant_channel":0,"event_index":11,"normalized_score_q20":580361},{"dominant_channel":0,"event_index":337,"normalized_score_q20":565582},{"dominant_channel":0,"event_index":245,"normalized_score_q20":562976},{"dominant_channel":0,"event_index":478,"normalized_score_q20":562631},{"dominant_channel":0,"event_index":233,"normalized_score_q20":560028},{"dominant_channel":0,"event_index":455,"normalized_score_q20":559611},{"dominant_channel":0,"event_index":462,"normalized_score_q20":559095},{"dominant_channel":0,"event_index":192,"normalized_score_q20":555219},{"dominant_channel":0,"event_index":360,"normalized_score_q20":554450},{"dominant_channel":0,"event_index":485,"normalized_score_q20":550040}],"objective_after_q20":817118,"objective_before_q20":811357,"rejected_births":1,"rejected_retirements":1,"retired_lineages":[],"training_observations":{"births":15,"certified":15360,"expert_evaluations":1245696,"rejected_births":1,"rejected_retirements":1,"retired":0,"samples":15360}}},"checkpoint_format":{"byte_order":"big_endian","magic_hex":"524156454c303500","payload_digest":"sha256","real_encoding":"signed_q20_int64","schema_version":5,"transition_support_min":2,"transition_top_k":2},"comparisons":{"fixed_8_expert":{"checkpoint_size_bytes":11294,"drift_holdout":{"classification_checksum":"afdb6b1427e3a492","correct":54,"expert_evaluations":2048,"prediction_checksum":"7e7bd54622ec2fb6","prediction_samples":256,"prediction_sse_q20":2144967969416,"reconstruction_checksum":"fc556ae4307f41e2","reconstruction_sse_q20":1775357111464,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"83a915a9bbcc3a85","transition_correct":105,"transition_supported":256,"transition_unknown":0},"expert_count":8,"planning":{"belief_set_target_reached":8,"cases":64,"checksum":"1f228005509df694","exact_world_state_target_reached":1,"executed_path_length":28,"expansions":148,"goal_expert_reached":8,"graph_disconnection_failures":42,"no_supported_edge_failures":0,"optimal_path_length":308,"path_found":22,"path_length_regret":0,"state_aliasing_failures":7,"transition_model_error_failures":14},"retention_holdout":{"classification_checksum":"398b17eee0dc4cc4","correct":71,"expert_evaluations":2048,"prediction_checksum":"f65771e0c3c516e2","prediction_samples":256,"prediction_sse_q20":2190002863396,"reconstruction_checksum":"87cc86aeb44413c0","reconstruction_sse_q20":1791889361781,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"84b177fd9b0f5d10","transition_correct":83,"transition_supported":256,"transition_unknown":0},"training_evaluations":94208},"fixed_topology_64_expert_routed":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"34bc2592d4a48278","correct":168,"expert_evaluations":2048,"prediction_checksum":"9a2544cdecd65ecd","prediction_samples":232,"prediction_sse_q20":25018781845,"reconstruction_checksum":"ae37320c473061b2","reconstruction_sse_q20":23333778463,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"d5ab8c66c32d9df3","transition_correct":232,"transition_supported":232,"transition_unknown":24},"expert_count":64,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"9aa62322da568126","exact_world_state_target_reached":64,"executed_path_length":328,"expansions":2286,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":308,"path_found":64,"path_length_regret":20,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"2162c85e078759c6","correct":256,"expert_evaluations":2048,"prediction_checksum":"46e2e3afa4033fc2","prediction_samples":237,"prediction_sse_q20":25893929068,"reconstruction_checksum":"1a504ac70b8ee0e0","reconstruction_sse_q20":23077721884,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"e6a88cf55dd1524e","transition_correct":237,"transition_supported":237,"transition_unknown":19},"training_evaluations":2588672},"flat_64_expert_complete_scan":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"34bc2592d4a48278","correct":168,"expert_evaluations":16384,"prediction_checksum":"9a2544cdecd65ecd","prediction_samples":232,"prediction_sse_q20":25018781845,"reconstruction_checksum":"ae37320c473061b2","reconstruction_sse_q20":23333778463,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"d5ab8c66c32d9df3","transition_correct":232,"transition_supported":232,"transition_unknown":24},"expert_count":64,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"9aa62322da568126","exact_world_state_target_reached":64,"executed_path_length":328,"expansions":2286,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":308,"path_found":64,"path_length_regret":20,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"2162c85e078759c6","correct":256,"expert_evaluations":16384,"prediction_checksum":"46e2e3afa4033fc2","prediction_samples":237,"prediction_sse_q20":25893929068,"reconstruction_checksum":"1a504ac70b8ee0e0","reconstruction_sse_q20":23077721884,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"e6a88cf55dd1524e","transition_correct":237,"transition_supported":237,"transition_unknown":19},"training_evaluations":2588672},"matched_compute_fixed_topology":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"c79fd434316db624","correct":150,"expert_evaluations":2048,"prediction_checksum":"39e36c3b3810cfb7","prediction_samples":232,"prediction_sse_q20":96233726644,"reconstruction_checksum":"95c30e4e70203b80","reconstruction_sse_q20":91808430073,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"435d071735a8b522","transition_correct":215,"transition_supported":232,"transition_unknown":24},"expert_count":64,"planning":{"belief_set_target_reached":40,"cases":64,"checksum":"d65fdb7c6d0ae898","exact_world_state_target_reached":32,"executed_path_length":244,"expansions":1876,"goal_expert_reached":40,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":308,"path_found":64,"path_length_regret":3,"state_aliasing_failures":8,"transition_model_error_failures":24},"retention_holdout":{"classification_checksum":"01c864ee055857c3","correct":241,"expert_evaluations":2048,"prediction_checksum":"c9ed9a38e49eddf2","prediction_samples":235,"prediction_sse_q20":93887731477,"reconstruction_checksum":"2a0910020c0bcf48","reconstruction_sse_q20":87318534791,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"f151c05eff27c353","transition_correct":222,"transition_supported":235,"transition_unknown":21},"training_evaluations":1882360},"matched_expert_count_capacity":{"checkpoint_size_bytes":51764,"drift_holdout":{"classification_checksum":"6ce8022781d52322","correct":168,"expert_evaluations":2048,"prediction_checksum":"d76aeb15b05965af","prediction_samples":216,"prediction_sse_q20":23790393079,"reconstruction_checksum":"c7bc78655fee5fd3","reconstruction_sse_q20":23264331135,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"b5ecb12d2b0a2938","transition_correct":199,"transition_supported":216,"transition_unknown":40},"expert_count":79,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"5f7c947b62325811","exact_world_state_target_reached":64,"executed_path_length":335,"expansions":2450,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":308,"path_found":64,"path_length_regret":27,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"05dece9b54cb795b","correct":256,"expert_evaluations":2048,"prediction_checksum":"c6f45a441022fb39","prediction_samples":218,"prediction_sse_q20":23712462739,"reconstruction_checksum":"14d87094e784a6f2","reconstruction_sse_q20":22981169325,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"16141b5d10eaa8b9","transition_correct":208,"transition_supported":218,"transition_unknown":38},"training_evaluations":3802112},"nearest_centroid_16_no_recursive_births":{"checkpoint_size_bytes":15854,"drift_holdout":{"classification_checksum":"6d30410de0aeb201","correct":66,"expert_evaluations":4096,"prediction_checksum":"830ef907f15b852f","prediction_samples":256,"prediction_sse_q20":1310081937511,"reconstruction_checksum":"7a5b5012deff85ef","reconstruction_sse_q20":1123387327038,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"ee57d615f5d89d03","transition_correct":136,"transition_supported":256,"transition_unknown":0},"expert_count":16,"planning":{"belief_set_target_reached":29,"cases":64,"checksum":"335c0afcc0313200","exact_world_state_target_reached":7,"executed_path_length":192,"expansions":516,"goal_expert_reached":29,"graph_disconnection_failures":2,"no_supported_edge_failures":0,"optimal_path_length":308,"path_found":62,"path_length_regret":3,"state_aliasing_failures":22,"transition_model_error_failures":33},"retention_holdout":{"classification_checksum":"c762de12f0cce4f2","correct":62,"expert_evaluations":4096,"prediction_checksum":"11814739f0edb6c9","prediction_samples":256,"prediction_sse_q20":1355463365443,"reconstruction_checksum":"5389a199785764e9","reconstruction_sse_q20":1160865924503,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"2338ec330d163cd9","transition_correct":147,"transition_supported":256,"transition_unknown":0},"training_evaluations":253952},"no_adaptation_static":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"c79fd434316db624","correct":150,"expert_evaluations":2048,"prediction_checksum":"39e36c3b3810cfb7","prediction_samples":232,"prediction_sse_q20":96233726644,"reconstruction_checksum":"95c30e4e70203b80","reconstruction_sse_q20":91808430073,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"435d071735a8b522","transition_correct":215,"transition_supported":232,"transition_unknown":24},"expert_count":64,"planning":{"belief_set_target_reached":40,"cases":64,"checksum":"d65fdb7c6d0ae898","exact_world_state_target_reached":32,"executed_path_length":244,"expansions":1876,"goal_expert_reached":40,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":308,"path_found":64,"path_length_regret":3,"state_aliasing_failures":8,"transition_model_error_failures":24},"retention_holdout":{"classification_checksum":"01c864ee055857c3","correct":241,"expert_evaluations":2048,"prediction_checksum":"c9ed9a38e49eddf2","prediction_samples":235,"prediction_sse_q20":93887731477,"reconstruction_checksum":"2a0910020c0bcf48","reconstruction_sse_q20":87318534791,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"f151c05eff27c353","transition_correct":222,"transition_supported":235,"transition_unknown":21},"training_evaluations":555256},"periodic_replay_policy":{"checkpoint_size_bytes":50624,"drift_holdout":{"classification_checksum":"cef8aae996371439","correct":157,"expert_evaluations":2048,"prediction_checksum":"37545bcf1773b451","prediction_samples":227,"prediction_sse_q20":95525361783,"reconstruction_checksum":"613a7011d5c0baa6","reconstruction_sse_q20":91631256761,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"c79b6ff9e4854ac7","transition_correct":207,"transition_supported":227,"transition_unknown":29},"expert_count":77,"planning":{"belief_set_target_reached":40,"cases":64,"checksum":"d65fdb7c6d0ae898","exact_world_state_target_reached":32,"executed_path_length":244,"expansions":1889,"goal_expert_reached":40,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":308,"path_found":64,"path_length_regret":3,"state_aliasing_failures":8,"transition_model_error_failures":24},"retention_holdout":{"classification_checksum":"98b8d63cafde4aad","correct":233,"expert_evaluations":2048,"prediction_checksum":"d700113d9e745e2d","prediction_samples":232,"prediction_sse_q20":93719354415,"reconstruction_checksum":"7713b7978b08a46e","reconstruction_sse_q20":87009833238,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"0a429c857ada0d54","transition_correct":213,"transition_supported":232,"transition_unknown":24},"training_evaluations":1172728},"ravel_0_5_candidate":{"checkpoint_size_bytes":51764,"drift_holdout":{"classification_checksum":"1c4c8b237ad58eb2","correct":158,"expert_evaluations":2048,"prediction_checksum":"684af22e23144680","prediction_samples":227,"prediction_sse_q20":95658064903,"reconstruction_checksum":"2925d01a75be640b","reconstruction_sse_q20":91603571115,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"d86ed3ff0c28105b","transition_correct":205,"transition_supported":227,"transition_unknown":29},"expert_count":79,"planning":{"belief_set_target_reached":40,"cases":64,"checksum":"d65fdb7c6d0ae898","exact_world_state_target_reached":32,"executed_path_length":244,"expansions":1902,"goal_expert_reached":40,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":308,"path_found":64,"path_length_regret":3,"state_aliasing_failures":8,"transition_model_error_failures":24},"retention_holdout":{"classification_checksum":"03694ac639b1a5cb","correct":232,"expert_evaluations":2048,"prediction_checksum":"bbf6f9b3b67859e4","prediction_samples":230,"prediction_sse_q20":93563349613,"reconstruction_checksum":"5fc387e8de02e30e","reconstruction_sse_q20":86963821783,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"a6f73fbcdf25a4bd","transition_correct":208,"transition_supported":230,"transition_unknown":26},"training_evaluations":1800952},"ravel_complete_scan_without_certification":{"checkpoint_size_bytes":51764,"drift_holdout":{"classification_checksum":"1c4c8b237ad58eb2","correct":158,"expert_evaluations":20224,"prediction_checksum":"684af22e23144680","prediction_samples":227,"prediction_sse_q20":95658064903,"reconstruction_checksum":"2925d01a75be640b","reconstruction_sse_q20":91603571115,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"d86ed3ff0c28105b","transition_correct":205,"transition_supported":227,"transition_unknown":29},"expert_count":79,"planning":{"belief_set_target_reached":40,"cases":64,"checksum":"d65fdb7c6d0ae898","exact_world_state_target_reached":32,"executed_path_length":244,"expansions":1902,"goal_expert_reached":40,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":308,"path_found":64,"path_length_regret":3,"state_aliasing_failures":8,"transition_model_error_failures":24},"retention_holdout":{"classification_checksum":"03694ac639b1a5cb","correct":232,"expert_evaluations":20224,"prediction_checksum":"bbf6f9b3b67859e4","prediction_samples":230,"prediction_sse_q20":93563349613,"reconstruction_checksum":"5fc387e8de02e30e","reconstruction_sse_q20":86963821783,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"a6f73fbcdf25a4bd","transition_correct":208,"transition_supported":230,"transition_unknown":26},"training_evaluations":2019064},"ravel_no_birth_same_replay_iterations":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"c79fd434316db624","correct":150,"expert_evaluations":2048,"prediction_checksum":"39e36c3b3810cfb7","prediction_samples":232,"prediction_sse_q20":96233726644,"reconstruction_checksum":"95c30e4e70203b80","reconstruction_sse_q20":91808430073,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"435d071735a8b522","transition_correct":215,"transition_supported":232,"transition_unknown":24},"expert_count":64,"planning":{"belief_set_target_reached":40,"cases":64,"checksum":"d65fdb7c6d0ae898","exact_world_state_target_reached":32,"executed_path_length":244,"expansions":1876,"goal_expert_reached":40,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":308,"path_found":64,"path_length_regret":3,"state_aliasing_failures":8,"transition_model_error_failures":24},"retention_holdout":{"classification_checksum":"01c864ee055857c3","correct":241,"expert_evaluations":2048,"prediction_checksum":"c9ed9a38e49eddf2","prediction_samples":235,"prediction_sse_q20":93887731477,"reconstruction_checksum":"2a0910020c0bcf48","reconstruction_sse_q20":87318534791,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"f151c05eff27c353","transition_correct":222,"transition_supported":235,"transition_unknown":21},"training_evaluations":776440},"ravel_random_births":{"checkpoint_size_bytes":44354,"drift_holdout":{"classification_checksum":"019586ad568fbdd9","correct":151,"expert_evaluations":2048,"prediction_checksum":"206217f28b545f41","prediction_samples":231,"prediction_sse_q20":96145180227,"reconstruction_checksum":"6bfe3bb099d3340f","reconstruction_sse_q20":91793717241,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"c9361b5a6c77c35f","transition_correct":213,"transition_supported":231,"transition_unknown":25},"expert_count":66,"planning":{"belief_set_target_reached":40,"cases":64,"checksum":"d65fdb7c6d0ae898","exact_world_state_target_reached":32,"executed_path_length":244,"expansions":1876,"goal_expert_reached":40,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":308,"path_found":64,"path_length_regret":3,"state_aliasing_failures":8,"transition_model_error_failures":24},"retention_holdout":{"classification_checksum":"92ec57bd26c4d63c","correct":239,"expert_evaluations":2048,"prediction_checksum":"7bfcd95a12c493da","prediction_samples":235,"prediction_sse_q20":94017377413,"reconstruction_checksum":"c8c6be08c255ebda","reconstruction_sse_q20":87233403527,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"2ef64e3e5d1c2fc5","transition_correct":222,"transition_supported":235,"transition_unknown":21},"training_evaluations":900856},"ravel_without_replay":{"checkpoint_size_bytes":52334,"drift_holdout":{"classification_checksum":"9ff2db4c63eb169c","correct":159,"expert_evaluations":2048,"prediction_checksum":"dab4607c08b032ae","prediction_samples":226,"prediction_sse_q20":95415843847,"reconstruction_checksum":"b5051933bbb6997c","reconstruction_sse_q20":91557124289,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"78f6f5ce7fb47f80","transition_correct":204,"transition_supported":226,"transition_unknown":30},"expert_count":80,"planning":{"belief_set_target_reached":40,"cases":64,"checksum":"d65fdb7c6d0ae898","exact_world_state_target_reached":32,"executed_path_length":244,"expansions":1902,"goal_expert_reached":40,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":308,"path_found":64,"path_length_regret":3,"state_aliasing_failures":8,"transition_model_error_failures":24},"retention_holdout":{"classification_checksum":"599a072ac93cb247","correct":232,"expert_evaluations":2048,"prediction_checksum":"bbf6f9b3b67859e4","prediction_samples":230,"prediction_sse_q20":93563349613,"reconstruction_checksum":"e274333469c2a121","reconstruction_sse_q20":86972414119,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"a6f73fbcdf25a4bd","transition_correct":208,"transition_supported":230,"transition_unknown":26},"training_evaluations":1728760},"ravel_without_retirement_matched_work":{"checkpoint_size_bytes":51764,"drift_holdout":{"classification_checksum":"1c4c8b237ad58eb2","correct":158,"expert_evaluations":2048,"prediction_checksum":"684af22e23144680","prediction_samples":227,"prediction_sse_q20":95658064903,"reconstruction_checksum":"2925d01a75be640b","reconstruction_sse_q20":91603571115,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"d86ed3ff0c28105b","transition_correct":205,"transition_supported":227,"transition_unknown":29},"expert_count":79,"planning":{"belief_set_target_reached":40,"cases":64,"checksum":"d65fdb7c6d0ae898","exact_world_state_target_reached":32,"executed_path_length":244,"expansions":1902,"goal_expert_reached":40,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":308,"path_found":64,"path_length_regret":3,"state_aliasing_failures":8,"transition_model_error_failures":24},"retention_holdout":{"classification_checksum":"03694ac639b1a5cb","correct":232,"expert_evaluations":2048,"prediction_checksum":"bbf6f9b3b67859e4","prediction_samples":230,"prediction_sse_q20":93563349613,"reconstruction_checksum":"5fc387e8de02e30e","reconstruction_sse_q20":86963821783,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"a6f73fbcdf25a4bd","transition_correct":208,"transition_supported":230,"transition_unknown":26},"training_evaluations":1800952}},"dataset_seeds":{"base_holdout":"0x708cef254f99e512","base_training":"0x6cf9289f85522af7","drift_adaptation_training":"0xd4602bb4469f052d","drift_holdout":"0xaebae78c47d97f05","original_task_retention_holdout":"0x9155adc558c7b38b","planning_cases":"0x7b8dce2b7f1e6f42"},"dataset_sizes":{"base_holdout":256,"base_training":1024,"drift_adaptation_training":512,"drift_holdout":256,"original_task_retention_holdout":256,"planning_cases":64},"integrity":{"checkpoint_behavior_match":true,"checkpoint_identity_match":true,"checkpoint_mutations":{"anchored_status":true,"appended_unexpected_byte":true,"checkpoint_substitution":true,"checkpoint_truncation":true,"incorrect_schema_version":true,"label":true,"label_count":true,"lineage":true,"next_observation_component":true,"payload_byte":true,"reconstruction_component":true,"retrieval_key_component":true,"transition_graph_edge":true,"transition_support":true},"checkpoint_roundtrip":true,"lineage_invariants":{"deterministic_topology_reproduction":true,"lineage_uniqueness":true,"no_accidental_lineage_reuse":true,"parent_child_generation_increment":true,"repeated_descendant_splitting":true,"sibling_generation_equality":true},"unsupported_graph_edge_violations":0},"regime":"label_drift","schema":"ravel-raw-trial/0.5","seed":"0x27b73cba3e16bfb3","trial_id":"validation-label-03"},{"candidate":{"adaptation_completed":true,"adaptation_training":{"classification_checksum":"3b1cdd5da618949c","correct":357,"expert_evaluations":6612,"prediction_checksum":"1a989672b061c76b","prediction_samples":469,"prediction_sse_q20":97882606046,"reconstruction_checksum":"0e5685f8bf66d5dd","reconstruction_sse_q20":79170261034,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":475,"samples":512,"transition_checksum":"40e71a74123359aa","transition_correct":444,"transition_supported":469,"transition_unknown":43},"adaptation_training_evaluations":1114258,"adapted_model_drift_holdout":{"classification_checksum":"a89d93e7d34c14fc","correct":169,"expert_evaluations":2932,"prediction_checksum":"d1795b1f8eb3a482","prediction_samples":231,"prediction_sse_q20":34474740235,"reconstruction_checksum":"ec69210f37edb7cd","reconstruction_sse_q20":36769717541,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":243,"samples":256,"transition_checksum":"3b75c34a1ac0e90e","transition_correct":215,"transition_supported":231,"transition_unknown":25},"base_holdout":{"classification_checksum":"4d253c1388418336","correct":251,"expert_evaluations":2048,"prediction_checksum":"b2881d708d3428ea","prediction_samples":236,"prediction_sse_q20":45870395921,"reconstruction_checksum":"ab65284b24bd85bb","reconstruction_sse_q20":41356014595,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"9f5255c50d408e40","transition_correct":229,"transition_supported":236,"transition_unknown":20},"base_holdout_retention":{"classification_checksum":"bf4ce839041937b7","correct":247,"expert_evaluations":2932,"prediction_checksum":"7039be11f355e9b3","prediction_samples":228,"prediction_sse_q20":41785135198,"reconstruction_checksum":"5539d02554acff57","reconstruction_sse_q20":34454456158,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":243,"samples":256,"transition_checksum":"af4cac2c18b6ac51","transition_correct":210,"transition_supported":228,"transition_unknown":28},"base_training_evaluations":554336,"behavior_identity":"2b5e1bf99e680bc948aed6a7bb11ff4d5bc328dab3fc86ebff4a32d5a71d72c4","checkpoint_size_bytes":50054,"expert_count":76,"model_identity":"f907c406244603027c88b67694e9b0f168c9b6eb5a72fa27f89fe1ec8f03f7d6","planning":{"belief_set_target_reached":56,"cases":64,"checksum":"1ddab1f2f53120fc","exact_world_state_target_reached":56,"executed_path_length":298,"expansions":2217,"goal_expert_reached":56,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":293,"path_found":64,"path_length_regret":19,"state_aliasing_failures":0,"transition_model_error_failures":8},"replay":{"actions_covered":4,"assigned_experts_covered":64,"high_loss_cases_selected":25,"labels_covered":8,"rare_cases_selected":64,"selected":256,"selection_checksum":"da8877a256b1e409","states_covered":64,"transition_pairs_covered":250,"unique":256},"static_model_drift_holdout":{"classification_checksum":"fb18abea8d339195","correct":164,"expert_evaluations":2048,"prediction_checksum":"0b74acfe91d51052","prediction_samples":231,"prediction_sse_q20":34238476287,"reconstruction_checksum":"517974e84108c83c","reconstruction_sse_q20":36836379758,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"b1a0773f5bfc2db4","transition_correct":225,"transition_supported":231,"transition_unknown":25},"topology":{"accepted_births":12,"accepted_retirements":0,"births":[{"dominant_channel":0,"event_index":266,"normalized_score_q20":575861},{"dominant_channel":0,"event_index":51,"normalized_score_q20":567342},{"dominant_channel":0,"event_index":45,"normalized_score_q20":567303},{"dominant_channel":0,"event_index":334,"normalized_score_q20":566464},{"dominant_channel":0,"event_index":409,"normalized_score_q20":566420},{"dominant_channel":0,"event_index":365,"normalized_score_q20":566139},{"dominant_channel":0,"event_index":377,"normalized_score_q20":557848},{"dominant_channel":0,"event_index":375,"normalized_score_q20":556135},{"dominant_channel":0,"event_index":380,"normalized_score_q20":555946},{"dominant_channel":0,"event_index":43,"normalized_score_q20":555332},{"dominant_channel":0,"event_index":123,"normalized_score_q20":550756},{"dominant_channel":0,"event_index":78,"normalized_score_q20":547412}],"objective_after_q20":851767,"objective_before_q20":845448,"rejected_births":4,"rejected_retirements":1,"retired_lineages":[],"training_observations":{"births":12,"certified":13294,"expert_evaluations":1114258,"rejected_births":4,"rejected_retirements":1,"retired":0,"samples":13824}}},"checkpoint_format":{"byte_order":"big_endian","magic_hex":"524156454c303500","payload_digest":"sha256","real_encoding":"signed_q20_int64","schema_version":5,"transition_support_min":2,"transition_top_k":2},"comparisons":{"fixed_8_expert":{"checkpoint_size_bytes":11294,"drift_holdout":{"classification_checksum":"8a9f6d57a6603c28","correct":37,"expert_evaluations":2048,"prediction_checksum":"74fe3ce9ba5abb69","prediction_samples":256,"prediction_sse_q20":2006234122759,"reconstruction_checksum":"7c86d22589902be3","reconstruction_sse_q20":1776880558806,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"8a50d9e602396047","transition_correct":124,"transition_supported":256,"transition_unknown":0},"expert_count":8,"planning":{"belief_set_target_reached":14,"cases":64,"checksum":"1ccc141a6ebbfc00","exact_world_state_target_reached":0,"executed_path_length":86,"expansions":264,"goal_expert_reached":14,"graph_disconnection_failures":18,"no_supported_edge_failures":0,"optimal_path_length":293,"path_found":46,"path_length_regret":0,"state_aliasing_failures":14,"transition_model_error_failures":32},"retention_holdout":{"classification_checksum":"8cc01e70469cdb98","correct":47,"expert_evaluations":2048,"prediction_checksum":"11d0cc1dd8c004d4","prediction_samples":256,"prediction_sse_q20":2030118278216,"reconstruction_checksum":"10884efd5e9f8a9f","reconstruction_sse_q20":1763515749782,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"cf80daec8dcd3238","transition_correct":119,"transition_supported":256,"transition_unknown":0},"training_evaluations":94208},"fixed_topology_64_expert_routed":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"f3013112a01ff959","correct":167,"expert_evaluations":2048,"prediction_checksum":"36676e659d1da4db","prediction_samples":231,"prediction_sse_q20":22403304683,"reconstruction_checksum":"ebd9feaf200c2286","reconstruction_sse_q20":23205208099,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"c1539b6d3e92ab7a","transition_correct":231,"transition_supported":231,"transition_unknown":25},"expert_count":64,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"306afecf5865250f","exact_world_state_target_reached":64,"executed_path_length":317,"expansions":2122,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":293,"path_found":64,"path_length_regret":24,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"67f6eca6a72597fe","correct":256,"expert_evaluations":2048,"prediction_checksum":"6c40861c06d9a044","prediction_samples":230,"prediction_sse_q20":24019056903,"reconstruction_checksum":"8842640fcb473389","reconstruction_sse_q20":23173613659,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"b320896c5be40e25","transition_correct":230,"transition_supported":230,"transition_unknown":26},"training_evaluations":2588672},"flat_64_expert_complete_scan":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"f3013112a01ff959","correct":167,"expert_evaluations":16384,"prediction_checksum":"36676e659d1da4db","prediction_samples":231,"prediction_sse_q20":22403304683,"reconstruction_checksum":"ebd9feaf200c2286","reconstruction_sse_q20":23205208099,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"c1539b6d3e92ab7a","transition_correct":231,"transition_supported":231,"transition_unknown":25},"expert_count":64,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"306afecf5865250f","exact_world_state_target_reached":64,"executed_path_length":317,"expansions":2122,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":293,"path_found":64,"path_length_regret":24,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"67f6eca6a72597fe","correct":256,"expert_evaluations":16384,"prediction_checksum":"6c40861c06d9a044","prediction_samples":230,"prediction_sse_q20":24019056903,"reconstruction_checksum":"8842640fcb473389","reconstruction_sse_q20":23173613659,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"b320896c5be40e25","transition_correct":230,"transition_supported":230,"transition_unknown":26},"training_evaluations":2588672},"matched_compute_fixed_topology":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"fb18abea8d339195","correct":164,"expert_evaluations":2048,"prediction_checksum":"0b74acfe91d51052","prediction_samples":231,"prediction_sse_q20":34238476287,"reconstruction_checksum":"517974e84108c83c","reconstruction_sse_q20":36836379758,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"b1a0773f5bfc2db4","transition_correct":225,"transition_supported":231,"transition_unknown":25},"expert_count":64,"planning":{"belief_set_target_reached":56,"cases":64,"checksum":"eae624372ac2672d","exact_world_state_target_reached":56,"executed_path_length":299,"expansions":2154,"goal_expert_reached":56,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":293,"path_found":64,"path_length_regret":20,"state_aliasing_failures":0,"transition_model_error_failures":8},"retention_holdout":{"classification_checksum":"b44b61eaa4d72d3f","correct":253,"expert_evaluations":2048,"prediction_checksum":"ac7d3d06cff08c96","prediction_samples":231,"prediction_sse_q20":42086426038,"reconstruction_checksum":"0669424309b8eb4a","reconstruction_sse_q20":34647078823,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"8405b6d77dd3e37b","transition_correct":227,"transition_supported":231,"transition_unknown":25},"training_evaluations":1881440},"matched_expert_count_capacity":{"checkpoint_size_bytes":50054,"drift_holdout":{"classification_checksum":"deff7dfb85177a74","correct":167,"expert_evaluations":2048,"prediction_checksum":"9bca7a055db8699e","prediction_samples":215,"prediction_sse_q20":20549745714,"reconstruction_checksum":"7b12dc13f8ac8943","reconstruction_sse_q20":23075125941,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"34ff0401ecf34845","transition_correct":201,"transition_supported":215,"transition_unknown":41},"expert_count":76,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"33a31c0dd12d9b38","exact_world_state_target_reached":64,"executed_path_length":332,"expansions":2306,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":293,"path_found":64,"path_length_regret":39,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"222eed9c7f8ec4db","correct":256,"expert_evaluations":2048,"prediction_checksum":"4bf40789d1d21322","prediction_samples":220,"prediction_sse_q20":23014969320,"reconstruction_checksum":"8d27156cfd7307ee","reconstruction_sse_q20":23063846228,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"2c880eb2474c0558","transition_correct":204,"transition_supported":220,"transition_unknown":36},"training_evaluations":3540992},"nearest_centroid_16_no_recursive_births":{"checkpoint_size_bytes":15854,"drift_holdout":{"classification_checksum":"1e44947b8697bce4","correct":49,"expert_evaluations":4096,"prediction_checksum":"8dcf7862981e0add","prediction_samples":256,"prediction_sse_q20":1305913780266,"reconstruction_checksum":"a22ba02c0b229890","reconstruction_sse_q20":1137533277207,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"f941af90d416b5aa","transition_correct":150,"transition_supported":256,"transition_unknown":0},"expert_count":16,"planning":{"belief_set_target_reached":33,"cases":64,"checksum":"cdbf24fdd99479cc","exact_world_state_target_reached":5,"executed_path_length":141,"expansions":520,"goal_expert_reached":33,"graph_disconnection_failures":2,"no_supported_edge_failures":0,"optimal_path_length":293,"path_found":62,"path_length_regret":1,"state_aliasing_failures":28,"transition_model_error_failures":29},"retention_holdout":{"classification_checksum":"fc5c2de36527b9da","correct":62,"expert_evaluations":4096,"prediction_checksum":"7b3647f8a253440d","prediction_samples":256,"prediction_sse_q20":1437600781845,"reconstruction_checksum":"13dc31388cd546cc","reconstruction_sse_q20":1131488358066,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"018102e04fe79bfb","transition_correct":150,"transition_supported":256,"transition_unknown":0},"training_evaluations":253952},"no_adaptation_static":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"fb18abea8d339195","correct":164,"expert_evaluations":2048,"prediction_checksum":"0b74acfe91d51052","prediction_samples":231,"prediction_sse_q20":34238476287,"reconstruction_checksum":"517974e84108c83c","reconstruction_sse_q20":36836379758,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"b1a0773f5bfc2db4","transition_correct":225,"transition_supported":231,"transition_unknown":25},"expert_count":64,"planning":{"belief_set_target_reached":56,"cases":64,"checksum":"eae624372ac2672d","exact_world_state_target_reached":56,"executed_path_length":299,"expansions":2154,"goal_expert_reached":56,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":293,"path_found":64,"path_length_regret":20,"state_aliasing_failures":0,"transition_model_error_failures":8},"retention_holdout":{"classification_checksum":"b44b61eaa4d72d3f","correct":253,"expert_evaluations":2048,"prediction_checksum":"ac7d3d06cff08c96","prediction_samples":231,"prediction_sse_q20":42086426038,"reconstruction_checksum":"0669424309b8eb4a","reconstruction_sse_q20":34647078823,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"8405b6d77dd3e37b","transition_correct":227,"transition_supported":231,"transition_unknown":25},"training_evaluations":554336},"periodic_replay_policy":{"checkpoint_size_bytes":51764,"drift_holdout":{"classification_checksum":"f854c9355f8185e5","correct":169,"expert_evaluations":2971,"prediction_checksum":"d1795b1f8eb3a482","prediction_samples":231,"prediction_sse_q20":34474740235,"reconstruction_checksum":"9d74dfe3addb421a","reconstruction_sse_q20":36760900183,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":243,"samples":256,"transition_checksum":"cf064b3e7e8f280e","transition_correct":215,"transition_supported":231,"transition_unknown":25},"expert_count":79,"planning":{"belief_set_target_reached":56,"cases":64,"checksum":"eae624372ac2672d","exact_world_state_target_reached":56,"executed_path_length":299,"expansions":2217,"goal_expert_reached":56,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":293,"path_found":64,"path_length_regret":20,"state_aliasing_failures":0,"transition_model_error_failures":8},"retention_holdout":{"classification_checksum":"5aa29d5fd0d62853","correct":247,"expert_evaluations":2971,"prediction_checksum":"1a43c1eaf467f066","prediction_samples":227,"prediction_sse_q20":41668743262,"reconstruction_checksum":"92b0824a9705d0a3","reconstruction_sse_q20":34440533400,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":243,"samples":256,"transition_checksum":"5e64bf02958b8d9e","transition_correct":211,"transition_supported":227,"transition_unknown":29},"training_evaluations":2364032},"ravel_0_5_candidate":{"checkpoint_size_bytes":50054,"drift_holdout":{"classification_checksum":"a89d93e7d34c14fc","correct":169,"expert_evaluations":2932,"prediction_checksum":"d1795b1f8eb3a482","prediction_samples":231,"prediction_sse_q20":34474740235,"reconstruction_checksum":"ec69210f37edb7cd","reconstruction_sse_q20":36769717541,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":243,"samples":256,"transition_checksum":"3b75c34a1ac0e90e","transition_correct":215,"transition_supported":231,"transition_unknown":25},"expert_count":76,"planning":{"belief_set_target_reached":56,"cases":64,"checksum":"1ddab1f2f53120fc","exact_world_state_target_reached":56,"executed_path_length":298,"expansions":2217,"goal_expert_reached":56,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":293,"path_found":64,"path_length_regret":19,"state_aliasing_failures":0,"transition_model_error_failures":8},"retention_holdout":{"classification_checksum":"bf4ce839041937b7","correct":247,"expert_evaluations":2932,"prediction_checksum":"7039be11f355e9b3","prediction_samples":228,"prediction_sse_q20":41785135198,"reconstruction_checksum":"5539d02554acff57","reconstruction_sse_q20":34454456158,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":243,"samples":256,"transition_checksum":"af4cac2c18b6ac51","transition_correct":210,"transition_supported":228,"transition_unknown":28},"training_evaluations":1668594},"ravel_complete_scan_without_certification":{"checkpoint_size_bytes":50054,"drift_holdout":{"classification_checksum":"a89d93e7d34c14fc","correct":169,"expert_evaluations":19456,"prediction_checksum":"d1795b1f8eb3a482","prediction_samples":231,"prediction_sse_q20":34474740235,"reconstruction_checksum":"ec69210f37edb7cd","reconstruction_sse_q20":36769717541,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"3b75c34a1ac0e90e","transition_correct":215,"transition_supported":231,"transition_unknown":25},"expert_count":76,"planning":{"belief_set_target_reached":56,"cases":64,"checksum":"1ddab1f2f53120fc","exact_world_state_target_reached":56,"executed_path_length":298,"expansions":2217,"goal_expert_reached":56,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":293,"path_found":64,"path_length_regret":19,"state_aliasing_failures":0,"transition_model_error_failures":8},"retention_holdout":{"classification_checksum":"bf4ce839041937b7","correct":247,"expert_evaluations":19456,"prediction_checksum":"7039be11f355e9b3","prediction_samples":228,"prediction_sse_q20":41785135198,"reconstruction_checksum":"5539d02554acff57","reconstruction_sse_q20":34454456158,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"af4cac2c18b6ac51","transition_correct":210,"transition_supported":228,"transition_unknown":28},"training_evaluations":1863074},"ravel_no_birth_same_replay_iterations":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"fb18abea8d339195","correct":164,"expert_evaluations":2048,"prediction_checksum":"0b74acfe91d51052","prediction_samples":231,"prediction_sse_q20":34238476287,"reconstruction_checksum":"517974e84108c83c","reconstruction_sse_q20":36836379758,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"b1a0773f5bfc2db4","transition_correct":225,"transition_supported":231,"transition_unknown":25},"expert_count":64,"planning":{"belief_set_target_reached":56,"cases":64,"checksum":"eae624372ac2672d","exact_world_state_target_reached":56,"executed_path_length":299,"expansions":2154,"goal_expert_reached":56,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":293,"path_found":64,"path_length_regret":20,"state_aliasing_failures":0,"transition_model_error_failures":8},"retention_holdout":{"classification_checksum":"b44b61eaa4d72d3f","correct":253,"expert_evaluations":2048,"prediction_checksum":"ac7d3d06cff08c96","prediction_samples":231,"prediction_sse_q20":42086426038,"reconstruction_checksum":"0669424309b8eb4a","reconstruction_sse_q20":34647078823,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"8405b6d77dd3e37b","transition_correct":227,"transition_supported":231,"transition_unknown":25},"training_evaluations":775520},"ravel_random_births":{"checkpoint_size_bytes":44354,"drift_holdout":{"classification_checksum":"edafe569a886909b","correct":166,"expert_evaluations":2048,"prediction_checksum":"63e46b31dc81930c","prediction_samples":230,"prediction_sse_q20":34010695001,"reconstruction_checksum":"82f122767e8000bc","reconstruction_sse_q20":36663817455,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"00303aa8ca8fc0c3","transition_correct":222,"transition_supported":230,"transition_unknown":26},"expert_count":66,"planning":{"belief_set_target_reached":54,"cases":64,"checksum":"d43b5557ef8ef0f4","exact_world_state_target_reached":54,"executed_path_length":304,"expansions":2262,"goal_expert_reached":54,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":293,"path_found":64,"path_length_regret":24,"state_aliasing_failures":0,"transition_model_error_failures":10},"retention_holdout":{"classification_checksum":"050282dc8ad610b2","correct":251,"expert_evaluations":2048,"prediction_checksum":"8b4c5220d96cce3c","prediction_samples":231,"prediction_sse_q20":42070956046,"reconstruction_checksum":"79280094cb65ca11","reconstruction_sse_q20":34584955407,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"6acbcc1bfe437dc4","transition_correct":225,"transition_supported":231,"transition_unknown":25},"training_evaluations":1125728},"ravel_without_replay":{"checkpoint_size_bytes":52334,"drift_holdout":{"classification_checksum":"e361f7aa96a69284","correct":168,"expert_evaluations":4496,"prediction_checksum":"91fcbe1e1d13c288","prediction_samples":231,"prediction_sse_q20":34337494469,"reconstruction_checksum":"77262be50ac6c385","reconstruction_sse_q20":36766460332,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":222,"samples":256,"transition_checksum":"793406c2dbe391fe","transition_correct":216,"transition_supported":231,"transition_unknown":25},"expert_count":80,"planning":{"belief_set_target_reached":54,"cases":64,"checksum":"8b57c74507741034","exact_world_state_target_reached":54,"executed_path_length":289,"expansions":2246,"goal_expert_reached":54,"graph_disconnection_failures":0,"no_supported_edge_failures":2,"optimal_path_length":293,"path_found":62,"path_length_regret":19,"state_aliasing_failures":0,"transition_model_error_failures":8},"retention_holdout":{"classification_checksum":"b40e65569c8373b6","correct":246,"expert_evaluations":3920,"prediction_checksum":"1a43c1eaf467f066","prediction_samples":227,"prediction_sse_q20":41668743262,"reconstruction_checksum":"eef28ff8a658dabb","reconstruction_sse_q20":34420111519,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":230,"samples":256,"transition_checksum":"a00578098c306fed","transition_correct":213,"transition_supported":227,"transition_unknown":29},"training_evaluations":1968450},"ravel_without_retirement_matched_work":{"checkpoint_size_bytes":50054,"drift_holdout":{"classification_checksum":"a89d93e7d34c14fc","correct":169,"expert_evaluations":2932,"prediction_checksum":"d1795b1f8eb3a482","prediction_samples":231,"prediction_sse_q20":34474740235,"reconstruction_checksum":"ec69210f37edb7cd","reconstruction_sse_q20":36769717541,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":243,"samples":256,"transition_checksum":"3b75c34a1ac0e90e","transition_correct":215,"transition_supported":231,"transition_unknown":25},"expert_count":76,"planning":{"belief_set_target_reached":56,"cases":64,"checksum":"1ddab1f2f53120fc","exact_world_state_target_reached":56,"executed_path_length":298,"expansions":2217,"goal_expert_reached":56,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":293,"path_found":64,"path_length_regret":19,"state_aliasing_failures":0,"transition_model_error_failures":8},"retention_holdout":{"classification_checksum":"bf4ce839041937b7","correct":247,"expert_evaluations":2932,"prediction_checksum":"7039be11f355e9b3","prediction_samples":228,"prediction_sse_q20":41785135198,"reconstruction_checksum":"5539d02554acff57","reconstruction_sse_q20":34454456158,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":243,"samples":256,"transition_checksum":"af4cac2c18b6ac51","transition_correct":210,"transition_supported":228,"transition_unknown":28},"training_evaluations":1668594}},"dataset_seeds":{"base_holdout":"0x29d4519891827dfb","base_training":"0xfcae56b3099b2b56","drift_adaptation_training":"0xe096782b2672e13c","drift_holdout":"0x5a2b03c6fa78b640","original_task_retention_holdout":"0x341a1582062e9ecd","planning_cases":"0x82b5389316febef1"},"dataset_sizes":{"base_holdout":256,"base_training":1024,"drift_adaptation_training":512,"drift_holdout":256,"original_task_retention_holdout":256,"planning_cases":64},"integrity":{"checkpoint_behavior_match":true,"checkpoint_identity_match":true,"checkpoint_mutations":{"anchored_status":true,"appended_unexpected_byte":true,"checkpoint_substitution":true,"checkpoint_truncation":true,"incorrect_schema_version":true,"label":true,"label_count":true,"lineage":true,"next_observation_component":true,"payload_byte":true,"reconstruction_component":true,"retrieval_key_component":true,"transition_graph_edge":true,"transition_support":true},"checkpoint_roundtrip":true,"lineage_invariants":{"deterministic_topology_reproduction":true,"lineage_uniqueness":true,"no_accidental_lineage_reuse":true,"parent_child_generation_increment":true,"repeated_descendant_splitting":true,"sibling_generation_equality":true},"unsupported_graph_edge_violations":0},"regime":"label_drift","schema":"ravel-raw-trial/0.5","seed":"0x8ad341ed9d31e4b2","trial_id":"validation-label-04"},{"candidate":{"adaptation_completed":true,"adaptation_training":{"classification_checksum":"5b0725944d60f9d3","correct":512,"expert_evaluations":4096,"prediction_checksum":"6d178d687f225f46","prediction_samples":465,"prediction_sse_q20":204216439449,"reconstruction_checksum":"ad23821a43645bdc","reconstruction_sse_q20":212333995246,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":512,"samples":512,"transition_checksum":"86f29d68a0fa58a0","transition_correct":452,"transition_supported":465,"transition_unknown":47},"adaptation_training_evaluations":691200,"adapted_model_drift_holdout":{"classification_checksum":"b35898c7c23dc56a","correct":256,"expert_evaluations":2048,"prediction_checksum":"b17c343fc1c8f6cb","prediction_samples":236,"prediction_sse_q20":114713612426,"reconstruction_checksum":"5421f83a3f37e10d","reconstruction_sse_q20":107290449807,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"c8377e3e2c3f76ab","transition_correct":229,"transition_supported":236,"transition_unknown":20},"base_holdout":{"classification_checksum":"1eaab8d22c7b9027","correct":239,"expert_evaluations":2048,"prediction_checksum":"a5b86aa5dcc4ab0e","prediction_samples":229,"prediction_sse_q20":89252739067,"reconstruction_checksum":"14dcc62385301dc1","reconstruction_sse_q20":83599299016,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"d9ed93eee16da199","transition_correct":214,"transition_supported":229,"transition_unknown":27},"base_holdout_retention":{"classification_checksum":"e79a98375c2d382c","correct":256,"expert_evaluations":2048,"prediction_checksum":"16e1c38ada9cafc4","prediction_samples":229,"prediction_sse_q20":38484917606,"reconstruction_checksum":"edfd3f9c1687e4c9","reconstruction_sse_q20":34917545017,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"8890e594f6d02ade","transition_correct":226,"transition_supported":229,"transition_unknown":27},"base_training_evaluations":551384,"behavior_identity":"66a0acba51fc2e95acc80ec3bcc01f004c8251e10bb5609ddbec3fd0cb38f367","checkpoint_size_bytes":45494,"expert_count":68,"model_identity":"03102d7435cc1a347e275f9578e49d417a61e0ce902ea0ca7121afec01aeac42","planning":{"belief_set_target_reached":58,"cases":64,"checksum":"a7ac89ee85cec34e","exact_world_state_target_reached":58,"executed_path_length":337,"expansions":2466,"goal_expert_reached":58,"graph_disconnection_failures":0,"no_supported_edge_failures":1,"optimal_path_length":318,"path_found":63,"path_length_regret":21,"state_aliasing_failures":0,"transition_model_error_failures":5},"replay":{"actions_covered":4,"assigned_experts_covered":62,"high_loss_cases_selected":15,"labels_covered":8,"rare_cases_selected":55,"selected":256,"selection_checksum":"63d02d1d7325b2e7","states_covered":64,"transition_pairs_covered":247,"unique":256},"static_model_drift_holdout":{"classification_checksum":"8a584306c21f3d6f","correct":239,"expert_evaluations":2048,"prediction_checksum":"44615f80d3b87da1","prediction_samples":236,"prediction_sse_q20":169952299190,"reconstruction_checksum":"9e04f1da737ca43b","reconstruction_sse_q20":158200459357,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"021724924ba49a05","transition_correct":223,"transition_supported":236,"transition_unknown":20},"topology":{"accepted_births":4,"accepted_retirements":0,"births":[{"dominant_channel":0,"event_index":251,"normalized_score_q20":536504},{"dominant_channel":0,"event_index":294,"normalized_score_q20":522597},{"dominant_channel":0,"event_index":336,"normalized_score_q20":516452},{"dominant_channel":2,"event_index":225,"normalized_score_q20":334852}],"objective_after_q20":902656,"objective_before_q20":883448,"rejected_births":12,"rejected_retirements":1,"retired_lineages":[],"training_observations":{"births":4,"certified":9216,"expert_evaluations":691200,"rejected_births":12,"rejected_retirements":1,"retired":0,"samples":9216}}},"checkpoint_format":{"byte_order":"big_endian","magic_hex":"524156454c303500","payload_digest":"sha256","real_encoding":"signed_q20_int64","schema_version":5,"transition_support_min":2,"transition_top_k":2},"comparisons":{"fixed_8_expert":{"checkpoint_size_bytes":11294,"drift_holdout":{"classification_checksum":"145445d9b7dd37a5","correct":35,"expert_evaluations":2048,"prediction_checksum":"68c27942eaa9b836","prediction_samples":256,"prediction_sse_q20":2060797576198,"reconstruction_checksum":"15a5bd3c7d43516e","reconstruction_sse_q20":1801433608408,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"e88ea86b9ccecb53","transition_correct":134,"transition_supported":256,"transition_unknown":0},"expert_count":8,"planning":{"belief_set_target_reached":23,"cases":64,"checksum":"283b27e26d02352b","exact_world_state_target_reached":2,"executed_path_length":109,"expansions":291,"goal_expert_reached":23,"graph_disconnection_failures":7,"no_supported_edge_failures":0,"optimal_path_length":318,"path_found":57,"path_length_regret":0,"state_aliasing_failures":21,"transition_model_error_failures":34},"retention_holdout":{"classification_checksum":"17ab5bdb533981fa","correct":53,"expert_evaluations":2048,"prediction_checksum":"f09f393e062c53c3","prediction_samples":256,"prediction_sse_q20":1913914616676,"reconstruction_checksum":"6a2f643e36098884","reconstruction_sse_q20":1769900421347,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"250a4584fa2681cc","transition_correct":153,"transition_supported":256,"transition_unknown":0},"training_evaluations":94208},"fixed_topology_64_expert_routed":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"a2001ec5454f2ae6","correct":256,"expert_evaluations":2048,"prediction_checksum":"628e22971fd92e36","prediction_samples":230,"prediction_sse_q20":93170459721,"reconstruction_checksum":"3fb0f3e60443b0e3","reconstruction_sse_q20":94819602962,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"fc30ef6acec531e0","transition_correct":230,"transition_supported":230,"transition_unknown":26},"expert_count":64,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"5067599862fca9c3","exact_world_state_target_reached":64,"executed_path_length":348,"expansions":2402,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":318,"path_found":64,"path_length_regret":30,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"e0d06747cb898e48","correct":256,"expert_evaluations":2048,"prediction_checksum":"88e47f3301f0c329","prediction_samples":228,"prediction_sse_q20":23618484951,"reconstruction_checksum":"629abab5edf2c635","reconstruction_sse_q20":22969413338,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"6d81bd8306443441","transition_correct":228,"transition_supported":228,"transition_unknown":28},"training_evaluations":2588672},"flat_64_expert_complete_scan":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"a2001ec5454f2ae6","correct":256,"expert_evaluations":16384,"prediction_checksum":"628e22971fd92e36","prediction_samples":230,"prediction_sse_q20":93170459721,"reconstruction_checksum":"3fb0f3e60443b0e3","reconstruction_sse_q20":94819602962,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"fc30ef6acec531e0","transition_correct":230,"transition_supported":230,"transition_unknown":26},"expert_count":64,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"5067599862fca9c3","exact_world_state_target_reached":64,"executed_path_length":348,"expansions":2402,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":318,"path_found":64,"path_length_regret":30,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"e0d06747cb898e48","correct":256,"expert_evaluations":16384,"prediction_checksum":"88e47f3301f0c329","prediction_samples":228,"prediction_sse_q20":23618484951,"reconstruction_checksum":"629abab5edf2c635","reconstruction_sse_q20":22969413338,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"6d81bd8306443441","transition_correct":228,"transition_supported":228,"transition_unknown":28},"training_evaluations":2588672},"matched_compute_fixed_topology":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"8a584306c21f3d6f","correct":239,"expert_evaluations":2048,"prediction_checksum":"44615f80d3b87da1","prediction_samples":236,"prediction_sse_q20":169952299190,"reconstruction_checksum":"9e04f1da737ca43b","reconstruction_sse_q20":158200459357,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"021724924ba49a05","transition_correct":223,"transition_supported":236,"transition_unknown":20},"expert_count":64,"planning":{"belief_set_target_reached":48,"cases":64,"checksum":"70c8abe7abafb5f3","exact_world_state_target_reached":46,"executed_path_length":320,"expansions":2298,"goal_expert_reached":48,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":318,"path_found":64,"path_length_regret":11,"state_aliasing_failures":2,"transition_model_error_failures":16},"retention_holdout":{"classification_checksum":"42de7a0a54a57e20","correct":248,"expert_evaluations":2048,"prediction_checksum":"3ef0cdb84a9c455f","prediction_samples":230,"prediction_sse_q20":73243589243,"reconstruction_checksum":"09fc32d0da2b0071","reconstruction_sse_q20":56476314561,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"6160279b64903e40","transition_correct":221,"transition_supported":230,"transition_unknown":26},"training_evaluations":1436120},"matched_expert_count_capacity":{"checkpoint_size_bytes":45494,"drift_holdout":{"classification_checksum":"8bad3d551373db07","correct":256,"expert_evaluations":2048,"prediction_checksum":"e9ccae6e89157355","prediction_samples":223,"prediction_sse_q20":91937354867,"reconstruction_checksum":"8c6f328073df9381","reconstruction_sse_q20":94762718192,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"de6e7b3c75ffc18b","transition_correct":217,"transition_supported":223,"transition_unknown":33},"expert_count":68,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"f6383e65cab7a3eb","exact_world_state_target_reached":64,"executed_path_length":354,"expansions":2465,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":318,"path_found":64,"path_length_regret":36,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"0a9a3f2999f260a8","correct":256,"expert_evaluations":2048,"prediction_checksum":"397391b93e4ad7d9","prediction_samples":225,"prediction_sse_q20":23331693913,"reconstruction_checksum":"9dd266a1025bdf7b","reconstruction_sse_q20":22870863629,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"9aa05c799d65d905","transition_correct":219,"transition_supported":225,"transition_unknown":31},"training_evaluations":2889728},"nearest_centroid_16_no_recursive_births":{"checkpoint_size_bytes":15854,"drift_holdout":{"classification_checksum":"c559ad1010d3a33b","correct":55,"expert_evaluations":4096,"prediction_checksum":"edc067bfb89bb639","prediction_samples":256,"prediction_sse_q20":1387724030566,"reconstruction_checksum":"aa6392d116127957","reconstruction_sse_q20":1177960287081,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"2deee9c2be46aeea","transition_correct":162,"transition_supported":256,"transition_unknown":0},"expert_count":16,"planning":{"belief_set_target_reached":28,"cases":64,"checksum":"04a381931c53d1a7","exact_world_state_target_reached":3,"executed_path_length":164,"expansions":562,"goal_expert_reached":28,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":318,"path_found":64,"path_length_regret":0,"state_aliasing_failures":25,"transition_model_error_failures":36},"retention_holdout":{"classification_checksum":"8e0e2a86104791e1","correct":62,"expert_evaluations":4096,"prediction_checksum":"f44cadbe2b536af4","prediction_samples":256,"prediction_sse_q20":1254840436066,"reconstruction_checksum":"478df3fb59956038","reconstruction_sse_q20":1112964846608,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"a7d63edea68664d0","transition_correct":160,"transition_supported":256,"transition_unknown":0},"training_evaluations":253952},"no_adaptation_static":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"8a584306c21f3d6f","correct":239,"expert_evaluations":2048,"prediction_checksum":"44615f80d3b87da1","prediction_samples":236,"prediction_sse_q20":169952299190,"reconstruction_checksum":"9e04f1da737ca43b","reconstruction_sse_q20":158200459357,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"021724924ba49a05","transition_correct":223,"transition_supported":236,"transition_unknown":20},"expert_count":64,"planning":{"belief_set_target_reached":48,"cases":64,"checksum":"70c8abe7abafb5f3","exact_world_state_target_reached":46,"executed_path_length":320,"expansions":2298,"goal_expert_reached":48,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":318,"path_found":64,"path_length_regret":11,"state_aliasing_failures":2,"transition_model_error_failures":16},"retention_holdout":{"classification_checksum":"42de7a0a54a57e20","correct":248,"expert_evaluations":2048,"prediction_checksum":"3ef0cdb84a9c455f","prediction_samples":230,"prediction_sse_q20":73243589243,"reconstruction_checksum":"09fc32d0da2b0071","reconstruction_sse_q20":56476314561,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"6160279b64903e40","transition_correct":221,"transition_supported":230,"transition_unknown":26},"training_evaluations":551384},"periodic_replay_policy":{"checkpoint_size_bytes":45494,"drift_holdout":{"classification_checksum":"b35898c7c23dc56a","correct":256,"expert_evaluations":2048,"prediction_checksum":"ccb792971aeeb4d0","prediction_samples":236,"prediction_sse_q20":115127402976,"reconstruction_checksum":"76f917b5bf570fbf","reconstruction_sse_q20":107137374106,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"c8377e3e2c3f76ab","transition_correct":229,"transition_supported":236,"transition_unknown":20},"expert_count":68,"planning":{"belief_set_target_reached":58,"cases":64,"checksum":"1154a9a394657ab9","exact_world_state_target_reached":58,"executed_path_length":334,"expansions":2461,"goal_expert_reached":58,"graph_disconnection_failures":0,"no_supported_edge_failures":1,"optimal_path_length":318,"path_found":63,"path_length_regret":18,"state_aliasing_failures":0,"transition_model_error_failures":5},"retention_holdout":{"classification_checksum":"e79a98375c2d382c","correct":256,"expert_evaluations":2048,"prediction_checksum":"c42dafc38b2205ae","prediction_samples":230,"prediction_sse_q20":39464634442,"reconstruction_checksum":"a0518955e3629065","reconstruction_sse_q20":35233802633,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"f1a1bd2da0c78a87","transition_correct":227,"transition_supported":230,"transition_unknown":26},"training_evaluations":1242584},"ravel_0_5_candidate":{"checkpoint_size_bytes":45494,"drift_holdout":{"classification_checksum":"b35898c7c23dc56a","correct":256,"expert_evaluations":2048,"prediction_checksum":"b17c343fc1c8f6cb","prediction_samples":236,"prediction_sse_q20":114713612426,"reconstruction_checksum":"5421f83a3f37e10d","reconstruction_sse_q20":107290449807,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"c8377e3e2c3f76ab","transition_correct":229,"transition_supported":236,"transition_unknown":20},"expert_count":68,"planning":{"belief_set_target_reached":58,"cases":64,"checksum":"a7ac89ee85cec34e","exact_world_state_target_reached":58,"executed_path_length":337,"expansions":2466,"goal_expert_reached":58,"graph_disconnection_failures":0,"no_supported_edge_failures":1,"optimal_path_length":318,"path_found":63,"path_length_regret":21,"state_aliasing_failures":0,"transition_model_error_failures":5},"retention_holdout":{"classification_checksum":"e79a98375c2d382c","correct":256,"expert_evaluations":2048,"prediction_checksum":"16e1c38ada9cafc4","prediction_samples":229,"prediction_sse_q20":38484917606,"reconstruction_checksum":"edfd3f9c1687e4c9","reconstruction_sse_q20":34917545017,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"8890e594f6d02ade","transition_correct":226,"transition_supported":229,"transition_unknown":27},"training_evaluations":1242584},"ravel_complete_scan_without_certification":{"checkpoint_size_bytes":45494,"drift_holdout":{"classification_checksum":"b35898c7c23dc56a","correct":256,"expert_evaluations":17408,"prediction_checksum":"b17c343fc1c8f6cb","prediction_samples":236,"prediction_sse_q20":114713612426,"reconstruction_checksum":"5421f83a3f37e10d","reconstruction_sse_q20":107290449807,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"c8377e3e2c3f76ab","transition_correct":229,"transition_supported":236,"transition_unknown":20},"expert_count":68,"planning":{"belief_set_target_reached":58,"cases":64,"checksum":"a7ac89ee85cec34e","exact_world_state_target_reached":58,"executed_path_length":337,"expansions":2466,"goal_expert_reached":58,"graph_disconnection_failures":0,"no_supported_edge_failures":1,"optimal_path_length":318,"path_found":63,"path_length_regret":21,"state_aliasing_failures":0,"transition_model_error_failures":5},"retention_holdout":{"classification_checksum":"e79a98375c2d382c","correct":256,"expert_evaluations":17408,"prediction_checksum":"16e1c38ada9cafc4","prediction_samples":229,"prediction_sse_q20":38484917606,"reconstruction_checksum":"edfd3f9c1687e4c9","reconstruction_sse_q20":34917545017,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"8890e594f6d02ade","transition_correct":226,"transition_supported":229,"transition_unknown":27},"training_evaluations":1426904},"ravel_no_birth_same_replay_iterations":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"8a584306c21f3d6f","correct":239,"expert_evaluations":2048,"prediction_checksum":"44615f80d3b87da1","prediction_samples":236,"prediction_sse_q20":169952299190,"reconstruction_checksum":"9e04f1da737ca43b","reconstruction_sse_q20":158200459357,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"021724924ba49a05","transition_correct":223,"transition_supported":236,"transition_unknown":20},"expert_count":64,"planning":{"belief_set_target_reached":48,"cases":64,"checksum":"70c8abe7abafb5f3","exact_world_state_target_reached":46,"executed_path_length":320,"expansions":2298,"goal_expert_reached":48,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":318,"path_found":64,"path_length_regret":11,"state_aliasing_failures":2,"transition_model_error_failures":16},"retention_holdout":{"classification_checksum":"42de7a0a54a57e20","correct":248,"expert_evaluations":2048,"prediction_checksum":"3ef0cdb84a9c455f","prediction_samples":230,"prediction_sse_q20":73243589243,"reconstruction_checksum":"09fc32d0da2b0071","reconstruction_sse_q20":56476314561,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"6160279b64903e40","transition_correct":221,"transition_supported":230,"transition_unknown":26},"training_evaluations":772568},"ravel_random_births":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"8a584306c21f3d6f","correct":239,"expert_evaluations":2048,"prediction_checksum":"44615f80d3b87da1","prediction_samples":236,"prediction_sse_q20":169952299190,"reconstruction_checksum":"9e04f1da737ca43b","reconstruction_sse_q20":158200459357,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"021724924ba49a05","transition_correct":223,"transition_supported":236,"transition_unknown":20},"expert_count":64,"planning":{"belief_set_target_reached":48,"cases":64,"checksum":"70c8abe7abafb5f3","exact_world_state_target_reached":46,"executed_path_length":320,"expansions":2298,"goal_expert_reached":48,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":318,"path_found":64,"path_length_regret":11,"state_aliasing_failures":2,"transition_model_error_failures":16},"retention_holdout":{"classification_checksum":"42de7a0a54a57e20","correct":248,"expert_evaluations":2048,"prediction_checksum":"3ef0cdb84a9c455f","prediction_samples":230,"prediction_sse_q20":73243589243,"reconstruction_checksum":"09fc32d0da2b0071","reconstruction_sse_q20":56476314561,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"6160279b64903e40","transition_correct":221,"transition_supported":230,"transition_unknown":26},"training_evaluations":772568},"ravel_without_replay":{"checkpoint_size_bytes":45494,"drift_holdout":{"classification_checksum":"b35898c7c23dc56a","correct":256,"expert_evaluations":2048,"prediction_checksum":"b3fd95e77e9f591f","prediction_samples":232,"prediction_sse_q20":113871825218,"reconstruction_checksum":"b10d86a4c8e298e3","reconstruction_sse_q20":106952039654,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"86231e5fb8308d02","transition_correct":225,"transition_supported":232,"transition_unknown":24},"expert_count":68,"planning":{"belief_set_target_reached":58,"cases":64,"checksum":"ae9cc07a4d2a2ea0","exact_world_state_target_reached":58,"executed_path_length":338,"expansions":2465,"goal_expert_reached":58,"graph_disconnection_failures":0,"no_supported_edge_failures":1,"optimal_path_length":318,"path_found":63,"path_length_regret":22,"state_aliasing_failures":0,"transition_model_error_failures":5},"retention_holdout":{"classification_checksum":"e79a98375c2d382c","correct":256,"expert_evaluations":2048,"prediction_checksum":"18f488b2c8001f20","prediction_samples":228,"prediction_sse_q20":39289571772,"reconstruction_checksum":"3af9a83f99e20ac1","reconstruction_sse_q20":36754905729,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"79d4f10436be75d8","transition_correct":225,"transition_supported":228,"transition_unknown":28},"training_evaluations":1012184},"ravel_without_retirement_matched_work":{"checkpoint_size_bytes":45494,"drift_holdout":{"classification_checksum":"b35898c7c23dc56a","correct":256,"expert_evaluations":2048,"prediction_checksum":"b17c343fc1c8f6cb","prediction_samples":236,"prediction_sse_q20":114713612426,"reconstruction_checksum":"5421f83a3f37e10d","reconstruction_sse_q20":107290449807,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"c8377e3e2c3f76ab","transition_correct":229,"transition_supported":236,"transition_unknown":20},"expert_count":68,"planning":{"belief_set_target_reached":58,"cases":64,"checksum":"a7ac89ee85cec34e","exact_world_state_target_reached":58,"executed_path_length":337,"expansions":2466,"goal_expert_reached":58,"graph_disconnection_failures":0,"no_supported_edge_failures":1,"optimal_path_length":318,"path_found":63,"path_length_regret":21,"state_aliasing_failures":0,"transition_model_error_failures":5},"retention_holdout":{"classification_checksum":"e79a98375c2d382c","correct":256,"expert_evaluations":2048,"prediction_checksum":"16e1c38ada9cafc4","prediction_samples":229,"prediction_sse_q20":38484917606,"reconstruction_checksum":"edfd3f9c1687e4c9","reconstruction_sse_q20":34917545017,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"8890e594f6d02ade","transition_correct":226,"transition_supported":229,"transition_unknown":27},"training_evaluations":1242584}},"dataset_seeds":{"base_holdout":"0x2b160188d39d8b19","base_training":"0xf50037db2ba1b50e","drift_adaptation_training":"0xb373834712b78ea9","drift_holdout":"0x1d9c7ebcb6fd074e","original_task_retention_holdout":"0xe6630ebefd290465","planning_cases":"0x4c860af7dfa1cb72"},"dataset_sizes":{"base_holdout":256,"base_training":1024,"drift_adaptation_training":512,"drift_holdout":256,"original_task_retention_holdout":256,"planning_cases":64},"integrity":{"checkpoint_behavior_match":true,"checkpoint_identity_match":true,"checkpoint_mutations":{"anchored_status":true,"appended_unexpected_byte":true,"checkpoint_substitution":true,"checkpoint_truncation":true,"incorrect_schema_version":true,"label":true,"label_count":true,"lineage":true,"next_observation_component":true,"payload_byte":true,"reconstruction_component":true,"retrieval_key_component":true,"transition_graph_edge":true,"transition_support":true},"checkpoint_roundtrip":true,"lineage_invariants":{"deterministic_topology_reproduction":true,"lineage_uniqueness":true,"no_accidental_lineage_reuse":true,"parent_child_generation_increment":true,"repeated_descendant_splitting":true,"sibling_generation_equality":true},"unsupported_graph_edge_violations":0},"regime":"observation_drift","schema":"ravel-raw-trial/0.5","seed":"0xd16b29b526b37eba","trial_id":"validation-observation-01"},{"candidate":{"adaptation_completed":true,"adaptation_training":{"classification_checksum":"4f93ac3a76f15f64","correct":512,"expert_evaluations":4096,"prediction_checksum":"6a9d4e462bcde7fc","prediction_samples":491,"prediction_sse_q20":209830929527,"reconstruction_checksum":"d01119da9565901b","reconstruction_sse_q20":193086454088,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":512,"samples":512,"transition_checksum":"2464f5255c4d4e62","transition_correct":467,"transition_supported":491,"transition_unknown":21},"adaptation_training_evaluations":935424,"adapted_model_drift_holdout":{"classification_checksum":"0fcae9662c28a7cc","correct":256,"expert_evaluations":2048,"prediction_checksum":"9278373a2568c9de","prediction_samples":242,"prediction_sse_q20":106895821632,"reconstruction_checksum":"0f39f875072e374d","reconstruction_sse_q20":95343125723,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"c1377e80fd5e99e8","transition_correct":231,"transition_supported":242,"transition_unknown":14},"base_holdout":{"classification_checksum":"34d6f32e0f6ab004","correct":239,"expert_evaluations":2048,"prediction_checksum":"10a1f823c2735577","prediction_samples":239,"prediction_sse_q20":94664740701,"reconstruction_checksum":"aa0e9b3df0bfffa4","reconstruction_sse_q20":85421164771,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"2c4a162226bcfe8d","transition_correct":219,"transition_supported":239,"transition_unknown":17},"base_holdout_retention":{"classification_checksum":"06cf2c4317dc7fa9","correct":256,"expert_evaluations":2048,"prediction_checksum":"48262ceb89e3d1c9","prediction_samples":229,"prediction_sse_q20":35046160031,"reconstruction_checksum":"2ea773000eb8818a","reconstruction_sse_q20":33057442468,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"91951de30a25f164","transition_correct":223,"transition_supported":229,"transition_unknown":27},"base_training_evaluations":557176,"behavior_identity":"59250918b7c689e7748da20e4b72d83d804ce664abf893777bd906e89679ff46","checkpoint_size_bytes":46634,"expert_count":70,"model_identity":"0be7e5ef6c7c1339b0a05a40a2b2c11d27738f7cf612a47bbeaea243fc9eee01","planning":{"belief_set_target_reached":48,"cases":64,"checksum":"d76d2db9312ebca4","exact_world_state_target_reached":48,"executed_path_length":282,"expansions":2182,"goal_expert_reached":48,"graph_disconnection_failures":0,"no_supported_edge_failures":1,"optimal_path_length":288,"path_found":63,"path_length_regret":20,"state_aliasing_failures":0,"transition_model_error_failures":15},"replay":{"actions_covered":4,"assigned_experts_covered":63,"high_loss_cases_selected":11,"labels_covered":8,"rare_cases_selected":55,"selected":256,"selection_checksum":"c903b85eaa07d489","states_covered":64,"transition_pairs_covered":253,"unique":256},"static_model_drift_holdout":{"classification_checksum":"e7fe5c972bd949ac","correct":234,"expert_evaluations":2048,"prediction_checksum":"0f0db15f5aa0c8f3","prediction_samples":245,"prediction_sse_q20":180448739977,"reconstruction_checksum":"36d7e9ec3554df69","reconstruction_sse_q20":169803983594,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"8bfe21e786ce90cf","transition_correct":229,"transition_supported":245,"transition_unknown":11},"topology":{"accepted_births":6,"accepted_retirements":0,"births":[{"dominant_channel":0,"event_index":412,"normalized_score_q20":544418},{"dominant_channel":0,"event_index":448,"normalized_score_q20":525724},{"dominant_channel":0,"event_index":143,"normalized_score_q20":503663},{"dominant_channel":2,"event_index":1,"normalized_score_q20":385728},{"dominant_channel":2,"event_index":301,"normalized_score_q20":327753},{"dominant_channel":2,"event_index":359,"normalized_score_q20":308043}],"objective_after_q20":906719,"objective_before_q20":887166,"rejected_births":10,"rejected_retirements":1,"retired_lineages":[],"training_observations":{"births":6,"certified":12288,"expert_evaluations":935424,"rejected_births":10,"rejected_retirements":1,"retired":0,"samples":12288}}},"checkpoint_format":{"byte_order":"big_endian","magic_hex":"524156454c303500","payload_digest":"sha256","real_encoding":"signed_q20_int64","schema_version":5,"transition_support_min":2,"transition_top_k":2},"comparisons":{"fixed_8_expert":{"checkpoint_size_bytes":11294,"drift_holdout":{"classification_checksum":"e48895f79c05d739","correct":57,"expert_evaluations":2048,"prediction_checksum":"ff4db3f805e37b79","prediction_samples":256,"prediction_sse_q20":2128553483801,"reconstruction_checksum":"440cad5021e96809","reconstruction_sse_q20":1862303863460,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"4c4f300b6c7c61c2","transition_correct":105,"transition_supported":256,"transition_unknown":0},"expert_count":8,"planning":{"belief_set_target_reached":14,"cases":64,"checksum":"63e477830f4788f0","exact_world_state_target_reached":2,"executed_path_length":24,"expansions":138,"goal_expert_reached":14,"graph_disconnection_failures":41,"no_supported_edge_failures":0,"optimal_path_length":288,"path_found":23,"path_length_regret":0,"state_aliasing_failures":12,"transition_model_error_failures":9},"retention_holdout":{"classification_checksum":"0157943589bffd6a","correct":60,"expert_evaluations":2048,"prediction_checksum":"d87730c958ce4f87","prediction_samples":256,"prediction_sse_q20":2018871794943,"reconstruction_checksum":"2f1772d9745be47d","reconstruction_sse_q20":1786644160644,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"67bdd342919036ab","transition_correct":108,"transition_supported":256,"transition_unknown":0},"training_evaluations":94208},"fixed_topology_64_expert_routed":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"fafe3d59e3032256","correct":256,"expert_evaluations":2048,"prediction_checksum":"c05b31690845f8f4","prediction_samples":247,"prediction_sse_q20":100869013320,"reconstruction_checksum":"b28580ac84d740f5","reconstruction_sse_q20":91737531345,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"f8fc4601c2fcc052","transition_correct":247,"transition_supported":247,"transition_unknown":9},"expert_count":64,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"9c33f1ea3cd9f4ab","exact_world_state_target_reached":64,"executed_path_length":306,"expansions":2104,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":288,"path_found":64,"path_length_regret":18,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"1a2ddaac4d5d4e2a","correct":256,"expert_evaluations":2048,"prediction_checksum":"287df3dd1952d68c","prediction_samples":233,"prediction_sse_q20":23941713465,"reconstruction_checksum":"4ae36205d89a55ce","reconstruction_sse_q20":22389550660,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"d7d7435e00cf0609","transition_correct":233,"transition_supported":233,"transition_unknown":23},"training_evaluations":2588672},"flat_64_expert_complete_scan":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"fafe3d59e3032256","correct":256,"expert_evaluations":16384,"prediction_checksum":"c05b31690845f8f4","prediction_samples":247,"prediction_sse_q20":100869013320,"reconstruction_checksum":"b28580ac84d740f5","reconstruction_sse_q20":91737531345,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"f8fc4601c2fcc052","transition_correct":247,"transition_supported":247,"transition_unknown":9},"expert_count":64,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"9c33f1ea3cd9f4ab","exact_world_state_target_reached":64,"executed_path_length":306,"expansions":2104,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":288,"path_found":64,"path_length_regret":18,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"1a2ddaac4d5d4e2a","correct":256,"expert_evaluations":16384,"prediction_checksum":"287df3dd1952d68c","prediction_samples":233,"prediction_sse_q20":23941713465,"reconstruction_checksum":"4ae36205d89a55ce","reconstruction_sse_q20":22389550660,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"d7d7435e00cf0609","transition_correct":233,"transition_supported":233,"transition_unknown":23},"training_evaluations":2588672},"matched_compute_fixed_topology":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"e7fe5c972bd949ac","correct":234,"expert_evaluations":2048,"prediction_checksum":"0f0db15f5aa0c8f3","prediction_samples":245,"prediction_sse_q20":180448739977,"reconstruction_checksum":"36d7e9ec3554df69","reconstruction_sse_q20":169803983594,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"8bfe21e786ce90cf","transition_correct":229,"transition_supported":245,"transition_unknown":11},"expert_count":64,"planning":{"belief_set_target_reached":43,"cases":64,"checksum":"e76d6cd62737ee05","exact_world_state_target_reached":37,"executed_path_length":245,"expansions":1769,"goal_expert_reached":43,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":288,"path_found":64,"path_length_regret":22,"state_aliasing_failures":6,"transition_model_error_failures":21},"retention_holdout":{"classification_checksum":"b534c2c9d063b814","correct":241,"expert_evaluations":2048,"prediction_checksum":"fe36ec6711fc3c2c","prediction_samples":234,"prediction_sse_q20":80862941846,"reconstruction_checksum":"6b53a0831c5a72a4","reconstruction_sse_q20":71121889464,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"48e410473a1157c4","transition_correct":221,"transition_supported":234,"transition_unknown":22},"training_evaluations":1663096},"matched_expert_count_capacity":{"checkpoint_size_bytes":46634,"drift_holdout":{"classification_checksum":"c6f0298aad635ad9","correct":256,"expert_evaluations":2048,"prediction_checksum":"404e74ded62d4fa4","prediction_samples":243,"prediction_sse_q20":100322022163,"reconstruction_checksum":"7b201c5640943716","reconstruction_sse_q20":91529390669,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"cbf24f2b50e2aa8a","transition_correct":232,"transition_supported":243,"transition_unknown":13},"expert_count":70,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"75fe064b1b7e5825","exact_world_state_target_reached":64,"executed_path_length":310,"expansions":2187,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":288,"path_found":64,"path_length_regret":22,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"a7d4bbfcd7b9a1b3","correct":256,"expert_evaluations":2048,"prediction_checksum":"7835ce1d116507eb","prediction_samples":227,"prediction_sse_q20":23611525473,"reconstruction_checksum":"2f2fb8de7d5b4eed","reconstruction_sse_q20":22335069116,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"c4d44bd79ab06fc1","transition_correct":213,"transition_supported":227,"transition_unknown":29},"training_evaluations":3046400},"nearest_centroid_16_no_recursive_births":{"checkpoint_size_bytes":15854,"drift_holdout":{"classification_checksum":"93dbdb5d5444df4c","correct":50,"expert_evaluations":4096,"prediction_checksum":"0f7a18129a649c71","prediction_samples":256,"prediction_sse_q20":1412741217972,"reconstruction_checksum":"d119eabcae2a3c6d","reconstruction_sse_q20":1206692935645,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"8cd2752e4a1dbee2","transition_correct":145,"transition_supported":256,"transition_unknown":0},"expert_count":16,"planning":{"belief_set_target_reached":31,"cases":64,"checksum":"7ca141058af4c1b3","exact_world_state_target_reached":12,"executed_path_length":161,"expansions":469,"goal_expert_reached":31,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":288,"path_found":64,"path_length_regret":0,"state_aliasing_failures":19,"transition_model_error_failures":33},"retention_holdout":{"classification_checksum":"ca0f6f20b374f9dc","correct":65,"expert_evaluations":4096,"prediction_checksum":"de779080a6271777","prediction_samples":256,"prediction_sse_q20":1374153671350,"reconstruction_checksum":"5c3adb178403a62e","reconstruction_sse_q20":1177232256305,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"deb14269b150dd83","transition_correct":145,"transition_supported":256,"transition_unknown":0},"training_evaluations":253952},"no_adaptation_static":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"e7fe5c972bd949ac","correct":234,"expert_evaluations":2048,"prediction_checksum":"0f0db15f5aa0c8f3","prediction_samples":245,"prediction_sse_q20":180448739977,"reconstruction_checksum":"36d7e9ec3554df69","reconstruction_sse_q20":169803983594,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"8bfe21e786ce90cf","transition_correct":229,"transition_supported":245,"transition_unknown":11},"expert_count":64,"planning":{"belief_set_target_reached":43,"cases":64,"checksum":"e76d6cd62737ee05","exact_world_state_target_reached":37,"executed_path_length":245,"expansions":1769,"goal_expert_reached":43,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":288,"path_found":64,"path_length_regret":22,"state_aliasing_failures":6,"transition_model_error_failures":21},"retention_holdout":{"classification_checksum":"b534c2c9d063b814","correct":241,"expert_evaluations":2048,"prediction_checksum":"fe36ec6711fc3c2c","prediction_samples":234,"prediction_sse_q20":80862941846,"reconstruction_checksum":"6b53a0831c5a72a4","reconstruction_sse_q20":71121889464,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"48e410473a1157c4","transition_correct":221,"transition_supported":234,"transition_unknown":22},"training_evaluations":557176},"periodic_replay_policy":{"checkpoint_size_bytes":46634,"drift_holdout":{"classification_checksum":"0fcae9662c28a7cc","correct":256,"expert_evaluations":2048,"prediction_checksum":"90fee62724c94faf","prediction_samples":240,"prediction_sse_q20":105859060844,"reconstruction_checksum":"f1a802fc3ae21ad4","reconstruction_sse_q20":94624517762,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"4cf5c44ad6b5209c","transition_correct":229,"transition_supported":240,"transition_unknown":16},"expert_count":70,"planning":{"belief_set_target_reached":48,"cases":64,"checksum":"d76d2db9312ebca4","exact_world_state_target_reached":48,"executed_path_length":282,"expansions":2186,"goal_expert_reached":48,"graph_disconnection_failures":0,"no_supported_edge_failures":1,"optimal_path_length":288,"path_found":63,"path_length_regret":20,"state_aliasing_failures":0,"transition_model_error_failures":15},"retention_holdout":{"classification_checksum":"06cf2c4317dc7fa9","correct":256,"expert_evaluations":2048,"prediction_checksum":"67c185220cb0d5f9","prediction_samples":228,"prediction_sse_q20":35625453644,"reconstruction_checksum":"9fa5af87e955a174","reconstruction_sse_q20":34033076880,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"d42622d4ec91b096","transition_correct":222,"transition_supported":228,"transition_unknown":28},"training_evaluations":1492600},"ravel_0_5_candidate":{"checkpoint_size_bytes":46634,"drift_holdout":{"classification_checksum":"0fcae9662c28a7cc","correct":256,"expert_evaluations":2048,"prediction_checksum":"9278373a2568c9de","prediction_samples":242,"prediction_sse_q20":106895821632,"reconstruction_checksum":"0f39f875072e374d","reconstruction_sse_q20":95343125723,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"c1377e80fd5e99e8","transition_correct":231,"transition_supported":242,"transition_unknown":14},"expert_count":70,"planning":{"belief_set_target_reached":48,"cases":64,"checksum":"d76d2db9312ebca4","exact_world_state_target_reached":48,"executed_path_length":282,"expansions":2182,"goal_expert_reached":48,"graph_disconnection_failures":0,"no_supported_edge_failures":1,"optimal_path_length":288,"path_found":63,"path_length_regret":20,"state_aliasing_failures":0,"transition_model_error_failures":15},"retention_holdout":{"classification_checksum":"06cf2c4317dc7fa9","correct":256,"expert_evaluations":2048,"prediction_checksum":"48262ceb89e3d1c9","prediction_samples":229,"prediction_sse_q20":35046160031,"reconstruction_checksum":"2ea773000eb8818a","reconstruction_sse_q20":33057442468,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"91951de30a25f164","transition_correct":223,"transition_supported":229,"transition_unknown":27},"training_evaluations":1492600},"ravel_complete_scan_without_certification":{"checkpoint_size_bytes":46634,"drift_holdout":{"classification_checksum":"0fcae9662c28a7cc","correct":256,"expert_evaluations":17920,"prediction_checksum":"9278373a2568c9de","prediction_samples":242,"prediction_sse_q20":106895821632,"reconstruction_checksum":"0f39f875072e374d","reconstruction_sse_q20":95343125723,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"c1377e80fd5e99e8","transition_correct":231,"transition_supported":242,"transition_unknown":14},"expert_count":70,"planning":{"belief_set_target_reached":48,"cases":64,"checksum":"d76d2db9312ebca4","exact_world_state_target_reached":48,"executed_path_length":282,"expansions":2182,"goal_expert_reached":48,"graph_disconnection_failures":0,"no_supported_edge_failures":1,"optimal_path_length":288,"path_found":63,"path_length_regret":20,"state_aliasing_failures":0,"transition_model_error_failures":15},"retention_holdout":{"classification_checksum":"06cf2c4317dc7fa9","correct":256,"expert_evaluations":17920,"prediction_checksum":"48262ceb89e3d1c9","prediction_samples":229,"prediction_sse_q20":35046160031,"reconstruction_checksum":"2ea773000eb8818a","reconstruction_sse_q20":33057442468,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"91951de30a25f164","transition_correct":223,"transition_supported":229,"transition_unknown":27},"training_evaluations":1683064},"ravel_no_birth_same_replay_iterations":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"e7fe5c972bd949ac","correct":234,"expert_evaluations":2048,"prediction_checksum":"0f0db15f5aa0c8f3","prediction_samples":245,"prediction_sse_q20":180448739977,"reconstruction_checksum":"36d7e9ec3554df69","reconstruction_sse_q20":169803983594,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"8bfe21e786ce90cf","transition_correct":229,"transition_supported":245,"transition_unknown":11},"expert_count":64,"planning":{"belief_set_target_reached":43,"cases":64,"checksum":"e76d6cd62737ee05","exact_world_state_target_reached":37,"executed_path_length":245,"expansions":1769,"goal_expert_reached":43,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":288,"path_found":64,"path_length_regret":22,"state_aliasing_failures":6,"transition_model_error_failures":21},"retention_holdout":{"classification_checksum":"b534c2c9d063b814","correct":241,"expert_evaluations":2048,"prediction_checksum":"fe36ec6711fc3c2c","prediction_samples":234,"prediction_sse_q20":80862941846,"reconstruction_checksum":"6b53a0831c5a72a4","reconstruction_sse_q20":71121889464,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"48e410473a1157c4","transition_correct":221,"transition_supported":234,"transition_unknown":22},"training_evaluations":778360},"ravel_random_births":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"e7fe5c972bd949ac","correct":234,"expert_evaluations":2048,"prediction_checksum":"0f0db15f5aa0c8f3","prediction_samples":245,"prediction_sse_q20":180448739977,"reconstruction_checksum":"36d7e9ec3554df69","reconstruction_sse_q20":169803983594,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"8bfe21e786ce90cf","transition_correct":229,"transition_supported":245,"transition_unknown":11},"expert_count":64,"planning":{"belief_set_target_reached":43,"cases":64,"checksum":"e76d6cd62737ee05","exact_world_state_target_reached":37,"executed_path_length":245,"expansions":1769,"goal_expert_reached":43,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":288,"path_found":64,"path_length_regret":22,"state_aliasing_failures":6,"transition_model_error_failures":21},"retention_holdout":{"classification_checksum":"b534c2c9d063b814","correct":241,"expert_evaluations":2048,"prediction_checksum":"fe36ec6711fc3c2c","prediction_samples":234,"prediction_sse_q20":80862941846,"reconstruction_checksum":"6b53a0831c5a72a4","reconstruction_sse_q20":71121889464,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"48e410473a1157c4","transition_correct":221,"transition_supported":234,"transition_unknown":22},"training_evaluations":778360},"ravel_without_replay":{"checkpoint_size_bytes":46634,"drift_holdout":{"classification_checksum":"0fcae9662c28a7cc","correct":256,"expert_evaluations":2048,"prediction_checksum":"781c89b5cdefdb7e","prediction_samples":240,"prediction_sse_q20":106278149858,"reconstruction_checksum":"ab70b75e8ebc2e12","reconstruction_sse_q20":94473290688,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"4cf5c44ad6b5209c","transition_correct":229,"transition_supported":240,"transition_unknown":16},"expert_count":70,"planning":{"belief_set_target_reached":48,"cases":64,"checksum":"d76d2db9312ebca4","exact_world_state_target_reached":48,"executed_path_length":282,"expansions":2186,"goal_expert_reached":48,"graph_disconnection_failures":0,"no_supported_edge_failures":1,"optimal_path_length":288,"path_found":63,"path_length_regret":20,"state_aliasing_failures":0,"transition_model_error_failures":15},"retention_holdout":{"classification_checksum":"06cf2c4317dc7fa9","correct":256,"expert_evaluations":2048,"prediction_checksum":"4da059c99a544e96","prediction_samples":228,"prediction_sse_q20":36330628281,"reconstruction_checksum":"e515be85ac985a07","reconstruction_sse_q20":34581314232,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"d42622d4ec91b096","transition_correct":222,"transition_supported":228,"transition_unknown":28},"training_evaluations":1180792},"ravel_without_retirement_matched_work":{"checkpoint_size_bytes":46634,"drift_holdout":{"classification_checksum":"0fcae9662c28a7cc","correct":256,"expert_evaluations":2048,"prediction_checksum":"9278373a2568c9de","prediction_samples":242,"prediction_sse_q20":106895821632,"reconstruction_checksum":"0f39f875072e374d","reconstruction_sse_q20":95343125723,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"c1377e80fd5e99e8","transition_correct":231,"transition_supported":242,"transition_unknown":14},"expert_count":70,"planning":{"belief_set_target_reached":48,"cases":64,"checksum":"d76d2db9312ebca4","exact_world_state_target_reached":48,"executed_path_length":282,"expansions":2182,"goal_expert_reached":48,"graph_disconnection_failures":0,"no_supported_edge_failures":1,"optimal_path_length":288,"path_found":63,"path_length_regret":20,"state_aliasing_failures":0,"transition_model_error_failures":15},"retention_holdout":{"classification_checksum":"06cf2c4317dc7fa9","correct":256,"expert_evaluations":2048,"prediction_checksum":"48262ceb89e3d1c9","prediction_samples":229,"prediction_sse_q20":35046160031,"reconstruction_checksum":"2ea773000eb8818a","reconstruction_sse_q20":33057442468,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"91951de30a25f164","transition_correct":223,"transition_supported":229,"transition_unknown":27},"training_evaluations":1492600}},"dataset_seeds":{"base_holdout":"0xcbfbb96c937bca9f","base_training":"0xe547ba4bf5979bc9","drift_adaptation_training":"0xac8c80ca028fccf2","drift_holdout":"0xac1082a950d8681c","original_task_retention_holdout":"0x154604eb84976b6f","planning_cases":"0xe7be3664ecabae69"},"dataset_sizes":{"base_holdout":256,"base_training":1024,"drift_adaptation_training":512,"drift_holdout":256,"original_task_retention_holdout":256,"planning_cases":64},"integrity":{"checkpoint_behavior_match":true,"checkpoint_identity_match":true,"checkpoint_mutations":{"anchored_status":true,"appended_unexpected_byte":true,"checkpoint_substitution":true,"checkpoint_truncation":true,"incorrect_schema_version":true,"label":true,"label_count":true,"lineage":true,"next_observation_component":true,"payload_byte":true,"reconstruction_component":true,"retrieval_key_component":true,"transition_graph_edge":true,"transition_support":true},"checkpoint_roundtrip":true,"lineage_invariants":{"deterministic_topology_reproduction":true,"lineage_uniqueness":true,"no_accidental_lineage_reuse":true,"parent_child_generation_increment":true,"repeated_descendant_splitting":true,"sibling_generation_equality":true},"unsupported_graph_edge_violations":0},"regime":"observation_drift","schema":"ravel-raw-trial/0.5","seed":"0xb1c136bde36659bf","trial_id":"validation-observation-02"},{"candidate":{"adaptation_completed":true,"adaptation_training":{"classification_checksum":"47c632357c2e30e6","correct":512,"expert_evaluations":4096,"prediction_checksum":"4d0b701036f8137e","prediction_samples":484,"prediction_sse_q20":211052394987,"reconstruction_checksum":"3507693eed0d5db7","reconstruction_sse_q20":213618341293,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":512,"samples":512,"transition_checksum":"cc1761efc0c9e85a","transition_correct":472,"transition_supported":484,"transition_unknown":28},"adaptation_training_evaluations":571734,"adapted_model_drift_holdout":{"classification_checksum":"08217e7d5a34a4c9","correct":256,"expert_evaluations":2048,"prediction_checksum":"75f1723b4a81f82f","prediction_samples":239,"prediction_sse_q20":104723371006,"reconstruction_checksum":"5560077fcf19f58e","reconstruction_sse_q20":113936358396,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"938ff55793bad615","transition_correct":230,"transition_supported":239,"transition_unknown":17},"base_holdout":{"classification_checksum":"85d1ccd786860e05","correct":246,"expert_evaluations":2104,"prediction_checksum":"d07635c87dbd8df8","prediction_samples":239,"prediction_sse_q20":91384292777,"reconstruction_checksum":"41e1f1ecb88d2be6","reconstruction_sse_q20":72080573745,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":255,"samples":256,"transition_checksum":"632861016fed81a2","transition_correct":226,"transition_supported":239,"transition_unknown":17},"base_holdout_retention":{"classification_checksum":"f04656a28c0e850d","correct":256,"expert_evaluations":2048,"prediction_checksum":"f3a13b2b7b76e262","prediction_samples":240,"prediction_sse_q20":48899750409,"reconstruction_checksum":"33fc65cab5e48199","reconstruction_sse_q20":39410301176,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"7b26749e8711938c","transition_correct":232,"transition_supported":240,"transition_unknown":16},"base_training_evaluations":557736,"behavior_identity":"27c946dfd584f9034e2565909d434243803f74902d18ec450da905774efe7ec4","checkpoint_size_bytes":44924,"expert_count":67,"model_identity":"d2d7f18ef6a4b02015af0c4601db86e42d9d3d7c6a9ef9268cae4910fdc6500e","planning":{"belief_set_target_reached":64,"cases":64,"checksum":"f009c784bb303604","exact_world_state_target_reached":64,"executed_path_length":348,"expansions":2497,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":323,"path_found":64,"path_length_regret":25,"state_aliasing_failures":0,"transition_model_error_failures":0},"replay":{"actions_covered":4,"assigned_experts_covered":63,"high_loss_cases_selected":19,"labels_covered":8,"rare_cases_selected":53,"selected":256,"selection_checksum":"3e4de4e96f858ad8","states_covered":64,"transition_pairs_covered":251,"unique":256},"static_model_drift_holdout":{"classification_checksum":"06a361874fbfad58","correct":245,"expert_evaluations":2048,"prediction_checksum":"e803a3fb4572d0d2","prediction_samples":239,"prediction_sse_q20":158476034916,"reconstruction_checksum":"29860c7dc10cfcc5","reconstruction_sse_q20":146298460816,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"78d3ec500d39b2f5","transition_correct":224,"transition_supported":239,"transition_unknown":17},"topology":{"accepted_births":3,"accepted_retirements":0,"births":[{"dominant_channel":0,"event_index":41,"normalized_score_q20":545642},{"dominant_channel":0,"event_index":342,"normalized_score_q20":544317},{"dominant_channel":0,"event_index":284,"normalized_score_q20":503491}],"objective_after_q20":906849,"objective_before_q20":891270,"rejected_births":13,"rejected_retirements":1,"retired_lineages":[],"training_observations":{"births":3,"certified":7674,"expert_evaluations":571734,"rejected_births":13,"rejected_retirements":1,"retired":0,"samples":7680}}},"checkpoint_format":{"byte_order":"big_endian","magic_hex":"524156454c303500","payload_digest":"sha256","real_encoding":"signed_q20_int64","schema_version":5,"transition_support_min":2,"transition_top_k":2},"comparisons":{"fixed_8_expert":{"checkpoint_size_bytes":11294,"drift_holdout":{"classification_checksum":"10c2ce3aaaf97972","correct":55,"expert_evaluations":2048,"prediction_checksum":"d7c8918f32f74103","prediction_samples":256,"prediction_sse_q20":2129043108211,"reconstruction_checksum":"80ad37b1dc7848ca","reconstruction_sse_q20":1894193373668,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"b7d8f62262e89268","transition_correct":112,"transition_supported":256,"transition_unknown":0},"expert_count":8,"planning":{"belief_set_target_reached":9,"cases":64,"checksum":"e999b75bac439390","exact_world_state_target_reached":1,"executed_path_length":13,"expansions":130,"goal_expert_reached":9,"graph_disconnection_failures":48,"no_supported_edge_failures":0,"optimal_path_length":323,"path_found":16,"path_length_regret":0,"state_aliasing_failures":8,"transition_model_error_failures":7},"retention_holdout":{"classification_checksum":"cb25e3adf98439b1","correct":65,"expert_evaluations":2048,"prediction_checksum":"22612f5cfad06619","prediction_samples":256,"prediction_sse_q20":2012404976122,"reconstruction_checksum":"7d68b9b81574cc7b","reconstruction_sse_q20":1793521657167,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"e6c14b17fdab9a2f","transition_correct":101,"transition_supported":256,"transition_unknown":0},"training_evaluations":94208},"fixed_topology_64_expert_routed":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"5564c91428f38232","correct":256,"expert_evaluations":2048,"prediction_checksum":"43f98c9c3b69de24","prediction_samples":233,"prediction_sse_q20":86051244775,"reconstruction_checksum":"896557cbe19148ff","reconstruction_sse_q20":97796938428,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"615e0d7a38c90cb2","transition_correct":233,"transition_supported":233,"transition_unknown":23},"expert_count":64,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"c0839744b1e7cbb1","exact_world_state_target_reached":64,"executed_path_length":348,"expansions":2428,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":323,"path_found":64,"path_length_regret":25,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"486dd695495839cc","correct":256,"expert_evaluations":2048,"prediction_checksum":"6f9a10c284d21c5a","prediction_samples":233,"prediction_sse_q20":23713462902,"reconstruction_checksum":"eb764e6ac5fc9c13","reconstruction_sse_q20":23805771685,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"43f267f5653f27fd","transition_correct":233,"transition_supported":233,"transition_unknown":23},"training_evaluations":2588672},"flat_64_expert_complete_scan":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"5564c91428f38232","correct":256,"expert_evaluations":16384,"prediction_checksum":"43f98c9c3b69de24","prediction_samples":233,"prediction_sse_q20":86051244775,"reconstruction_checksum":"896557cbe19148ff","reconstruction_sse_q20":97796938428,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"615e0d7a38c90cb2","transition_correct":233,"transition_supported":233,"transition_unknown":23},"expert_count":64,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"c0839744b1e7cbb1","exact_world_state_target_reached":64,"executed_path_length":348,"expansions":2428,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":323,"path_found":64,"path_length_regret":25,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"486dd695495839cc","correct":256,"expert_evaluations":16384,"prediction_checksum":"6f9a10c284d21c5a","prediction_samples":233,"prediction_sse_q20":23713462902,"reconstruction_checksum":"eb764e6ac5fc9c13","reconstruction_sse_q20":23805771685,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"43f267f5653f27fd","transition_correct":233,"transition_supported":233,"transition_unknown":23},"training_evaluations":2588672},"matched_compute_fixed_topology":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"06a361874fbfad58","correct":245,"expert_evaluations":2048,"prediction_checksum":"e803a3fb4572d0d2","prediction_samples":239,"prediction_sse_q20":158476034916,"reconstruction_checksum":"29860c7dc10cfcc5","reconstruction_sse_q20":146298460816,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"78d3ec500d39b2f5","transition_correct":224,"transition_supported":239,"transition_unknown":17},"expert_count":64,"planning":{"belief_set_target_reached":42,"cases":64,"checksum":"5c2c6b2d7a800ed6","exact_world_state_target_reached":41,"executed_path_length":332,"expansions":2366,"goal_expert_reached":42,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":323,"path_found":64,"path_length_regret":6,"state_aliasing_failures":1,"transition_model_error_failures":22},"retention_holdout":{"classification_checksum":"2302d1e35823b53f","correct":240,"expert_evaluations":2104,"prediction_checksum":"08b7d5fffd4919dd","prediction_samples":243,"prediction_sse_q20":139965626839,"reconstruction_checksum":"d5fb9c0fa319afce","reconstruction_sse_q20":95234302242,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":255,"samples":256,"transition_checksum":"1aac80c85b0fe3a0","transition_correct":228,"transition_supported":243,"transition_unknown":13},"training_evaluations":1223304},"matched_expert_count_capacity":{"checkpoint_size_bytes":44924,"drift_holdout":{"classification_checksum":"9100178a030fcbd4","correct":256,"expert_evaluations":2048,"prediction_checksum":"e438ff8019ce03af","prediction_samples":227,"prediction_sse_q20":84221742683,"reconstruction_checksum":"1cf9e2deba31bcd7","reconstruction_sse_q20":97497206876,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"9bcbef8c968ec5ea","transition_correct":224,"transition_supported":227,"transition_unknown":29},"expert_count":67,"planning":{"belief_set_target_reached":63,"cases":64,"checksum":"b3ef93ad8c29e713","exact_world_state_target_reached":63,"executed_path_length":353,"expansions":2524,"goal_expert_reached":63,"graph_disconnection_failures":0,"no_supported_edge_failures":1,"optimal_path_length":323,"path_found":63,"path_length_regret":36,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"e3b46f2b189afe24","correct":256,"expert_evaluations":2048,"prediction_checksum":"ae81b4b3d7ff5e40","prediction_samples":230,"prediction_sse_q20":23471798767,"reconstruction_checksum":"6624994f8427870b","reconstruction_sse_q20":23806632076,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"4aacfcb5fce1ace6","transition_correct":227,"transition_supported":230,"transition_unknown":26},"training_evaluations":2812928},"nearest_centroid_16_no_recursive_births":{"checkpoint_size_bytes":15854,"drift_holdout":{"classification_checksum":"217cea6199be0390","correct":63,"expert_evaluations":4096,"prediction_checksum":"fc230f88630d0655","prediction_samples":256,"prediction_sse_q20":1254975927496,"reconstruction_checksum":"11eefffd3fc9eedc","reconstruction_sse_q20":1227809369711,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"fd649c6c97752c58","transition_correct":155,"transition_supported":256,"transition_unknown":0},"expert_count":16,"planning":{"belief_set_target_reached":31,"cases":64,"checksum":"023507a1526ed043","exact_world_state_target_reached":4,"executed_path_length":164,"expansions":536,"goal_expert_reached":31,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":323,"path_found":64,"path_length_regret":0,"state_aliasing_failures":27,"transition_model_error_failures":33},"retention_holdout":{"classification_checksum":"0ec09b9e7cc3cba8","correct":55,"expert_evaluations":4096,"prediction_checksum":"9824f1a681214062","prediction_samples":256,"prediction_sse_q20":1247645690731,"reconstruction_checksum":"daf16f8cd208fc3c","reconstruction_sse_q20":1160678624204,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"0aaa5072a6cde75d","transition_correct":158,"transition_supported":256,"transition_unknown":0},"training_evaluations":253952},"no_adaptation_static":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"06a361874fbfad58","correct":245,"expert_evaluations":2048,"prediction_checksum":"e803a3fb4572d0d2","prediction_samples":239,"prediction_sse_q20":158476034916,"reconstruction_checksum":"29860c7dc10cfcc5","reconstruction_sse_q20":146298460816,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"78d3ec500d39b2f5","transition_correct":224,"transition_supported":239,"transition_unknown":17},"expert_count":64,"planning":{"belief_set_target_reached":42,"cases":64,"checksum":"5c2c6b2d7a800ed6","exact_world_state_target_reached":41,"executed_path_length":332,"expansions":2366,"goal_expert_reached":42,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":323,"path_found":64,"path_length_regret":6,"state_aliasing_failures":1,"transition_model_error_failures":22},"retention_holdout":{"classification_checksum":"2302d1e35823b53f","correct":240,"expert_evaluations":2104,"prediction_checksum":"08b7d5fffd4919dd","prediction_samples":243,"prediction_sse_q20":139965626839,"reconstruction_checksum":"d5fb9c0fa319afce","reconstruction_sse_q20":95234302242,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":255,"samples":256,"transition_checksum":"1aac80c85b0fe3a0","transition_correct":228,"transition_supported":243,"transition_unknown":13},"training_evaluations":557736},"periodic_replay_policy":{"checkpoint_size_bytes":44924,"drift_holdout":{"classification_checksum":"08217e7d5a34a4c9","correct":256,"expert_evaluations":2048,"prediction_checksum":"e58337df1d1e55cc","prediction_samples":236,"prediction_sse_q20":104095511970,"reconstruction_checksum":"a02f9b1c6324d754","reconstruction_sse_q20":113815708669,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"d72c27fcae3c98bb","transition_correct":227,"transition_supported":236,"transition_unknown":20},"expert_count":67,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"1aea7107a3401169","exact_world_state_target_reached":64,"executed_path_length":352,"expansions":2489,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":323,"path_found":64,"path_length_regret":29,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"f04656a28c0e850d","correct":256,"expert_evaluations":2048,"prediction_checksum":"784c7fae2b3d16f8","prediction_samples":237,"prediction_sse_q20":48610784445,"reconstruction_checksum":"6822c52d2ad8e53e","reconstruction_sse_q20":39951169851,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"e3af3cfc34d5859d","transition_correct":229,"transition_supported":237,"transition_unknown":19},"training_evaluations":1129242},"ravel_0_5_candidate":{"checkpoint_size_bytes":44924,"drift_holdout":{"classification_checksum":"08217e7d5a34a4c9","correct":256,"expert_evaluations":2048,"prediction_checksum":"75f1723b4a81f82f","prediction_samples":239,"prediction_sse_q20":104723371006,"reconstruction_checksum":"5560077fcf19f58e","reconstruction_sse_q20":113936358396,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"938ff55793bad615","transition_correct":230,"transition_supported":239,"transition_unknown":17},"expert_count":67,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"f009c784bb303604","exact_world_state_target_reached":64,"executed_path_length":348,"expansions":2497,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":323,"path_found":64,"path_length_regret":25,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"f04656a28c0e850d","correct":256,"expert_evaluations":2048,"prediction_checksum":"f3a13b2b7b76e262","prediction_samples":240,"prediction_sse_q20":48899750409,"reconstruction_checksum":"33fc65cab5e48199","reconstruction_sse_q20":39410301176,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"7b26749e8711938c","transition_correct":232,"transition_supported":240,"transition_unknown":16},"training_evaluations":1129470},"ravel_complete_scan_without_certification":{"checkpoint_size_bytes":44924,"drift_holdout":{"classification_checksum":"08217e7d5a34a4c9","correct":256,"expert_evaluations":17152,"prediction_checksum":"75f1723b4a81f82f","prediction_samples":239,"prediction_sse_q20":104723371006,"reconstruction_checksum":"5560077fcf19f58e","reconstruction_sse_q20":113936358396,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"938ff55793bad615","transition_correct":230,"transition_supported":239,"transition_unknown":17},"expert_count":67,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"f009c784bb303604","exact_world_state_target_reached":64,"executed_path_length":348,"expansions":2497,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":323,"path_found":64,"path_length_regret":25,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"f04656a28c0e850d","correct":256,"expert_evaluations":17152,"prediction_checksum":"f3a13b2b7b76e262","prediction_samples":240,"prediction_sse_q20":48899750409,"reconstruction_checksum":"33fc65cab5e48199","reconstruction_sse_q20":39410301176,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"7b26749e8711938c","transition_correct":232,"transition_supported":240,"transition_unknown":16},"training_evaluations":1310718},"ravel_no_birth_same_replay_iterations":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"06a361874fbfad58","correct":245,"expert_evaluations":2048,"prediction_checksum":"e803a3fb4572d0d2","prediction_samples":239,"prediction_sse_q20":158476034916,"reconstruction_checksum":"29860c7dc10cfcc5","reconstruction_sse_q20":146298460816,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"78d3ec500d39b2f5","transition_correct":224,"transition_supported":239,"transition_unknown":17},"expert_count":64,"planning":{"belief_set_target_reached":42,"cases":64,"checksum":"5c2c6b2d7a800ed6","exact_world_state_target_reached":41,"executed_path_length":332,"expansions":2366,"goal_expert_reached":42,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":323,"path_found":64,"path_length_regret":6,"state_aliasing_failures":1,"transition_model_error_failures":22},"retention_holdout":{"classification_checksum":"2302d1e35823b53f","correct":240,"expert_evaluations":2104,"prediction_checksum":"08b7d5fffd4919dd","prediction_samples":243,"prediction_sse_q20":139965626839,"reconstruction_checksum":"d5fb9c0fa319afce","reconstruction_sse_q20":95234302242,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":255,"samples":256,"transition_checksum":"1aac80c85b0fe3a0","transition_correct":228,"transition_supported":243,"transition_unknown":13},"training_evaluations":779592},"ravel_random_births":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"06a361874fbfad58","correct":245,"expert_evaluations":2048,"prediction_checksum":"e803a3fb4572d0d2","prediction_samples":239,"prediction_sse_q20":158476034916,"reconstruction_checksum":"29860c7dc10cfcc5","reconstruction_sse_q20":146298460816,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"78d3ec500d39b2f5","transition_correct":224,"transition_supported":239,"transition_unknown":17},"expert_count":64,"planning":{"belief_set_target_reached":42,"cases":64,"checksum":"5c2c6b2d7a800ed6","exact_world_state_target_reached":41,"executed_path_length":332,"expansions":2366,"goal_expert_reached":42,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":323,"path_found":64,"path_length_regret":6,"state_aliasing_failures":1,"transition_model_error_failures":22},"retention_holdout":{"classification_checksum":"2302d1e35823b53f","correct":240,"expert_evaluations":2104,"prediction_checksum":"08b7d5fffd4919dd","prediction_samples":243,"prediction_sse_q20":139965626839,"reconstruction_checksum":"d5fb9c0fa319afce","reconstruction_sse_q20":95234302242,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":255,"samples":256,"transition_checksum":"1aac80c85b0fe3a0","transition_correct":228,"transition_supported":243,"transition_unknown":13},"training_evaluations":779592},"ravel_without_replay":{"checkpoint_size_bytes":44924,"drift_holdout":{"classification_checksum":"08217e7d5a34a4c9","correct":256,"expert_evaluations":2048,"prediction_checksum":"9a7e53a0743ef024","prediction_samples":233,"prediction_sse_q20":103730891800,"reconstruction_checksum":"a9f15d8a7946c921","reconstruction_sse_q20":113803001961,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"60be0fe399f8ff6c","transition_correct":224,"transition_supported":233,"transition_unknown":23},"expert_count":67,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"1aea7107a3401169","exact_world_state_target_reached":64,"executed_path_length":352,"expansions":2485,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":323,"path_found":64,"path_length_regret":29,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"f04656a28c0e850d","correct":256,"expert_evaluations":2048,"prediction_checksum":"8f67530be5f37dcf","prediction_samples":234,"prediction_sse_q20":48240133801,"reconstruction_checksum":"adb865ff4b72ee7c","reconstruction_sse_q20":40213729607,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"88601dfcfa21a89a","transition_correct":226,"transition_supported":234,"transition_unknown":22},"training_evaluations":938778},"ravel_without_retirement_matched_work":{"checkpoint_size_bytes":44924,"drift_holdout":{"classification_checksum":"08217e7d5a34a4c9","correct":256,"expert_evaluations":2048,"prediction_checksum":"75f1723b4a81f82f","prediction_samples":239,"prediction_sse_q20":104723371006,"reconstruction_checksum":"5560077fcf19f58e","reconstruction_sse_q20":113936358396,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"938ff55793bad615","transition_correct":230,"transition_supported":239,"transition_unknown":17},"expert_count":67,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"f009c784bb303604","exact_world_state_target_reached":64,"executed_path_length":348,"expansions":2497,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":323,"path_found":64,"path_length_regret":25,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"f04656a28c0e850d","correct":256,"expert_evaluations":2048,"prediction_checksum":"f3a13b2b7b76e262","prediction_samples":240,"prediction_sse_q20":48899750409,"reconstruction_checksum":"33fc65cab5e48199","reconstruction_sse_q20":39410301176,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"7b26749e8711938c","transition_correct":232,"transition_supported":240,"transition_unknown":16},"training_evaluations":1129470}},"dataset_seeds":{"base_holdout":"0x2b7a081943bef09f","base_training":"0x569f44674285726c","drift_adaptation_training":"0x2b97afb83cacdf9f","drift_holdout":"0xa031761dbf2f157c","original_task_retention_holdout":"0xa799301d9a26321a","planning_cases":"0xf89a22d36f4b5e43"},"dataset_sizes":{"base_holdout":256,"base_training":1024,"drift_adaptation_training":512,"drift_holdout":256,"original_task_retention_holdout":256,"planning_cases":64},"integrity":{"checkpoint_behavior_match":true,"checkpoint_identity_match":true,"checkpoint_mutations":{"anchored_status":true,"appended_unexpected_byte":true,"checkpoint_substitution":true,"checkpoint_truncation":true,"incorrect_schema_version":true,"label":true,"label_count":true,"lineage":true,"next_observation_component":true,"payload_byte":true,"reconstruction_component":true,"retrieval_key_component":true,"transition_graph_edge":true,"transition_support":true},"checkpoint_roundtrip":true,"lineage_invariants":{"deterministic_topology_reproduction":true,"lineage_uniqueness":true,"no_accidental_lineage_reuse":true,"parent_child_generation_increment":true,"repeated_descendant_splitting":true,"sibling_generation_equality":true},"unsupported_graph_edge_violations":0},"regime":"observation_drift","schema":"ravel-raw-trial/0.5","seed":"0xcdfacd756a25c973","trial_id":"validation-observation-03"},{"candidate":{"adaptation_completed":true,"adaptation_training":{"classification_checksum":"2f05e5c8a0d97345","correct":512,"expert_evaluations":4096,"prediction_checksum":"7f619e8b9d03ad19","prediction_samples":477,"prediction_sse_q20":185082314262,"reconstruction_checksum":"0b99e5d88cf14016","reconstruction_sse_q20":170819637308,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":512,"samples":512,"transition_checksum":"e33ca57f80c50311","transition_correct":443,"transition_supported":477,"transition_unknown":35},"adaptation_training_evaluations":935424,"adapted_model_drift_holdout":{"classification_checksum":"7ad1223eaad7af78","correct":256,"expert_evaluations":2048,"prediction_checksum":"9e271540dfc70c02","prediction_samples":236,"prediction_sse_q20":90160471148,"reconstruction_checksum":"23ac48c5b2ad7b4d","reconstruction_sse_q20":81997478952,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"ca37dba8ef4d9142","transition_correct":220,"transition_supported":236,"transition_unknown":20},"base_holdout":{"classification_checksum":"f87eeaa46b98bb61","correct":247,"expert_evaluations":2048,"prediction_checksum":"8cde5ef41e413af3","prediction_samples":236,"prediction_sse_q20":74472798836,"reconstruction_checksum":"b2f57a61c4537ba7","reconstruction_sse_q20":62087959956,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"c851770afe38d691","transition_correct":228,"transition_supported":236,"transition_unknown":20},"base_holdout_retention":{"classification_checksum":"a73805265242eaac","correct":256,"expert_evaluations":2048,"prediction_checksum":"d26f4f5c87c92cf1","prediction_samples":230,"prediction_sse_q20":34558242377,"reconstruction_checksum":"1474499e0caf7a7c","reconstruction_sse_q20":28927510487,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"69fa7d6016cbf1dc","transition_correct":227,"transition_supported":230,"transition_unknown":26},"base_training_evaluations":556056,"behavior_identity":"1f15d899fbd2448366c18764db5c701dde258adb31bb1d8f247f14068fef7bf0","checkpoint_size_bytes":46634,"expert_count":70,"model_identity":"44161e981086a6bfb6ad487f325bf0bb0907798818def7dd8e5bf75265bc4a49","planning":{"belief_set_target_reached":52,"cases":64,"checksum":"49aeefb73c04a34f","exact_world_state_target_reached":52,"executed_path_length":302,"expansions":2482,"goal_expert_reached":52,"graph_disconnection_failures":0,"no_supported_edge_failures":4,"optimal_path_length":320,"path_found":60,"path_length_regret":11,"state_aliasing_failures":0,"transition_model_error_failures":8},"replay":{"actions_covered":4,"assigned_experts_covered":62,"high_loss_cases_selected":24,"labels_covered":8,"rare_cases_selected":56,"selected":256,"selection_checksum":"281ecdc1f2be95c5","states_covered":64,"transition_pairs_covered":251,"unique":256},"static_model_drift_holdout":{"classification_checksum":"13f057001e50b3e7","correct":245,"expert_evaluations":2104,"prediction_checksum":"e1d3ccaea1290b22","prediction_samples":238,"prediction_sse_q20":136470797889,"reconstruction_checksum":"8c9b760cd39c57dc","reconstruction_sse_q20":135127182724,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":255,"samples":256,"transition_checksum":"fe524b5d86c632c3","transition_correct":229,"transition_supported":238,"transition_unknown":18},"topology":{"accepted_births":6,"accepted_retirements":0,"births":[{"dominant_channel":0,"event_index":255,"normalized_score_q20":539768},{"dominant_channel":0,"event_index":174,"normalized_score_q20":513630},{"dominant_channel":2,"event_index":103,"normalized_score_q20":316036},{"dominant_channel":2,"event_index":428,"normalized_score_q20":309148},{"dominant_channel":2,"event_index":227,"normalized_score_q20":305889},{"dominant_channel":2,"event_index":256,"normalized_score_q20":304698}],"objective_after_q20":907470,"objective_before_q20":896792,"rejected_births":10,"rejected_retirements":1,"retired_lineages":[],"training_observations":{"births":6,"certified":12288,"expert_evaluations":935424,"rejected_births":10,"rejected_retirements":1,"retired":0,"samples":12288}}},"checkpoint_format":{"byte_order":"big_endian","magic_hex":"524156454c303500","payload_digest":"sha256","real_encoding":"signed_q20_int64","schema_version":5,"transition_support_min":2,"transition_top_k":2},"comparisons":{"fixed_8_expert":{"checkpoint_size_bytes":11294,"drift_holdout":{"classification_checksum":"aa508e43057d3226","correct":60,"expert_evaluations":2048,"prediction_checksum":"bada9445ba260490","prediction_samples":256,"prediction_sse_q20":2027581075613,"reconstruction_checksum":"bb4d9110518c7a3f","reconstruction_sse_q20":1790305986880,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"00274f4d337eaf51","transition_correct":106,"transition_supported":256,"transition_unknown":0},"expert_count":8,"planning":{"belief_set_target_reached":18,"cases":64,"checksum":"46b5bca67d5c076d","exact_world_state_target_reached":0,"executed_path_length":55,"expansions":222,"goal_expert_reached":18,"graph_disconnection_failures":30,"no_supported_edge_failures":0,"optimal_path_length":320,"path_found":34,"path_length_regret":0,"state_aliasing_failures":18,"transition_model_error_failures":16},"retention_holdout":{"classification_checksum":"6cbab1edcb23917d","correct":66,"expert_evaluations":2048,"prediction_checksum":"fc9534d5bf05adc0","prediction_samples":256,"prediction_sse_q20":2044341901239,"reconstruction_checksum":"d81445ba51373bd3","reconstruction_sse_q20":1798535774292,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"af988de88d64f7c7","transition_correct":114,"transition_supported":256,"transition_unknown":0},"training_evaluations":94208},"fixed_topology_64_expert_routed":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"834daf8d5f5a4d1e","correct":256,"expert_evaluations":2048,"prediction_checksum":"edf808efd0c0880e","prediction_samples":231,"prediction_sse_q20":86848160889,"reconstruction_checksum":"d72382a7702da0d7","reconstruction_sse_q20":88005712578,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"a4c7fccf4fd83a10","transition_correct":231,"transition_supported":231,"transition_unknown":25},"expert_count":64,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"258abdbb34bdd0e4","exact_world_state_target_reached":64,"executed_path_length":337,"expansions":2325,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":320,"path_found":64,"path_length_regret":17,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"10388a221b01fb82","correct":256,"expert_evaluations":2048,"prediction_checksum":"7bc4e6614459c6f1","prediction_samples":226,"prediction_sse_q20":24633677022,"reconstruction_checksum":"0fa22dad2a167fda","reconstruction_sse_q20":22747239532,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"940f98cd1ee6f0ea","transition_correct":226,"transition_supported":226,"transition_unknown":30},"training_evaluations":2588672},"flat_64_expert_complete_scan":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"834daf8d5f5a4d1e","correct":256,"expert_evaluations":16384,"prediction_checksum":"edf808efd0c0880e","prediction_samples":231,"prediction_sse_q20":86848160889,"reconstruction_checksum":"d72382a7702da0d7","reconstruction_sse_q20":88005712578,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"a4c7fccf4fd83a10","transition_correct":231,"transition_supported":231,"transition_unknown":25},"expert_count":64,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"258abdbb34bdd0e4","exact_world_state_target_reached":64,"executed_path_length":337,"expansions":2325,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":320,"path_found":64,"path_length_regret":17,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"10388a221b01fb82","correct":256,"expert_evaluations":16384,"prediction_checksum":"7bc4e6614459c6f1","prediction_samples":226,"prediction_sse_q20":24633677022,"reconstruction_checksum":"0fa22dad2a167fda","reconstruction_sse_q20":22747239532,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"940f98cd1ee6f0ea","transition_correct":226,"transition_supported":226,"transition_unknown":30},"training_evaluations":2588672},"matched_compute_fixed_topology":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"13f057001e50b3e7","correct":245,"expert_evaluations":2104,"prediction_checksum":"e1d3ccaea1290b22","prediction_samples":238,"prediction_sse_q20":136470797889,"reconstruction_checksum":"8c9b760cd39c57dc","reconstruction_sse_q20":135127182724,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":255,"samples":256,"transition_checksum":"fe524b5d86c632c3","transition_correct":229,"transition_supported":238,"transition_unknown":18},"expert_count":64,"planning":{"belief_set_target_reached":41,"cases":64,"checksum":"c3b3d10e421af7d6","exact_world_state_target_reached":41,"executed_path_length":290,"expansions":2212,"goal_expert_reached":41,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":320,"path_found":64,"path_length_regret":6,"state_aliasing_failures":0,"transition_model_error_failures":23},"retention_holdout":{"classification_checksum":"567563ca4aed7047","correct":248,"expert_evaluations":2048,"prediction_checksum":"48b7615078f8af80","prediction_samples":230,"prediction_sse_q20":76724345455,"reconstruction_checksum":"f2e2fd66f62871e0","reconstruction_sse_q20":60486980484,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"d687df4bed9b0c58","transition_correct":222,"transition_supported":230,"transition_unknown":26},"training_evaluations":1661976},"matched_expert_count_capacity":{"checkpoint_size_bytes":46634,"drift_holdout":{"classification_checksum":"f69545b1b7ae7f2b","correct":256,"expert_evaluations":2048,"prediction_checksum":"c0f0bad18fb3714e","prediction_samples":225,"prediction_sse_q20":84927897604,"reconstruction_checksum":"7eb4d9b8cd351f85","reconstruction_sse_q20":87738635640,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"a7e015edb15ea79b","transition_correct":220,"transition_supported":225,"transition_unknown":31},"expert_count":70,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"c19cf842770c9856","exact_world_state_target_reached":64,"executed_path_length":346,"expansions":2492,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":320,"path_found":64,"path_length_regret":26,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"e54ce891f8bed164","correct":256,"expert_evaluations":2048,"prediction_checksum":"3e528774f9637e52","prediction_samples":223,"prediction_sse_q20":24484770441,"reconstruction_checksum":"d613648073823d4e","reconstruction_sse_q20":22546835659,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"876d15be1a16c948","transition_correct":216,"transition_supported":223,"transition_unknown":33},"training_evaluations":3046400},"nearest_centroid_16_no_recursive_births":{"checkpoint_size_bytes":15854,"drift_holdout":{"classification_checksum":"5ac291c9a089cec7","correct":72,"expert_evaluations":4096,"prediction_checksum":"17aacd8931825d9c","prediction_samples":256,"prediction_sse_q20":1435181947238,"reconstruction_checksum":"b2ad959d7b414d36","reconstruction_sse_q20":1201155306168,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"3b1ae6c4d3e6a900","transition_correct":137,"transition_supported":256,"transition_unknown":0},"expert_count":16,"planning":{"belief_set_target_reached":30,"cases":64,"checksum":"87bf348de6f4ac47","exact_world_state_target_reached":6,"executed_path_length":125,"expansions":528,"goal_expert_reached":30,"graph_disconnection_failures":23,"no_supported_edge_failures":0,"optimal_path_length":320,"path_found":41,"path_length_regret":4,"state_aliasing_failures":24,"transition_model_error_failures":11},"retention_holdout":{"classification_checksum":"139ab18844e767fe","correct":66,"expert_evaluations":4096,"prediction_checksum":"ff6a39f7dcb1e50f","prediction_samples":256,"prediction_sse_q20":1500567447792,"reconstruction_checksum":"058bffbace865ed9","reconstruction_sse_q20":1228675342618,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"c33e52169a6affcd","transition_correct":133,"transition_supported":256,"transition_unknown":0},"training_evaluations":253952},"no_adaptation_static":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"13f057001e50b3e7","correct":245,"expert_evaluations":2104,"prediction_checksum":"e1d3ccaea1290b22","prediction_samples":238,"prediction_sse_q20":136470797889,"reconstruction_checksum":"8c9b760cd39c57dc","reconstruction_sse_q20":135127182724,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":255,"samples":256,"transition_checksum":"fe524b5d86c632c3","transition_correct":229,"transition_supported":238,"transition_unknown":18},"expert_count":64,"planning":{"belief_set_target_reached":41,"cases":64,"checksum":"c3b3d10e421af7d6","exact_world_state_target_reached":41,"executed_path_length":290,"expansions":2212,"goal_expert_reached":41,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":320,"path_found":64,"path_length_regret":6,"state_aliasing_failures":0,"transition_model_error_failures":23},"retention_holdout":{"classification_checksum":"567563ca4aed7047","correct":248,"expert_evaluations":2048,"prediction_checksum":"48b7615078f8af80","prediction_samples":230,"prediction_sse_q20":76724345455,"reconstruction_checksum":"f2e2fd66f62871e0","reconstruction_sse_q20":60486980484,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"d687df4bed9b0c58","transition_correct":222,"transition_supported":230,"transition_unknown":26},"training_evaluations":556056},"periodic_replay_policy":{"checkpoint_size_bytes":46634,"drift_holdout":{"classification_checksum":"7ad1223eaad7af78","correct":256,"expert_evaluations":2048,"prediction_checksum":"a0314f710b642293","prediction_samples":235,"prediction_sse_q20":90056662138,"reconstruction_checksum":"4f5d4705b2f22bd9","reconstruction_sse_q20":82069539176,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"99507f4b8b9fcf26","transition_correct":219,"transition_supported":235,"transition_unknown":21},"expert_count":70,"planning":{"belief_set_target_reached":52,"cases":64,"checksum":"49aeefb73c04a34f","exact_world_state_target_reached":52,"executed_path_length":302,"expansions":2477,"goal_expert_reached":52,"graph_disconnection_failures":0,"no_supported_edge_failures":4,"optimal_path_length":320,"path_found":60,"path_length_regret":11,"state_aliasing_failures":0,"transition_model_error_failures":8},"retention_holdout":{"classification_checksum":"a73805265242eaac","correct":256,"expert_evaluations":2048,"prediction_checksum":"29ee9c3b9e5d6597","prediction_samples":229,"prediction_sse_q20":34322429241,"reconstruction_checksum":"eb3e79c42cb20029","reconstruction_sse_q20":28973143593,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"19a9a534020ef114","transition_correct":226,"transition_supported":229,"transition_unknown":27},"training_evaluations":1491480},"ravel_0_5_candidate":{"checkpoint_size_bytes":46634,"drift_holdout":{"classification_checksum":"7ad1223eaad7af78","correct":256,"expert_evaluations":2048,"prediction_checksum":"9e271540dfc70c02","prediction_samples":236,"prediction_sse_q20":90160471148,"reconstruction_checksum":"23ac48c5b2ad7b4d","reconstruction_sse_q20":81997478952,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"ca37dba8ef4d9142","transition_correct":220,"transition_supported":236,"transition_unknown":20},"expert_count":70,"planning":{"belief_set_target_reached":52,"cases":64,"checksum":"49aeefb73c04a34f","exact_world_state_target_reached":52,"executed_path_length":302,"expansions":2482,"goal_expert_reached":52,"graph_disconnection_failures":0,"no_supported_edge_failures":4,"optimal_path_length":320,"path_found":60,"path_length_regret":11,"state_aliasing_failures":0,"transition_model_error_failures":8},"retention_holdout":{"classification_checksum":"a73805265242eaac","correct":256,"expert_evaluations":2048,"prediction_checksum":"d26f4f5c87c92cf1","prediction_samples":230,"prediction_sse_q20":34558242377,"reconstruction_checksum":"1474499e0caf7a7c","reconstruction_sse_q20":28927510487,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"69fa7d6016cbf1dc","transition_correct":227,"transition_supported":230,"transition_unknown":26},"training_evaluations":1491480},"ravel_complete_scan_without_certification":{"checkpoint_size_bytes":46634,"drift_holdout":{"classification_checksum":"7ad1223eaad7af78","correct":256,"expert_evaluations":17920,"prediction_checksum":"9e271540dfc70c02","prediction_samples":236,"prediction_sse_q20":90160471148,"reconstruction_checksum":"23ac48c5b2ad7b4d","reconstruction_sse_q20":81997478952,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"ca37dba8ef4d9142","transition_correct":220,"transition_supported":236,"transition_unknown":20},"expert_count":70,"planning":{"belief_set_target_reached":52,"cases":64,"checksum":"49aeefb73c04a34f","exact_world_state_target_reached":52,"executed_path_length":302,"expansions":2482,"goal_expert_reached":52,"graph_disconnection_failures":0,"no_supported_edge_failures":4,"optimal_path_length":320,"path_found":60,"path_length_regret":11,"state_aliasing_failures":0,"transition_model_error_failures":8},"retention_holdout":{"classification_checksum":"a73805265242eaac","correct":256,"expert_evaluations":17920,"prediction_checksum":"d26f4f5c87c92cf1","prediction_samples":230,"prediction_sse_q20":34558242377,"reconstruction_checksum":"1474499e0caf7a7c","reconstruction_sse_q20":28927510487,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"69fa7d6016cbf1dc","transition_correct":227,"transition_supported":230,"transition_unknown":26},"training_evaluations":1681944},"ravel_no_birth_same_replay_iterations":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"13f057001e50b3e7","correct":245,"expert_evaluations":2104,"prediction_checksum":"e1d3ccaea1290b22","prediction_samples":238,"prediction_sse_q20":136470797889,"reconstruction_checksum":"8c9b760cd39c57dc","reconstruction_sse_q20":135127182724,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":255,"samples":256,"transition_checksum":"fe524b5d86c632c3","transition_correct":229,"transition_supported":238,"transition_unknown":18},"expert_count":64,"planning":{"belief_set_target_reached":41,"cases":64,"checksum":"c3b3d10e421af7d6","exact_world_state_target_reached":41,"executed_path_length":290,"expansions":2212,"goal_expert_reached":41,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":320,"path_found":64,"path_length_regret":6,"state_aliasing_failures":0,"transition_model_error_failures":23},"retention_holdout":{"classification_checksum":"567563ca4aed7047","correct":248,"expert_evaluations":2048,"prediction_checksum":"48b7615078f8af80","prediction_samples":230,"prediction_sse_q20":76724345455,"reconstruction_checksum":"f2e2fd66f62871e0","reconstruction_sse_q20":60486980484,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"d687df4bed9b0c58","transition_correct":222,"transition_supported":230,"transition_unknown":26},"training_evaluations":777240},"ravel_random_births":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"13f057001e50b3e7","correct":245,"expert_evaluations":2104,"prediction_checksum":"e1d3ccaea1290b22","prediction_samples":238,"prediction_sse_q20":136470797889,"reconstruction_checksum":"8c9b760cd39c57dc","reconstruction_sse_q20":135127182724,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":255,"samples":256,"transition_checksum":"fe524b5d86c632c3","transition_correct":229,"transition_supported":238,"transition_unknown":18},"expert_count":64,"planning":{"belief_set_target_reached":41,"cases":64,"checksum":"c3b3d10e421af7d6","exact_world_state_target_reached":41,"executed_path_length":290,"expansions":2212,"goal_expert_reached":41,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":320,"path_found":64,"path_length_regret":6,"state_aliasing_failures":0,"transition_model_error_failures":23},"retention_holdout":{"classification_checksum":"567563ca4aed7047","correct":248,"expert_evaluations":2048,"prediction_checksum":"48b7615078f8af80","prediction_samples":230,"prediction_sse_q20":76724345455,"reconstruction_checksum":"f2e2fd66f62871e0","reconstruction_sse_q20":60486980484,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"d687df4bed9b0c58","transition_correct":222,"transition_supported":230,"transition_unknown":26},"training_evaluations":777240},"ravel_without_replay":{"checkpoint_size_bytes":46064,"drift_holdout":{"classification_checksum":"1d175c80594019d1","correct":256,"expert_evaluations":2048,"prediction_checksum":"50f1f6915635302f","prediction_samples":235,"prediction_sse_q20":89430360510,"reconstruction_checksum":"8ebb58f8e0285f00","reconstruction_sse_q20":82029013745,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"231d146d32f885f6","transition_correct":221,"transition_supported":235,"transition_unknown":21},"expert_count":69,"planning":{"belief_set_target_reached":52,"cases":64,"checksum":"c82c6b3d480f14d6","exact_world_state_target_reached":52,"executed_path_length":304,"expansions":2487,"goal_expert_reached":52,"graph_disconnection_failures":0,"no_supported_edge_failures":4,"optimal_path_length":320,"path_found":60,"path_length_regret":13,"state_aliasing_failures":0,"transition_model_error_failures":8},"retention_holdout":{"classification_checksum":"a73805265242eaac","correct":256,"expert_evaluations":2048,"prediction_checksum":"d5b9a37f05d57358","prediction_samples":229,"prediction_sse_q20":35355043599,"reconstruction_checksum":"583470e74afe8c2c","reconstruction_sse_q20":29826289089,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"19a9a534020ef114","transition_correct":226,"transition_supported":229,"transition_unknown":27},"training_evaluations":1097752},"ravel_without_retirement_matched_work":{"checkpoint_size_bytes":46634,"drift_holdout":{"classification_checksum":"7ad1223eaad7af78","correct":256,"expert_evaluations":2048,"prediction_checksum":"9e271540dfc70c02","prediction_samples":236,"prediction_sse_q20":90160471148,"reconstruction_checksum":"23ac48c5b2ad7b4d","reconstruction_sse_q20":81997478952,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"ca37dba8ef4d9142","transition_correct":220,"transition_supported":236,"transition_unknown":20},"expert_count":70,"planning":{"belief_set_target_reached":52,"cases":64,"checksum":"49aeefb73c04a34f","exact_world_state_target_reached":52,"executed_path_length":302,"expansions":2482,"goal_expert_reached":52,"graph_disconnection_failures":0,"no_supported_edge_failures":4,"optimal_path_length":320,"path_found":60,"path_length_regret":11,"state_aliasing_failures":0,"transition_model_error_failures":8},"retention_holdout":{"classification_checksum":"a73805265242eaac","correct":256,"expert_evaluations":2048,"prediction_checksum":"d26f4f5c87c92cf1","prediction_samples":230,"prediction_sse_q20":34558242377,"reconstruction_checksum":"1474499e0caf7a7c","reconstruction_sse_q20":28927510487,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"69fa7d6016cbf1dc","transition_correct":227,"transition_supported":230,"transition_unknown":26},"training_evaluations":1491480}},"dataset_seeds":{"base_holdout":"0x6be323dc992f632a","base_training":"0x616c1afe264ac4ec","drift_adaptation_training":"0x4989bf5196e802fe","drift_holdout":"0xd460b934a6f91dd5","original_task_retention_holdout":"0x789be6c34f3ff925","planning_cases":"0x2b5a046842e124ab"},"dataset_sizes":{"base_holdout":256,"base_training":1024,"drift_adaptation_training":512,"drift_holdout":256,"original_task_retention_holdout":256,"planning_cases":64},"integrity":{"checkpoint_behavior_match":true,"checkpoint_identity_match":true,"checkpoint_mutations":{"anchored_status":true,"appended_unexpected_byte":true,"checkpoint_substitution":true,"checkpoint_truncation":true,"incorrect_schema_version":true,"label":true,"label_count":true,"lineage":true,"next_observation_component":true,"payload_byte":true,"reconstruction_component":true,"retrieval_key_component":true,"transition_graph_edge":true,"transition_support":true},"checkpoint_roundtrip":true,"lineage_invariants":{"deterministic_topology_reproduction":true,"lineage_uniqueness":true,"no_accidental_lineage_reuse":true,"parent_child_generation_increment":true,"repeated_descendant_splitting":true,"sibling_generation_equality":true},"unsupported_graph_edge_violations":0},"regime":"observation_drift","schema":"ravel-raw-trial/0.5","seed":"0x76a01eddce0b3fc5","trial_id":"validation-observation-04"},{"candidate":{"adaptation_completed":true,"adaptation_training":{"classification_checksum":"a46ed56a9496499c","correct":512,"expert_evaluations":4096,"prediction_checksum":"4e9b967c10477eda","prediction_samples":481,"prediction_sse_q20":1528913665903,"reconstruction_checksum":"8be0dc1e88a0de56","reconstruction_sse_q20":72247539327,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":512,"samples":512,"transition_checksum":"5e04dcb0d05db3f6","transition_correct":402,"transition_supported":481,"transition_unknown":31},"adaptation_training_evaluations":691200,"adapted_model_drift_holdout":{"classification_checksum":"652ddb27bed7e98f","correct":256,"expert_evaluations":2048,"prediction_checksum":"290febf800a2c287","prediction_samples":236,"prediction_sse_q20":1275549768350,"reconstruction_checksum":"88fd1a730815aad6","reconstruction_sse_q20":36972601509,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"6121a3f36b36bff6","transition_correct":173,"transition_supported":236,"transition_unknown":20},"base_holdout":{"classification_checksum":"0de65ba7bb3e474e","correct":244,"expert_evaluations":2048,"prediction_checksum":"4e58fb428ecb8a12","prediction_samples":238,"prediction_sse_q20":88590376495,"reconstruction_checksum":"3991f204233e7bfe","reconstruction_sse_q20":78121950374,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"32402e3ba8ef793a","transition_correct":224,"transition_supported":238,"transition_unknown":18},"base_holdout_retention":{"classification_checksum":"af965e8c6ca2edae","correct":256,"expert_evaluations":2048,"prediction_checksum":"b241547c970357d9","prediction_samples":233,"prediction_sse_q20":60407449687,"reconstruction_checksum":"151abb0fcdb9fca4","reconstruction_sse_q20":42612306566,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"bd8b8a800c3e1edb","transition_correct":222,"transition_supported":233,"transition_unknown":23},"base_training_evaluations":555864,"behavior_identity":"75095cc68b5764565ce33fadc66d762432d7d208a2dd23bc5e8407749e9948c2","checkpoint_size_bytes":45494,"expert_count":68,"model_identity":"69b8310de12654d65640b026ad75746d96d42275da437b83ae0c40c19e98841d","planning":{"belief_set_target_reached":42,"cases":64,"checksum":"1108db488c84bda0","exact_world_state_target_reached":42,"executed_path_length":296,"expansions":2013,"goal_expert_reached":42,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":234,"path_found":64,"path_length_regret":35,"state_aliasing_failures":0,"transition_model_error_failures":22},"replay":{"actions_covered":4,"assigned_experts_covered":63,"high_loss_cases_selected":13,"labels_covered":8,"rare_cases_selected":64,"selected":256,"selection_checksum":"cc620205a62a7c86","states_covered":64,"transition_pairs_covered":252,"unique":256},"static_model_drift_holdout":{"classification_checksum":"4542e16f81be8061","correct":243,"expert_evaluations":2048,"prediction_checksum":"aeade2293916d1a0","prediction_samples":238,"prediction_sse_q20":1372500764567,"reconstruction_checksum":"e22dd079bbe78770","reconstruction_sse_q20":72507912000,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"315e409919087e50","transition_correct":170,"transition_supported":238,"transition_unknown":18},"topology":{"accepted_births":4,"accepted_retirements":0,"births":[{"dominant_channel":0,"event_index":365,"normalized_score_q20":557232},{"dominant_channel":0,"event_index":323,"normalized_score_q20":551717},{"dominant_channel":0,"event_index":139,"normalized_score_q20":491956},{"dominant_channel":2,"event_index":281,"normalized_score_q20":306201}],"objective_after_q20":906509,"objective_before_q20":890400,"rejected_births":12,"rejected_retirements":1,"retired_lineages":[],"training_observations":{"births":4,"certified":9216,"expert_evaluations":691200,"rejected_births":12,"rejected_retirements":1,"retired":0,"samples":9216}}},"checkpoint_format":{"byte_order":"big_endian","magic_hex":"524156454c303500","payload_digest":"sha256","real_encoding":"signed_q20_int64","schema_version":5,"transition_support_min":2,"transition_top_k":2},"comparisons":{"fixed_8_expert":{"checkpoint_size_bytes":11294,"drift_holdout":{"classification_checksum":"00bb4aac6cd09de5","correct":49,"expert_evaluations":2048,"prediction_checksum":"64a1da2bdc07616c","prediction_samples":256,"prediction_sse_q20":2545035136646,"reconstruction_checksum":"99cafa1c888ffc8b","reconstruction_sse_q20":1822116616878,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"0c8d81312bb7cc90","transition_correct":90,"transition_supported":256,"transition_unknown":0},"expert_count":8,"planning":{"belief_set_target_reached":11,"cases":64,"checksum":"3d130e6a3e419faa","exact_world_state_target_reached":1,"executed_path_length":87,"expansions":244,"goal_expert_reached":11,"graph_disconnection_failures":13,"no_supported_edge_failures":0,"optimal_path_length":234,"path_found":51,"path_length_regret":0,"state_aliasing_failures":10,"transition_model_error_failures":40},"retention_holdout":{"classification_checksum":"cf6bcf99d3349a1c","correct":53,"expert_evaluations":2048,"prediction_checksum":"164c785ab59a4f99","prediction_samples":256,"prediction_sse_q20":1904673508026,"reconstruction_checksum":"e355f425cd9441b3","reconstruction_sse_q20":1764140861952,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"ad28a31cf5155c60","transition_correct":116,"transition_supported":256,"transition_unknown":0},"training_evaluations":94208},"fixed_topology_64_expert_routed":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"bab7e9d6bc2243c8","correct":256,"expert_evaluations":2048,"prediction_checksum":"9d93267540f44625","prediction_samples":233,"prediction_sse_q20":1286109453926,"reconstruction_checksum":"28c450efdf7c8f0b","reconstruction_sse_q20":23212959628,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"ace4da62feef2f29","transition_correct":176,"transition_supported":233,"transition_unknown":23},"expert_count":64,"planning":{"belief_set_target_reached":45,"cases":64,"checksum":"92334b3e76b584c7","exact_world_state_target_reached":45,"executed_path_length":297,"expansions":2040,"goal_expert_reached":45,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":234,"path_found":64,"path_length_regret":43,"state_aliasing_failures":0,"transition_model_error_failures":19},"retention_holdout":{"classification_checksum":"dab8313223c299ff","correct":256,"expert_evaluations":2048,"prediction_checksum":"2a021ad9d5137e36","prediction_samples":233,"prediction_sse_q20":25115767603,"reconstruction_checksum":"f2a8d79e7e5240c4","reconstruction_sse_q20":22709492014,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"f13b00bc25c5ba10","transition_correct":233,"transition_supported":233,"transition_unknown":23},"training_evaluations":2588672},"flat_64_expert_complete_scan":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"bab7e9d6bc2243c8","correct":256,"expert_evaluations":16384,"prediction_checksum":"9d93267540f44625","prediction_samples":233,"prediction_sse_q20":1286109453926,"reconstruction_checksum":"28c450efdf7c8f0b","reconstruction_sse_q20":23212959628,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"ace4da62feef2f29","transition_correct":176,"transition_supported":233,"transition_unknown":23},"expert_count":64,"planning":{"belief_set_target_reached":45,"cases":64,"checksum":"92334b3e76b584c7","exact_world_state_target_reached":45,"executed_path_length":297,"expansions":2040,"goal_expert_reached":45,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":234,"path_found":64,"path_length_regret":43,"state_aliasing_failures":0,"transition_model_error_failures":19},"retention_holdout":{"classification_checksum":"dab8313223c299ff","correct":256,"expert_evaluations":16384,"prediction_checksum":"2a021ad9d5137e36","prediction_samples":233,"prediction_sse_q20":25115767603,"reconstruction_checksum":"f2a8d79e7e5240c4","reconstruction_sse_q20":22709492014,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"f13b00bc25c5ba10","transition_correct":233,"transition_supported":233,"transition_unknown":23},"training_evaluations":2588672},"matched_compute_fixed_topology":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"4542e16f81be8061","correct":243,"expert_evaluations":2048,"prediction_checksum":"aeade2293916d1a0","prediction_samples":238,"prediction_sse_q20":1372500764567,"reconstruction_checksum":"e22dd079bbe78770","reconstruction_sse_q20":72507912000,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"315e409919087e50","transition_correct":170,"transition_supported":238,"transition_unknown":18},"expert_count":64,"planning":{"belief_set_target_reached":39,"cases":64,"checksum":"5aea46f093513234","exact_world_state_target_reached":38,"executed_path_length":295,"expansions":1959,"goal_expert_reached":39,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":234,"path_found":64,"path_length_regret":29,"state_aliasing_failures":1,"transition_model_error_failures":25},"retention_holdout":{"classification_checksum":"653de4f13d3f55f8","correct":244,"expert_evaluations":2048,"prediction_checksum":"5daf9bec07dbed56","prediction_samples":234,"prediction_sse_q20":90519331509,"reconstruction_checksum":"a1328e2b93e674b9","reconstruction_sse_q20":76482326735,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"ab785dc8e3479ec6","transition_correct":224,"transition_supported":234,"transition_unknown":22},"training_evaluations":1440600},"matched_expert_count_capacity":{"checkpoint_size_bytes":45494,"drift_holdout":{"classification_checksum":"a395589610ff496c","correct":256,"expert_evaluations":2048,"prediction_checksum":"a88190bc894555f6","prediction_samples":230,"prediction_sse_q20":1263565281085,"reconstruction_checksum":"62ae98f8c0ea462f","reconstruction_sse_q20":23207804351,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"e26ba9483dcbc5cc","transition_correct":172,"transition_supported":230,"transition_unknown":26},"expert_count":68,"planning":{"belief_set_target_reached":45,"cases":64,"checksum":"c6634400781ced34","exact_world_state_target_reached":45,"executed_path_length":301,"expansions":2096,"goal_expert_reached":45,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":234,"path_found":64,"path_length_regret":45,"state_aliasing_failures":0,"transition_model_error_failures":19},"retention_holdout":{"classification_checksum":"e186ccd3c041c604","correct":256,"expert_evaluations":2048,"prediction_checksum":"5059a90ee8ee650e","prediction_samples":231,"prediction_sse_q20":25108233425,"reconstruction_checksum":"0321bea8a96e65f3","reconstruction_sse_q20":22650765893,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"8ea0c7eb04d7240b","transition_correct":225,"transition_supported":231,"transition_unknown":25},"training_evaluations":2889728},"nearest_centroid_16_no_recursive_births":{"checkpoint_size_bytes":15854,"drift_holdout":{"classification_checksum":"c772c08c00f1b2e3","correct":59,"expert_evaluations":4096,"prediction_checksum":"5b2434df55815053","prediction_samples":256,"prediction_sse_q20":2153385555946,"reconstruction_checksum":"77e34c6d4d89d001","reconstruction_sse_q20":1179654264233,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"4f3ca3f584cd6f78","transition_correct":131,"transition_supported":256,"transition_unknown":0},"expert_count":16,"planning":{"belief_set_target_reached":16,"cases":64,"checksum":"ebb5ed3d0c1fea36","exact_world_state_target_reached":6,"executed_path_length":180,"expansions":584,"goal_expert_reached":16,"graph_disconnection_failures":6,"no_supported_edge_failures":0,"optimal_path_length":234,"path_found":58,"path_length_regret":0,"state_aliasing_failures":10,"transition_model_error_failures":42},"retention_holdout":{"classification_checksum":"ba0879f1c262fce5","correct":68,"expert_evaluations":4096,"prediction_checksum":"66a0e2d77942b172","prediction_samples":256,"prediction_sse_q20":1298600699630,"reconstruction_checksum":"dc756dd254d0489a","reconstruction_sse_q20":1151381673889,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"26915e18815eae40","transition_correct":172,"transition_supported":256,"transition_unknown":0},"training_evaluations":253952},"no_adaptation_static":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"4542e16f81be8061","correct":243,"expert_evaluations":2048,"prediction_checksum":"aeade2293916d1a0","prediction_samples":238,"prediction_sse_q20":1372500764567,"reconstruction_checksum":"e22dd079bbe78770","reconstruction_sse_q20":72507912000,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"315e409919087e50","transition_correct":170,"transition_supported":238,"transition_unknown":18},"expert_count":64,"planning":{"belief_set_target_reached":39,"cases":64,"checksum":"5aea46f093513234","exact_world_state_target_reached":38,"executed_path_length":295,"expansions":1959,"goal_expert_reached":39,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":234,"path_found":64,"path_length_regret":29,"state_aliasing_failures":1,"transition_model_error_failures":25},"retention_holdout":{"classification_checksum":"653de4f13d3f55f8","correct":244,"expert_evaluations":2048,"prediction_checksum":"5daf9bec07dbed56","prediction_samples":234,"prediction_sse_q20":90519331509,"reconstruction_checksum":"a1328e2b93e674b9","reconstruction_sse_q20":76482326735,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"ab785dc8e3479ec6","transition_correct":224,"transition_supported":234,"transition_unknown":22},"training_evaluations":555864},"periodic_replay_policy":{"checkpoint_size_bytes":44924,"drift_holdout":{"classification_checksum":"8c1e53004491e1ad","correct":256,"expert_evaluations":2048,"prediction_checksum":"42ea57702a25bd8f","prediction_samples":236,"prediction_sse_q20":1273638675886,"reconstruction_checksum":"d9ddfa1fa74154c8","reconstruction_sse_q20":37029004390,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"87fb62f4373d9c36","transition_correct":174,"transition_supported":236,"transition_unknown":20},"expert_count":67,"planning":{"belief_set_target_reached":42,"cases":64,"checksum":"2835ea216d968e88","exact_world_state_target_reached":42,"executed_path_length":299,"expansions":2013,"goal_expert_reached":42,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":234,"path_found":64,"path_length_regret":36,"state_aliasing_failures":0,"transition_model_error_failures":22},"retention_holdout":{"classification_checksum":"af965e8c6ca2edae","correct":256,"expert_evaluations":2048,"prediction_checksum":"93e6ef820b84f112","prediction_samples":227,"prediction_sse_q20":72053568307,"reconstruction_checksum":"9e0321ac61f74166","reconstruction_sse_q20":42628316821,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"c20903f85c2abe62","transition_correct":216,"transition_supported":227,"transition_unknown":29},"training_evaluations":1012056},"ravel_0_5_candidate":{"checkpoint_size_bytes":45494,"drift_holdout":{"classification_checksum":"652ddb27bed7e98f","correct":256,"expert_evaluations":2048,"prediction_checksum":"290febf800a2c287","prediction_samples":236,"prediction_sse_q20":1275549768350,"reconstruction_checksum":"88fd1a730815aad6","reconstruction_sse_q20":36972601509,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"6121a3f36b36bff6","transition_correct":173,"transition_supported":236,"transition_unknown":20},"expert_count":68,"planning":{"belief_set_target_reached":42,"cases":64,"checksum":"1108db488c84bda0","exact_world_state_target_reached":42,"executed_path_length":296,"expansions":2013,"goal_expert_reached":42,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":234,"path_found":64,"path_length_regret":35,"state_aliasing_failures":0,"transition_model_error_failures":22},"retention_holdout":{"classification_checksum":"af965e8c6ca2edae","correct":256,"expert_evaluations":2048,"prediction_checksum":"b241547c970357d9","prediction_samples":233,"prediction_sse_q20":60407449687,"reconstruction_checksum":"151abb0fcdb9fca4","reconstruction_sse_q20":42612306566,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"bd8b8a800c3e1edb","transition_correct":222,"transition_supported":233,"transition_unknown":23},"training_evaluations":1247064},"ravel_complete_scan_without_certification":{"checkpoint_size_bytes":45494,"drift_holdout":{"classification_checksum":"652ddb27bed7e98f","correct":256,"expert_evaluations":17408,"prediction_checksum":"290febf800a2c287","prediction_samples":236,"prediction_sse_q20":1275549768350,"reconstruction_checksum":"88fd1a730815aad6","reconstruction_sse_q20":36972601509,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"6121a3f36b36bff6","transition_correct":173,"transition_supported":236,"transition_unknown":20},"expert_count":68,"planning":{"belief_set_target_reached":42,"cases":64,"checksum":"1108db488c84bda0","exact_world_state_target_reached":42,"executed_path_length":296,"expansions":2013,"goal_expert_reached":42,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":234,"path_found":64,"path_length_regret":35,"state_aliasing_failures":0,"transition_model_error_failures":22},"retention_holdout":{"classification_checksum":"af965e8c6ca2edae","correct":256,"expert_evaluations":17408,"prediction_checksum":"b241547c970357d9","prediction_samples":233,"prediction_sse_q20":60407449687,"reconstruction_checksum":"151abb0fcdb9fca4","reconstruction_sse_q20":42612306566,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"bd8b8a800c3e1edb","transition_correct":222,"transition_supported":233,"transition_unknown":23},"training_evaluations":1431384},"ravel_no_birth_same_replay_iterations":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"4542e16f81be8061","correct":243,"expert_evaluations":2048,"prediction_checksum":"aeade2293916d1a0","prediction_samples":238,"prediction_sse_q20":1372500764567,"reconstruction_checksum":"e22dd079bbe78770","reconstruction_sse_q20":72507912000,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"315e409919087e50","transition_correct":170,"transition_supported":238,"transition_unknown":18},"expert_count":64,"planning":{"belief_set_target_reached":39,"cases":64,"checksum":"5aea46f093513234","exact_world_state_target_reached":38,"executed_path_length":295,"expansions":1959,"goal_expert_reached":39,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":234,"path_found":64,"path_length_regret":29,"state_aliasing_failures":1,"transition_model_error_failures":25},"retention_holdout":{"classification_checksum":"653de4f13d3f55f8","correct":244,"expert_evaluations":2048,"prediction_checksum":"5daf9bec07dbed56","prediction_samples":234,"prediction_sse_q20":90519331509,"reconstruction_checksum":"a1328e2b93e674b9","reconstruction_sse_q20":76482326735,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"ab785dc8e3479ec6","transition_correct":224,"transition_supported":234,"transition_unknown":22},"training_evaluations":777048},"ravel_random_births":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"4542e16f81be8061","correct":243,"expert_evaluations":2048,"prediction_checksum":"aeade2293916d1a0","prediction_samples":238,"prediction_sse_q20":1372500764567,"reconstruction_checksum":"e22dd079bbe78770","reconstruction_sse_q20":72507912000,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"315e409919087e50","transition_correct":170,"transition_supported":238,"transition_unknown":18},"expert_count":64,"planning":{"belief_set_target_reached":39,"cases":64,"checksum":"5aea46f093513234","exact_world_state_target_reached":38,"executed_path_length":295,"expansions":1959,"goal_expert_reached":39,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":234,"path_found":64,"path_length_regret":29,"state_aliasing_failures":1,"transition_model_error_failures":25},"retention_holdout":{"classification_checksum":"653de4f13d3f55f8","correct":244,"expert_evaluations":2048,"prediction_checksum":"5daf9bec07dbed56","prediction_samples":234,"prediction_sse_q20":90519331509,"reconstruction_checksum":"a1328e2b93e674b9","reconstruction_sse_q20":76482326735,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"ab785dc8e3479ec6","transition_correct":224,"transition_supported":234,"transition_unknown":22},"training_evaluations":777048},"ravel_without_replay":{"checkpoint_size_bytes":44924,"drift_holdout":{"classification_checksum":"8c1e53004491e1ad","correct":256,"expert_evaluations":2048,"prediction_checksum":"d0203b5d31d41555","prediction_samples":235,"prediction_sse_q20":1273530711637,"reconstruction_checksum":"67d3e837aeb79506","reconstruction_sse_q20":37039486440,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"72ec5b03e017c21e","transition_correct":173,"transition_supported":235,"transition_unknown":21},"expert_count":67,"planning":{"belief_set_target_reached":42,"cases":64,"checksum":"2835ea216d968e88","exact_world_state_target_reached":42,"executed_path_length":299,"expansions":2011,"goal_expert_reached":42,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":234,"path_found":64,"path_length_regret":36,"state_aliasing_failures":0,"transition_model_error_failures":22},"retention_holdout":{"classification_checksum":"af965e8c6ca2edae","correct":256,"expert_evaluations":2048,"prediction_checksum":"ae7e78d7958196ff","prediction_samples":225,"prediction_sse_q20":71738012467,"reconstruction_checksum":"dd22ad3325403b4a","reconstruction_sse_q20":42587992315,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"464b82b69a5c3774","transition_correct":214,"transition_supported":225,"transition_unknown":31},"training_evaluations":859992},"ravel_without_retirement_matched_work":{"checkpoint_size_bytes":45494,"drift_holdout":{"classification_checksum":"652ddb27bed7e98f","correct":256,"expert_evaluations":2048,"prediction_checksum":"290febf800a2c287","prediction_samples":236,"prediction_sse_q20":1275549768350,"reconstruction_checksum":"88fd1a730815aad6","reconstruction_sse_q20":36972601509,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"6121a3f36b36bff6","transition_correct":173,"transition_supported":236,"transition_unknown":20},"expert_count":68,"planning":{"belief_set_target_reached":42,"cases":64,"checksum":"1108db488c84bda0","exact_world_state_target_reached":42,"executed_path_length":296,"expansions":2013,"goal_expert_reached":42,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":234,"path_found":64,"path_length_regret":35,"state_aliasing_failures":0,"transition_model_error_failures":22},"retention_holdout":{"classification_checksum":"af965e8c6ca2edae","correct":256,"expert_evaluations":2048,"prediction_checksum":"b241547c970357d9","prediction_samples":233,"prediction_sse_q20":60407449687,"reconstruction_checksum":"151abb0fcdb9fca4","reconstruction_sse_q20":42612306566,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"bd8b8a800c3e1edb","transition_correct":222,"transition_supported":233,"transition_unknown":23},"training_evaluations":1247064}},"dataset_seeds":{"base_holdout":"0x8a6cc5f741a620fd","base_training":"0xbd56612ad271c1fb","drift_adaptation_training":"0x7582947a6853d4d4","drift_holdout":"0x184ecfb6d28cd855","original_task_retention_holdout":"0x53e348ca8f317430","planning_cases":"0xf10de20bceb4413f"},"dataset_sizes":{"base_holdout":256,"base_training":1024,"drift_adaptation_training":512,"drift_holdout":256,"original_task_retention_holdout":256,"planning_cases":64},"integrity":{"checkpoint_behavior_match":true,"checkpoint_identity_match":true,"checkpoint_mutations":{"anchored_status":true,"appended_unexpected_byte":true,"checkpoint_substitution":true,"checkpoint_truncation":true,"incorrect_schema_version":true,"label":true,"label_count":true,"lineage":true,"next_observation_component":true,"payload_byte":true,"reconstruction_component":true,"retrieval_key_component":true,"transition_graph_edge":true,"transition_support":true},"checkpoint_roundtrip":true,"lineage_invariants":{"deterministic_topology_reproduction":true,"lineage_uniqueness":true,"no_accidental_lineage_reuse":true,"parent_child_generation_increment":true,"repeated_descendant_splitting":true,"sibling_generation_equality":true},"unsupported_graph_edge_violations":0},"regime":"transition_drift","schema":"ravel-raw-trial/0.5","seed":"0xcd5ff324852e0944","trial_id":"validation-transition-01"},{"candidate":{"adaptation_completed":true,"adaptation_training":{"classification_checksum":"639817d3586dd7bd","correct":512,"expert_evaluations":4096,"prediction_checksum":"cbcf61750a72bbf3","prediction_samples":457,"prediction_sse_q20":1584807262191,"reconstruction_checksum":"272b6468f3a4e99e","reconstruction_sse_q20":81698107977,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":512,"samples":512,"transition_checksum":"2d869fbadb8d2917","transition_correct":364,"transition_supported":457,"transition_unknown":55},"adaptation_training_evaluations":812544,"adapted_model_drift_holdout":{"classification_checksum":"e41ae26d40a6418b","correct":256,"expert_evaluations":2048,"prediction_checksum":"92b684f479a7992c","prediction_samples":230,"prediction_sse_q20":764170897577,"reconstruction_checksum":"eb5e22e6ea8de428","reconstruction_sse_q20":46327748957,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"3e0a8428addde984","transition_correct":187,"transition_supported":230,"transition_unknown":26},"base_holdout":{"classification_checksum":"b54c8adadb6df34d","correct":243,"expert_evaluations":2048,"prediction_checksum":"34484730e653a900","prediction_samples":232,"prediction_sse_q20":83499959372,"reconstruction_checksum":"0bf534f1234a4ff8","reconstruction_sse_q20":81462765921,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"a9ba5dbacdd9e8cf","transition_correct":208,"transition_supported":232,"transition_unknown":24},"base_holdout_retention":{"classification_checksum":"bc3732441eb4838f","correct":256,"expert_evaluations":2048,"prediction_checksum":"ad28086b6a2a1d84","prediction_samples":230,"prediction_sse_q20":93150125360,"reconstruction_checksum":"d28bc022f91f5e46","reconstruction_sse_q20":50909386705,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"88bddb63c369c3d8","transition_correct":210,"transition_supported":230,"transition_unknown":26},"base_training_evaluations":560040,"behavior_identity":"9b8bfa4cb3e82c5d42dad75ca42325bf9196075754a61527ace2878656135308","checkpoint_size_bytes":46064,"expert_count":69,"model_identity":"85eb162966ec86691206a16cc9b44a34717b9e2572355da34c6b6f658ee646a2","planning":{"belief_set_target_reached":35,"cases":64,"checksum":"3d67fe5569b9269b","exact_world_state_target_reached":35,"executed_path_length":285,"expansions":2245,"goal_expert_reached":35,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":223,"path_found":64,"path_length_regret":25,"state_aliasing_failures":0,"transition_model_error_failures":29},"replay":{"actions_covered":4,"assigned_experts_covered":63,"high_loss_cases_selected":14,"labels_covered":8,"rare_cases_selected":59,"selected":256,"selection_checksum":"60f4a94f2fcda833","states_covered":64,"transition_pairs_covered":250,"unique":256},"static_model_drift_holdout":{"classification_checksum":"9ec50a7d6a0071a3","correct":240,"expert_evaluations":2048,"prediction_checksum":"ce68244ba0d7241b","prediction_samples":230,"prediction_sse_q20":846935393147,"reconstruction_checksum":"7ee9e80de44bb36d","reconstruction_sse_q20":94757840736,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"d671ebda77d2101e","transition_correct":173,"transition_supported":230,"transition_unknown":26},"topology":{"accepted_births":5,"accepted_retirements":0,"births":[{"dominant_channel":0,"event_index":295,"normalized_score_q20":570715},{"dominant_channel":0,"event_index":474,"normalized_score_q20":545922},{"dominant_channel":0,"event_index":407,"normalized_score_q20":542167},{"dominant_channel":0,"event_index":167,"normalized_score_q20":523873},{"dominant_channel":2,"event_index":8,"normalized_score_q20":321880}],"objective_after_q20":899191,"objective_before_q20":866067,"rejected_births":11,"rejected_retirements":1,"retired_lineages":[],"training_observations":{"births":5,"certified":10752,"expert_evaluations":812544,"rejected_births":11,"rejected_retirements":1,"retired":0,"samples":10752}}},"checkpoint_format":{"byte_order":"big_endian","magic_hex":"524156454c303500","payload_digest":"sha256","real_encoding":"signed_q20_int64","schema_version":5,"transition_support_min":2,"transition_top_k":2},"comparisons":{"fixed_8_expert":{"checkpoint_size_bytes":11294,"drift_holdout":{"classification_checksum":"6ea2c5f691782dc1","correct":57,"expert_evaluations":2048,"prediction_checksum":"b40822fb1de4be50","prediction_samples":256,"prediction_sse_q20":2231676892305,"reconstruction_checksum":"2f691f59b9abc188","reconstruction_sse_q20":1716164764147,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"fe95c6732346f60c","transition_correct":126,"transition_supported":256,"transition_unknown":0},"expert_count":8,"planning":{"belief_set_target_reached":12,"cases":64,"checksum":"b8e0e4d97587c3bf","exact_world_state_target_reached":2,"executed_path_length":34,"expansions":202,"goal_expert_reached":12,"graph_disconnection_failures":39,"no_supported_edge_failures":0,"optimal_path_length":223,"path_found":25,"path_length_regret":0,"state_aliasing_failures":10,"transition_model_error_failures":13},"retention_holdout":{"classification_checksum":"fe27ca90e619906f","correct":44,"expert_evaluations":2048,"prediction_checksum":"980e8250081ff09d","prediction_samples":256,"prediction_sse_q20":1902350125914,"reconstruction_checksum":"188251f5f425e3b6","reconstruction_sse_q20":1722695178953,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"530b4ce805ba624a","transition_correct":143,"transition_supported":256,"transition_unknown":0},"training_evaluations":94208},"fixed_topology_64_expert_routed":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"54d53d5e69f9ded1","correct":256,"expert_evaluations":2048,"prediction_checksum":"64330724a0a7d12f","prediction_samples":231,"prediction_sse_q20":796327104952,"reconstruction_checksum":"2281b85c7567fb29","reconstruction_sse_q20":22981744118,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"057ef528d79c53c0","transition_correct":192,"transition_supported":231,"transition_unknown":25},"expert_count":64,"planning":{"belief_set_target_reached":30,"cases":64,"checksum":"776a7acf29dc700a","exact_world_state_target_reached":30,"executed_path_length":308,"expansions":2149,"goal_expert_reached":30,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":223,"path_found":64,"path_length_regret":14,"state_aliasing_failures":0,"transition_model_error_failures":34},"retention_holdout":{"classification_checksum":"18f4c08d3c73b820","correct":256,"expert_evaluations":2048,"prediction_checksum":"c3664bb0af1ab324","prediction_samples":230,"prediction_sse_q20":23633037684,"reconstruction_checksum":"b5cde165ae1a27a3","reconstruction_sse_q20":22360035774,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"b447a3890cc3c783","transition_correct":230,"transition_supported":230,"transition_unknown":26},"training_evaluations":2588672},"flat_64_expert_complete_scan":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"54d53d5e69f9ded1","correct":256,"expert_evaluations":16384,"prediction_checksum":"64330724a0a7d12f","prediction_samples":231,"prediction_sse_q20":796327104952,"reconstruction_checksum":"2281b85c7567fb29","reconstruction_sse_q20":22981744118,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"057ef528d79c53c0","transition_correct":192,"transition_supported":231,"transition_unknown":25},"expert_count":64,"planning":{"belief_set_target_reached":30,"cases":64,"checksum":"776a7acf29dc700a","exact_world_state_target_reached":30,"executed_path_length":308,"expansions":2149,"goal_expert_reached":30,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":223,"path_found":64,"path_length_regret":14,"state_aliasing_failures":0,"transition_model_error_failures":34},"retention_holdout":{"classification_checksum":"18f4c08d3c73b820","correct":256,"expert_evaluations":16384,"prediction_checksum":"c3664bb0af1ab324","prediction_samples":230,"prediction_sse_q20":23633037684,"reconstruction_checksum":"b5cde165ae1a27a3","reconstruction_sse_q20":22360035774,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"b447a3890cc3c783","transition_correct":230,"transition_supported":230,"transition_unknown":26},"training_evaluations":2588672},"matched_compute_fixed_topology":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"9ec50a7d6a0071a3","correct":240,"expert_evaluations":2048,"prediction_checksum":"ce68244ba0d7241b","prediction_samples":230,"prediction_sse_q20":846935393147,"reconstruction_checksum":"7ee9e80de44bb36d","reconstruction_sse_q20":94757840736,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"d671ebda77d2101e","transition_correct":173,"transition_supported":230,"transition_unknown":26},"expert_count":64,"planning":{"belief_set_target_reached":25,"cases":64,"checksum":"16f2c4375c9c4bb6","exact_world_state_target_reached":23,"executed_path_length":283,"expansions":2168,"goal_expert_reached":25,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":223,"path_found":64,"path_length_regret":8,"state_aliasing_failures":2,"transition_model_error_failures":39},"retention_holdout":{"classification_checksum":"4a09320341dc666c","correct":240,"expert_evaluations":2048,"prediction_checksum":"10980053217fafc8","prediction_samples":234,"prediction_sse_q20":105820279400,"reconstruction_checksum":"4c6eb2e70f8a2b06","reconstruction_sse_q20":97650129606,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"58a04979405f6838","transition_correct":208,"transition_supported":234,"transition_unknown":22},"training_evaluations":1444776},"matched_expert_count_capacity":{"checkpoint_size_bytes":46064,"drift_holdout":{"classification_checksum":"af13c2c01255b2ac","correct":256,"expert_evaluations":2048,"prediction_checksum":"e93aab2d37f7ea83","prediction_samples":224,"prediction_sse_q20":754206930675,"reconstruction_checksum":"454a588bcc24b8f4","reconstruction_sse_q20":22579278773,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"9dd7985bc5c1c026","transition_correct":185,"transition_supported":224,"transition_unknown":32},"expert_count":69,"planning":{"belief_set_target_reached":30,"cases":64,"checksum":"a7c08e64578defdb","exact_world_state_target_reached":30,"executed_path_length":312,"expansions":2229,"goal_expert_reached":30,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":223,"path_found":64,"path_length_regret":14,"state_aliasing_failures":0,"transition_model_error_failures":34},"retention_holdout":{"classification_checksum":"bd58648eaf68991d","correct":256,"expert_evaluations":2048,"prediction_checksum":"2fc3c2a7db2b6c4f","prediction_samples":224,"prediction_sse_q20":23574287459,"reconstruction_checksum":"0f2bd1444b002c0d","reconstruction_sse_q20":22234197169,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"fcc1d239a25e1007","transition_correct":213,"transition_supported":224,"transition_unknown":32},"training_evaluations":2967552},"nearest_centroid_16_no_recursive_births":{"checkpoint_size_bytes":15854,"drift_holdout":{"classification_checksum":"b83216a4e7ede647","correct":73,"expert_evaluations":4096,"prediction_checksum":"a7a6ee0badef5d34","prediction_samples":254,"prediction_sse_q20":1785969422714,"reconstruction_checksum":"ae087050014f6576","reconstruction_sse_q20":1069735179971,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"372fbb1a74cb11ee","transition_correct":182,"transition_supported":254,"transition_unknown":2},"expert_count":16,"planning":{"belief_set_target_reached":33,"cases":64,"checksum":"55c9d864cb6db161","exact_world_state_target_reached":8,"executed_path_length":180,"expansions":632,"goal_expert_reached":33,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":223,"path_found":64,"path_length_regret":2,"state_aliasing_failures":25,"transition_model_error_failures":31},"retention_holdout":{"classification_checksum":"b2d6123b002e8fc8","correct":74,"expert_evaluations":4096,"prediction_checksum":"271d02ed5f6b9ae1","prediction_samples":254,"prediction_sse_q20":1204641018909,"reconstruction_checksum":"d6e5e17ec385ae32","reconstruction_sse_q20":1014101176163,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"75ecadf5cac01176","transition_correct":214,"transition_supported":254,"transition_unknown":2},"training_evaluations":253952},"no_adaptation_static":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"9ec50a7d6a0071a3","correct":240,"expert_evaluations":2048,"prediction_checksum":"ce68244ba0d7241b","prediction_samples":230,"prediction_sse_q20":846935393147,"reconstruction_checksum":"7ee9e80de44bb36d","reconstruction_sse_q20":94757840736,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"d671ebda77d2101e","transition_correct":173,"transition_supported":230,"transition_unknown":26},"expert_count":64,"planning":{"belief_set_target_reached":25,"cases":64,"checksum":"16f2c4375c9c4bb6","exact_world_state_target_reached":23,"executed_path_length":283,"expansions":2168,"goal_expert_reached":25,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":223,"path_found":64,"path_length_regret":8,"state_aliasing_failures":2,"transition_model_error_failures":39},"retention_holdout":{"classification_checksum":"4a09320341dc666c","correct":240,"expert_evaluations":2048,"prediction_checksum":"10980053217fafc8","prediction_samples":234,"prediction_sse_q20":105820279400,"reconstruction_checksum":"4c6eb2e70f8a2b06","reconstruction_sse_q20":97650129606,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"58a04979405f6838","transition_correct":208,"transition_supported":234,"transition_unknown":22},"training_evaluations":560040},"periodic_replay_policy":{"checkpoint_size_bytes":46064,"drift_holdout":{"classification_checksum":"e41ae26d40a6418b","correct":256,"expert_evaluations":2048,"prediction_checksum":"dd0d91a14c6874c9","prediction_samples":229,"prediction_sse_q20":763546800571,"reconstruction_checksum":"f8ac837c490e9787","reconstruction_sse_q20":46397720941,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"61fd7e81fcef0897","transition_correct":186,"transition_supported":229,"transition_unknown":27},"expert_count":69,"planning":{"belief_set_target_reached":35,"cases":64,"checksum":"c2ff2fc555996f25","exact_world_state_target_reached":35,"executed_path_length":293,"expansions":2309,"goal_expert_reached":35,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":223,"path_found":64,"path_length_regret":25,"state_aliasing_failures":0,"transition_model_error_failures":29},"retention_holdout":{"classification_checksum":"bc3732441eb4838f","correct":256,"expert_evaluations":2048,"prediction_checksum":"442ef6eea719114b","prediction_samples":230,"prediction_sse_q20":104685697165,"reconstruction_checksum":"61cad3f80990882c","reconstruction_sse_q20":50943242263,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"88bddb63c369c3d8","transition_correct":210,"transition_supported":230,"transition_unknown":26},"training_evaluations":1372584},"ravel_0_5_candidate":{"checkpoint_size_bytes":46064,"drift_holdout":{"classification_checksum":"e41ae26d40a6418b","correct":256,"expert_evaluations":2048,"prediction_checksum":"92b684f479a7992c","prediction_samples":230,"prediction_sse_q20":764170897577,"reconstruction_checksum":"eb5e22e6ea8de428","reconstruction_sse_q20":46327748957,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"3e0a8428addde984","transition_correct":187,"transition_supported":230,"transition_unknown":26},"expert_count":69,"planning":{"belief_set_target_reached":35,"cases":64,"checksum":"3d67fe5569b9269b","exact_world_state_target_reached":35,"executed_path_length":285,"expansions":2245,"goal_expert_reached":35,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":223,"path_found":64,"path_length_regret":25,"state_aliasing_failures":0,"transition_model_error_failures":29},"retention_holdout":{"classification_checksum":"bc3732441eb4838f","correct":256,"expert_evaluations":2048,"prediction_checksum":"ad28086b6a2a1d84","prediction_samples":230,"prediction_sse_q20":93150125360,"reconstruction_checksum":"d28bc022f91f5e46","reconstruction_sse_q20":50909386705,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"88bddb63c369c3d8","transition_correct":210,"transition_supported":230,"transition_unknown":26},"training_evaluations":1372584},"ravel_complete_scan_without_certification":{"checkpoint_size_bytes":46064,"drift_holdout":{"classification_checksum":"e41ae26d40a6418b","correct":256,"expert_evaluations":17664,"prediction_checksum":"92b684f479a7992c","prediction_samples":230,"prediction_sse_q20":764170897577,"reconstruction_checksum":"eb5e22e6ea8de428","reconstruction_sse_q20":46327748957,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"3e0a8428addde984","transition_correct":187,"transition_supported":230,"transition_unknown":26},"expert_count":69,"planning":{"belief_set_target_reached":35,"cases":64,"checksum":"3d67fe5569b9269b","exact_world_state_target_reached":35,"executed_path_length":285,"expansions":2245,"goal_expert_reached":35,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":223,"path_found":64,"path_length_regret":25,"state_aliasing_failures":0,"transition_model_error_failures":29},"retention_holdout":{"classification_checksum":"bc3732441eb4838f","correct":256,"expert_evaluations":17664,"prediction_checksum":"ad28086b6a2a1d84","prediction_samples":230,"prediction_sse_q20":93150125360,"reconstruction_checksum":"d28bc022f91f5e46","reconstruction_sse_q20":50909386705,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"88bddb63c369c3d8","transition_correct":210,"transition_supported":230,"transition_unknown":26},"training_evaluations":1559976},"ravel_no_birth_same_replay_iterations":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"9ec50a7d6a0071a3","correct":240,"expert_evaluations":2048,"prediction_checksum":"ce68244ba0d7241b","prediction_samples":230,"prediction_sse_q20":846935393147,"reconstruction_checksum":"7ee9e80de44bb36d","reconstruction_sse_q20":94757840736,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"d671ebda77d2101e","transition_correct":173,"transition_supported":230,"transition_unknown":26},"expert_count":64,"planning":{"belief_set_target_reached":25,"cases":64,"checksum":"16f2c4375c9c4bb6","exact_world_state_target_reached":23,"executed_path_length":283,"expansions":2168,"goal_expert_reached":25,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":223,"path_found":64,"path_length_regret":8,"state_aliasing_failures":2,"transition_model_error_failures":39},"retention_holdout":{"classification_checksum":"4a09320341dc666c","correct":240,"expert_evaluations":2048,"prediction_checksum":"10980053217fafc8","prediction_samples":234,"prediction_sse_q20":105820279400,"reconstruction_checksum":"4c6eb2e70f8a2b06","reconstruction_sse_q20":97650129606,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"58a04979405f6838","transition_correct":208,"transition_supported":234,"transition_unknown":22},"training_evaluations":781224},"ravel_random_births":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"9ec50a7d6a0071a3","correct":240,"expert_evaluations":2048,"prediction_checksum":"ce68244ba0d7241b","prediction_samples":230,"prediction_sse_q20":846935393147,"reconstruction_checksum":"7ee9e80de44bb36d","reconstruction_sse_q20":94757840736,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"d671ebda77d2101e","transition_correct":173,"transition_supported":230,"transition_unknown":26},"expert_count":64,"planning":{"belief_set_target_reached":25,"cases":64,"checksum":"16f2c4375c9c4bb6","exact_world_state_target_reached":23,"executed_path_length":283,"expansions":2168,"goal_expert_reached":25,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":223,"path_found":64,"path_length_regret":8,"state_aliasing_failures":2,"transition_model_error_failures":39},"retention_holdout":{"classification_checksum":"4a09320341dc666c","correct":240,"expert_evaluations":2048,"prediction_checksum":"10980053217fafc8","prediction_samples":234,"prediction_sse_q20":105820279400,"reconstruction_checksum":"4c6eb2e70f8a2b06","reconstruction_sse_q20":97650129606,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"58a04979405f6838","transition_correct":208,"transition_supported":234,"transition_unknown":22},"training_evaluations":781224},"ravel_without_replay":{"checkpoint_size_bytes":45494,"drift_holdout":{"classification_checksum":"e41ae26d40a6418b","correct":256,"expert_evaluations":2048,"prediction_checksum":"27f7a49c42daf806","prediction_samples":227,"prediction_sse_q20":763419291403,"reconstruction_checksum":"d2d073543cc5dc55","reconstruction_sse_q20":46390146169,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"1a15e9ec336e1b43","transition_correct":185,"transition_supported":227,"transition_unknown":29},"expert_count":68,"planning":{"belief_set_target_reached":35,"cases":64,"checksum":"c2ff2fc555996f25","exact_world_state_target_reached":35,"executed_path_length":293,"expansions":2308,"goal_expert_reached":35,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":223,"path_found":64,"path_length_regret":25,"state_aliasing_failures":0,"transition_model_error_failures":29},"retention_holdout":{"classification_checksum":"be88fff4d335d2fe","correct":256,"expert_evaluations":2048,"prediction_checksum":"6f2f902080f87270","prediction_samples":229,"prediction_sse_q20":118008122658,"reconstruction_checksum":"a492611b4939c487","reconstruction_sse_q20":51067479026,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"b771788f1c02e74f","transition_correct":209,"transition_supported":229,"transition_unknown":27},"training_evaluations":1020840},"ravel_without_retirement_matched_work":{"checkpoint_size_bytes":46064,"drift_holdout":{"classification_checksum":"e41ae26d40a6418b","correct":256,"expert_evaluations":2048,"prediction_checksum":"92b684f479a7992c","prediction_samples":230,"prediction_sse_q20":764170897577,"reconstruction_checksum":"eb5e22e6ea8de428","reconstruction_sse_q20":46327748957,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"3e0a8428addde984","transition_correct":187,"transition_supported":230,"transition_unknown":26},"expert_count":69,"planning":{"belief_set_target_reached":35,"cases":64,"checksum":"3d67fe5569b9269b","exact_world_state_target_reached":35,"executed_path_length":285,"expansions":2245,"goal_expert_reached":35,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":223,"path_found":64,"path_length_regret":25,"state_aliasing_failures":0,"transition_model_error_failures":29},"retention_holdout":{"classification_checksum":"bc3732441eb4838f","correct":256,"expert_evaluations":2048,"prediction_checksum":"ad28086b6a2a1d84","prediction_samples":230,"prediction_sse_q20":93150125360,"reconstruction_checksum":"d28bc022f91f5e46","reconstruction_sse_q20":50909386705,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"88bddb63c369c3d8","transition_correct":210,"transition_supported":230,"transition_unknown":26},"training_evaluations":1372584}},"dataset_seeds":{"base_holdout":"0x963b80442574235a","base_training":"0x04a860640b3a1ac2","drift_adaptation_training":"0x885b14713d358cd8","drift_holdout":"0x148fc2c2e24e9473","original_task_retention_holdout":"0xb89442f5e5906e94","planning_cases":"0x118163ab8f090b59"},"dataset_sizes":{"base_holdout":256,"base_training":1024,"drift_adaptation_training":512,"drift_holdout":256,"original_task_retention_holdout":256,"planning_cases":64},"integrity":{"checkpoint_behavior_match":true,"checkpoint_identity_match":true,"checkpoint_mutations":{"anchored_status":true,"appended_unexpected_byte":true,"checkpoint_substitution":true,"checkpoint_truncation":true,"incorrect_schema_version":true,"label":true,"label_count":true,"lineage":true,"next_observation_component":true,"payload_byte":true,"reconstruction_component":true,"retrieval_key_component":true,"transition_graph_edge":true,"transition_support":true},"checkpoint_roundtrip":true,"lineage_invariants":{"deterministic_topology_reproduction":true,"lineage_uniqueness":true,"no_accidental_lineage_reuse":true,"parent_child_generation_increment":true,"repeated_descendant_splitting":true,"sibling_generation_equality":true},"unsupported_graph_edge_violations":0},"regime":"transition_drift","schema":"ravel-raw-trial/0.5","seed":"0x446029e572acbddb","trial_id":"validation-transition-02"},{"candidate":{"adaptation_completed":true,"adaptation_training":{"classification_checksum":"764d8620b8b70d69","correct":512,"expert_evaluations":4096,"prediction_checksum":"16a877f12ad316cf","prediction_samples":480,"prediction_sse_q20":1743295188471,"reconstruction_checksum":"6c980ecfaff1f278","reconstruction_sse_q20":53283784158,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":512,"samples":512,"transition_checksum":"7f4a9959dfda10b6","transition_correct":391,"transition_supported":480,"transition_unknown":32},"adaptation_training_evaluations":571392,"adapted_model_drift_holdout":{"classification_checksum":"2f7037b13ea3ff5d","correct":256,"expert_evaluations":2048,"prediction_checksum":"354aed1588314d78","prediction_samples":231,"prediction_sse_q20":783957060027,"reconstruction_checksum":"32e7afc32cb3636a","reconstruction_sse_q20":23385381612,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"df5f672631e843c9","transition_correct":190,"transition_supported":231,"transition_unknown":25},"base_holdout":{"classification_checksum":"4b01202640c253b0","correct":255,"expert_evaluations":2048,"prediction_checksum":"389d4c12bf9b6f07","prediction_samples":237,"prediction_sse_q20":27497877082,"reconstruction_checksum":"386226d60d53c180","reconstruction_sse_q20":26603147280,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"ec62617b687186f5","transition_correct":234,"transition_supported":237,"transition_unknown":19},"base_holdout_retention":{"classification_checksum":"404ea2d58c4f511b","correct":256,"expert_evaluations":2048,"prediction_checksum":"c3c99a7918a44815","prediction_samples":217,"prediction_sse_q20":36461382080,"reconstruction_checksum":"d0b8a751cc2dc22d","reconstruction_sse_q20":29303048828,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"5ddf38e2beb9a9a2","transition_correct":215,"transition_supported":217,"transition_unknown":39},"base_training_evaluations":552392,"behavior_identity":"9a27a46639ab67f07d872a6d6e6f9a233b2ece2f3d1baa95ae46288d2340558c","checkpoint_size_bytes":44924,"expert_count":67,"model_identity":"17b46b591e07c933f6ef7e9aa67f1d6675c0c30df92b52fa951188a4fadea130","planning":{"belief_set_target_reached":40,"cases":64,"checksum":"4f01a31797e93961","exact_world_state_target_reached":40,"executed_path_length":258,"expansions":1788,"goal_expert_reached":40,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":220,"path_found":64,"path_length_regret":27,"state_aliasing_failures":0,"transition_model_error_failures":24},"replay":{"actions_covered":4,"assigned_experts_covered":63,"high_loss_cases_selected":21,"labels_covered":8,"rare_cases_selected":54,"selected":256,"selection_checksum":"6fc8a9290436082a","states_covered":64,"transition_pairs_covered":248,"unique":256},"static_model_drift_holdout":{"classification_checksum":"d2aff7039b1403a4","correct":249,"expert_evaluations":2048,"prediction_checksum":"06ef937247a4cfeb","prediction_samples":230,"prediction_sse_q20":854896063671,"reconstruction_checksum":"712ee82dcc1278ee","reconstruction_sse_q20":49141661248,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"1bcf33df7910fc06","transition_correct":188,"transition_supported":230,"transition_unknown":26},"topology":{"accepted_births":3,"accepted_retirements":0,"births":[{"dominant_channel":0,"event_index":423,"normalized_score_q20":562203},{"dominant_channel":2,"event_index":446,"normalized_score_q20":337871},{"dominant_channel":2,"event_index":343,"normalized_score_q20":329976}],"objective_after_q20":910923,"objective_before_q20":904954,"rejected_births":13,"rejected_retirements":1,"retired_lineages":[],"training_observations":{"births":3,"certified":7680,"expert_evaluations":571392,"rejected_births":13,"rejected_retirements":1,"retired":0,"samples":7680}}},"checkpoint_format":{"byte_order":"big_endian","magic_hex":"524156454c303500","payload_digest":"sha256","real_encoding":"signed_q20_int64","schema_version":5,"transition_support_min":2,"transition_top_k":2},"comparisons":{"fixed_8_expert":{"checkpoint_size_bytes":11294,"drift_holdout":{"classification_checksum":"e1e216ce9d40a185","correct":67,"expert_evaluations":2048,"prediction_checksum":"78895fa4158a8d94","prediction_samples":256,"prediction_sse_q20":2332312167330,"reconstruction_checksum":"113964f9c489a134","reconstruction_sse_q20":1720610529051,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"dbf71f2e4e10e95f","transition_correct":90,"transition_supported":256,"transition_unknown":0},"expert_count":8,"planning":{"belief_set_target_reached":14,"cases":64,"checksum":"55193101dce93e29","exact_world_state_target_reached":1,"executed_path_length":52,"expansions":224,"goal_expert_reached":14,"graph_disconnection_failures":27,"no_supported_edge_failures":0,"optimal_path_length":220,"path_found":37,"path_length_regret":0,"state_aliasing_failures":13,"transition_model_error_failures":23},"retention_holdout":{"classification_checksum":"fb4066c506e83a21","correct":45,"expert_evaluations":2048,"prediction_checksum":"6e2c93c2f3db9888","prediction_samples":256,"prediction_sse_q20":1982355846955,"reconstruction_checksum":"0fd13453fe4c4ef0","reconstruction_sse_q20":1803899220272,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"5522d45a69a41260","transition_correct":96,"transition_supported":256,"transition_unknown":0},"training_evaluations":94208},"fixed_topology_64_expert_routed":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"fd9a2df21c42f2c7","correct":256,"expert_evaluations":2048,"prediction_checksum":"70d6ecf2847bc144","prediction_samples":227,"prediction_sse_q20":769435353947,"reconstruction_checksum":"b82776312c5bb175","reconstruction_sse_q20":22950884444,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"3f9f774a4fa93da4","transition_correct":191,"transition_supported":227,"transition_unknown":29},"expert_count":64,"planning":{"belief_set_target_reached":40,"cases":64,"checksum":"368acc7edc965fef","exact_world_state_target_reached":40,"executed_path_length":262,"expansions":1741,"goal_expert_reached":40,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":220,"path_found":64,"path_length_regret":30,"state_aliasing_failures":0,"transition_model_error_failures":24},"retention_holdout":{"classification_checksum":"3bcd23676977acf5","correct":256,"expert_evaluations":2048,"prediction_checksum":"759a053633c73f94","prediction_samples":218,"prediction_sse_q20":24214982457,"reconstruction_checksum":"e2c33e379d5b235e","reconstruction_sse_q20":23247015253,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"5f2398b89899fb31","transition_correct":218,"transition_supported":218,"transition_unknown":38},"training_evaluations":2588672},"flat_64_expert_complete_scan":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"fd9a2df21c42f2c7","correct":256,"expert_evaluations":16384,"prediction_checksum":"70d6ecf2847bc144","prediction_samples":227,"prediction_sse_q20":769435353947,"reconstruction_checksum":"b82776312c5bb175","reconstruction_sse_q20":22950884444,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"3f9f774a4fa93da4","transition_correct":191,"transition_supported":227,"transition_unknown":29},"expert_count":64,"planning":{"belief_set_target_reached":40,"cases":64,"checksum":"368acc7edc965fef","exact_world_state_target_reached":40,"executed_path_length":262,"expansions":1741,"goal_expert_reached":40,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":220,"path_found":64,"path_length_regret":30,"state_aliasing_failures":0,"transition_model_error_failures":24},"retention_holdout":{"classification_checksum":"3bcd23676977acf5","correct":256,"expert_evaluations":16384,"prediction_checksum":"759a053633c73f94","prediction_samples":218,"prediction_sse_q20":24214982457,"reconstruction_checksum":"e2c33e379d5b235e","reconstruction_sse_q20":23247015253,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"5f2398b89899fb31","transition_correct":218,"transition_supported":218,"transition_unknown":38},"training_evaluations":2588672},"matched_compute_fixed_topology":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"d2aff7039b1403a4","correct":249,"expert_evaluations":2048,"prediction_checksum":"06ef937247a4cfeb","prediction_samples":230,"prediction_sse_q20":854896063671,"reconstruction_checksum":"712ee82dcc1278ee","reconstruction_sse_q20":49141661248,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"1bcf33df7910fc06","transition_correct":188,"transition_supported":230,"transition_unknown":26},"expert_count":64,"planning":{"belief_set_target_reached":40,"cases":64,"checksum":"88279132351699b6","exact_world_state_target_reached":40,"executed_path_length":262,"expansions":1749,"goal_expert_reached":40,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":220,"path_found":64,"path_length_regret":30,"state_aliasing_failures":0,"transition_model_error_failures":24},"retention_holdout":{"classification_checksum":"f54d9e3f43f955a4","correct":253,"expert_evaluations":2048,"prediction_checksum":"46bedeaaabe47af4","prediction_samples":218,"prediction_sse_q20":39220105364,"reconstruction_checksum":"3ab5eed229fe1596","reconstruction_sse_q20":41050247678,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"e9cd61b1092da465","transition_correct":215,"transition_supported":218,"transition_unknown":38},"training_evaluations":1215944},"matched_expert_count_capacity":{"checkpoint_size_bytes":44924,"drift_holdout":{"classification_checksum":"c0805d5c513fd64d","correct":256,"expert_evaluations":2048,"prediction_checksum":"4f3f3ad857b4eecc","prediction_samples":225,"prediction_sse_q20":769294157026,"reconstruction_checksum":"6319e2be3f8e4c10","reconstruction_sse_q20":22877886642,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"c7471be1c948e02d","transition_correct":182,"transition_supported":225,"transition_unknown":31},"expert_count":67,"planning":{"belief_set_target_reached":39,"cases":64,"checksum":"885077a1f5ac6b8f","exact_world_state_target_reached":39,"executed_path_length":262,"expansions":1747,"goal_expert_reached":39,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":220,"path_found":64,"path_length_regret":29,"state_aliasing_failures":0,"transition_model_error_failures":25},"retention_holdout":{"classification_checksum":"f5f441692bd85186","correct":256,"expert_evaluations":2048,"prediction_checksum":"9f1bd6688f891a8d","prediction_samples":216,"prediction_sse_q20":24057885794,"reconstruction_checksum":"14700d7f45d63d2d","reconstruction_sse_q20":23251254337,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"e568230f143c7d10","transition_correct":213,"transition_supported":216,"transition_unknown":40},"training_evaluations":2812928},"nearest_centroid_16_no_recursive_births":{"checkpoint_size_bytes":15854,"drift_holdout":{"classification_checksum":"03547fb1b1a24a66","correct":77,"expert_evaluations":4096,"prediction_checksum":"35ceba6db0522a17","prediction_samples":256,"prediction_sse_q20":1930706178496,"reconstruction_checksum":"56804d35f9d2a140","reconstruction_sse_q20":1154968552216,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"b2ff7a0e09a51dea","transition_correct":132,"transition_supported":256,"transition_unknown":0},"expert_count":16,"planning":{"belief_set_target_reached":22,"cases":64,"checksum":"c363b370db16528e","exact_world_state_target_reached":8,"executed_path_length":155,"expansions":501,"goal_expert_reached":22,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":220,"path_found":64,"path_length_regret":0,"state_aliasing_failures":14,"transition_model_error_failures":42},"retention_holdout":{"classification_checksum":"08ff3c34c2866c78","correct":63,"expert_evaluations":4096,"prediction_checksum":"208e410985f373aa","prediction_samples":256,"prediction_sse_q20":1318898928299,"reconstruction_checksum":"4f470b8c1a069930","reconstruction_sse_q20":1165771868483,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"9fb05c54a612c7b2","transition_correct":155,"transition_supported":256,"transition_unknown":0},"training_evaluations":253952},"no_adaptation_static":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"d2aff7039b1403a4","correct":249,"expert_evaluations":2048,"prediction_checksum":"06ef937247a4cfeb","prediction_samples":230,"prediction_sse_q20":854896063671,"reconstruction_checksum":"712ee82dcc1278ee","reconstruction_sse_q20":49141661248,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"1bcf33df7910fc06","transition_correct":188,"transition_supported":230,"transition_unknown":26},"expert_count":64,"planning":{"belief_set_target_reached":40,"cases":64,"checksum":"88279132351699b6","exact_world_state_target_reached":40,"executed_path_length":262,"expansions":1749,"goal_expert_reached":40,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":220,"path_found":64,"path_length_regret":30,"state_aliasing_failures":0,"transition_model_error_failures":24},"retention_holdout":{"classification_checksum":"f54d9e3f43f955a4","correct":253,"expert_evaluations":2048,"prediction_checksum":"46bedeaaabe47af4","prediction_samples":218,"prediction_sse_q20":39220105364,"reconstruction_checksum":"3ab5eed229fe1596","reconstruction_sse_q20":41050247678,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"e9cd61b1092da465","transition_correct":215,"transition_supported":218,"transition_unknown":38},"training_evaluations":552392},"periodic_replay_policy":{"checkpoint_size_bytes":44354,"drift_holdout":{"classification_checksum":"2f7037b13ea3ff5d","correct":256,"expert_evaluations":2048,"prediction_checksum":"65f0e92c27641999","prediction_samples":227,"prediction_sse_q20":769946453559,"reconstruction_checksum":"33e58d117537b27e","reconstruction_sse_q20":23441039942,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"d3c42fdcbbf5245a","transition_correct":188,"transition_supported":227,"transition_unknown":29},"expert_count":66,"planning":{"belief_set_target_reached":40,"cases":64,"checksum":"4f01a31797e93961","exact_world_state_target_reached":40,"executed_path_length":258,"expansions":1788,"goal_expert_reached":40,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":220,"path_found":64,"path_length_regret":27,"state_aliasing_failures":0,"transition_model_error_failures":24},"retention_holdout":{"classification_checksum":"404ea2d58c4f511b","correct":256,"expert_evaluations":2048,"prediction_checksum":"4d450f0ee8c3fd95","prediction_samples":215,"prediction_sse_q20":44391995384,"reconstruction_checksum":"da29b59787c1e5b8","reconstruction_sse_q20":29277633650,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"7e0100eff213e9ac","transition_correct":214,"transition_supported":215,"transition_unknown":41},"training_evaluations":1005512},"ravel_0_5_candidate":{"checkpoint_size_bytes":44924,"drift_holdout":{"classification_checksum":"2f7037b13ea3ff5d","correct":256,"expert_evaluations":2048,"prediction_checksum":"354aed1588314d78","prediction_samples":231,"prediction_sse_q20":783957060027,"reconstruction_checksum":"32e7afc32cb3636a","reconstruction_sse_q20":23385381612,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"df5f672631e843c9","transition_correct":190,"transition_supported":231,"transition_unknown":25},"expert_count":67,"planning":{"belief_set_target_reached":40,"cases":64,"checksum":"4f01a31797e93961","exact_world_state_target_reached":40,"executed_path_length":258,"expansions":1788,"goal_expert_reached":40,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":220,"path_found":64,"path_length_regret":27,"state_aliasing_failures":0,"transition_model_error_failures":24},"retention_holdout":{"classification_checksum":"404ea2d58c4f511b","correct":256,"expert_evaluations":2048,"prediction_checksum":"c3c99a7918a44815","prediction_samples":217,"prediction_sse_q20":36461382080,"reconstruction_checksum":"d0b8a751cc2dc22d","reconstruction_sse_q20":29303048828,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"5ddf38e2beb9a9a2","transition_correct":215,"transition_supported":217,"transition_unknown":39},"training_evaluations":1123784},"ravel_complete_scan_without_certification":{"checkpoint_size_bytes":44924,"drift_holdout":{"classification_checksum":"2f7037b13ea3ff5d","correct":256,"expert_evaluations":17152,"prediction_checksum":"354aed1588314d78","prediction_samples":231,"prediction_sse_q20":783957060027,"reconstruction_checksum":"32e7afc32cb3636a","reconstruction_sse_q20":23385381612,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"df5f672631e843c9","transition_correct":190,"transition_supported":231,"transition_unknown":25},"expert_count":67,"planning":{"belief_set_target_reached":40,"cases":64,"checksum":"4f01a31797e93961","exact_world_state_target_reached":40,"executed_path_length":258,"expansions":1788,"goal_expert_reached":40,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":220,"path_found":64,"path_length_regret":27,"state_aliasing_failures":0,"transition_model_error_failures":24},"retention_holdout":{"classification_checksum":"404ea2d58c4f511b","correct":256,"expert_evaluations":17152,"prediction_checksum":"c3c99a7918a44815","prediction_samples":217,"prediction_sse_q20":36461382080,"reconstruction_checksum":"d0b8a751cc2dc22d","reconstruction_sse_q20":29303048828,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"5ddf38e2beb9a9a2","transition_correct":215,"transition_supported":217,"transition_unknown":39},"training_evaluations":1305032},"ravel_no_birth_same_replay_iterations":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"d2aff7039b1403a4","correct":249,"expert_evaluations":2048,"prediction_checksum":"06ef937247a4cfeb","prediction_samples":230,"prediction_sse_q20":854896063671,"reconstruction_checksum":"712ee82dcc1278ee","reconstruction_sse_q20":49141661248,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"1bcf33df7910fc06","transition_correct":188,"transition_supported":230,"transition_unknown":26},"expert_count":64,"planning":{"belief_set_target_reached":40,"cases":64,"checksum":"88279132351699b6","exact_world_state_target_reached":40,"executed_path_length":262,"expansions":1749,"goal_expert_reached":40,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":220,"path_found":64,"path_length_regret":30,"state_aliasing_failures":0,"transition_model_error_failures":24},"retention_holdout":{"classification_checksum":"f54d9e3f43f955a4","correct":253,"expert_evaluations":2048,"prediction_checksum":"46bedeaaabe47af4","prediction_samples":218,"prediction_sse_q20":39220105364,"reconstruction_checksum":"3ab5eed229fe1596","reconstruction_sse_q20":41050247678,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"e9cd61b1092da465","transition_correct":215,"transition_supported":218,"transition_unknown":38},"training_evaluations":773576},"ravel_random_births":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"d2aff7039b1403a4","correct":249,"expert_evaluations":2048,"prediction_checksum":"06ef937247a4cfeb","prediction_samples":230,"prediction_sse_q20":854896063671,"reconstruction_checksum":"712ee82dcc1278ee","reconstruction_sse_q20":49141661248,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"1bcf33df7910fc06","transition_correct":188,"transition_supported":230,"transition_unknown":26},"expert_count":64,"planning":{"belief_set_target_reached":40,"cases":64,"checksum":"88279132351699b6","exact_world_state_target_reached":40,"executed_path_length":262,"expansions":1749,"goal_expert_reached":40,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":220,"path_found":64,"path_length_regret":30,"state_aliasing_failures":0,"transition_model_error_failures":24},"retention_holdout":{"classification_checksum":"f54d9e3f43f955a4","correct":253,"expert_evaluations":2048,"prediction_checksum":"46bedeaaabe47af4","prediction_samples":218,"prediction_sse_q20":39220105364,"reconstruction_checksum":"3ab5eed229fe1596","reconstruction_sse_q20":41050247678,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"e9cd61b1092da465","transition_correct":215,"transition_supported":218,"transition_unknown":38},"training_evaluations":773576},"ravel_without_replay":{"checkpoint_size_bytes":44354,"drift_holdout":{"classification_checksum":"2986f7c7521fd4a3","correct":256,"expert_evaluations":2048,"prediction_checksum":"e717658f46d3fb7d","prediction_samples":226,"prediction_sse_q20":769900119607,"reconstruction_checksum":"828a1f84cf0201ce","reconstruction_sse_q20":23468918526,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"3e71856e18f97ab5","transition_correct":188,"transition_supported":226,"transition_unknown":30},"expert_count":66,"planning":{"belief_set_target_reached":40,"cases":64,"checksum":"4f01a31797e93961","exact_world_state_target_reached":40,"executed_path_length":258,"expansions":1788,"goal_expert_reached":40,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":220,"path_found":64,"path_length_regret":27,"state_aliasing_failures":0,"transition_model_error_failures":24},"retention_holdout":{"classification_checksum":"d4de0ccfae2885b7","correct":256,"expert_evaluations":2048,"prediction_checksum":"1756e3c103f0e8ef","prediction_samples":216,"prediction_sse_q20":44610099192,"reconstruction_checksum":"36a0e3fb54a7ba18","reconstruction_sse_q20":29293623436,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"f70edee214085863","transition_correct":215,"transition_supported":216,"transition_unknown":40},"training_evaluations":854472},"ravel_without_retirement_matched_work":{"checkpoint_size_bytes":44924,"drift_holdout":{"classification_checksum":"2f7037b13ea3ff5d","correct":256,"expert_evaluations":2048,"prediction_checksum":"354aed1588314d78","prediction_samples":231,"prediction_sse_q20":783957060027,"reconstruction_checksum":"32e7afc32cb3636a","reconstruction_sse_q20":23385381612,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"df5f672631e843c9","transition_correct":190,"transition_supported":231,"transition_unknown":25},"expert_count":67,"planning":{"belief_set_target_reached":40,"cases":64,"checksum":"4f01a31797e93961","exact_world_state_target_reached":40,"executed_path_length":258,"expansions":1788,"goal_expert_reached":40,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":220,"path_found":64,"path_length_regret":27,"state_aliasing_failures":0,"transition_model_error_failures":24},"retention_holdout":{"classification_checksum":"404ea2d58c4f511b","correct":256,"expert_evaluations":2048,"prediction_checksum":"c3c99a7918a44815","prediction_samples":217,"prediction_sse_q20":36461382080,"reconstruction_checksum":"d0b8a751cc2dc22d","reconstruction_sse_q20":29303048828,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"5ddf38e2beb9a9a2","transition_correct":215,"transition_supported":217,"transition_unknown":39},"training_evaluations":1123784}},"dataset_seeds":{"base_holdout":"0x9181af3a79412f55","base_training":"0xa8fb9b46bf45bcc4","drift_adaptation_training":"0x882ac184cb56fa12","drift_holdout":"0x91a84f54a4ec154e","original_task_retention_holdout":"0x53c641c200ceff36","planning_cases":"0x421cc91f89cfadc9"},"dataset_sizes":{"base_holdout":256,"base_training":1024,"drift_adaptation_training":512,"drift_holdout":256,"original_task_retention_holdout":256,"planning_cases":64},"integrity":{"checkpoint_behavior_match":true,"checkpoint_identity_match":true,"checkpoint_mutations":{"anchored_status":true,"appended_unexpected_byte":true,"checkpoint_substitution":true,"checkpoint_truncation":true,"incorrect_schema_version":true,"label":true,"label_count":true,"lineage":true,"next_observation_component":true,"payload_byte":true,"reconstruction_component":true,"retrieval_key_component":true,"transition_graph_edge":true,"transition_support":true},"checkpoint_roundtrip":true,"lineage_invariants":{"deterministic_topology_reproduction":true,"lineage_uniqueness":true,"no_accidental_lineage_reuse":true,"parent_child_generation_increment":true,"repeated_descendant_splitting":true,"sibling_generation_equality":true},"unsupported_graph_edge_violations":0},"regime":"transition_drift","schema":"ravel-raw-trial/0.5","seed":"0x60919d13af913fb7","trial_id":"validation-transition-03"},{"candidate":{"adaptation_completed":true,"adaptation_training":{"classification_checksum":"5082e7b2371a69d5","correct":512,"expert_evaluations":4096,"prediction_checksum":"01752d3082886047","prediction_samples":472,"prediction_sse_q20":1322178879392,"reconstruction_checksum":"2a05af179c05e9fc","reconstruction_sse_q20":72627103461,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":512,"samples":512,"transition_checksum":"1923828cbb39ffde","transition_correct":393,"transition_supported":472,"transition_unknown":40},"adaptation_training_evaluations":1185792,"adapted_model_drift_holdout":{"classification_checksum":"50ec78372625ff38","correct":256,"expert_evaluations":2048,"prediction_checksum":"b71a2c8eecbbd5b6","prediction_samples":226,"prediction_sse_q20":941834713054,"reconstruction_checksum":"2ec4db3af952d00c","reconstruction_sse_q20":45047611726,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"7b5346c768153116","transition_correct":174,"transition_supported":226,"transition_unknown":30},"base_holdout":{"classification_checksum":"0830e87c256b69b6","correct":237,"expert_evaluations":2048,"prediction_checksum":"5975eb268f0f8557","prediction_samples":235,"prediction_sse_q20":110844354444,"reconstruction_checksum":"6a908491cc230a5a","reconstruction_sse_q20":95150622585,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"f10d54d191900bcc","transition_correct":214,"transition_supported":235,"transition_unknown":21},"base_holdout_retention":{"classification_checksum":"bf03d3afd84a5c36","correct":256,"expert_evaluations":2048,"prediction_checksum":"874604b5d2e8b24b","prediction_samples":227,"prediction_sse_q20":146179337600,"reconstruction_checksum":"6a8b1da751ceec8a","reconstruction_sse_q20":39100068874,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"06154780dfdc0489","transition_correct":204,"transition_supported":227,"transition_unknown":29},"base_training_evaluations":557112,"behavior_identity":"e5f5199f84c90360462832cd5e70c98b781cd337f46a23f811729ddb648543c0","checkpoint_size_bytes":47774,"expert_count":72,"model_identity":"546c494b363f6a315869183ce46e40ce5233c415b8fef519733faae9fbc34921","planning":{"belief_set_target_reached":27,"cases":64,"checksum":"31d3aa12d8fdeb65","exact_world_state_target_reached":27,"executed_path_length":259,"expansions":2143,"goal_expert_reached":27,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":214,"path_found":64,"path_length_regret":4,"state_aliasing_failures":0,"transition_model_error_failures":37},"replay":{"actions_covered":4,"assigned_experts_covered":63,"high_loss_cases_selected":15,"labels_covered":8,"rare_cases_selected":56,"selected":256,"selection_checksum":"bcc2e79ec112612f","states_covered":64,"transition_pairs_covered":250,"unique":256},"static_model_drift_holdout":{"classification_checksum":"54348ec604174daa","correct":236,"expert_evaluations":2048,"prediction_checksum":"951feb7395652caa","prediction_samples":234,"prediction_sse_q20":1213589737368,"reconstruction_checksum":"e1ed96ae01525456","reconstruction_sse_q20":103916376985,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"f8d521534f7825af","transition_correct":169,"transition_supported":234,"transition_unknown":22},"topology":{"accepted_births":8,"accepted_retirements":0,"births":[{"dominant_channel":0,"event_index":41,"normalized_score_q20":660402},{"dominant_channel":0,"event_index":490,"normalized_score_q20":563053},{"dominant_channel":0,"event_index":405,"normalized_score_q20":549541},{"dominant_channel":0,"event_index":100,"normalized_score_q20":540695},{"dominant_channel":0,"event_index":499,"normalized_score_q20":506127},{"dominant_channel":2,"event_index":31,"normalized_score_q20":380420},{"dominant_channel":2,"event_index":174,"normalized_score_q20":344084},{"dominant_channel":2,"event_index":163,"normalized_score_q20":322672}],"objective_after_q20":903301,"objective_before_q20":864256,"rejected_births":8,"rejected_retirements":1,"retired_lineages":[],"training_observations":{"births":8,"certified":15360,"expert_evaluations":1185792,"rejected_births":8,"rejected_retirements":1,"retired":0,"samples":15360}}},"checkpoint_format":{"byte_order":"big_endian","magic_hex":"524156454c303500","payload_digest":"sha256","real_encoding":"signed_q20_int64","schema_version":5,"transition_support_min":2,"transition_top_k":2},"comparisons":{"fixed_8_expert":{"checkpoint_size_bytes":11294,"drift_holdout":{"classification_checksum":"aa14b31d7d427787","correct":58,"expert_evaluations":2048,"prediction_checksum":"563c02fdf4a70828","prediction_samples":256,"prediction_sse_q20":2462622659076,"reconstruction_checksum":"dffc071ad3110717","reconstruction_sse_q20":1761199049689,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"72f530637b419ca2","transition_correct":100,"transition_supported":256,"transition_unknown":0},"expert_count":8,"planning":{"belief_set_target_reached":17,"cases":64,"checksum":"170a5cecae4628b9","exact_world_state_target_reached":0,"executed_path_length":53,"expansions":230,"goal_expert_reached":17,"graph_disconnection_failures":24,"no_supported_edge_failures":0,"optimal_path_length":214,"path_found":40,"path_length_regret":0,"state_aliasing_failures":17,"transition_model_error_failures":23},"retention_holdout":{"classification_checksum":"b98b30076970fe77","correct":54,"expert_evaluations":2048,"prediction_checksum":"1cf53f097faf71d4","prediction_samples":256,"prediction_sse_q20":1868089007291,"reconstruction_checksum":"dec0034856b46fe6","reconstruction_sse_q20":1710142990162,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"51eb24d83dd6da07","transition_correct":131,"transition_supported":256,"transition_unknown":0},"training_evaluations":94208},"fixed_topology_64_expert_routed":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"ce498d150fc415a1","correct":256,"expert_evaluations":2048,"prediction_checksum":"8a3eb86e328f3ead","prediction_samples":230,"prediction_sse_q20":1122247480850,"reconstruction_checksum":"59606588dd4a8212","reconstruction_sse_q20":24084563787,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"292d75289506bf4c","transition_correct":178,"transition_supported":230,"transition_unknown":26},"expert_count":64,"planning":{"belief_set_target_reached":38,"cases":64,"checksum":"8bbb1ca1ed38bf3f","exact_world_state_target_reached":38,"executed_path_length":316,"expansions":2109,"goal_expert_reached":38,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":214,"path_found":64,"path_length_regret":50,"state_aliasing_failures":0,"transition_model_error_failures":26},"retention_holdout":{"classification_checksum":"0e67f95314b012f6","correct":256,"expert_evaluations":2048,"prediction_checksum":"0180ba47878a8e39","prediction_samples":223,"prediction_sse_q20":24193609968,"reconstruction_checksum":"9afbb783f04348e5","reconstruction_sse_q20":22243093043,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"f4703bad1808adfe","transition_correct":223,"transition_supported":223,"transition_unknown":33},"training_evaluations":2588672},"flat_64_expert_complete_scan":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"ce498d150fc415a1","correct":256,"expert_evaluations":16384,"prediction_checksum":"8a3eb86e328f3ead","prediction_samples":230,"prediction_sse_q20":1122247480850,"reconstruction_checksum":"59606588dd4a8212","reconstruction_sse_q20":24084563787,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"292d75289506bf4c","transition_correct":178,"transition_supported":230,"transition_unknown":26},"expert_count":64,"planning":{"belief_set_target_reached":38,"cases":64,"checksum":"8bbb1ca1ed38bf3f","exact_world_state_target_reached":38,"executed_path_length":316,"expansions":2109,"goal_expert_reached":38,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":214,"path_found":64,"path_length_regret":50,"state_aliasing_failures":0,"transition_model_error_failures":26},"retention_holdout":{"classification_checksum":"0e67f95314b012f6","correct":256,"expert_evaluations":16384,"prediction_checksum":"0180ba47878a8e39","prediction_samples":223,"prediction_sse_q20":24193609968,"reconstruction_checksum":"9afbb783f04348e5","reconstruction_sse_q20":22243093043,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"f4703bad1808adfe","transition_correct":223,"transition_supported":223,"transition_unknown":33},"training_evaluations":2588672},"matched_compute_fixed_topology":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"54348ec604174daa","correct":236,"expert_evaluations":2048,"prediction_checksum":"951feb7395652caa","prediction_samples":234,"prediction_sse_q20":1213589737368,"reconstruction_checksum":"e1ed96ae01525456","reconstruction_sse_q20":103916376985,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"f8d521534f7825af","transition_correct":169,"transition_supported":234,"transition_unknown":22},"expert_count":64,"planning":{"belief_set_target_reached":24,"cases":64,"checksum":"e9baadd06b58f53c","exact_world_state_target_reached":23,"executed_path_length":258,"expansions":1887,"goal_expert_reached":24,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":214,"path_found":64,"path_length_regret":11,"state_aliasing_failures":1,"transition_model_error_failures":40},"retention_holdout":{"classification_checksum":"86ab57ccf8539a0c","correct":235,"expert_evaluations":2048,"prediction_checksum":"be8ebddf685bf95c","prediction_samples":230,"prediction_sse_q20":121069256503,"reconstruction_checksum":"ac49fa1399183e33","reconstruction_sse_q20":98008036994,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"7f6446f1ec07e616","transition_correct":210,"transition_supported":230,"transition_unknown":26},"training_evaluations":1884216},"matched_expert_count_capacity":{"checkpoint_size_bytes":47774,"drift_holdout":{"classification_checksum":"fd535caa84d31fbd","correct":256,"expert_evaluations":2048,"prediction_checksum":"be29266182812b6f","prediction_samples":218,"prediction_sse_q20":1086382857147,"reconstruction_checksum":"206535ea00cf21bb","reconstruction_sse_q20":24062992979,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"6b1b16a56c7e5bde","transition_correct":163,"transition_supported":218,"transition_unknown":38},"expert_count":72,"planning":{"belief_set_target_reached":37,"cases":64,"checksum":"1c8f5f496abaac36","exact_world_state_target_reached":37,"executed_path_length":313,"expansions":2316,"goal_expert_reached":37,"graph_disconnection_failures":0,"no_supported_edge_failures":2,"optimal_path_length":214,"path_found":62,"path_length_regret":55,"state_aliasing_failures":0,"transition_model_error_failures":25},"retention_holdout":{"classification_checksum":"9211d700fb42482e","correct":256,"expert_evaluations":2048,"prediction_checksum":"2faeded2ff877cc0","prediction_samples":213,"prediction_sse_q20":23206198151,"reconstruction_checksum":"484d2596055cfaa0","reconstruction_sse_q20":22286143502,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"932ccda0448dbbb7","transition_correct":208,"transition_supported":213,"transition_unknown":43},"training_evaluations":3207168},"nearest_centroid_16_no_recursive_births":{"checkpoint_size_bytes":15854,"drift_holdout":{"classification_checksum":"1cb5ec529393a2cf","correct":65,"expert_evaluations":4096,"prediction_checksum":"bae2ff1877a75d1d","prediction_samples":256,"prediction_sse_q20":2123319295089,"reconstruction_checksum":"206013afd60160dd","reconstruction_sse_q20":1088014429520,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"cd808348c181500c","transition_correct":171,"transition_supported":256,"transition_unknown":0},"expert_count":16,"planning":{"belief_set_target_reached":37,"cases":64,"checksum":"b0dafffd0d91b28b","exact_world_state_target_reached":4,"executed_path_length":140,"expansions":504,"goal_expert_reached":37,"graph_disconnection_failures":2,"no_supported_edge_failures":0,"optimal_path_length":214,"path_found":62,"path_length_regret":2,"state_aliasing_failures":33,"transition_model_error_failures":25},"retention_holdout":{"classification_checksum":"cf84088b5870e957","correct":57,"expert_evaluations":4096,"prediction_checksum":"d51a2cf9bfa93c4b","prediction_samples":256,"prediction_sse_q20":1175769793120,"reconstruction_checksum":"de0cfaa74d64977e","reconstruction_sse_q20":1063892961701,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"bbd67d3fd62730e7","transition_correct":213,"transition_supported":256,"transition_unknown":0},"training_evaluations":253952},"no_adaptation_static":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"54348ec604174daa","correct":236,"expert_evaluations":2048,"prediction_checksum":"951feb7395652caa","prediction_samples":234,"prediction_sse_q20":1213589737368,"reconstruction_checksum":"e1ed96ae01525456","reconstruction_sse_q20":103916376985,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"f8d521534f7825af","transition_correct":169,"transition_supported":234,"transition_unknown":22},"expert_count":64,"planning":{"belief_set_target_reached":24,"cases":64,"checksum":"e9baadd06b58f53c","exact_world_state_target_reached":23,"executed_path_length":258,"expansions":1887,"goal_expert_reached":24,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":214,"path_found":64,"path_length_regret":11,"state_aliasing_failures":1,"transition_model_error_failures":40},"retention_holdout":{"classification_checksum":"86ab57ccf8539a0c","correct":235,"expert_evaluations":2048,"prediction_checksum":"be8ebddf685bf95c","prediction_samples":230,"prediction_sse_q20":121069256503,"reconstruction_checksum":"ac49fa1399183e33","reconstruction_sse_q20":98008036994,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"7f6446f1ec07e616","transition_correct":210,"transition_supported":230,"transition_unknown":26},"training_evaluations":557112},"periodic_replay_policy":{"checkpoint_size_bytes":47774,"drift_holdout":{"classification_checksum":"cde9897050d06408","correct":256,"expert_evaluations":2048,"prediction_checksum":"f5c4c2db5d4ddee0","prediction_samples":228,"prediction_sse_q20":965652101135,"reconstruction_checksum":"83cab7a3818c688c","reconstruction_sse_q20":45038914725,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"19dac514c9a76190","transition_correct":174,"transition_supported":228,"transition_unknown":28},"expert_count":72,"planning":{"belief_set_target_reached":28,"cases":64,"checksum":"e9d1e148db7fa985","exact_world_state_target_reached":28,"executed_path_length":260,"expansions":2186,"goal_expert_reached":28,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":214,"path_found":64,"path_length_regret":5,"state_aliasing_failures":0,"transition_model_error_failures":36},"retention_holdout":{"classification_checksum":"bf03d3afd84a5c36","correct":256,"expert_evaluations":2048,"prediction_checksum":"43e3048c059934a4","prediction_samples":224,"prediction_sse_q20":182134457039,"reconstruction_checksum":"f9311fa3fdeafda9","reconstruction_sse_q20":39106847104,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"740051b87b5085ad","transition_correct":202,"transition_supported":224,"transition_unknown":32},"training_evaluations":1742904},"ravel_0_5_candidate":{"checkpoint_size_bytes":47774,"drift_holdout":{"classification_checksum":"50ec78372625ff38","correct":256,"expert_evaluations":2048,"prediction_checksum":"b71a2c8eecbbd5b6","prediction_samples":226,"prediction_sse_q20":941834713054,"reconstruction_checksum":"2ec4db3af952d00c","reconstruction_sse_q20":45047611726,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"7b5346c768153116","transition_correct":174,"transition_supported":226,"transition_unknown":30},"expert_count":72,"planning":{"belief_set_target_reached":27,"cases":64,"checksum":"31d3aa12d8fdeb65","exact_world_state_target_reached":27,"executed_path_length":259,"expansions":2143,"goal_expert_reached":27,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":214,"path_found":64,"path_length_regret":4,"state_aliasing_failures":0,"transition_model_error_failures":37},"retention_holdout":{"classification_checksum":"bf03d3afd84a5c36","correct":256,"expert_evaluations":2048,"prediction_checksum":"874604b5d2e8b24b","prediction_samples":227,"prediction_sse_q20":146179337600,"reconstruction_checksum":"6a8b1da751ceec8a","reconstruction_sse_q20":39100068874,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"06154780dfdc0489","transition_correct":204,"transition_supported":227,"transition_unknown":29},"training_evaluations":1742904},"ravel_complete_scan_without_certification":{"checkpoint_size_bytes":47774,"drift_holdout":{"classification_checksum":"50ec78372625ff38","correct":256,"expert_evaluations":18432,"prediction_checksum":"b71a2c8eecbbd5b6","prediction_samples":226,"prediction_sse_q20":941834713054,"reconstruction_checksum":"2ec4db3af952d00c","reconstruction_sse_q20":45047611726,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"7b5346c768153116","transition_correct":174,"transition_supported":226,"transition_unknown":30},"expert_count":72,"planning":{"belief_set_target_reached":27,"cases":64,"checksum":"31d3aa12d8fdeb65","exact_world_state_target_reached":27,"executed_path_length":259,"expansions":2143,"goal_expert_reached":27,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":214,"path_found":64,"path_length_regret":4,"state_aliasing_failures":0,"transition_model_error_failures":37},"retention_holdout":{"classification_checksum":"bf03d3afd84a5c36","correct":256,"expert_evaluations":18432,"prediction_checksum":"874604b5d2e8b24b","prediction_samples":227,"prediction_sse_q20":146179337600,"reconstruction_checksum":"6a8b1da751ceec8a","reconstruction_sse_q20":39100068874,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"06154780dfdc0489","transition_correct":204,"transition_supported":227,"transition_unknown":29},"training_evaluations":1939512},"ravel_no_birth_same_replay_iterations":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"54348ec604174daa","correct":236,"expert_evaluations":2048,"prediction_checksum":"951feb7395652caa","prediction_samples":234,"prediction_sse_q20":1213589737368,"reconstruction_checksum":"e1ed96ae01525456","reconstruction_sse_q20":103916376985,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"f8d521534f7825af","transition_correct":169,"transition_supported":234,"transition_unknown":22},"expert_count":64,"planning":{"belief_set_target_reached":24,"cases":64,"checksum":"e9baadd06b58f53c","exact_world_state_target_reached":23,"executed_path_length":258,"expansions":1887,"goal_expert_reached":24,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":214,"path_found":64,"path_length_regret":11,"state_aliasing_failures":1,"transition_model_error_failures":40},"retention_holdout":{"classification_checksum":"86ab57ccf8539a0c","correct":235,"expert_evaluations":2048,"prediction_checksum":"be8ebddf685bf95c","prediction_samples":230,"prediction_sse_q20":121069256503,"reconstruction_checksum":"ac49fa1399183e33","reconstruction_sse_q20":98008036994,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"7f6446f1ec07e616","transition_correct":210,"transition_supported":230,"transition_unknown":26},"training_evaluations":778296},"ravel_random_births":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"54348ec604174daa","correct":236,"expert_evaluations":2048,"prediction_checksum":"951feb7395652caa","prediction_samples":234,"prediction_sse_q20":1213589737368,"reconstruction_checksum":"e1ed96ae01525456","reconstruction_sse_q20":103916376985,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"f8d521534f7825af","transition_correct":169,"transition_supported":234,"transition_unknown":22},"expert_count":64,"planning":{"belief_set_target_reached":24,"cases":64,"checksum":"e9baadd06b58f53c","exact_world_state_target_reached":23,"executed_path_length":258,"expansions":1887,"goal_expert_reached":24,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":214,"path_found":64,"path_length_regret":11,"state_aliasing_failures":1,"transition_model_error_failures":40},"retention_holdout":{"classification_checksum":"86ab57ccf8539a0c","correct":235,"expert_evaluations":2048,"prediction_checksum":"be8ebddf685bf95c","prediction_samples":230,"prediction_sse_q20":121069256503,"reconstruction_checksum":"ac49fa1399183e33","reconstruction_sse_q20":98008036994,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"7f6446f1ec07e616","transition_correct":210,"transition_supported":230,"transition_unknown":26},"training_evaluations":778296},"ravel_without_replay":{"checkpoint_size_bytes":47774,"drift_holdout":{"classification_checksum":"50ec78372625ff38","correct":256,"expert_evaluations":2048,"prediction_checksum":"0e106578fddbc0ac","prediction_samples":224,"prediction_sse_q20":932160117438,"reconstruction_checksum":"06849aadfe17b959","reconstruction_sse_q20":45046210621,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"ec3f563e2d4e8c5f","transition_correct":172,"transition_supported":224,"transition_unknown":32},"expert_count":72,"planning":{"belief_set_target_reached":27,"cases":64,"checksum":"2caa5d014cc2ddea","exact_world_state_target_reached":27,"executed_path_length":259,"expansions":2136,"goal_expert_reached":27,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":214,"path_found":64,"path_length_regret":4,"state_aliasing_failures":0,"transition_model_error_failures":37},"retention_holdout":{"classification_checksum":"bf03d3afd84a5c36","correct":256,"expert_evaluations":2048,"prediction_checksum":"b19336e106a4eff7","prediction_samples":223,"prediction_sse_q20":211722214821,"reconstruction_checksum":"5adc84a3d589ca31","reconstruction_sse_q20":39158641631,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"ff77d483f9a16f2b","transition_correct":201,"transition_supported":223,"transition_unknown":33},"training_evaluations":1347640},"ravel_without_retirement_matched_work":{"checkpoint_size_bytes":47774,"drift_holdout":{"classification_checksum":"50ec78372625ff38","correct":256,"expert_evaluations":2048,"prediction_checksum":"b71a2c8eecbbd5b6","prediction_samples":226,"prediction_sse_q20":941834713054,"reconstruction_checksum":"2ec4db3af952d00c","reconstruction_sse_q20":45047611726,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"7b5346c768153116","transition_correct":174,"transition_supported":226,"transition_unknown":30},"expert_count":72,"planning":{"belief_set_target_reached":27,"cases":64,"checksum":"31d3aa12d8fdeb65","exact_world_state_target_reached":27,"executed_path_length":259,"expansions":2143,"goal_expert_reached":27,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":214,"path_found":64,"path_length_regret":4,"state_aliasing_failures":0,"transition_model_error_failures":37},"retention_holdout":{"classification_checksum":"bf03d3afd84a5c36","correct":256,"expert_evaluations":2048,"prediction_checksum":"874604b5d2e8b24b","prediction_samples":227,"prediction_sse_q20":146179337600,"reconstruction_checksum":"6a8b1da751ceec8a","reconstruction_sse_q20":39100068874,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"06154780dfdc0489","transition_correct":204,"transition_supported":227,"transition_unknown":29},"training_evaluations":1742904}},"dataset_seeds":{"base_holdout":"0x1a7d2fb71809b555","base_training":"0x4b279402e63a1d79","drift_adaptation_training":"0x7a1ebd03204bdb79","drift_holdout":"0x4f7da3a9d31d4c37","original_task_retention_holdout":"0xfafa28ae658585a8","planning_cases":"0x7e2d18e91ce618b2"},"dataset_sizes":{"base_holdout":256,"base_training":1024,"drift_adaptation_training":512,"drift_holdout":256,"original_task_retention_holdout":256,"planning_cases":64},"integrity":{"checkpoint_behavior_match":true,"checkpoint_identity_match":true,"checkpoint_mutations":{"anchored_status":true,"appended_unexpected_byte":true,"checkpoint_substitution":true,"checkpoint_truncation":true,"incorrect_schema_version":true,"label":true,"label_count":true,"lineage":true,"next_observation_component":true,"payload_byte":true,"reconstruction_component":true,"retrieval_key_component":true,"transition_graph_edge":true,"transition_support":true},"checkpoint_roundtrip":true,"lineage_invariants":{"deterministic_topology_reproduction":true,"lineage_uniqueness":true,"no_accidental_lineage_reuse":true,"parent_child_generation_increment":true,"repeated_descendant_splitting":true,"sibling_generation_equality":true},"unsupported_graph_edge_violations":0},"regime":"transition_drift","schema":"ravel-raw-trial/0.5","seed":"0xe8f0f59872923c4c","trial_id":"validation-transition-04"},{"candidate":{"adaptation_completed":true,"adaptation_training":{"classification_checksum":"65ce52f17a18d1d6","correct":406,"expert_evaluations":5824,"prediction_checksum":"bc47f6b15778974c","prediction_samples":480,"prediction_sse_q20":276839225691,"reconstruction_checksum":"60a7d59cf8100853","reconstruction_sse_q20":261939841728,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":488,"samples":512,"transition_checksum":"f2cd2e8724231078","transition_correct":425,"transition_supported":480,"transition_unknown":32},"adaptation_training_evaluations":2216180,"adapted_model_drift_holdout":{"classification_checksum":"3f7507fac56f80aa","correct":199,"expert_evaluations":2912,"prediction_checksum":"c1e23d95196381c2","prediction_samples":229,"prediction_sse_q20":143507167744,"reconstruction_checksum":"92918517d24fdb9e","reconstruction_sse_q20":132389549772,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":244,"samples":256,"transition_checksum":"ae6838aee46db266","transition_correct":197,"transition_supported":229,"transition_unknown":27},"base_holdout":{"classification_checksum":"9ad528ae1910afd0","correct":243,"expert_evaluations":2384,"prediction_checksum":"0337ec963be0b6c3","prediction_samples":235,"prediction_sse_q20":93510371439,"reconstruction_checksum":"bd71a7ac42ccc5dd","reconstruction_sse_q20":75175546529,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":250,"samples":256,"transition_checksum":"79fc9b5fedb85791","transition_correct":221,"transition_supported":235,"transition_unknown":21},"base_holdout_retention":{"classification_checksum":"41210aae48a1284d","correct":248,"expert_evaluations":2264,"prediction_checksum":"13790f2f4976237f","prediction_samples":230,"prediction_sse_q20":62132800681,"reconstruction_checksum":"c42cec193534285b","reconstruction_sse_q20":56680388952,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":253,"samples":256,"transition_checksum":"abe9af67064366c1","transition_correct":218,"transition_supported":230,"transition_unknown":26},"base_training_evaluations":577720,"behavior_identity":"d48e80e26cb592acf36281097e6bac707d7c6fee7a6c0b607ed4c87ec105c2c2","checkpoint_size_bytes":52334,"expert_count":80,"model_identity":"c767ee69efbb473584396d0041c3c774ef300c123c9a3e0d2ad982ba0b151bef","planning":{"belief_set_target_reached":47,"cases":64,"checksum":"be6052f983195d6e","exact_world_state_target_reached":47,"executed_path_length":292,"expansions":2384,"goal_expert_reached":47,"graph_disconnection_failures":0,"no_supported_edge_failures":4,"optimal_path_length":276,"path_found":60,"path_length_regret":43,"state_aliasing_failures":0,"transition_model_error_failures":13},"replay":{"actions_covered":4,"assigned_experts_covered":62,"high_loss_cases_selected":13,"labels_covered":8,"rare_cases_selected":60,"selected":256,"selection_checksum":"47c980d6b8dd353e","states_covered":64,"transition_pairs_covered":255,"unique":256},"static_model_drift_holdout":{"classification_checksum":"9df6af3e4f64679e","correct":157,"expert_evaluations":3112,"prediction_checksum":"e9fe1a933152aa43","prediction_samples":233,"prediction_sse_q20":194723929899,"reconstruction_checksum":"23cb3093c0621fc9","reconstruction_sse_q20":173766613986,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":237,"samples":256,"transition_checksum":"4945ea65fda03463","transition_correct":218,"transition_supported":233,"transition_unknown":23},"topology":{"accepted_births":16,"accepted_retirements":0,"births":[{"dominant_channel":0,"event_index":458,"normalized_score_q20":588577},{"dominant_channel":0,"event_index":450,"normalized_score_q20":582721},{"dominant_channel":0,"event_index":124,"normalized_score_q20":578615},{"dominant_channel":0,"event_index":89,"normalized_score_q20":577534},{"dominant_channel":0,"event_index":465,"normalized_score_q20":563083},{"dominant_channel":0,"event_index":433,"normalized_score_q20":562624},{"dominant_channel":0,"event_index":159,"normalized_score_q20":558359},{"dominant_channel":0,"event_index":181,"normalized_score_q20":531421},{"dominant_channel":0,"event_index":443,"normalized_score_q20":522606},{"dominant_channel":0,"event_index":455,"normalized_score_q20":504019},{"dominant_channel":0,"event_index":281,"normalized_score_q20":496674},{"dominant_channel":0,"event_index":276,"normalized_score_q20":489950},{"dominant_channel":0,"event_index":268,"normalized_score_q20":437362},{"dominant_channel":0,"event_index":214,"normalized_score_q20":437202},{"dominant_channel":0,"event_index":481,"normalized_score_q20":430134},{"dominant_channel":0,"event_index":420,"normalized_score_q20":428122}],"objective_after_q20":856847,"objective_before_q20":807559,"rejected_births":0,"rejected_retirements":1,"retired_lineages":[],"training_observations":{"births":16,"certified":24625,"expert_evaluations":2216180,"rejected_births":0,"rejected_retirements":1,"retired":0,"samples":26112}}},"checkpoint_format":{"byte_order":"big_endian","magic_hex":"524156454c303500","payload_digest":"sha256","real_encoding":"signed_q20_int64","schema_version":5,"transition_support_min":2,"transition_top_k":2},"comparisons":{"fixed_8_expert":{"checkpoint_size_bytes":11294,"drift_holdout":{"classification_checksum":"f3befe5edfe616ba","correct":39,"expert_evaluations":2048,"prediction_checksum":"d1b6fcf02740b7f7","prediction_samples":256,"prediction_sse_q20":1516059146998,"reconstruction_checksum":"99ccedafef3975e4","reconstruction_sse_q20":1312877462777,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"6502a682fe797823","transition_correct":133,"transition_supported":256,"transition_unknown":0},"expert_count":8,"planning":{"belief_set_target_reached":28,"cases":64,"checksum":"6c476157f9626a25","exact_world_state_target_reached":4,"executed_path_length":69,"expansions":223,"goal_expert_reached":28,"graph_disconnection_failures":14,"no_supported_edge_failures":0,"optimal_path_length":276,"path_found":50,"path_length_regret":0,"state_aliasing_failures":24,"transition_model_error_failures":22},"retention_holdout":{"classification_checksum":"2b743156d20dfb4c","correct":37,"expert_evaluations":2048,"prediction_checksum":"de586ed68743991f","prediction_samples":256,"prediction_sse_q20":1423679680629,"reconstruction_checksum":"5a5c5cb0c1441505","reconstruction_sse_q20":1221276170388,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"f40511cca68e4061","transition_correct":154,"transition_supported":256,"transition_unknown":0},"training_evaluations":94208},"fixed_topology_64_expert_routed":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"7263305129930af1","correct":169,"expert_evaluations":2552,"prediction_checksum":"87df102897c095b0","prediction_samples":230,"prediction_sse_q20":141731052454,"reconstruction_checksum":"f89d87cf419b2a9d","reconstruction_sse_q20":143443582679,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":247,"samples":256,"transition_checksum":"2a4340d949f0765b","transition_correct":230,"transition_supported":230,"transition_unknown":26},"expert_count":64,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"89ce570a338da1bc","exact_world_state_target_reached":64,"executed_path_length":318,"expansions":2072,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":276,"path_found":64,"path_length_regret":42,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"7cbb54f464691410","correct":256,"expert_evaluations":2048,"prediction_checksum":"238cc742c2d3f258","prediction_samples":234,"prediction_sse_q20":46655944299,"reconstruction_checksum":"032be68080540b8a","reconstruction_sse_q20":40949027910,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"151f665cc5b8b8c0","transition_correct":234,"transition_supported":234,"transition_unknown":22},"training_evaluations":2588672},"flat_64_expert_complete_scan":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"7263305129930af1","correct":169,"expert_evaluations":16384,"prediction_checksum":"87df102897c095b0","prediction_samples":230,"prediction_sse_q20":141731052454,"reconstruction_checksum":"f89d87cf419b2a9d","reconstruction_sse_q20":143443582679,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"2a4340d949f0765b","transition_correct":230,"transition_supported":230,"transition_unknown":26},"expert_count":64,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"89ce570a338da1bc","exact_world_state_target_reached":64,"executed_path_length":318,"expansions":2072,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":276,"path_found":64,"path_length_regret":42,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"7cbb54f464691410","correct":256,"expert_evaluations":16384,"prediction_checksum":"238cc742c2d3f258","prediction_samples":234,"prediction_sse_q20":46655944299,"reconstruction_checksum":"032be68080540b8a","reconstruction_sse_q20":40949027910,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"151f665cc5b8b8c0","transition_correct":234,"transition_supported":234,"transition_unknown":22},"training_evaluations":2588672},"matched_compute_fixed_topology":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"9df6af3e4f64679e","correct":157,"expert_evaluations":3112,"prediction_checksum":"e9fe1a933152aa43","prediction_samples":233,"prediction_sse_q20":194723929899,"reconstruction_checksum":"23cb3093c0621fc9","reconstruction_sse_q20":173766613986,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":237,"samples":256,"transition_checksum":"4945ea65fda03463","transition_correct":218,"transition_supported":233,"transition_unknown":23},"expert_count":64,"planning":{"belief_set_target_reached":39,"cases":64,"checksum":"43d610c6dd921ee1","exact_world_state_target_reached":36,"executed_path_length":243,"expansions":1973,"goal_expert_reached":39,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":276,"path_found":64,"path_length_regret":21,"state_aliasing_failures":3,"transition_model_error_failures":25},"retention_holdout":{"classification_checksum":"8fba0b512b56c23f","correct":244,"expert_evaluations":2552,"prediction_checksum":"2704c9956ffd5cd6","prediction_samples":233,"prediction_sse_q20":81222786563,"reconstruction_checksum":"2fb964254ca774a9","reconstruction_sse_q20":78397652349,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":247,"samples":256,"transition_checksum":"57b27de6cec4164a","transition_correct":216,"transition_supported":233,"transition_unknown":23},"training_evaluations":2685304},"matched_expert_count_capacity":{"checkpoint_size_bytes":52334,"drift_holdout":{"classification_checksum":"2df3de985b9adddf","correct":169,"expert_evaluations":3344,"prediction_checksum":"92bb13bc649ea7ed","prediction_samples":212,"prediction_sse_q20":131138075625,"reconstruction_checksum":"9ac42dc81a3088d5","reconstruction_sse_q20":141133971556,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":238,"samples":256,"transition_checksum":"6668fcafe8944251","transition_correct":188,"transition_supported":212,"transition_unknown":44},"expert_count":80,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"09e2219b90c90d97","exact_world_state_target_reached":64,"executed_path_length":334,"expansions":2358,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":276,"path_found":64,"path_length_regret":58,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"5249604eeb5f4952","correct":256,"expert_evaluations":2048,"prediction_checksum":"26ab992c0c3b8e3c","prediction_samples":212,"prediction_sse_q20":42614274473,"reconstruction_checksum":"cf0cb8873e8372bc","reconstruction_sse_q20":40146012520,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"b4549f28cedc6ac1","transition_correct":183,"transition_supported":212,"transition_unknown":44},"training_evaluations":3891200},"nearest_centroid_16_no_recursive_births":{"checkpoint_size_bytes":15854,"drift_holdout":{"classification_checksum":"6063235a50618506","correct":46,"expert_evaluations":4096,"prediction_checksum":"1e534461d9e0dc2c","prediction_samples":256,"prediction_sse_q20":913886087703,"reconstruction_checksum":"73256c0c1c5f45c0","reconstruction_sse_q20":853088887936,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"08c417f91f5490d2","transition_correct":163,"transition_supported":256,"transition_unknown":0},"expert_count":16,"planning":{"belief_set_target_reached":46,"cases":64,"checksum":"795128dd7c885dba","exact_world_state_target_reached":10,"executed_path_length":151,"expansions":520,"goal_expert_reached":46,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":276,"path_found":64,"path_length_regret":2,"state_aliasing_failures":36,"transition_model_error_failures":18},"retention_holdout":{"classification_checksum":"36fabc4d2f906b7f","correct":55,"expert_evaluations":4096,"prediction_checksum":"88d29a9d41b80012","prediction_samples":256,"prediction_sse_q20":824065404089,"reconstruction_checksum":"72cd9ccd95c1c8b3","reconstruction_sse_q20":779571381853,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"6c49af53f8d12848","transition_correct":190,"transition_supported":256,"transition_unknown":0},"training_evaluations":253952},"no_adaptation_static":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"9df6af3e4f64679e","correct":157,"expert_evaluations":3112,"prediction_checksum":"e9fe1a933152aa43","prediction_samples":233,"prediction_sse_q20":194723929899,"reconstruction_checksum":"23cb3093c0621fc9","reconstruction_sse_q20":173766613986,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":237,"samples":256,"transition_checksum":"4945ea65fda03463","transition_correct":218,"transition_supported":233,"transition_unknown":23},"expert_count":64,"planning":{"belief_set_target_reached":39,"cases":64,"checksum":"43d610c6dd921ee1","exact_world_state_target_reached":36,"executed_path_length":243,"expansions":1973,"goal_expert_reached":39,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":276,"path_found":64,"path_length_regret":21,"state_aliasing_failures":3,"transition_model_error_failures":25},"retention_holdout":{"classification_checksum":"8fba0b512b56c23f","correct":244,"expert_evaluations":2552,"prediction_checksum":"2704c9956ffd5cd6","prediction_samples":233,"prediction_sse_q20":81222786563,"reconstruction_checksum":"2fb964254ca774a9","reconstruction_sse_q20":78397652349,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":247,"samples":256,"transition_checksum":"57b27de6cec4164a","transition_correct":216,"transition_supported":233,"transition_unknown":23},"training_evaluations":577720},"periodic_replay_policy":{"checkpoint_size_bytes":52334,"drift_holdout":{"classification_checksum":"3f7507fac56f80aa","correct":199,"expert_evaluations":2912,"prediction_checksum":"d11261090290ec48","prediction_samples":227,"prediction_sse_q20":142996183568,"reconstruction_checksum":"560facc590c6ed77","reconstruction_sse_q20":132587769980,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":244,"samples":256,"transition_checksum":"8b320568daddad9e","transition_correct":195,"transition_supported":227,"transition_unknown":29},"expert_count":80,"planning":{"belief_set_target_reached":47,"cases":64,"checksum":"748b00bab23033cd","exact_world_state_target_reached":47,"executed_path_length":289,"expansions":2335,"goal_expert_reached":47,"graph_disconnection_failures":0,"no_supported_edge_failures":5,"optimal_path_length":276,"path_found":59,"path_length_regret":45,"state_aliasing_failures":0,"transition_model_error_failures":12},"retention_holdout":{"classification_checksum":"41210aae48a1284d","correct":248,"expert_evaluations":2264,"prediction_checksum":"a8666225636ced1a","prediction_samples":225,"prediction_sse_q20":59349188821,"reconstruction_checksum":"e23c329030d8ee31","reconstruction_sse_q20":56802591027,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":253,"samples":256,"transition_checksum":"156a204a1e8bf912","transition_correct":216,"transition_supported":225,"transition_unknown":31},"training_evaluations":2522178},"ravel_0_5_candidate":{"checkpoint_size_bytes":52334,"drift_holdout":{"classification_checksum":"3f7507fac56f80aa","correct":199,"expert_evaluations":2912,"prediction_checksum":"c1e23d95196381c2","prediction_samples":229,"prediction_sse_q20":143507167744,"reconstruction_checksum":"92918517d24fdb9e","reconstruction_sse_q20":132389549772,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":244,"samples":256,"transition_checksum":"ae6838aee46db266","transition_correct":197,"transition_supported":229,"transition_unknown":27},"expert_count":80,"planning":{"belief_set_target_reached":47,"cases":64,"checksum":"be6052f983195d6e","exact_world_state_target_reached":47,"executed_path_length":292,"expansions":2384,"goal_expert_reached":47,"graph_disconnection_failures":0,"no_supported_edge_failures":4,"optimal_path_length":276,"path_found":60,"path_length_regret":43,"state_aliasing_failures":0,"transition_model_error_failures":13},"retention_holdout":{"classification_checksum":"41210aae48a1284d","correct":248,"expert_evaluations":2264,"prediction_checksum":"13790f2f4976237f","prediction_samples":230,"prediction_sse_q20":62132800681,"reconstruction_checksum":"c42cec193534285b","reconstruction_sse_q20":56680388952,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":253,"samples":256,"transition_checksum":"abe9af67064366c1","transition_correct":218,"transition_supported":230,"transition_unknown":26},"training_evaluations":2793900},"ravel_complete_scan_without_certification":{"checkpoint_size_bytes":52334,"drift_holdout":{"classification_checksum":"3f7507fac56f80aa","correct":199,"expert_evaluations":20480,"prediction_checksum":"c1e23d95196381c2","prediction_samples":229,"prediction_sse_q20":143507167744,"reconstruction_checksum":"92918517d24fdb9e","reconstruction_sse_q20":132389549772,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"ae6838aee46db266","transition_correct":197,"transition_supported":229,"transition_unknown":27},"expert_count":80,"planning":{"belief_set_target_reached":47,"cases":64,"checksum":"be6052f983195d6e","exact_world_state_target_reached":47,"executed_path_length":292,"expansions":2384,"goal_expert_reached":47,"graph_disconnection_failures":0,"no_supported_edge_failures":4,"optimal_path_length":276,"path_found":60,"path_length_regret":43,"state_aliasing_failures":0,"transition_model_error_failures":13},"retention_holdout":{"classification_checksum":"41210aae48a1284d","correct":248,"expert_evaluations":20480,"prediction_checksum":"13790f2f4976237f","prediction_samples":230,"prediction_sse_q20":62132800681,"reconstruction_checksum":"c42cec193534285b","reconstruction_sse_q20":56680388952,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"abe9af67064366c1","transition_correct":218,"transition_supported":230,"transition_unknown":26},"training_evaluations":3007596},"ravel_no_birth_same_replay_iterations":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"9df6af3e4f64679e","correct":157,"expert_evaluations":3112,"prediction_checksum":"e9fe1a933152aa43","prediction_samples":233,"prediction_sse_q20":194723929899,"reconstruction_checksum":"23cb3093c0621fc9","reconstruction_sse_q20":173766613986,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":237,"samples":256,"transition_checksum":"4945ea65fda03463","transition_correct":218,"transition_supported":233,"transition_unknown":23},"expert_count":64,"planning":{"belief_set_target_reached":39,"cases":64,"checksum":"43d610c6dd921ee1","exact_world_state_target_reached":36,"executed_path_length":243,"expansions":1973,"goal_expert_reached":39,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":276,"path_found":64,"path_length_regret":21,"state_aliasing_failures":3,"transition_model_error_failures":25},"retention_holdout":{"classification_checksum":"8fba0b512b56c23f","correct":244,"expert_evaluations":2552,"prediction_checksum":"2704c9956ffd5cd6","prediction_samples":233,"prediction_sse_q20":81222786563,"reconstruction_checksum":"2fb964254ca774a9","reconstruction_sse_q20":78397652349,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":247,"samples":256,"transition_checksum":"57b27de6cec4164a","transition_correct":216,"transition_supported":233,"transition_unknown":23},"training_evaluations":811896},"ravel_random_births":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"9df6af3e4f64679e","correct":157,"expert_evaluations":3112,"prediction_checksum":"e9fe1a933152aa43","prediction_samples":233,"prediction_sse_q20":194723929899,"reconstruction_checksum":"23cb3093c0621fc9","reconstruction_sse_q20":173766613986,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":237,"samples":256,"transition_checksum":"4945ea65fda03463","transition_correct":218,"transition_supported":233,"transition_unknown":23},"expert_count":64,"planning":{"belief_set_target_reached":39,"cases":64,"checksum":"43d610c6dd921ee1","exact_world_state_target_reached":36,"executed_path_length":243,"expansions":1973,"goal_expert_reached":39,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":276,"path_found":64,"path_length_regret":21,"state_aliasing_failures":3,"transition_model_error_failures":25},"retention_holdout":{"classification_checksum":"8fba0b512b56c23f","correct":244,"expert_evaluations":2552,"prediction_checksum":"2704c9956ffd5cd6","prediction_samples":233,"prediction_sse_q20":81222786563,"reconstruction_checksum":"2fb964254ca774a9","reconstruction_sse_q20":78397652349,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":247,"samples":256,"transition_checksum":"57b27de6cec4164a","transition_correct":216,"transition_supported":233,"transition_unknown":23},"training_evaluations":811896},"ravel_without_replay":{"checkpoint_size_bytes":52334,"drift_holdout":{"classification_checksum":"3f7507fac56f80aa","correct":199,"expert_evaluations":2912,"prediction_checksum":"f1485838b163bc18","prediction_samples":225,"prediction_sse_q20":141922587386,"reconstruction_checksum":"e978c6a5fc49bd9e","reconstruction_sse_q20":132878857211,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":244,"samples":256,"transition_checksum":"f27b2ece208bc607","transition_correct":193,"transition_supported":225,"transition_unknown":31},"expert_count":80,"planning":{"belief_set_target_reached":47,"cases":64,"checksum":"410dee7a5eb5dd0e","exact_world_state_target_reached":47,"executed_path_length":291,"expansions":2340,"goal_expert_reached":47,"graph_disconnection_failures":0,"no_supported_edge_failures":5,"optimal_path_length":276,"path_found":59,"path_length_regret":47,"state_aliasing_failures":0,"transition_model_error_failures":12},"retention_holdout":{"classification_checksum":"49fef56dd7e840a8","correct":249,"expert_evaluations":2264,"prediction_checksum":"a10f14548ef76564","prediction_samples":225,"prediction_sse_q20":60856088715,"reconstruction_checksum":"0b3d239354d1933a","reconstruction_sse_q20":59451576856,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":253,"samples":256,"transition_checksum":"1a5196527f165b5a","transition_correct":216,"transition_supported":225,"transition_unknown":31},"training_evaluations":1987400},"ravel_without_retirement_matched_work":{"checkpoint_size_bytes":52334,"drift_holdout":{"classification_checksum":"3f7507fac56f80aa","correct":199,"expert_evaluations":2912,"prediction_checksum":"c1e23d95196381c2","prediction_samples":229,"prediction_sse_q20":143507167744,"reconstruction_checksum":"92918517d24fdb9e","reconstruction_sse_q20":132389549772,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":244,"samples":256,"transition_checksum":"ae6838aee46db266","transition_correct":197,"transition_supported":229,"transition_unknown":27},"expert_count":80,"planning":{"belief_set_target_reached":47,"cases":64,"checksum":"be6052f983195d6e","exact_world_state_target_reached":47,"executed_path_length":292,"expansions":2384,"goal_expert_reached":47,"graph_disconnection_failures":0,"no_supported_edge_failures":4,"optimal_path_length":276,"path_found":60,"path_length_regret":43,"state_aliasing_failures":0,"transition_model_error_failures":13},"retention_holdout":{"classification_checksum":"41210aae48a1284d","correct":248,"expert_evaluations":2264,"prediction_checksum":"13790f2f4976237f","prediction_samples":230,"prediction_sse_q20":62132800681,"reconstruction_checksum":"c42cec193534285b","reconstruction_sse_q20":56680388952,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":253,"samples":256,"transition_checksum":"abe9af67064366c1","transition_correct":218,"transition_supported":230,"transition_unknown":26},"training_evaluations":2793900}},"dataset_seeds":{"base_holdout":"0x38e29327f9ff5a43","base_training":"0xd1e6d7f1cf52f9a4","drift_adaptation_training":"0x4d885cb47c4305e2","drift_holdout":"0x68d562319153fa22","original_task_retention_holdout":"0x0f7b7cb9da01ebaf","planning_cases":"0x8d14e0e7f7a8b2d7"},"dataset_sizes":{"base_holdout":256,"base_training":1024,"drift_adaptation_training":512,"drift_holdout":256,"original_task_retention_holdout":256,"planning_cases":64},"integrity":{"checkpoint_behavior_match":true,"checkpoint_identity_match":true,"checkpoint_mutations":{"anchored_status":true,"appended_unexpected_byte":true,"checkpoint_substitution":true,"checkpoint_truncation":true,"incorrect_schema_version":true,"label":true,"label_count":true,"lineage":true,"next_observation_component":true,"payload_byte":true,"reconstruction_component":true,"retrieval_key_component":true,"transition_graph_edge":true,"transition_support":true},"checkpoint_roundtrip":true,"lineage_invariants":{"deterministic_topology_reproduction":true,"lineage_uniqueness":true,"no_accidental_lineage_reuse":true,"parent_child_generation_increment":true,"repeated_descendant_splitting":true,"sibling_generation_equality":true},"unsupported_graph_edge_violations":0},"regime":"combined_observation_and_label_drift","schema":"ravel-raw-trial/0.5","seed":"0x979e1c635f578971","trial_id":"validation-combined-01"},{"candidate":{"adaptation_completed":true,"adaptation_training":{"classification_checksum":"ae1e9b73df6efa10","correct":381,"expert_evaluations":7192,"prediction_checksum":"c16c1f2a58b6514e","prediction_samples":474,"prediction_sse_q20":322920239631,"reconstruction_checksum":"dc44854976c10f3b","reconstruction_sse_q20":301343822532,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":469,"samples":512,"transition_checksum":"a16cdc3cc57e82b7","transition_correct":406,"transition_supported":474,"transition_unknown":38},"adaptation_training_evaluations":2032522,"adapted_model_drift_holdout":{"classification_checksum":"98d3ad62176a57f6","correct":192,"expert_evaluations":3776,"prediction_checksum":"d6389f6cc809bbff","prediction_samples":219,"prediction_sse_q20":170072846722,"reconstruction_checksum":"21e423d304439ad2","reconstruction_sse_q20":153749963989,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":232,"samples":256,"transition_checksum":"2e39f1be9551fd9b","transition_correct":181,"transition_supported":219,"transition_unknown":37},"base_holdout":{"classification_checksum":"ef2ca7b3df66b5c1","correct":220,"expert_evaluations":3280,"prediction_checksum":"4a7c5d3043f3cbf9","prediction_samples":225,"prediction_sse_q20":150137684162,"reconstruction_checksum":"892ff7cd351d12c6","reconstruction_sse_q20":130026626844,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":234,"samples":256,"transition_checksum":"354387d4c7520385","transition_correct":190,"transition_supported":225,"transition_unknown":31},"base_holdout_retention":{"classification_checksum":"50a94d399a5efe46","correct":238,"expert_evaluations":2408,"prediction_checksum":"9e78ccf04ef81cbe","prediction_samples":226,"prediction_sse_q20":95199366973,"reconstruction_checksum":"181fe1375405de16","reconstruction_sse_q20":80983241767,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":251,"samples":256,"transition_checksum":"193d336d95e6abf8","transition_correct":203,"transition_supported":226,"transition_unknown":30},"base_training_evaluations":578360,"behavior_identity":"82d7a311f056feeb096ad3a3d73261d6261aab2c17433a879128642d6141bdc4","checkpoint_size_bytes":52334,"expert_count":80,"model_identity":"b8887f8ff08f650b79a31f66be61cce21dcd5300433ddcb4b7ec28999966268a","planning":{"belief_set_target_reached":30,"cases":64,"checksum":"e85695eb1ae63878","exact_world_state_target_reached":30,"executed_path_length":234,"expansions":2491,"goal_expert_reached":30,"graph_disconnection_failures":0,"no_supported_edge_failures":10,"optimal_path_length":298,"path_found":54,"path_length_regret":7,"state_aliasing_failures":0,"transition_model_error_failures":24},"replay":{"actions_covered":4,"assigned_experts_covered":62,"high_loss_cases_selected":18,"labels_covered":8,"rare_cases_selected":54,"selected":256,"selection_checksum":"581a8c941ce3d060","states_covered":64,"transition_pairs_covered":250,"unique":256},"static_model_drift_holdout":{"classification_checksum":"76f55d463ab099bc","correct":144,"expert_evaluations":4400,"prediction_checksum":"25001502bd1b65a9","prediction_samples":224,"prediction_sse_q20":245177491858,"reconstruction_checksum":"c4e1da5c6cba51e9","reconstruction_sse_q20":220470631051,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":214,"samples":256,"transition_checksum":"1a7f77a2a9966b02","transition_correct":182,"transition_supported":224,"transition_unknown":32},"topology":{"accepted_births":16,"accepted_retirements":0,"births":[{"dominant_channel":0,"event_index":91,"normalized_score_q20":662312},{"dominant_channel":0,"event_index":2,"normalized_score_q20":657645},{"dominant_channel":0,"event_index":461,"normalized_score_q20":617094},{"dominant_channel":0,"event_index":31,"normalized_score_q20":613252},{"dominant_channel":0,"event_index":69,"normalized_score_q20":577825},{"dominant_channel":0,"event_index":199,"normalized_score_q20":569400},{"dominant_channel":0,"event_index":291,"normalized_score_q20":566576},{"dominant_channel":0,"event_index":108,"normalized_score_q20":565200},{"dominant_channel":0,"event_index":491,"normalized_score_q20":528946},{"dominant_channel":0,"event_index":100,"normalized_score_q20":514584},{"dominant_channel":0,"event_index":339,"normalized_score_q20":510547},{"dominant_channel":0,"event_index":313,"normalized_score_q20":508474},{"dominant_channel":0,"event_index":118,"normalized_score_q20":505802},{"dominant_channel":0,"event_index":430,"normalized_score_q20":505228},{"dominant_channel":0,"event_index":224,"normalized_score_q20":503229},{"dominant_channel":0,"event_index":96,"normalized_score_q20":502508}],"objective_after_q20":835777,"objective_before_q20":779059,"rejected_births":0,"rejected_retirements":1,"retired_lineages":[],"training_observations":{"births":16,"certified":20408,"expert_evaluations":2032522,"rejected_births":0,"rejected_retirements":1,"retired":0,"samples":23040}}},"checkpoint_format":{"byte_order":"big_endian","magic_hex":"524156454c303500","payload_digest":"sha256","real_encoding":"signed_q20_int64","schema_version":5,"transition_support_min":2,"transition_top_k":2},"comparisons":{"fixed_8_expert":{"checkpoint_size_bytes":11294,"drift_holdout":{"classification_checksum":"a7929048bc4279fb","correct":38,"expert_evaluations":2048,"prediction_checksum":"76b1271cfea524f3","prediction_samples":256,"prediction_sse_q20":1358299280635,"reconstruction_checksum":"67bf2f6a9b5302f8","reconstruction_sse_q20":1237965199120,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"19f0dafc59051410","transition_correct":197,"transition_supported":256,"transition_unknown":0},"expert_count":8,"planning":{"belief_set_target_reached":25,"cases":64,"checksum":"45069dbc3c791f73","exact_world_state_target_reached":4,"executed_path_length":65,"expansions":229,"goal_expert_reached":25,"graph_disconnection_failures":29,"no_supported_edge_failures":0,"optimal_path_length":298,"path_found":35,"path_length_regret":0,"state_aliasing_failures":21,"transition_model_error_failures":10},"retention_holdout":{"classification_checksum":"36e58487c31a6aa1","correct":61,"expert_evaluations":2048,"prediction_checksum":"1102ef147f4b6b6e","prediction_samples":256,"prediction_sse_q20":1304562719178,"reconstruction_checksum":"7d49157b54019df3","reconstruction_sse_q20":1188195668749,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"a984d610c4b9cad7","transition_correct":180,"transition_supported":256,"transition_unknown":0},"training_evaluations":94208},"fixed_topology_64_expert_routed":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"e8fdf04f0b07cf27","correct":168,"expert_evaluations":2888,"prediction_checksum":"2be829b71dde3fb0","prediction_samples":222,"prediction_sse_q20":132355481651,"reconstruction_checksum":"a289ced1e46027e0","reconstruction_sse_q20":143851195109,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":241,"samples":256,"transition_checksum":"c0d16b5ce9c40a64","transition_correct":222,"transition_supported":222,"transition_unknown":34},"expert_count":64,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"b49dfd8a6fe90d37","exact_world_state_target_reached":64,"executed_path_length":311,"expansions":2171,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":298,"path_found":64,"path_length_regret":13,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"2d584de796223bf3","correct":256,"expert_evaluations":2048,"prediction_checksum":"b1b7fcb081cf2b66","prediction_samples":227,"prediction_sse_q20":45308801677,"reconstruction_checksum":"48ee554f359d6d44","reconstruction_sse_q20":45460411029,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"37d12ed2dd0e99a1","transition_correct":227,"transition_supported":227,"transition_unknown":29},"training_evaluations":2588672},"flat_64_expert_complete_scan":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"e8fdf04f0b07cf27","correct":168,"expert_evaluations":16384,"prediction_checksum":"2be829b71dde3fb0","prediction_samples":222,"prediction_sse_q20":132355481651,"reconstruction_checksum":"a289ced1e46027e0","reconstruction_sse_q20":143851195109,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"c0d16b5ce9c40a64","transition_correct":222,"transition_supported":222,"transition_unknown":34},"expert_count":64,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"b49dfd8a6fe90d37","exact_world_state_target_reached":64,"executed_path_length":311,"expansions":2171,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":298,"path_found":64,"path_length_regret":13,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"2d584de796223bf3","correct":256,"expert_evaluations":16384,"prediction_checksum":"b1b7fcb081cf2b66","prediction_samples":227,"prediction_sse_q20":45308801677,"reconstruction_checksum":"48ee554f359d6d44","reconstruction_sse_q20":45460411029,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"37d12ed2dd0e99a1","transition_correct":227,"transition_supported":227,"transition_unknown":29},"training_evaluations":2588672},"matched_compute_fixed_topology":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"76f55d463ab099bc","correct":144,"expert_evaluations":4400,"prediction_checksum":"25001502bd1b65a9","prediction_samples":224,"prediction_sse_q20":245177491858,"reconstruction_checksum":"c4e1da5c6cba51e9","reconstruction_sse_q20":220470631051,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":214,"samples":256,"transition_checksum":"1a7f77a2a9966b02","transition_correct":182,"transition_supported":224,"transition_unknown":32},"expert_count":64,"planning":{"belief_set_target_reached":33,"cases":64,"checksum":"5486309831fe7864","exact_world_state_target_reached":28,"executed_path_length":239,"expansions":1869,"goal_expert_reached":33,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":298,"path_found":64,"path_length_regret":6,"state_aliasing_failures":5,"transition_model_error_failures":31},"retention_holdout":{"classification_checksum":"94886f8cf95cb3ad","correct":226,"expert_evaluations":2944,"prediction_checksum":"3ab580ca0bbab3fc","prediction_samples":229,"prediction_sse_q20":133892530384,"reconstruction_checksum":"d0bbe1096381fa97","reconstruction_sse_q20":125179893715,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":240,"samples":256,"transition_checksum":"8bd371ac57d4a98a","transition_correct":199,"transition_supported":229,"transition_unknown":27},"training_evaluations":2786744},"matched_expert_count_capacity":{"checkpoint_size_bytes":52334,"drift_holdout":{"classification_checksum":"947fa7d8b49daa39","correct":168,"expert_evaluations":3416,"prediction_checksum":"416cb6242f78fdad","prediction_samples":210,"prediction_sse_q20":125111951930,"reconstruction_checksum":"6f6bb72cb524c80e","reconstruction_sse_q20":141923988927,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":237,"samples":256,"transition_checksum":"cd4b5e1b4d4804e7","transition_correct":185,"transition_supported":210,"transition_unknown":46},"expert_count":80,"planning":{"belief_set_target_reached":61,"cases":64,"checksum":"9d29f8b8a4e78f0d","exact_world_state_target_reached":61,"executed_path_length":312,"expansions":2459,"goal_expert_reached":61,"graph_disconnection_failures":0,"no_supported_edge_failures":3,"optimal_path_length":298,"path_found":61,"path_length_regret":24,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"d3fb4a9b19d8eab2","correct":256,"expert_evaluations":2048,"prediction_checksum":"2f8d85b7e28a21ef","prediction_samples":210,"prediction_sse_q20":43566236404,"reconstruction_checksum":"250c53d6b68afead","reconstruction_sse_q20":44528677720,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"2cad9b9af117ec56","transition_correct":187,"transition_supported":210,"transition_unknown":46},"training_evaluations":3891200},"nearest_centroid_16_no_recursive_births":{"checkpoint_size_bytes":15854,"drift_holdout":{"classification_checksum":"31caa0226afc4dfa","correct":38,"expert_evaluations":4096,"prediction_checksum":"b25552314760a2ce","prediction_samples":256,"prediction_sse_q20":1083338085065,"reconstruction_checksum":"113f57ded93b4b0f","reconstruction_sse_q20":879630798745,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"e6f0f3073c02e696","transition_correct":169,"transition_supported":256,"transition_unknown":0},"expert_count":16,"planning":{"belief_set_target_reached":35,"cases":64,"checksum":"a3e1c86caef752f4","exact_world_state_target_reached":6,"executed_path_length":189,"expansions":604,"goal_expert_reached":35,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":298,"path_found":64,"path_length_regret":6,"state_aliasing_failures":29,"transition_model_error_failures":29},"retention_holdout":{"classification_checksum":"84e912cc72047008","correct":94,"expert_evaluations":4096,"prediction_checksum":"58900d93d38683e7","prediction_samples":256,"prediction_sse_q20":918633661097,"reconstruction_checksum":"f90fd0ea84e2a709","reconstruction_sse_q20":772649291877,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"f1ed054daf9fde48","transition_correct":170,"transition_supported":256,"transition_unknown":0},"training_evaluations":253952},"no_adaptation_static":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"76f55d463ab099bc","correct":144,"expert_evaluations":4400,"prediction_checksum":"25001502bd1b65a9","prediction_samples":224,"prediction_sse_q20":245177491858,"reconstruction_checksum":"c4e1da5c6cba51e9","reconstruction_sse_q20":220470631051,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":214,"samples":256,"transition_checksum":"1a7f77a2a9966b02","transition_correct":182,"transition_supported":224,"transition_unknown":32},"expert_count":64,"planning":{"belief_set_target_reached":33,"cases":64,"checksum":"5486309831fe7864","exact_world_state_target_reached":28,"executed_path_length":239,"expansions":1869,"goal_expert_reached":33,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":298,"path_found":64,"path_length_regret":6,"state_aliasing_failures":5,"transition_model_error_failures":31},"retention_holdout":{"classification_checksum":"94886f8cf95cb3ad","correct":226,"expert_evaluations":2944,"prediction_checksum":"3ab580ca0bbab3fc","prediction_samples":229,"prediction_sse_q20":133892530384,"reconstruction_checksum":"d0bbe1096381fa97","reconstruction_sse_q20":125179893715,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":240,"samples":256,"transition_checksum":"8bd371ac57d4a98a","transition_correct":199,"transition_supported":229,"transition_unknown":27},"training_evaluations":578360},"periodic_replay_policy":{"checkpoint_size_bytes":52334,"drift_holdout":{"classification_checksum":"6eab3b6efd876da4","correct":192,"expert_evaluations":3776,"prediction_checksum":"0953c6247c73d52a","prediction_samples":213,"prediction_sse_q20":166784286920,"reconstruction_checksum":"bdebe81315831a08","reconstruction_sse_q20":153860778933,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":232,"samples":256,"transition_checksum":"1349e647252a23e7","transition_correct":178,"transition_supported":213,"transition_unknown":43},"expert_count":80,"planning":{"belief_set_target_reached":31,"cases":64,"checksum":"7b263453d20796c5","exact_world_state_target_reached":31,"executed_path_length":239,"expansions":2438,"goal_expert_reached":31,"graph_disconnection_failures":0,"no_supported_edge_failures":10,"optimal_path_length":298,"path_found":54,"path_length_regret":10,"state_aliasing_failures":0,"transition_model_error_failures":23},"retention_holdout":{"classification_checksum":"50a94d399a5efe46","correct":238,"expert_evaluations":2408,"prediction_checksum":"54669911d8c5ee84","prediction_samples":224,"prediction_sse_q20":94843852857,"reconstruction_checksum":"93ea2092990153e5","reconstruction_sse_q20":81155929924,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":251,"samples":256,"transition_checksum":"b0f909b53c15f6c9","transition_correct":198,"transition_supported":224,"transition_unknown":32},"training_evaluations":2590469},"ravel_0_5_candidate":{"checkpoint_size_bytes":52334,"drift_holdout":{"classification_checksum":"98d3ad62176a57f6","correct":192,"expert_evaluations":3776,"prediction_checksum":"d6389f6cc809bbff","prediction_samples":219,"prediction_sse_q20":170072846722,"reconstruction_checksum":"21e423d304439ad2","reconstruction_sse_q20":153749963989,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":232,"samples":256,"transition_checksum":"2e39f1be9551fd9b","transition_correct":181,"transition_supported":219,"transition_unknown":37},"expert_count":80,"planning":{"belief_set_target_reached":30,"cases":64,"checksum":"e85695eb1ae63878","exact_world_state_target_reached":30,"executed_path_length":234,"expansions":2491,"goal_expert_reached":30,"graph_disconnection_failures":0,"no_supported_edge_failures":10,"optimal_path_length":298,"path_found":54,"path_length_regret":7,"state_aliasing_failures":0,"transition_model_error_failures":24},"retention_holdout":{"classification_checksum":"50a94d399a5efe46","correct":238,"expert_evaluations":2408,"prediction_checksum":"9e78ccf04ef81cbe","prediction_samples":226,"prediction_sse_q20":95199366973,"reconstruction_checksum":"181fe1375405de16","reconstruction_sse_q20":80983241767,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":251,"samples":256,"transition_checksum":"193d336d95e6abf8","transition_correct":203,"transition_supported":226,"transition_unknown":30},"training_evaluations":2610882},"ravel_complete_scan_without_certification":{"checkpoint_size_bytes":52334,"drift_holdout":{"classification_checksum":"98d3ad62176a57f6","correct":192,"expert_evaluations":20480,"prediction_checksum":"d6389f6cc809bbff","prediction_samples":219,"prediction_sse_q20":170072846722,"reconstruction_checksum":"21e423d304439ad2","reconstruction_sse_q20":153749963989,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"2e39f1be9551fd9b","transition_correct":181,"transition_supported":219,"transition_unknown":37},"expert_count":80,"planning":{"belief_set_target_reached":30,"cases":64,"checksum":"e85695eb1ae63878","exact_world_state_target_reached":30,"executed_path_length":234,"expansions":2491,"goal_expert_reached":30,"graph_disconnection_failures":0,"no_supported_edge_failures":10,"optimal_path_length":298,"path_found":54,"path_length_regret":7,"state_aliasing_failures":0,"transition_model_error_failures":24},"retention_holdout":{"classification_checksum":"50a94d399a5efe46","correct":238,"expert_evaluations":20480,"prediction_checksum":"9e78ccf04ef81cbe","prediction_samples":226,"prediction_sse_q20":95199366973,"reconstruction_checksum":"181fe1375405de16","reconstruction_sse_q20":80983241767,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"193d336d95e6abf8","transition_correct":203,"transition_supported":226,"transition_unknown":30},"training_evaluations":2816514},"ravel_no_birth_same_replay_iterations":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"76f55d463ab099bc","correct":144,"expert_evaluations":4400,"prediction_checksum":"25001502bd1b65a9","prediction_samples":224,"prediction_sse_q20":245177491858,"reconstruction_checksum":"c4e1da5c6cba51e9","reconstruction_sse_q20":220470631051,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":214,"samples":256,"transition_checksum":"1a7f77a2a9966b02","transition_correct":182,"transition_supported":224,"transition_unknown":32},"expert_count":64,"planning":{"belief_set_target_reached":33,"cases":64,"checksum":"5486309831fe7864","exact_world_state_target_reached":28,"executed_path_length":239,"expansions":1869,"goal_expert_reached":33,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":298,"path_found":64,"path_length_regret":6,"state_aliasing_failures":5,"transition_model_error_failures":31},"retention_holdout":{"classification_checksum":"94886f8cf95cb3ad","correct":226,"expert_evaluations":2944,"prediction_checksum":"3ab580ca0bbab3fc","prediction_samples":229,"prediction_sse_q20":133892530384,"reconstruction_checksum":"d0bbe1096381fa97","reconstruction_sse_q20":125179893715,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":240,"samples":256,"transition_checksum":"8bd371ac57d4a98a","transition_correct":199,"transition_supported":229,"transition_unknown":27},"training_evaluations":823736},"ravel_random_births":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"76f55d463ab099bc","correct":144,"expert_evaluations":4400,"prediction_checksum":"25001502bd1b65a9","prediction_samples":224,"prediction_sse_q20":245177491858,"reconstruction_checksum":"c4e1da5c6cba51e9","reconstruction_sse_q20":220470631051,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":214,"samples":256,"transition_checksum":"1a7f77a2a9966b02","transition_correct":182,"transition_supported":224,"transition_unknown":32},"expert_count":64,"planning":{"belief_set_target_reached":33,"cases":64,"checksum":"5486309831fe7864","exact_world_state_target_reached":28,"executed_path_length":239,"expansions":1869,"goal_expert_reached":33,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":298,"path_found":64,"path_length_regret":6,"state_aliasing_failures":5,"transition_model_error_failures":31},"retention_holdout":{"classification_checksum":"94886f8cf95cb3ad","correct":226,"expert_evaluations":2944,"prediction_checksum":"3ab580ca0bbab3fc","prediction_samples":229,"prediction_sse_q20":133892530384,"reconstruction_checksum":"d0bbe1096381fa97","reconstruction_sse_q20":125179893715,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":240,"samples":256,"transition_checksum":"8bd371ac57d4a98a","transition_correct":199,"transition_supported":229,"transition_unknown":27},"training_evaluations":823736},"ravel_without_replay":{"checkpoint_size_bytes":52334,"drift_holdout":{"classification_checksum":"98d3ad62176a57f6","correct":192,"expert_evaluations":3776,"prediction_checksum":"a22eeac6e629ecae","prediction_samples":209,"prediction_sse_q20":166129225486,"reconstruction_checksum":"babe4fa8fcadcdb0","reconstruction_sse_q20":153759807287,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":232,"samples":256,"transition_checksum":"bf589cd781270bcc","transition_correct":173,"transition_supported":209,"transition_unknown":47},"expert_count":80,"planning":{"belief_set_target_reached":29,"cases":64,"checksum":"04a1670132426d8f","exact_world_state_target_reached":29,"executed_path_length":241,"expansions":2454,"goal_expert_reached":29,"graph_disconnection_failures":0,"no_supported_edge_failures":10,"optimal_path_length":298,"path_found":54,"path_length_regret":7,"state_aliasing_failures":0,"transition_model_error_failures":25},"retention_holdout":{"classification_checksum":"d8b56c842584e7b5","correct":240,"expert_evaluations":2480,"prediction_checksum":"0e8fcd49f94a7eb9","prediction_samples":224,"prediction_sse_q20":97410856925,"reconstruction_checksum":"472751eb3f898101","reconstruction_sse_q20":85567436534,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":250,"samples":256,"transition_checksum":"a950aeba5d8a152d","transition_correct":198,"transition_supported":224,"transition_unknown":32},"training_evaluations":2232377},"ravel_without_retirement_matched_work":{"checkpoint_size_bytes":52334,"drift_holdout":{"classification_checksum":"98d3ad62176a57f6","correct":192,"expert_evaluations":3776,"prediction_checksum":"d6389f6cc809bbff","prediction_samples":219,"prediction_sse_q20":170072846722,"reconstruction_checksum":"21e423d304439ad2","reconstruction_sse_q20":153749963989,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":232,"samples":256,"transition_checksum":"2e39f1be9551fd9b","transition_correct":181,"transition_supported":219,"transition_unknown":37},"expert_count":80,"planning":{"belief_set_target_reached":30,"cases":64,"checksum":"e85695eb1ae63878","exact_world_state_target_reached":30,"executed_path_length":234,"expansions":2491,"goal_expert_reached":30,"graph_disconnection_failures":0,"no_supported_edge_failures":10,"optimal_path_length":298,"path_found":54,"path_length_regret":7,"state_aliasing_failures":0,"transition_model_error_failures":24},"retention_holdout":{"classification_checksum":"50a94d399a5efe46","correct":238,"expert_evaluations":2408,"prediction_checksum":"9e78ccf04ef81cbe","prediction_samples":226,"prediction_sse_q20":95199366973,"reconstruction_checksum":"181fe1375405de16","reconstruction_sse_q20":80983241767,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":251,"samples":256,"transition_checksum":"193d336d95e6abf8","transition_correct":203,"transition_supported":226,"transition_unknown":30},"training_evaluations":2610882}},"dataset_seeds":{"base_holdout":"0xff86befa181c1960","base_training":"0xecbe631bfa822262","drift_adaptation_training":"0x83d09596b3f372d5","drift_holdout":"0x2ed669b239cef930","original_task_retention_holdout":"0xb9af8eda382f21e1","planning_cases":"0x304822a459675ef7"},"dataset_sizes":{"base_holdout":256,"base_training":1024,"drift_adaptation_training":512,"drift_holdout":256,"original_task_retention_holdout":256,"planning_cases":64},"integrity":{"checkpoint_behavior_match":true,"checkpoint_identity_match":true,"checkpoint_mutations":{"anchored_status":true,"appended_unexpected_byte":true,"checkpoint_substitution":true,"checkpoint_truncation":true,"incorrect_schema_version":true,"label":true,"label_count":true,"lineage":true,"next_observation_component":true,"payload_byte":true,"reconstruction_component":true,"retrieval_key_component":true,"transition_graph_edge":true,"transition_support":true},"checkpoint_roundtrip":true,"lineage_invariants":{"deterministic_topology_reproduction":true,"lineage_uniqueness":true,"no_accidental_lineage_reuse":true,"parent_child_generation_increment":true,"repeated_descendant_splitting":true,"sibling_generation_equality":true},"unsupported_graph_edge_violations":0},"regime":"combined_observation_and_label_drift","schema":"ravel-raw-trial/0.5","seed":"0xae29c26efd3217a6","trial_id":"validation-combined-02"},{"candidate":{"adaptation_completed":true,"adaptation_training":{"classification_checksum":"cf936e0728e7cb41","correct":427,"expert_evaluations":5608,"prediction_checksum":"fab2d4ce59b066f4","prediction_samples":478,"prediction_sse_q20":263632751865,"reconstruction_checksum":"4fbf52513ca06796","reconstruction_sse_q20":252063858054,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":491,"samples":512,"transition_checksum":"05df84b7ce2cedb1","transition_correct":416,"transition_supported":478,"transition_unknown":34},"adaptation_training_evaluations":1817261,"adapted_model_drift_holdout":{"classification_checksum":"c04f584bd49b968f","correct":210,"expert_evaluations":2480,"prediction_checksum":"87067ad4c1b4735b","prediction_samples":228,"prediction_sse_q20":161930151652,"reconstruction_checksum":"15a8929c3de0111c","reconstruction_sse_q20":128717475472,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":250,"samples":256,"transition_checksum":"b9cf1fe013b5f857","transition_correct":191,"transition_supported":228,"transition_unknown":28},"base_holdout":{"classification_checksum":"b14d756ad115bbf0","correct":233,"expert_evaluations":2720,"prediction_checksum":"0b1d19f7b4799715","prediction_samples":232,"prediction_sse_q20":104123904141,"reconstruction_checksum":"79c1f7f3750f06be","reconstruction_sse_q20":95299710345,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":244,"samples":256,"transition_checksum":"a05b4a3fd7bd64de","transition_correct":215,"transition_supported":232,"transition_unknown":24},"base_holdout_retention":{"classification_checksum":"b6fa4df5ba643dfa","correct":244,"expert_evaluations":2120,"prediction_checksum":"ce5520574d1b7faf","prediction_samples":229,"prediction_sse_q20":55702269519,"reconstruction_checksum":"fbb6c6b288bb7e76","reconstruction_sse_q20":56573193530,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":255,"samples":256,"transition_checksum":"acb10d90c5c7c195","transition_correct":221,"transition_supported":229,"transition_unknown":27},"base_training_evaluations":570896,"behavior_identity":"528fa57b9de3addc6ed3f4fa80172d8ae7f67a7131801e5bdf202fd9afd36fb5","checkpoint_size_bytes":52334,"expert_count":80,"model_identity":"5415f6108f87eb0d05008fadf531017b77b3d1bde9e6651f4b9d37845e4d84fe","planning":{"belief_set_target_reached":43,"cases":64,"checksum":"2c2417c8f001ba9d","exact_world_state_target_reached":43,"executed_path_length":242,"expansions":2257,"goal_expert_reached":43,"graph_disconnection_failures":0,"no_supported_edge_failures":9,"optimal_path_length":272,"path_found":55,"path_length_regret":17,"state_aliasing_failures":0,"transition_model_error_failures":12},"replay":{"actions_covered":4,"assigned_experts_covered":64,"high_loss_cases_selected":13,"labels_covered":8,"rare_cases_selected":51,"selected":256,"selection_checksum":"8a694bf79d5ce3ee","states_covered":64,"transition_pairs_covered":253,"unique":256},"static_model_drift_holdout":{"classification_checksum":"634d2de62b30f3a2","correct":151,"expert_evaluations":3280,"prediction_checksum":"1a290b3e832b1919","prediction_samples":236,"prediction_sse_q20":244332161389,"reconstruction_checksum":"47e283c3ea540a8b","reconstruction_sse_q20":201306707205,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":234,"samples":256,"transition_checksum":"0981a46d13e64541","transition_correct":216,"transition_supported":236,"transition_unknown":20},"topology":{"accepted_births":16,"accepted_retirements":0,"births":[{"dominant_channel":0,"event_index":228,"normalized_score_q20":596468},{"dominant_channel":0,"event_index":250,"normalized_score_q20":593214},{"dominant_channel":0,"event_index":365,"normalized_score_q20":583797},{"dominant_channel":0,"event_index":83,"normalized_score_q20":575386},{"dominant_channel":0,"event_index":404,"normalized_score_q20":565300},{"dominant_channel":0,"event_index":297,"normalized_score_q20":557021},{"dominant_channel":0,"event_index":153,"normalized_score_q20":526734},{"dominant_channel":0,"event_index":413,"normalized_score_q20":522988},{"dominant_channel":0,"event_index":292,"normalized_score_q20":500499},{"dominant_channel":0,"event_index":157,"normalized_score_q20":498922},{"dominant_channel":0,"event_index":119,"normalized_score_q20":498642},{"dominant_channel":0,"event_index":58,"normalized_score_q20":496434},{"dominant_channel":0,"event_index":85,"normalized_score_q20":439291},{"dominant_channel":0,"event_index":138,"normalized_score_q20":434024},{"dominant_channel":0,"event_index":317,"normalized_score_q20":431869},{"dominant_channel":0,"event_index":448,"normalized_score_q20":431597}],"objective_after_q20":862186,"objective_before_q20":811119,"rejected_births":0,"rejected_retirements":1,"retired_lineages":[],"training_observations":{"births":16,"certified":20338,"expert_evaluations":1817261,"rejected_births":0,"rejected_retirements":1,"retired":0,"samples":21504}}},"checkpoint_format":{"byte_order":"big_endian","magic_hex":"524156454c303500","payload_digest":"sha256","real_encoding":"signed_q20_int64","schema_version":5,"transition_support_min":2,"transition_top_k":2},"comparisons":{"fixed_8_expert":{"checkpoint_size_bytes":11294,"drift_holdout":{"classification_checksum":"745192af066aabc9","correct":51,"expert_evaluations":2048,"prediction_checksum":"0759918902bf4dca","prediction_samples":256,"prediction_sse_q20":1546065082634,"reconstruction_checksum":"c172353e460572a1","reconstruction_sse_q20":1326560369754,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"3e01195ba21996cd","transition_correct":111,"transition_supported":256,"transition_unknown":0},"expert_count":8,"planning":{"belief_set_target_reached":10,"cases":64,"checksum":"1f0358f0707bd979","exact_world_state_target_reached":2,"executed_path_length":10,"expansions":155,"goal_expert_reached":10,"graph_disconnection_failures":48,"no_supported_edge_failures":0,"optimal_path_length":272,"path_found":16,"path_length_regret":0,"state_aliasing_failures":8,"transition_model_error_failures":6},"retention_holdout":{"classification_checksum":"e9bcd54c09388ab4","correct":61,"expert_evaluations":2048,"prediction_checksum":"992d1ffbd79cee24","prediction_samples":256,"prediction_sse_q20":1448976712190,"reconstruction_checksum":"f8372e1d06419528","reconstruction_sse_q20":1281352608310,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"6f8bd5f7b33e638b","transition_correct":91,"transition_supported":256,"transition_unknown":0},"training_evaluations":94208},"fixed_topology_64_expert_routed":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"5d687f68518740ba","correct":166,"expert_evaluations":2384,"prediction_checksum":"ee503aa677c20eb8","prediction_samples":224,"prediction_sse_q20":145675850451,"reconstruction_checksum":"031fcbe79846ef2c","reconstruction_sse_q20":140778181327,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":250,"samples":256,"transition_checksum":"71db779d5f3fe223","transition_correct":224,"transition_supported":224,"transition_unknown":32},"expert_count":64,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"69ff6168d1dffec3","exact_world_state_target_reached":64,"executed_path_length":300,"expansions":1956,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":272,"path_found":64,"path_length_regret":28,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"31658f1e6f6f6d5d","correct":256,"expert_evaluations":2048,"prediction_checksum":"686b582231b6db4c","prediction_samples":229,"prediction_sse_q20":45952382586,"reconstruction_checksum":"fb3aaca281bd69d0","reconstruction_sse_q20":43617101486,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"6dbb739d9e58703a","transition_correct":229,"transition_supported":229,"transition_unknown":27},"training_evaluations":2588672},"flat_64_expert_complete_scan":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"5d687f68518740ba","correct":166,"expert_evaluations":16384,"prediction_checksum":"ee503aa677c20eb8","prediction_samples":224,"prediction_sse_q20":145675850451,"reconstruction_checksum":"031fcbe79846ef2c","reconstruction_sse_q20":140778181327,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"71db779d5f3fe223","transition_correct":224,"transition_supported":224,"transition_unknown":32},"expert_count":64,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"69ff6168d1dffec3","exact_world_state_target_reached":64,"executed_path_length":300,"expansions":1956,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":272,"path_found":64,"path_length_regret":28,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"31658f1e6f6f6d5d","correct":256,"expert_evaluations":16384,"prediction_checksum":"686b582231b6db4c","prediction_samples":229,"prediction_sse_q20":45952382586,"reconstruction_checksum":"fb3aaca281bd69d0","reconstruction_sse_q20":43617101486,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"6dbb739d9e58703a","transition_correct":229,"transition_supported":229,"transition_unknown":27},"training_evaluations":2588672},"matched_compute_fixed_topology":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"634d2de62b30f3a2","correct":151,"expert_evaluations":3280,"prediction_checksum":"1a290b3e832b1919","prediction_samples":236,"prediction_sse_q20":244332161389,"reconstruction_checksum":"47e283c3ea540a8b","reconstruction_sse_q20":201306707205,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":234,"samples":256,"transition_checksum":"0981a46d13e64541","transition_correct":216,"transition_supported":236,"transition_unknown":20},"expert_count":64,"planning":{"belief_set_target_reached":39,"cases":64,"checksum":"9b90740c7d87ba23","exact_world_state_target_reached":38,"executed_path_length":239,"expansions":1886,"goal_expert_reached":39,"graph_disconnection_failures":0,"no_supported_edge_failures":1,"optimal_path_length":272,"path_found":63,"path_length_regret":10,"state_aliasing_failures":1,"transition_model_error_failures":24},"retention_holdout":{"classification_checksum":"a152f0dd9b0d3b78","correct":240,"expert_evaluations":2328,"prediction_checksum":"06801eae2a6751fe","prediction_samples":230,"prediction_sse_q20":83088104053,"reconstruction_checksum":"7131fb38e10e6b40","reconstruction_sse_q20":86798896738,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":251,"samples":256,"transition_checksum":"c0c6abf054f96dd7","transition_correct":219,"transition_supported":230,"transition_unknown":26},"training_evaluations":2429968},"matched_expert_count_capacity":{"checkpoint_size_bytes":52334,"drift_holdout":{"classification_checksum":"34aed8a8e5989f4b","correct":166,"expert_evaluations":2696,"prediction_checksum":"29e9686e04edc514","prediction_samples":208,"prediction_sse_q20":135115870685,"reconstruction_checksum":"37571025092179b4","reconstruction_sse_q20":139548425228,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":247,"samples":256,"transition_checksum":"9cbe59b546a5cca3","transition_correct":184,"transition_supported":208,"transition_unknown":48},"expert_count":80,"planning":{"belief_set_target_reached":57,"cases":64,"checksum":"0eb26f7596269e42","exact_world_state_target_reached":57,"executed_path_length":294,"expansions":2393,"goal_expert_reached":57,"graph_disconnection_failures":0,"no_supported_edge_failures":7,"optimal_path_length":272,"path_found":57,"path_length_regret":48,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"270b4dd08bbc9ccf","correct":256,"expert_evaluations":2048,"prediction_checksum":"21368396e7ac2958","prediction_samples":209,"prediction_sse_q20":42160029955,"reconstruction_checksum":"11ee4706931457ea","reconstruction_sse_q20":43384244225,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"eef3e9f1dad74577","transition_correct":180,"transition_supported":209,"transition_unknown":47},"training_evaluations":3891200},"nearest_centroid_16_no_recursive_births":{"checkpoint_size_bytes":15854,"drift_holdout":{"classification_checksum":"31567eb8b2007781","correct":53,"expert_evaluations":4096,"prediction_checksum":"86b881fc9343cde4","prediction_samples":256,"prediction_sse_q20":1056238063658,"reconstruction_checksum":"dfb38bcdf0dcbcda","reconstruction_sse_q20":873879090935,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"c1cff8f31dbfa669","transition_correct":156,"transition_supported":256,"transition_unknown":0},"expert_count":16,"planning":{"belief_set_target_reached":38,"cases":64,"checksum":"f5703404709fd152","exact_world_state_target_reached":13,"executed_path_length":155,"expansions":488,"goal_expert_reached":38,"graph_disconnection_failures":1,"no_supported_edge_failures":0,"optimal_path_length":272,"path_found":63,"path_length_regret":0,"state_aliasing_failures":25,"transition_model_error_failures":25},"retention_holdout":{"classification_checksum":"d5a90e7b90f3e31b","correct":72,"expert_evaluations":4096,"prediction_checksum":"9f587a4b1dd5514b","prediction_samples":256,"prediction_sse_q20":854683685076,"reconstruction_checksum":"85ec3a5f32c9cfac","reconstruction_sse_q20":757693541594,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"17a998fcd1efe0ff","transition_correct":173,"transition_supported":256,"transition_unknown":0},"training_evaluations":253952},"no_adaptation_static":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"634d2de62b30f3a2","correct":151,"expert_evaluations":3280,"prediction_checksum":"1a290b3e832b1919","prediction_samples":236,"prediction_sse_q20":244332161389,"reconstruction_checksum":"47e283c3ea540a8b","reconstruction_sse_q20":201306707205,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":234,"samples":256,"transition_checksum":"0981a46d13e64541","transition_correct":216,"transition_supported":236,"transition_unknown":20},"expert_count":64,"planning":{"belief_set_target_reached":39,"cases":64,"checksum":"9b90740c7d87ba23","exact_world_state_target_reached":38,"executed_path_length":239,"expansions":1886,"goal_expert_reached":39,"graph_disconnection_failures":0,"no_supported_edge_failures":1,"optimal_path_length":272,"path_found":63,"path_length_regret":10,"state_aliasing_failures":1,"transition_model_error_failures":24},"retention_holdout":{"classification_checksum":"a152f0dd9b0d3b78","correct":240,"expert_evaluations":2328,"prediction_checksum":"06801eae2a6751fe","prediction_samples":230,"prediction_sse_q20":83088104053,"reconstruction_checksum":"7131fb38e10e6b40","reconstruction_sse_q20":86798896738,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":251,"samples":256,"transition_checksum":"c0c6abf054f96dd7","transition_correct":219,"transition_supported":230,"transition_unknown":26},"training_evaluations":570896},"periodic_replay_policy":{"checkpoint_size_bytes":52334,"drift_holdout":{"classification_checksum":"c04f584bd49b968f","correct":210,"expert_evaluations":2480,"prediction_checksum":"69d4a82e084e0c2b","prediction_samples":226,"prediction_sse_q20":160547805892,"reconstruction_checksum":"d4b9de1ceaf160c1","reconstruction_sse_q20":128778229518,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":250,"samples":256,"transition_checksum":"aa9a4a44488a6d0d","transition_correct":188,"transition_supported":226,"transition_unknown":30},"expert_count":80,"planning":{"belief_set_target_reached":42,"cases":64,"checksum":"231145979d0d931d","exact_world_state_target_reached":42,"executed_path_length":236,"expansions":2274,"goal_expert_reached":42,"graph_disconnection_failures":0,"no_supported_edge_failures":9,"optimal_path_length":272,"path_found":55,"path_length_regret":15,"state_aliasing_failures":0,"transition_model_error_failures":13},"retention_holdout":{"classification_checksum":"89ef673cd1bc4621","correct":245,"expert_evaluations":2120,"prediction_checksum":"abdee8e5422876a2","prediction_samples":226,"prediction_sse_q20":56239167247,"reconstruction_checksum":"7f80b50a5165338b","reconstruction_sse_q20":56685511771,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":255,"samples":256,"transition_checksum":"ac03395b37307faa","transition_correct":217,"transition_supported":226,"transition_unknown":30},"training_evaluations":2515180},"ravel_0_5_candidate":{"checkpoint_size_bytes":52334,"drift_holdout":{"classification_checksum":"c04f584bd49b968f","correct":210,"expert_evaluations":2480,"prediction_checksum":"87067ad4c1b4735b","prediction_samples":228,"prediction_sse_q20":161930151652,"reconstruction_checksum":"15a8929c3de0111c","reconstruction_sse_q20":128717475472,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":250,"samples":256,"transition_checksum":"b9cf1fe013b5f857","transition_correct":191,"transition_supported":228,"transition_unknown":28},"expert_count":80,"planning":{"belief_set_target_reached":43,"cases":64,"checksum":"2c2417c8f001ba9d","exact_world_state_target_reached":43,"executed_path_length":242,"expansions":2257,"goal_expert_reached":43,"graph_disconnection_failures":0,"no_supported_edge_failures":9,"optimal_path_length":272,"path_found":55,"path_length_regret":17,"state_aliasing_failures":0,"transition_model_error_failures":12},"retention_holdout":{"classification_checksum":"b6fa4df5ba643dfa","correct":244,"expert_evaluations":2120,"prediction_checksum":"ce5520574d1b7faf","prediction_samples":229,"prediction_sse_q20":55702269519,"reconstruction_checksum":"fbb6c6b288bb7e76","reconstruction_sse_q20":56573193530,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":255,"samples":256,"transition_checksum":"acb10d90c5c7c195","transition_correct":221,"transition_supported":229,"transition_unknown":27},"training_evaluations":2388157},"ravel_complete_scan_without_certification":{"checkpoint_size_bytes":52334,"drift_holdout":{"classification_checksum":"c04f584bd49b968f","correct":210,"expert_evaluations":20480,"prediction_checksum":"87067ad4c1b4735b","prediction_samples":228,"prediction_sse_q20":161930151652,"reconstruction_checksum":"15a8929c3de0111c","reconstruction_sse_q20":128717475472,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"b9cf1fe013b5f857","transition_correct":191,"transition_supported":228,"transition_unknown":28},"expert_count":80,"planning":{"belief_set_target_reached":43,"cases":64,"checksum":"2c2417c8f001ba9d","exact_world_state_target_reached":43,"executed_path_length":242,"expansions":2257,"goal_expert_reached":43,"graph_disconnection_failures":0,"no_supported_edge_failures":9,"optimal_path_length":272,"path_found":55,"path_length_regret":17,"state_aliasing_failures":0,"transition_model_error_failures":12},"retention_holdout":{"classification_checksum":"b6fa4df5ba643dfa","correct":244,"expert_evaluations":20480,"prediction_checksum":"ce5520574d1b7faf","prediction_samples":229,"prediction_sse_q20":55702269519,"reconstruction_checksum":"fbb6c6b288bb7e76","reconstruction_sse_q20":56573193530,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"acb10d90c5c7c195","transition_correct":221,"transition_supported":229,"transition_unknown":27},"training_evaluations":2602141},"ravel_no_birth_same_replay_iterations":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"634d2de62b30f3a2","correct":151,"expert_evaluations":3280,"prediction_checksum":"1a290b3e832b1919","prediction_samples":236,"prediction_sse_q20":244332161389,"reconstruction_checksum":"47e283c3ea540a8b","reconstruction_sse_q20":201306707205,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":234,"samples":256,"transition_checksum":"0981a46d13e64541","transition_correct":216,"transition_supported":236,"transition_unknown":20},"expert_count":64,"planning":{"belief_set_target_reached":39,"cases":64,"checksum":"9b90740c7d87ba23","exact_world_state_target_reached":38,"executed_path_length":239,"expansions":1886,"goal_expert_reached":39,"graph_disconnection_failures":0,"no_supported_edge_failures":1,"optimal_path_length":272,"path_found":63,"path_length_regret":10,"state_aliasing_failures":1,"transition_model_error_failures":24},"retention_holdout":{"classification_checksum":"a152f0dd9b0d3b78","correct":240,"expert_evaluations":2328,"prediction_checksum":"06801eae2a6751fe","prediction_samples":230,"prediction_sse_q20":83088104053,"reconstruction_checksum":"7131fb38e10e6b40","reconstruction_sse_q20":86798896738,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":251,"samples":256,"transition_checksum":"c0c6abf054f96dd7","transition_correct":219,"transition_supported":230,"transition_unknown":26},"training_evaluations":803280},"ravel_random_births":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"634d2de62b30f3a2","correct":151,"expert_evaluations":3280,"prediction_checksum":"1a290b3e832b1919","prediction_samples":236,"prediction_sse_q20":244332161389,"reconstruction_checksum":"47e283c3ea540a8b","reconstruction_sse_q20":201306707205,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":234,"samples":256,"transition_checksum":"0981a46d13e64541","transition_correct":216,"transition_supported":236,"transition_unknown":20},"expert_count":64,"planning":{"belief_set_target_reached":39,"cases":64,"checksum":"9b90740c7d87ba23","exact_world_state_target_reached":38,"executed_path_length":239,"expansions":1886,"goal_expert_reached":39,"graph_disconnection_failures":0,"no_supported_edge_failures":1,"optimal_path_length":272,"path_found":63,"path_length_regret":10,"state_aliasing_failures":1,"transition_model_error_failures":24},"retention_holdout":{"classification_checksum":"a152f0dd9b0d3b78","correct":240,"expert_evaluations":2328,"prediction_checksum":"06801eae2a6751fe","prediction_samples":230,"prediction_sse_q20":83088104053,"reconstruction_checksum":"7131fb38e10e6b40","reconstruction_sse_q20":86798896738,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":251,"samples":256,"transition_checksum":"c0c6abf054f96dd7","transition_correct":219,"transition_supported":230,"transition_unknown":26},"training_evaluations":803280},"ravel_without_replay":{"checkpoint_size_bytes":52334,"drift_holdout":{"classification_checksum":"c04f584bd49b968f","correct":210,"expert_evaluations":2480,"prediction_checksum":"4fd89d36b5839130","prediction_samples":219,"prediction_sse_q20":157192953646,"reconstruction_checksum":"395a53ec33f05407","reconstruction_sse_q20":129190423707,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":250,"samples":256,"transition_checksum":"9c6935d29c80900a","transition_correct":181,"transition_supported":219,"transition_unknown":37},"expert_count":80,"planning":{"belief_set_target_reached":42,"cases":64,"checksum":"e260b4e773fe0f31","exact_world_state_target_reached":42,"executed_path_length":239,"expansions":2272,"goal_expert_reached":42,"graph_disconnection_failures":0,"no_supported_edge_failures":9,"optimal_path_length":272,"path_found":55,"path_length_regret":18,"state_aliasing_failures":0,"transition_model_error_failures":13},"retention_holdout":{"classification_checksum":"89ef673cd1bc4621","correct":245,"expert_evaluations":2120,"prediction_checksum":"ca8906ae81c0f5fb","prediction_samples":222,"prediction_sse_q20":55588934841,"reconstruction_checksum":"491086b48db5970a","reconstruction_sse_q20":60063916622,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":255,"samples":256,"transition_checksum":"85e24265ce04ce4a","transition_correct":213,"transition_supported":222,"transition_unknown":34},"training_evaluations":1882459},"ravel_without_retirement_matched_work":{"checkpoint_size_bytes":52334,"drift_holdout":{"classification_checksum":"c04f584bd49b968f","correct":210,"expert_evaluations":2480,"prediction_checksum":"87067ad4c1b4735b","prediction_samples":228,"prediction_sse_q20":161930151652,"reconstruction_checksum":"15a8929c3de0111c","reconstruction_sse_q20":128717475472,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":250,"samples":256,"transition_checksum":"b9cf1fe013b5f857","transition_correct":191,"transition_supported":228,"transition_unknown":28},"expert_count":80,"planning":{"belief_set_target_reached":43,"cases":64,"checksum":"2c2417c8f001ba9d","exact_world_state_target_reached":43,"executed_path_length":242,"expansions":2257,"goal_expert_reached":43,"graph_disconnection_failures":0,"no_supported_edge_failures":9,"optimal_path_length":272,"path_found":55,"path_length_regret":17,"state_aliasing_failures":0,"transition_model_error_failures":12},"retention_holdout":{"classification_checksum":"b6fa4df5ba643dfa","correct":244,"expert_evaluations":2120,"prediction_checksum":"ce5520574d1b7faf","prediction_samples":229,"prediction_sse_q20":55702269519,"reconstruction_checksum":"fbb6c6b288bb7e76","reconstruction_sse_q20":56573193530,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":255,"samples":256,"transition_checksum":"acb10d90c5c7c195","transition_correct":221,"transition_supported":229,"transition_unknown":27},"training_evaluations":2388157}},"dataset_seeds":{"base_holdout":"0x3650e00a951d3d3a","base_training":"0xdcc5ba2a8dea9a3b","drift_adaptation_training":"0x3e8f82a4d3fc628d","drift_holdout":"0x6f6dde7e7a0b9481","original_task_retention_holdout":"0x1ab072542e55db9d","planning_cases":"0xc092b3171f623570"},"dataset_sizes":{"base_holdout":256,"base_training":1024,"drift_adaptation_training":512,"drift_holdout":256,"original_task_retention_holdout":256,"planning_cases":64},"integrity":{"checkpoint_behavior_match":true,"checkpoint_identity_match":true,"checkpoint_mutations":{"anchored_status":true,"appended_unexpected_byte":true,"checkpoint_substitution":true,"checkpoint_truncation":true,"incorrect_schema_version":true,"label":true,"label_count":true,"lineage":true,"next_observation_component":true,"payload_byte":true,"reconstruction_component":true,"retrieval_key_component":true,"transition_graph_edge":true,"transition_support":true},"checkpoint_roundtrip":true,"lineage_invariants":{"deterministic_topology_reproduction":true,"lineage_uniqueness":true,"no_accidental_lineage_reuse":true,"parent_child_generation_increment":true,"repeated_descendant_splitting":true,"sibling_generation_equality":true},"unsupported_graph_edge_violations":0},"regime":"combined_observation_and_label_drift","schema":"ravel-raw-trial/0.5","seed":"0xbb7d6905881932af","trial_id":"validation-combined-03"},{"candidate":{"adaptation_completed":true,"adaptation_training":{"classification_checksum":"93c407084d6b6a85","correct":369,"expert_evaluations":5968,"prediction_checksum":"ef874a6acce8d1bb","prediction_samples":473,"prediction_sse_q20":278526213771,"reconstruction_checksum":"9c268aa179c58cad","reconstruction_sse_q20":286627862218,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":486,"samples":512,"transition_checksum":"253ef3722999cba6","transition_correct":415,"transition_supported":473,"transition_unknown":39},"adaptation_training_evaluations":1809941,"adapted_model_drift_holdout":{"classification_checksum":"ed8b4ee45475d17b","correct":197,"expert_evaluations":2840,"prediction_checksum":"9aadfab21ea1f1a6","prediction_samples":231,"prediction_sse_q20":144632467861,"reconstruction_checksum":"dbbfd0870a829464","reconstruction_sse_q20":143168613712,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":245,"samples":256,"transition_checksum":"f9bad6c1838a036b","transition_correct":202,"transition_supported":231,"transition_unknown":25},"base_holdout":{"classification_checksum":"7604a5ee9d6a9c50","correct":234,"expert_evaluations":2608,"prediction_checksum":"c28327aa0f9ef889","prediction_samples":234,"prediction_sse_q20":111069754106,"reconstruction_checksum":"d6f35c2a0f3d8145","reconstruction_sse_q20":93701249166,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":246,"samples":256,"transition_checksum":"1234a8cbf0c3cd02","transition_correct":213,"transition_supported":234,"transition_unknown":22},"base_holdout_retention":{"classification_checksum":"2144aec525719352","correct":246,"expert_evaluations":2120,"prediction_checksum":"5c967dca27c45d6b","prediction_samples":218,"prediction_sse_q20":62982991588,"reconstruction_checksum":"09e71ae36a506509","reconstruction_sse_q20":57282103615,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":255,"samples":256,"transition_checksum":"71c0d27913f87174","transition_correct":203,"transition_supported":218,"transition_unknown":38},"base_training_evaluations":573880,"behavior_identity":"5d4e5b54e0e5c25db2688f1132bc970e6fd98210097af8e15fd7fda839782efa","checkpoint_size_bytes":52334,"expert_count":80,"model_identity":"b17075f0d476947018b8d37e900e6bb323f1a88d1547277d35874d210e62f9d8","planning":{"belief_set_target_reached":42,"cases":64,"checksum":"211f4882a0824e46","exact_world_state_target_reached":42,"executed_path_length":235,"expansions":2227,"goal_expert_reached":42,"graph_disconnection_failures":0,"no_supported_edge_failures":8,"optimal_path_length":267,"path_found":56,"path_length_regret":8,"state_aliasing_failures":0,"transition_model_error_failures":14},"replay":{"actions_covered":4,"assigned_experts_covered":62,"high_loss_cases_selected":13,"labels_covered":8,"rare_cases_selected":60,"selected":256,"selection_checksum":"ec974f0592c0f2a7","states_covered":64,"transition_pairs_covered":252,"unique":256},"static_model_drift_holdout":{"classification_checksum":"c7718cfe19b3e12d","correct":141,"expert_evaluations":3896,"prediction_checksum":"264177f21ec78656","prediction_samples":236,"prediction_sse_q20":216274708459,"reconstruction_checksum":"442c1eac2a829c2d","reconstruction_sse_q20":210748925997,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":223,"samples":256,"transition_checksum":"1dcf36f4f83b8812","transition_correct":210,"transition_supported":236,"transition_unknown":20},"topology":{"accepted_births":16,"accepted_retirements":0,"births":[{"dominant_channel":0,"event_index":140,"normalized_score_q20":606615},{"dominant_channel":0,"event_index":264,"normalized_score_q20":604163},{"dominant_channel":0,"event_index":68,"normalized_score_q20":602462},{"dominant_channel":0,"event_index":192,"normalized_score_q20":597009},{"dominant_channel":0,"event_index":40,"normalized_score_q20":589019},{"dominant_channel":0,"event_index":77,"normalized_score_q20":576232},{"dominant_channel":0,"event_index":307,"normalized_score_q20":572091},{"dominant_channel":0,"event_index":509,"normalized_score_q20":566071},{"dominant_channel":0,"event_index":424,"normalized_score_q20":555673},{"dominant_channel":0,"event_index":310,"normalized_score_q20":543622},{"dominant_channel":0,"event_index":324,"normalized_score_q20":532872},{"dominant_channel":0,"event_index":359,"normalized_score_q20":532337},{"dominant_channel":0,"event_index":70,"normalized_score_q20":523640},{"dominant_channel":0,"event_index":320,"normalized_score_q20":512875},{"dominant_channel":0,"event_index":109,"normalized_score_q20":487166},{"dominant_channel":0,"event_index":206,"normalized_score_q20":483654}],"objective_after_q20":839975,"objective_before_q20":799105,"rejected_births":0,"rejected_retirements":1,"retired_lineages":[],"training_observations":{"births":16,"certified":20161,"expert_evaluations":1809941,"rejected_births":0,"rejected_retirements":1,"retired":0,"samples":21504}}},"checkpoint_format":{"byte_order":"big_endian","magic_hex":"524156454c303500","payload_digest":"sha256","real_encoding":"signed_q20_int64","schema_version":5,"transition_support_min":2,"transition_top_k":2},"comparisons":{"fixed_8_expert":{"checkpoint_size_bytes":11294,"drift_holdout":{"classification_checksum":"b430598bd16ac99e","correct":43,"expert_evaluations":2048,"prediction_checksum":"ffacc43a72313e2d","prediction_samples":256,"prediction_sse_q20":1411272206433,"reconstruction_checksum":"c0f7016bbb905563","reconstruction_sse_q20":1275494643115,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"7a08a8b277e4a503","transition_correct":138,"transition_supported":256,"transition_unknown":0},"expert_count":8,"planning":{"belief_set_target_reached":31,"cases":64,"checksum":"35770bd300af0804","exact_world_state_target_reached":7,"executed_path_length":122,"expansions":254,"goal_expert_reached":31,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":267,"path_found":64,"path_length_regret":2,"state_aliasing_failures":24,"transition_model_error_failures":33},"retention_holdout":{"classification_checksum":"25c5001a60e48e15","correct":59,"expert_evaluations":2048,"prediction_checksum":"9fab84ffef7e0c79","prediction_samples":256,"prediction_sse_q20":1340030720798,"reconstruction_checksum":"b13c64fa4f4969aa","reconstruction_sse_q20":1206776756075,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"6ad9e25afd289750","transition_correct":145,"transition_supported":256,"transition_unknown":0},"training_evaluations":94208},"fixed_topology_64_expert_routed":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"89e097acd8c2b126","correct":168,"expert_evaluations":2552,"prediction_checksum":"d4a61a0c774ba751","prediction_samples":241,"prediction_sse_q20":143822720080,"reconstruction_checksum":"f15285e76ef0d083","reconstruction_sse_q20":143168313873,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":247,"samples":256,"transition_checksum":"c3bb092cddc7b21d","transition_correct":241,"transition_supported":241,"transition_unknown":15},"expert_count":64,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"9b3f653b3b9e38ca","exact_world_state_target_reached":64,"executed_path_length":274,"expansions":1901,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":267,"path_found":64,"path_length_regret":7,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"ab3e449e83ac78cb","correct":256,"expert_evaluations":2048,"prediction_checksum":"e0807101836149d5","prediction_samples":224,"prediction_sse_q20":44523775574,"reconstruction_checksum":"fd2cd56b80e70de5","reconstruction_sse_q20":42488194957,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"45029dfa63ee77f6","transition_correct":224,"transition_supported":224,"transition_unknown":32},"training_evaluations":2588672},"flat_64_expert_complete_scan":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"89e097acd8c2b126","correct":168,"expert_evaluations":16384,"prediction_checksum":"d4a61a0c774ba751","prediction_samples":241,"prediction_sse_q20":143822720080,"reconstruction_checksum":"f15285e76ef0d083","reconstruction_sse_q20":143168313873,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"c3bb092cddc7b21d","transition_correct":241,"transition_supported":241,"transition_unknown":15},"expert_count":64,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"9b3f653b3b9e38ca","exact_world_state_target_reached":64,"executed_path_length":274,"expansions":1901,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":267,"path_found":64,"path_length_regret":7,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"ab3e449e83ac78cb","correct":256,"expert_evaluations":16384,"prediction_checksum":"e0807101836149d5","prediction_samples":224,"prediction_sse_q20":44523775574,"reconstruction_checksum":"fd2cd56b80e70de5","reconstruction_sse_q20":42488194957,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"45029dfa63ee77f6","transition_correct":224,"transition_supported":224,"transition_unknown":32},"training_evaluations":2588672},"matched_compute_fixed_topology":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"c7718cfe19b3e12d","correct":141,"expert_evaluations":3896,"prediction_checksum":"264177f21ec78656","prediction_samples":236,"prediction_sse_q20":216274708459,"reconstruction_checksum":"442c1eac2a829c2d","reconstruction_sse_q20":210748925997,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":223,"samples":256,"transition_checksum":"1dcf36f4f83b8812","transition_correct":210,"transition_supported":236,"transition_unknown":20},"expert_count":64,"planning":{"belief_set_target_reached":45,"cases":64,"checksum":"97554d585d6d38fb","exact_world_state_target_reached":38,"executed_path_length":241,"expansions":1683,"goal_expert_reached":45,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":267,"path_found":64,"path_length_regret":6,"state_aliasing_failures":7,"transition_model_error_failures":19},"retention_holdout":{"classification_checksum":"17f832270ac15428","correct":239,"expert_evaluations":2552,"prediction_checksum":"1b17c24bd9dc6046","prediction_samples":226,"prediction_sse_q20":103659956080,"reconstruction_checksum":"1eaa8ffc82883c36","reconstruction_sse_q20":89249734581,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":247,"samples":256,"transition_checksum":"40e99bd6b946acb5","transition_correct":205,"transition_supported":226,"transition_unknown":30},"training_evaluations":2434744},"matched_expert_count_capacity":{"checkpoint_size_bytes":52334,"drift_holdout":{"classification_checksum":"2c7eaa2ca829ca60","correct":168,"expert_evaluations":2768,"prediction_checksum":"6dde0f0f75af322d","prediction_samples":202,"prediction_sse_q20":123225692077,"reconstruction_checksum":"4752348de063ac37","reconstruction_sse_q20":139501200868,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":246,"samples":256,"transition_checksum":"f3af5bba19f0b604","transition_correct":177,"transition_supported":202,"transition_unknown":54},"expert_count":80,"planning":{"belief_set_target_reached":64,"cases":64,"checksum":"75296b9fe72cfb0e","exact_world_state_target_reached":64,"executed_path_length":299,"expansions":2223,"goal_expert_reached":64,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":267,"path_found":64,"path_length_regret":32,"state_aliasing_failures":0,"transition_model_error_failures":0},"retention_holdout":{"classification_checksum":"c56e6d0a5259bcd6","correct":256,"expert_evaluations":2048,"prediction_checksum":"cc7d388c76ae1c4b","prediction_samples":209,"prediction_sse_q20":41908074343,"reconstruction_checksum":"7e4ad97b10de890a","reconstruction_sse_q20":42494531888,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"98a622be4ee8723e","transition_correct":183,"transition_supported":209,"transition_unknown":47},"training_evaluations":3891200},"nearest_centroid_16_no_recursive_births":{"checkpoint_size_bytes":15854,"drift_holdout":{"classification_checksum":"49f6c28a71c06ee4","correct":53,"expert_evaluations":4096,"prediction_checksum":"57ba34c7eaa037ee","prediction_samples":256,"prediction_sse_q20":951577572341,"reconstruction_checksum":"80194cbf8f133cb0","reconstruction_sse_q20":876450730593,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"3f600363b203e7b9","transition_correct":180,"transition_supported":256,"transition_unknown":0},"expert_count":16,"planning":{"belief_set_target_reached":31,"cases":64,"checksum":"e2a4ba421a9aad28","exact_world_state_target_reached":8,"executed_path_length":150,"expansions":537,"goal_expert_reached":31,"graph_disconnection_failures":4,"no_supported_edge_failures":0,"optimal_path_length":267,"path_found":60,"path_length_regret":4,"state_aliasing_failures":23,"transition_model_error_failures":29},"retention_holdout":{"classification_checksum":"9a02dfb611875722","correct":80,"expert_evaluations":4096,"prediction_checksum":"f754e5e87c87f15f","prediction_samples":256,"prediction_sse_q20":925268778080,"reconstruction_checksum":"c4be26cd1ffc9864","reconstruction_sse_q20":786731059454,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"d686306ccf362cae","transition_correct":170,"transition_supported":256,"transition_unknown":0},"training_evaluations":253952},"no_adaptation_static":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"c7718cfe19b3e12d","correct":141,"expert_evaluations":3896,"prediction_checksum":"264177f21ec78656","prediction_samples":236,"prediction_sse_q20":216274708459,"reconstruction_checksum":"442c1eac2a829c2d","reconstruction_sse_q20":210748925997,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":223,"samples":256,"transition_checksum":"1dcf36f4f83b8812","transition_correct":210,"transition_supported":236,"transition_unknown":20},"expert_count":64,"planning":{"belief_set_target_reached":45,"cases":64,"checksum":"97554d585d6d38fb","exact_world_state_target_reached":38,"executed_path_length":241,"expansions":1683,"goal_expert_reached":45,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":267,"path_found":64,"path_length_regret":6,"state_aliasing_failures":7,"transition_model_error_failures":19},"retention_holdout":{"classification_checksum":"17f832270ac15428","correct":239,"expert_evaluations":2552,"prediction_checksum":"1b17c24bd9dc6046","prediction_samples":226,"prediction_sse_q20":103659956080,"reconstruction_checksum":"1eaa8ffc82883c36","reconstruction_sse_q20":89249734581,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":247,"samples":256,"transition_checksum":"40e99bd6b946acb5","transition_correct":205,"transition_supported":226,"transition_unknown":30},"training_evaluations":573880},"periodic_replay_policy":{"checkpoint_size_bytes":52334,"drift_holdout":{"classification_checksum":"ed8b4ee45475d17b","correct":197,"expert_evaluations":2840,"prediction_checksum":"22bf4ea49b5fa4f1","prediction_samples":220,"prediction_sse_q20":137136754642,"reconstruction_checksum":"1a8b7cc884cc1610","reconstruction_sse_q20":142678801785,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":245,"samples":256,"transition_checksum":"205a7c01784b6f2a","transition_correct":191,"transition_supported":220,"transition_unknown":36},"expert_count":80,"planning":{"belief_set_target_reached":43,"cases":64,"checksum":"ed9fc3b13cd9f570","exact_world_state_target_reached":43,"executed_path_length":239,"expansions":2185,"goal_expert_reached":43,"graph_disconnection_failures":0,"no_supported_edge_failures":9,"optimal_path_length":267,"path_found":55,"path_length_regret":17,"state_aliasing_failures":0,"transition_model_error_failures":12},"retention_holdout":{"classification_checksum":"c7e6f5a36b913738","correct":247,"expert_evaluations":2120,"prediction_checksum":"1c94454a9111dda4","prediction_samples":210,"prediction_sse_q20":59777516265,"reconstruction_checksum":"c9979c07d6d31504","reconstruction_sse_q20":59197740185,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":255,"samples":256,"transition_checksum":"bb2498f740aaf4db","transition_correct":197,"transition_supported":210,"transition_unknown":46},"training_evaluations":2648479},"ravel_0_5_candidate":{"checkpoint_size_bytes":52334,"drift_holdout":{"classification_checksum":"ed8b4ee45475d17b","correct":197,"expert_evaluations":2840,"prediction_checksum":"9aadfab21ea1f1a6","prediction_samples":231,"prediction_sse_q20":144632467861,"reconstruction_checksum":"dbbfd0870a829464","reconstruction_sse_q20":143168613712,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":245,"samples":256,"transition_checksum":"f9bad6c1838a036b","transition_correct":202,"transition_supported":231,"transition_unknown":25},"expert_count":80,"planning":{"belief_set_target_reached":42,"cases":64,"checksum":"211f4882a0824e46","exact_world_state_target_reached":42,"executed_path_length":235,"expansions":2227,"goal_expert_reached":42,"graph_disconnection_failures":0,"no_supported_edge_failures":8,"optimal_path_length":267,"path_found":56,"path_length_regret":8,"state_aliasing_failures":0,"transition_model_error_failures":14},"retention_holdout":{"classification_checksum":"2144aec525719352","correct":246,"expert_evaluations":2120,"prediction_checksum":"5c967dca27c45d6b","prediction_samples":218,"prediction_sse_q20":62982991588,"reconstruction_checksum":"09e71ae36a506509","reconstruction_sse_q20":57282103615,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":255,"samples":256,"transition_checksum":"71c0d27913f87174","transition_correct":203,"transition_supported":218,"transition_unknown":38},"training_evaluations":2383821},"ravel_complete_scan_without_certification":{"checkpoint_size_bytes":52334,"drift_holdout":{"classification_checksum":"ed8b4ee45475d17b","correct":197,"expert_evaluations":20480,"prediction_checksum":"9aadfab21ea1f1a6","prediction_samples":231,"prediction_sse_q20":144632467861,"reconstruction_checksum":"dbbfd0870a829464","reconstruction_sse_q20":143168613712,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"f9bad6c1838a036b","transition_correct":202,"transition_supported":231,"transition_unknown":25},"expert_count":80,"planning":{"belief_set_target_reached":42,"cases":64,"checksum":"211f4882a0824e46","exact_world_state_target_reached":42,"executed_path_length":235,"expansions":2227,"goal_expert_reached":42,"graph_disconnection_failures":0,"no_supported_edge_failures":8,"optimal_path_length":267,"path_found":56,"path_length_regret":8,"state_aliasing_failures":0,"transition_model_error_failures":14},"retention_holdout":{"classification_checksum":"2144aec525719352","correct":246,"expert_evaluations":20480,"prediction_checksum":"5c967dca27c45d6b","prediction_samples":218,"prediction_sse_q20":62982991588,"reconstruction_checksum":"09e71ae36a506509","reconstruction_sse_q20":57282103615,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"71c0d27913f87174","transition_correct":203,"transition_supported":218,"transition_unknown":38},"training_evaluations":2597157},"ravel_no_birth_same_replay_iterations":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"c7718cfe19b3e12d","correct":141,"expert_evaluations":3896,"prediction_checksum":"264177f21ec78656","prediction_samples":236,"prediction_sse_q20":216274708459,"reconstruction_checksum":"442c1eac2a829c2d","reconstruction_sse_q20":210748925997,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":223,"samples":256,"transition_checksum":"1dcf36f4f83b8812","transition_correct":210,"transition_supported":236,"transition_unknown":20},"expert_count":64,"planning":{"belief_set_target_reached":45,"cases":64,"checksum":"97554d585d6d38fb","exact_world_state_target_reached":38,"executed_path_length":241,"expansions":1683,"goal_expert_reached":45,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":267,"path_found":64,"path_length_regret":6,"state_aliasing_failures":7,"transition_model_error_failures":19},"retention_holdout":{"classification_checksum":"17f832270ac15428","correct":239,"expert_evaluations":2552,"prediction_checksum":"1b17c24bd9dc6046","prediction_samples":226,"prediction_sse_q20":103659956080,"reconstruction_checksum":"1eaa8ffc82883c36","reconstruction_sse_q20":89249734581,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":247,"samples":256,"transition_checksum":"40e99bd6b946acb5","transition_correct":205,"transition_supported":226,"transition_unknown":30},"training_evaluations":806488},"ravel_random_births":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"c7718cfe19b3e12d","correct":141,"expert_evaluations":3896,"prediction_checksum":"264177f21ec78656","prediction_samples":236,"prediction_sse_q20":216274708459,"reconstruction_checksum":"442c1eac2a829c2d","reconstruction_sse_q20":210748925997,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":223,"samples":256,"transition_checksum":"1dcf36f4f83b8812","transition_correct":210,"transition_supported":236,"transition_unknown":20},"expert_count":64,"planning":{"belief_set_target_reached":45,"cases":64,"checksum":"97554d585d6d38fb","exact_world_state_target_reached":38,"executed_path_length":241,"expansions":1683,"goal_expert_reached":45,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":267,"path_found":64,"path_length_regret":6,"state_aliasing_failures":7,"transition_model_error_failures":19},"retention_holdout":{"classification_checksum":"17f832270ac15428","correct":239,"expert_evaluations":2552,"prediction_checksum":"1b17c24bd9dc6046","prediction_samples":226,"prediction_sse_q20":103659956080,"reconstruction_checksum":"1eaa8ffc82883c36","reconstruction_sse_q20":89249734581,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":247,"samples":256,"transition_checksum":"40e99bd6b946acb5","transition_correct":205,"transition_supported":226,"transition_unknown":30},"training_evaluations":806488},"ravel_without_replay":{"checkpoint_size_bytes":52334,"drift_holdout":{"classification_checksum":"ed8b4ee45475d17b","correct":197,"expert_evaluations":2840,"prediction_checksum":"2730b1942f585a73","prediction_samples":213,"prediction_sse_q20":134652770237,"reconstruction_checksum":"d8474e051c77db2e","reconstruction_sse_q20":144994794702,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":245,"samples":256,"transition_checksum":"7fa7a64c0d209ee3","transition_correct":186,"transition_supported":213,"transition_unknown":43},"expert_count":80,"planning":{"belief_set_target_reached":43,"cases":64,"checksum":"ab39ed827b1d8b3b","exact_world_state_target_reached":43,"executed_path_length":240,"expansions":2190,"goal_expert_reached":43,"graph_disconnection_failures":0,"no_supported_edge_failures":9,"optimal_path_length":267,"path_found":55,"path_length_regret":18,"state_aliasing_failures":0,"transition_model_error_failures":12},"retention_holdout":{"classification_checksum":"c7e6f5a36b913738","correct":247,"expert_evaluations":2120,"prediction_checksum":"bb22df38eb32d123","prediction_samples":207,"prediction_sse_q20":58915490226,"reconstruction_checksum":"878136fb842321fa","reconstruction_sse_q20":60887786658,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":255,"samples":256,"transition_checksum":"9e50d32479327825","transition_correct":192,"transition_supported":207,"transition_unknown":49},"training_evaluations":1879660},"ravel_without_retirement_matched_work":{"checkpoint_size_bytes":52334,"drift_holdout":{"classification_checksum":"ed8b4ee45475d17b","correct":197,"expert_evaluations":2840,"prediction_checksum":"9aadfab21ea1f1a6","prediction_samples":231,"prediction_sse_q20":144632467861,"reconstruction_checksum":"dbbfd0870a829464","reconstruction_sse_q20":143168613712,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":245,"samples":256,"transition_checksum":"f9bad6c1838a036b","transition_correct":202,"transition_supported":231,"transition_unknown":25},"expert_count":80,"planning":{"belief_set_target_reached":42,"cases":64,"checksum":"211f4882a0824e46","exact_world_state_target_reached":42,"executed_path_length":235,"expansions":2227,"goal_expert_reached":42,"graph_disconnection_failures":0,"no_supported_edge_failures":8,"optimal_path_length":267,"path_found":56,"path_length_regret":8,"state_aliasing_failures":0,"transition_model_error_failures":14},"retention_holdout":{"classification_checksum":"2144aec525719352","correct":246,"expert_evaluations":2120,"prediction_checksum":"5c967dca27c45d6b","prediction_samples":218,"prediction_sse_q20":62982991588,"reconstruction_checksum":"09e71ae36a506509","reconstruction_sse_q20":57282103615,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":255,"samples":256,"transition_checksum":"71c0d27913f87174","transition_correct":203,"transition_supported":218,"transition_unknown":38},"training_evaluations":2383821}},"dataset_seeds":{"base_holdout":"0xb032f1bc110a8259","base_training":"0xa093a5eec6b1b50b","drift_adaptation_training":"0xe07d152a3b10f3a0","drift_holdout":"0x933d40f706d56f06","original_task_retention_holdout":"0x4ab9d63415efd0a7","planning_cases":"0x104244e806880100"},"dataset_sizes":{"base_holdout":256,"base_training":1024,"drift_adaptation_training":512,"drift_holdout":256,"original_task_retention_holdout":256,"planning_cases":64},"integrity":{"checkpoint_behavior_match":true,"checkpoint_identity_match":true,"checkpoint_mutations":{"anchored_status":true,"appended_unexpected_byte":true,"checkpoint_substitution":true,"checkpoint_truncation":true,"incorrect_schema_version":true,"label":true,"label_count":true,"lineage":true,"next_observation_component":true,"payload_byte":true,"reconstruction_component":true,"retrieval_key_component":true,"transition_graph_edge":true,"transition_support":true},"checkpoint_roundtrip":true,"lineage_invariants":{"deterministic_topology_reproduction":true,"lineage_uniqueness":true,"no_accidental_lineage_reuse":true,"parent_child_generation_increment":true,"repeated_descendant_splitting":true,"sibling_generation_equality":true},"unsupported_graph_edge_violations":0},"regime":"combined_observation_and_label_drift","schema":"ravel-raw-trial/0.5","seed":"0x5a6a789f3e8a6718","trial_id":"validation-combined-04"},{"candidate":{"adaptation_completed":true,"adaptation_training":{"classification_checksum":"7a035c0ccc86b9c2","correct":457,"expert_evaluations":4993,"prediction_checksum":"3da454cc7a05ccd7","prediction_samples":470,"prediction_sse_q20":977461630252,"reconstruction_checksum":"8ab53931288c2da0","reconstruction_sse_q20":199417707929,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":499,"samples":512,"transition_checksum":"75097dfe4b851ec9","transition_correct":197,"transition_supported":470,"transition_unknown":42},"adaptation_training_evaluations":1899666,"adapted_model_drift_holdout":{"classification_checksum":"f338a891c067f436","correct":228,"expert_evaluations":2393,"prediction_checksum":"9738a606f9c3cae1","prediction_samples":230,"prediction_sse_q20":535694858800,"reconstruction_checksum":"61b704421e9fadb5","reconstruction_sse_q20":104833483725,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":251,"samples":256,"transition_checksum":"bd907b886e819fca","transition_correct":99,"transition_supported":230,"transition_unknown":26},"base_holdout":{"classification_checksum":"514b11c8a493baf5","correct":256,"expert_evaluations":2048,"prediction_checksum":"968c729fc3050cd4","prediction_samples":237,"prediction_sse_q20":457637510788,"reconstruction_checksum":"6cb60db7a13aaee2","reconstruction_sse_q20":62759531407,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"ba7ea0fea3b7c7cf","transition_correct":109,"transition_supported":237,"transition_unknown":19},"base_holdout_retention":{"classification_checksum":"d3140b723e5d7fe7","correct":256,"expert_evaluations":2048,"prediction_checksum":"57a8bd9dd564f814","prediction_samples":237,"prediction_sse_q20":448140071749,"reconstruction_checksum":"f3a665fcea8f1f72","reconstruction_sse_q20":64372555708,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"810a69f7530c8522","transition_correct":96,"transition_supported":237,"transition_unknown":19},"base_training_evaluations":549480,"behavior_identity":"c72bf07136e3e701f8d371c5dc6ef3ff36585b0027809cda05c4a7866ef2e9fb","checkpoint_size_bytes":50624,"expert_count":77,"model_identity":"3ec8ab6e503cf1e8be6df8e7ba636f2521974cf4066f4834bd51a779f8fcf2b8","planning":{"belief_set_target_reached":26,"cases":64,"checksum":"abfc7caed9c8b68d","exact_world_state_target_reached":9,"executed_path_length":192,"expansions":2178,"goal_expert_reached":26,"graph_disconnection_failures":0,"no_supported_edge_failures":12,"optimal_path_length":205,"path_found":52,"path_length_regret":6,"state_aliasing_failures":17,"transition_model_error_failures":26},"replay":{"actions_covered":4,"assigned_experts_covered":60,"high_loss_cases_selected":31,"labels_covered":8,"rare_cases_selected":63,"selected":256,"selection_checksum":"2a744c008f84e054","states_covered":64,"transition_pairs_covered":254,"unique":256},"static_model_drift_holdout":{"classification_checksum":"590cdad662b7ff5f","correct":148,"expert_evaluations":3784,"prediction_checksum":"8831da7106c04b22","prediction_samples":221,"prediction_sse_q20":811001568483,"reconstruction_checksum":"5488f455fee4f066","reconstruction_sse_q20":143472924409,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":225,"samples":256,"transition_checksum":"ef04b50771d425a4","transition_correct":75,"transition_supported":221,"transition_unknown":35},"topology":{"accepted_births":14,"accepted_retirements":1,"births":[{"dominant_channel":0,"event_index":108,"normalized_score_q20":625549},{"dominant_channel":0,"event_index":283,"normalized_score_q20":618544},{"dominant_channel":0,"event_index":287,"normalized_score_q20":614962},{"dominant_channel":0,"event_index":59,"normalized_score_q20":595700},{"dominant_channel":0,"event_index":376,"normalized_score_q20":580377},{"dominant_channel":0,"event_index":210,"normalized_score_q20":579754},{"dominant_channel":0,"event_index":219,"normalized_score_q20":571925},{"dominant_channel":0,"event_index":305,"normalized_score_q20":570824},{"dominant_channel":0,"event_index":457,"normalized_score_q20":452130},{"dominant_channel":0,"event_index":217,"normalized_score_q20":441964},{"dominant_channel":0,"event_index":147,"normalized_score_q20":434740},{"dominant_channel":0,"event_index":501,"normalized_score_q20":434298},{"dominant_channel":0,"event_index":175,"normalized_score_q20":430535},{"dominant_channel":0,"event_index":129,"normalized_score_q20":423464}],"objective_after_q20":880962,"objective_before_q20":830207,"rejected_births":2,"rejected_retirements":1,"retired_lineages":["d56da310d9d70d42"],"training_observations":{"births":14,"certified":22103,"expert_evaluations":1899666,"rejected_births":2,"rejected_retirements":1,"retired":1,"samples":23040}}},"checkpoint_format":{"byte_order":"big_endian","magic_hex":"524156454c303500","payload_digest":"sha256","real_encoding":"signed_q20_int64","schema_version":5,"transition_support_min":2,"transition_top_k":2},"comparisons":{"fixed_8_expert":{"checkpoint_size_bytes":11294,"drift_holdout":{"classification_checksum":"3e2a568a7241efd5","correct":51,"expert_evaluations":2048,"prediction_checksum":"e561563bb03483ef","prediction_samples":256,"prediction_sse_q20":1280073956398,"reconstruction_checksum":"ac5f4e45453d50f1","reconstruction_sse_q20":782869245125,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"392926462a31c2c0","transition_correct":157,"transition_supported":256,"transition_unknown":0},"expert_count":8,"planning":{"belief_set_target_reached":22,"cases":64,"checksum":"22ee769da83b1340","exact_world_state_target_reached":3,"executed_path_length":31,"expansions":153,"goal_expert_reached":22,"graph_disconnection_failures":32,"no_supported_edge_failures":0,"optimal_path_length":205,"path_found":32,"path_length_regret":2,"state_aliasing_failures":19,"transition_model_error_failures":10},"retention_holdout":{"classification_checksum":"0df0c9535dcae655","correct":73,"expert_evaluations":2048,"prediction_checksum":"e0b9707346a77602","prediction_samples":256,"prediction_sse_q20":944952294230,"reconstruction_checksum":"b64c07e6fd4fe235","reconstruction_sse_q20":662578148127,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"8497e02d8a0fd236","transition_correct":181,"transition_supported":256,"transition_unknown":0},"training_evaluations":94208},"fixed_topology_64_expert_routed":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"21d80027ee2318d8","correct":148,"expert_evaluations":3728,"prediction_checksum":"e877afa3f6e13413","prediction_samples":235,"prediction_sse_q20":919869487021,"reconstruction_checksum":"0b7e7cecd470a095","reconstruction_sse_q20":145132125336,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":226,"samples":256,"transition_checksum":"6454033411e1cbc0","transition_correct":85,"transition_supported":235,"transition_unknown":21},"expert_count":64,"planning":{"belief_set_target_reached":18,"cases":64,"checksum":"b946f5f73377172b","exact_world_state_target_reached":8,"executed_path_length":266,"expansions":1762,"goal_expert_reached":18,"graph_disconnection_failures":0,"no_supported_edge_failures":2,"optimal_path_length":205,"path_found":62,"path_length_regret":4,"state_aliasing_failures":10,"transition_model_error_failures":44},"retention_holdout":{"classification_checksum":"038913c7bef54817","correct":256,"expert_evaluations":2048,"prediction_checksum":"231b592dee1d5e25","prediction_samples":233,"prediction_sse_q20":476910241115,"reconstruction_checksum":"c2b22c9b79001dad","reconstruction_sse_q20":63674632449,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"43e0a8f0856be400","transition_correct":99,"transition_supported":233,"transition_unknown":23},"training_evaluations":2588672},"flat_64_expert_complete_scan":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"21d80027ee2318d8","correct":148,"expert_evaluations":16384,"prediction_checksum":"e877afa3f6e13413","prediction_samples":235,"prediction_sse_q20":919869487021,"reconstruction_checksum":"0b7e7cecd470a095","reconstruction_sse_q20":145132125336,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"6454033411e1cbc0","transition_correct":85,"transition_supported":235,"transition_unknown":21},"expert_count":64,"planning":{"belief_set_target_reached":18,"cases":64,"checksum":"b946f5f73377172b","exact_world_state_target_reached":8,"executed_path_length":266,"expansions":1762,"goal_expert_reached":18,"graph_disconnection_failures":0,"no_supported_edge_failures":2,"optimal_path_length":205,"path_found":62,"path_length_regret":4,"state_aliasing_failures":10,"transition_model_error_failures":44},"retention_holdout":{"classification_checksum":"038913c7bef54817","correct":256,"expert_evaluations":16384,"prediction_checksum":"231b592dee1d5e25","prediction_samples":233,"prediction_sse_q20":476910241115,"reconstruction_checksum":"c2b22c9b79001dad","reconstruction_sse_q20":63674632449,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"43e0a8f0856be400","transition_correct":99,"transition_supported":233,"transition_unknown":23},"training_evaluations":2588672},"matched_compute_fixed_topology":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"590cdad662b7ff5f","correct":148,"expert_evaluations":3784,"prediction_checksum":"8831da7106c04b22","prediction_samples":221,"prediction_sse_q20":811001568483,"reconstruction_checksum":"5488f455fee4f066","reconstruction_sse_q20":143472924409,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":225,"samples":256,"transition_checksum":"ef04b50771d425a4","transition_correct":75,"transition_supported":221,"transition_unknown":35},"expert_count":64,"planning":{"belief_set_target_reached":18,"cases":64,"checksum":"f7df05c8d53a1f65","exact_world_state_target_reached":8,"executed_path_length":230,"expansions":1631,"goal_expert_reached":18,"graph_disconnection_failures":0,"no_supported_edge_failures":4,"optimal_path_length":205,"path_found":60,"path_length_regret":8,"state_aliasing_failures":10,"transition_model_error_failures":42},"retention_holdout":{"classification_checksum":"d3140b723e5d7fe7","correct":256,"expert_evaluations":2048,"prediction_checksum":"57a8bd9dd564f814","prediction_samples":237,"prediction_sse_q20":448140071749,"reconstruction_checksum":"f3a665fcea8f1f72","reconstruction_sse_q20":64372555708,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"6e3bf8b810d05dba","transition_correct":97,"transition_supported":237,"transition_unknown":19},"training_evaluations":2644968},"matched_expert_count_capacity":{"checkpoint_size_bytes":50624,"drift_holdout":{"classification_checksum":"f43cda0937be5d7a","correct":148,"expert_evaluations":4325,"prediction_checksum":"6de8dd0749852508","prediction_samples":215,"prediction_sse_q20":842682132125,"reconstruction_checksum":"febfa981785245d0","reconstruction_sse_q20":140079768261,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":223,"samples":256,"transition_checksum":"1da660f14fb30f15","transition_correct":63,"transition_supported":215,"transition_unknown":41},"expert_count":77,"planning":{"belief_set_target_reached":13,"cases":64,"checksum":"305adc3ec6c1d162","exact_world_state_target_reached":7,"executed_path_length":339,"expansions":2175,"goal_expert_reached":13,"graph_disconnection_failures":0,"no_supported_edge_failures":2,"optimal_path_length":205,"path_found":62,"path_length_regret":0,"state_aliasing_failures":6,"transition_model_error_failures":49},"retention_holdout":{"classification_checksum":"e94602b2a16d71f2","correct":256,"expert_evaluations":2048,"prediction_checksum":"732356fccd95ada7","prediction_samples":211,"prediction_sse_q20":409057323841,"reconstruction_checksum":"f275875830a7345c","reconstruction_sse_q20":62153455036,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"78819a3aa5886674","transition_correct":77,"transition_supported":211,"transition_unknown":45},"training_evaluations":3627008},"nearest_centroid_16_no_recursive_births":{"checkpoint_size_bytes":15854,"drift_holdout":{"classification_checksum":"e75c20472cc5236c","correct":64,"expert_evaluations":4096,"prediction_checksum":"6f1d7e71b9636d6a","prediction_samples":256,"prediction_sse_q20":1107394315423,"reconstruction_checksum":"1f1885247fe8cad7","reconstruction_sse_q20":393279169262,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"f4790d89b5329cfb","transition_correct":155,"transition_supported":256,"transition_unknown":0},"expert_count":16,"planning":{"belief_set_target_reached":21,"cases":64,"checksum":"efff68706a7f41a5","exact_world_state_target_reached":4,"executed_path_length":230,"expansions":457,"goal_expert_reached":21,"graph_disconnection_failures":3,"no_supported_edge_failures":0,"optimal_path_length":205,"path_found":61,"path_length_regret":2,"state_aliasing_failures":17,"transition_model_error_failures":40},"retention_holdout":{"classification_checksum":"af4370f07abbead7","correct":113,"expert_evaluations":4096,"prediction_checksum":"9bbd12b6290a9e71","prediction_samples":256,"prediction_sse_q20":643786384398,"reconstruction_checksum":"d0829f687b5f1da8","reconstruction_sse_q20":310603611084,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"f31852b2385b2dd0","transition_correct":189,"transition_supported":256,"transition_unknown":0},"training_evaluations":253952},"no_adaptation_static":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"590cdad662b7ff5f","correct":148,"expert_evaluations":3784,"prediction_checksum":"8831da7106c04b22","prediction_samples":221,"prediction_sse_q20":811001568483,"reconstruction_checksum":"5488f455fee4f066","reconstruction_sse_q20":143472924409,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":225,"samples":256,"transition_checksum":"ef04b50771d425a4","transition_correct":75,"transition_supported":221,"transition_unknown":35},"expert_count":64,"planning":{"belief_set_target_reached":18,"cases":64,"checksum":"f7df05c8d53a1f65","exact_world_state_target_reached":8,"executed_path_length":230,"expansions":1631,"goal_expert_reached":18,"graph_disconnection_failures":0,"no_supported_edge_failures":4,"optimal_path_length":205,"path_found":60,"path_length_regret":8,"state_aliasing_failures":10,"transition_model_error_failures":42},"retention_holdout":{"classification_checksum":"d3140b723e5d7fe7","correct":256,"expert_evaluations":2048,"prediction_checksum":"57a8bd9dd564f814","prediction_samples":237,"prediction_sse_q20":448140071749,"reconstruction_checksum":"f3a665fcea8f1f72","reconstruction_sse_q20":64372555708,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"6e3bf8b810d05dba","transition_correct":97,"transition_supported":237,"transition_unknown":19},"training_evaluations":549480},"periodic_replay_policy":{"checkpoint_size_bytes":51764,"drift_holdout":{"classification_checksum":"9badcee2d802943b","correct":229,"expert_evaluations":2403,"prediction_checksum":"d556135bde2dc355","prediction_samples":230,"prediction_sse_q20":525679565989,"reconstruction_checksum":"5c97c05a85ba426f","reconstruction_sse_q20":104739940434,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":251,"samples":256,"transition_checksum":"00dbef356c915418","transition_correct":100,"transition_supported":230,"transition_unknown":26},"expert_count":79,"planning":{"belief_set_target_reached":23,"cases":64,"checksum":"dff1551cd518508a","exact_world_state_target_reached":9,"executed_path_length":187,"expansions":2142,"goal_expert_reached":23,"graph_disconnection_failures":0,"no_supported_edge_failures":12,"optimal_path_length":205,"path_found":52,"path_length_regret":6,"state_aliasing_failures":14,"transition_model_error_failures":29},"retention_holdout":{"classification_checksum":"d3140b723e5d7fe7","correct":256,"expert_evaluations":2048,"prediction_checksum":"57a8bd9dd564f814","prediction_samples":237,"prediction_sse_q20":448140071749,"reconstruction_checksum":"f3a665fcea8f1f72","reconstruction_sse_q20":64372555708,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"959ba44f00175b68","transition_correct":96,"transition_supported":237,"transition_unknown":19},"training_evaluations":2588440},"ravel_0_5_candidate":{"checkpoint_size_bytes":50624,"drift_holdout":{"classification_checksum":"f338a891c067f436","correct":228,"expert_evaluations":2393,"prediction_checksum":"9738a606f9c3cae1","prediction_samples":230,"prediction_sse_q20":535694858800,"reconstruction_checksum":"61b704421e9fadb5","reconstruction_sse_q20":104833483725,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":251,"samples":256,"transition_checksum":"bd907b886e819fca","transition_correct":99,"transition_supported":230,"transition_unknown":26},"expert_count":77,"planning":{"belief_set_target_reached":26,"cases":64,"checksum":"abfc7caed9c8b68d","exact_world_state_target_reached":9,"executed_path_length":192,"expansions":2178,"goal_expert_reached":26,"graph_disconnection_failures":0,"no_supported_edge_failures":12,"optimal_path_length":205,"path_found":52,"path_length_regret":6,"state_aliasing_failures":17,"transition_model_error_failures":26},"retention_holdout":{"classification_checksum":"d3140b723e5d7fe7","correct":256,"expert_evaluations":2048,"prediction_checksum":"57a8bd9dd564f814","prediction_samples":237,"prediction_sse_q20":448140071749,"reconstruction_checksum":"f3a665fcea8f1f72","reconstruction_sse_q20":64372555708,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"810a69f7530c8522","transition_correct":96,"transition_supported":237,"transition_unknown":19},"training_evaluations":2449146},"ravel_complete_scan_without_certification":{"checkpoint_size_bytes":50624,"drift_holdout":{"classification_checksum":"f338a891c067f436","correct":228,"expert_evaluations":19712,"prediction_checksum":"9738a606f9c3cae1","prediction_samples":230,"prediction_sse_q20":535694858800,"reconstruction_checksum":"61b704421e9fadb5","reconstruction_sse_q20":104833483725,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"bd907b886e819fca","transition_correct":99,"transition_supported":230,"transition_unknown":26},"expert_count":77,"planning":{"belief_set_target_reached":26,"cases":64,"checksum":"abfc7caed9c8b68d","exact_world_state_target_reached":9,"executed_path_length":192,"expansions":2178,"goal_expert_reached":26,"graph_disconnection_failures":0,"no_supported_edge_failures":12,"optimal_path_length":205,"path_found":52,"path_length_regret":6,"state_aliasing_failures":17,"transition_model_error_failures":26},"retention_holdout":{"classification_checksum":"d3140b723e5d7fe7","correct":256,"expert_evaluations":19712,"prediction_checksum":"57a8bd9dd564f814","prediction_samples":237,"prediction_sse_q20":448140071749,"reconstruction_checksum":"f3a665fcea8f1f72","reconstruction_sse_q20":64372555708,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"810a69f7530c8522","transition_correct":96,"transition_supported":237,"transition_unknown":19},"training_evaluations":2660546},"ravel_no_birth_same_replay_iterations":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"590cdad662b7ff5f","correct":148,"expert_evaluations":3784,"prediction_checksum":"8831da7106c04b22","prediction_samples":221,"prediction_sse_q20":811001568483,"reconstruction_checksum":"5488f455fee4f066","reconstruction_sse_q20":143472924409,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":225,"samples":256,"transition_checksum":"ef04b50771d425a4","transition_correct":75,"transition_supported":221,"transition_unknown":35},"expert_count":64,"planning":{"belief_set_target_reached":18,"cases":64,"checksum":"f7df05c8d53a1f65","exact_world_state_target_reached":8,"executed_path_length":230,"expansions":1631,"goal_expert_reached":18,"graph_disconnection_failures":0,"no_supported_edge_failures":4,"optimal_path_length":205,"path_found":60,"path_length_regret":8,"state_aliasing_failures":10,"transition_model_error_failures":42},"retention_holdout":{"classification_checksum":"d3140b723e5d7fe7","correct":256,"expert_evaluations":2048,"prediction_checksum":"57a8bd9dd564f814","prediction_samples":237,"prediction_sse_q20":448140071749,"reconstruction_checksum":"f3a665fcea8f1f72","reconstruction_sse_q20":64372555708,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"6e3bf8b810d05dba","transition_correct":97,"transition_supported":237,"transition_unknown":19},"training_evaluations":782312},"ravel_random_births":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"590cdad662b7ff5f","correct":148,"expert_evaluations":3784,"prediction_checksum":"8831da7106c04b22","prediction_samples":221,"prediction_sse_q20":811001568483,"reconstruction_checksum":"5488f455fee4f066","reconstruction_sse_q20":143472924409,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":225,"samples":256,"transition_checksum":"ef04b50771d425a4","transition_correct":75,"transition_supported":221,"transition_unknown":35},"expert_count":64,"planning":{"belief_set_target_reached":18,"cases":64,"checksum":"f7df05c8d53a1f65","exact_world_state_target_reached":8,"executed_path_length":230,"expansions":1631,"goal_expert_reached":18,"graph_disconnection_failures":0,"no_supported_edge_failures":4,"optimal_path_length":205,"path_found":60,"path_length_regret":8,"state_aliasing_failures":10,"transition_model_error_failures":42},"retention_holdout":{"classification_checksum":"d3140b723e5d7fe7","correct":256,"expert_evaluations":2048,"prediction_checksum":"57a8bd9dd564f814","prediction_samples":237,"prediction_sse_q20":448140071749,"reconstruction_checksum":"f3a665fcea8f1f72","reconstruction_sse_q20":64372555708,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"6e3bf8b810d05dba","transition_correct":97,"transition_supported":237,"transition_unknown":19},"training_evaluations":782312},"ravel_without_replay":{"checkpoint_size_bytes":52334,"drift_holdout":{"classification_checksum":"f3d1234bc6ab6f57","correct":229,"expert_evaluations":2480,"prediction_checksum":"7af211ca6fe8c9ee","prediction_samples":228,"prediction_sse_q20":524286721843,"reconstruction_checksum":"de2c99644b31e246","reconstruction_sse_q20":104649003824,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":250,"samples":256,"transition_checksum":"e3d4bf2554373b10","transition_correct":98,"transition_supported":228,"transition_unknown":28},"expert_count":80,"planning":{"belief_set_target_reached":26,"cases":64,"checksum":"3bd0bc023bfeefae","exact_world_state_target_reached":9,"executed_path_length":192,"expansions":2174,"goal_expert_reached":26,"graph_disconnection_failures":0,"no_supported_edge_failures":12,"optimal_path_length":205,"path_found":52,"path_length_regret":6,"state_aliasing_failures":17,"transition_model_error_failures":26},"retention_holdout":{"classification_checksum":"d3140b723e5d7fe7","correct":256,"expert_evaluations":2048,"prediction_checksum":"57a8bd9dd564f814","prediction_samples":237,"prediction_sse_q20":448140071749,"reconstruction_checksum":"f3a665fcea8f1f72","reconstruction_sse_q20":64372555708,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"810a69f7530c8522","transition_correct":96,"transition_supported":237,"transition_unknown":19},"training_evaluations":1932024},"ravel_without_retirement_matched_work":{"checkpoint_size_bytes":51194,"drift_holdout":{"classification_checksum":"f338a891c067f436","correct":228,"expert_evaluations":2398,"prediction_checksum":"9738a606f9c3cae1","prediction_samples":230,"prediction_sse_q20":535694858800,"reconstruction_checksum":"61b704421e9fadb5","reconstruction_sse_q20":104833483725,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":251,"samples":256,"transition_checksum":"81cb5b0aae554064","transition_correct":99,"transition_supported":230,"transition_unknown":26},"expert_count":78,"planning":{"belief_set_target_reached":26,"cases":64,"checksum":"abfc7caed9c8b68d","exact_world_state_target_reached":9,"executed_path_length":192,"expansions":2178,"goal_expert_reached":26,"graph_disconnection_failures":0,"no_supported_edge_failures":12,"optimal_path_length":205,"path_found":52,"path_length_regret":6,"state_aliasing_failures":17,"transition_model_error_failures":26},"retention_holdout":{"classification_checksum":"d3140b723e5d7fe7","correct":256,"expert_evaluations":2048,"prediction_checksum":"57a8bd9dd564f814","prediction_samples":237,"prediction_sse_q20":448140071749,"reconstruction_checksum":"f3a665fcea8f1f72","reconstruction_sse_q20":64372555708,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"810a69f7530c8522","transition_correct":96,"transition_supported":237,"transition_unknown":19},"training_evaluations":2449146}},"dataset_seeds":{"base_holdout":"0x88e01c9e7d2dee3a","base_training":"0x4877c4f35ae6a021","drift_adaptation_training":"0x0df6ee246568bc75","drift_holdout":"0xfd31d90369aca038","original_task_retention_holdout":"0xdff5b2bb610b1991","planning_cases":"0x32b4d0fc7c7ea5c5"},"dataset_sizes":{"base_holdout":256,"base_training":1024,"drift_adaptation_training":512,"drift_holdout":256,"original_task_retention_holdout":256,"planning_cases":64},"integrity":{"checkpoint_behavior_match":true,"checkpoint_identity_match":true,"checkpoint_mutations":{"anchored_status":true,"appended_unexpected_byte":true,"checkpoint_substitution":true,"checkpoint_truncation":true,"incorrect_schema_version":true,"label":true,"label_count":true,"lineage":true,"next_observation_component":true,"payload_byte":true,"reconstruction_component":true,"retrieval_key_component":true,"transition_graph_edge":true,"transition_support":true},"checkpoint_roundtrip":true,"lineage_invariants":{"deterministic_topology_reproduction":true,"lineage_uniqueness":true,"no_accidental_lineage_reuse":true,"parent_child_generation_increment":true,"repeated_descendant_splitting":true,"sibling_generation_equality":true},"unsupported_graph_edge_violations":0},"regime":"partially_observed_ambiguous","schema":"ravel-raw-trial/0.5","seed":"0xf2128c2769bbcb97","trial_id":"validation-ambiguous-01"},{"candidate":{"adaptation_completed":true,"adaptation_training":{"classification_checksum":"be887932f7e7d901","correct":465,"expert_evaluations":4912,"prediction_checksum":"817346704a14c73d","prediction_samples":449,"prediction_sse_q20":876752723300,"reconstruction_checksum":"386c0554ebec80c9","reconstruction_sse_q20":192703706552,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":500,"samples":512,"transition_checksum":"cac0d1b0408c3fc2","transition_correct":199,"transition_supported":449,"transition_unknown":63},"adaptation_training_evaluations":1669452,"adapted_model_drift_holdout":{"classification_checksum":"9745211ec15fb32e","correct":233,"expert_evaluations":2388,"prediction_checksum":"11cbcfc83a3a3c65","prediction_samples":209,"prediction_sse_q20":480718706209,"reconstruction_checksum":"08de1b039aa01197","reconstruction_sse_q20":100109539336,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":251,"samples":256,"transition_checksum":"7a2dad0ab1e03f32","transition_correct":93,"transition_supported":209,"transition_unknown":47},"base_holdout":{"classification_checksum":"fe8d66a5369a71de","correct":256,"expert_evaluations":2048,"prediction_checksum":"d6bab3efaec3849e","prediction_samples":238,"prediction_sse_q20":492577014349,"reconstruction_checksum":"0e2472c6e84f811f","reconstruction_sse_q20":62848786650,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"ea0040f3a37440ad","transition_correct":118,"transition_supported":238,"transition_unknown":18},"base_holdout_retention":{"classification_checksum":"41d029185a4381ab","correct":253,"expert_evaluations":2048,"prediction_checksum":"03b93e67bfd511fd","prediction_samples":224,"prediction_sse_q20":380248690092,"reconstruction_checksum":"0dad1b5d2dd022ab","reconstruction_sse_q20":61184191950,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"e648796b338ec47c","transition_correct":100,"transition_supported":224,"transition_unknown":32},"base_training_evaluations":546472,"behavior_identity":"e37e230f51a59a14cef4cd4ea54040282c3e3d69302512c26c8f43a4363b088a","checkpoint_size_bytes":50054,"expert_count":76,"model_identity":"6c4bd33a4b8db682a568caa863197c844374938c3bec933cf6c091207cab539c","planning":{"belief_set_target_reached":8,"cases":64,"checksum":"9045e9428b66fed2","exact_world_state_target_reached":4,"executed_path_length":200,"expansions":2145,"goal_expert_reached":8,"graph_disconnection_failures":0,"no_supported_edge_failures":17,"optimal_path_length":230,"path_found":47,"path_length_regret":0,"state_aliasing_failures":4,"transition_model_error_failures":39},"replay":{"actions_covered":4,"assigned_experts_covered":61,"high_loss_cases_selected":29,"labels_covered":8,"rare_cases_selected":58,"selected":256,"selection_checksum":"b2b018a74afa52df","states_covered":64,"transition_pairs_covered":252,"unique":256},"static_model_drift_holdout":{"classification_checksum":"c56179d4d8732630","correct":158,"expert_evaluations":3224,"prediction_checksum":"de4466fb9a2cb64a","prediction_samples":230,"prediction_sse_q20":907357087104,"reconstruction_checksum":"28824b17d3535e1c","reconstruction_sse_q20":136862010905,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":235,"samples":256,"transition_checksum":"99eedd6a6caf6f7c","transition_correct":88,"transition_supported":230,"transition_unknown":26},"topology":{"accepted_births":16,"accepted_retirements":4,"births":[{"dominant_channel":0,"event_index":27,"normalized_score_q20":618281},{"dominant_channel":0,"event_index":136,"normalized_score_q20":568219},{"dominant_channel":0,"event_index":456,"normalized_score_q20":470334},{"dominant_channel":0,"event_index":254,"normalized_score_q20":465474},{"dominant_channel":0,"event_index":367,"normalized_score_q20":440339},{"dominant_channel":0,"event_index":144,"normalized_score_q20":439895},{"dominant_channel":0,"event_index":272,"normalized_score_q20":432464},{"dominant_channel":0,"event_index":469,"normalized_score_q20":421556},{"dominant_channel":0,"event_index":122,"normalized_score_q20":420415},{"dominant_channel":0,"event_index":262,"normalized_score_q20":419356},{"dominant_channel":0,"event_index":21,"normalized_score_q20":417972},{"dominant_channel":0,"event_index":472,"normalized_score_q20":413066},{"dominant_channel":0,"event_index":259,"normalized_score_q20":413028},{"dominant_channel":0,"event_index":290,"normalized_score_q20":410779},{"dominant_channel":0,"event_index":415,"normalized_score_q20":409342},{"dominant_channel":0,"event_index":13,"normalized_score_q20":409322}],"objective_after_q20":879883,"objective_before_q20":837999,"rejected_births":0,"rejected_retirements":0,"retired_lineages":["98236284a7fed9a7","81547b6a05b1611b","564d426389c51bcc","4829115c02fac5dd"],"training_observations":{"births":16,"certified":19105,"expert_evaluations":1669452,"rejected_births":0,"rejected_retirements":0,"retired":4,"samples":19968}}},"checkpoint_format":{"byte_order":"big_endian","magic_hex":"524156454c303500","payload_digest":"sha256","real_encoding":"signed_q20_int64","schema_version":5,"transition_support_min":2,"transition_top_k":2},"comparisons":{"fixed_8_expert":{"checkpoint_size_bytes":11294,"drift_holdout":{"classification_checksum":"5db99bce1561e37f","correct":56,"expert_evaluations":2048,"prediction_checksum":"68e9983d4ff6788c","prediction_samples":256,"prediction_sse_q20":1330168725808,"reconstruction_checksum":"4991c4b0956e2116","reconstruction_sse_q20":811760484538,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"d3ad994186494417","transition_correct":133,"transition_supported":256,"transition_unknown":0},"expert_count":8,"planning":{"belief_set_target_reached":18,"cases":64,"checksum":"fe954e24713d6969","exact_world_state_target_reached":3,"executed_path_length":59,"expansions":207,"goal_expert_reached":18,"graph_disconnection_failures":25,"no_supported_edge_failures":0,"optimal_path_length":230,"path_found":39,"path_length_regret":0,"state_aliasing_failures":15,"transition_model_error_failures":21},"retention_holdout":{"classification_checksum":"9d71ce1859351704","correct":81,"expert_evaluations":2048,"prediction_checksum":"0bedfb85918c534b","prediction_samples":256,"prediction_sse_q20":1024373903245,"reconstruction_checksum":"974af5af9344384e","reconstruction_sse_q20":760030105718,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"90bc47deb48e85c1","transition_correct":146,"transition_supported":256,"transition_unknown":0},"training_evaluations":94208},"fixed_topology_64_expert_routed":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"e09a9e16a841b442","correct":158,"expert_evaluations":3392,"prediction_checksum":"e9f599fa4cd47621","prediction_samples":237,"prediction_sse_q20":944710218889,"reconstruction_checksum":"fba5aa9fc4a2c12f","reconstruction_sse_q20":137828734574,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":232,"samples":256,"transition_checksum":"50baeb530a16ad1e","transition_correct":73,"transition_supported":237,"transition_unknown":19},"expert_count":64,"planning":{"belief_set_target_reached":11,"cases":64,"checksum":"206605c895814f93","exact_world_state_target_reached":4,"executed_path_length":276,"expansions":2016,"goal_expert_reached":11,"graph_disconnection_failures":0,"no_supported_edge_failures":1,"optimal_path_length":230,"path_found":63,"path_length_regret":0,"state_aliasing_failures":7,"transition_model_error_failures":52},"retention_holdout":{"classification_checksum":"619f6f084fa749f1","correct":256,"expert_evaluations":2048,"prediction_checksum":"c1726198b8086fc8","prediction_samples":226,"prediction_sse_q20":404943707959,"reconstruction_checksum":"ea9446f6bb22edae","reconstruction_sse_q20":60418974396,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"2462f526af26cbf5","transition_correct":99,"transition_supported":226,"transition_unknown":30},"training_evaluations":2588672},"flat_64_expert_complete_scan":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"e09a9e16a841b442","correct":158,"expert_evaluations":16384,"prediction_checksum":"e9f599fa4cd47621","prediction_samples":237,"prediction_sse_q20":944710218889,"reconstruction_checksum":"fba5aa9fc4a2c12f","reconstruction_sse_q20":137828734574,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"50baeb530a16ad1e","transition_correct":73,"transition_supported":237,"transition_unknown":19},"expert_count":64,"planning":{"belief_set_target_reached":11,"cases":64,"checksum":"206605c895814f93","exact_world_state_target_reached":4,"executed_path_length":276,"expansions":2016,"goal_expert_reached":11,"graph_disconnection_failures":0,"no_supported_edge_failures":1,"optimal_path_length":230,"path_found":63,"path_length_regret":0,"state_aliasing_failures":7,"transition_model_error_failures":52},"retention_holdout":{"classification_checksum":"619f6f084fa749f1","correct":256,"expert_evaluations":16384,"prediction_checksum":"c1726198b8086fc8","prediction_samples":226,"prediction_sse_q20":404943707959,"reconstruction_checksum":"ea9446f6bb22edae","reconstruction_sse_q20":60418974396,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"2462f526af26cbf5","transition_correct":99,"transition_supported":226,"transition_unknown":30},"training_evaluations":2588672},"matched_compute_fixed_topology":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"c56179d4d8732630","correct":158,"expert_evaluations":3224,"prediction_checksum":"de4466fb9a2cb64a","prediction_samples":230,"prediction_sse_q20":907357087104,"reconstruction_checksum":"28824b17d3535e1c","reconstruction_sse_q20":136862010905,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":235,"samples":256,"transition_checksum":"99eedd6a6caf6f7c","transition_correct":88,"transition_supported":230,"transition_unknown":26},"expert_count":64,"planning":{"belief_set_target_reached":8,"cases":64,"checksum":"a359d315616cb7b1","exact_world_state_target_reached":4,"executed_path_length":290,"expansions":1722,"goal_expert_reached":8,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":230,"path_found":64,"path_length_regret":0,"state_aliasing_failures":4,"transition_model_error_failures":56},"retention_holdout":{"classification_checksum":"ac97c67d3458ace1","correct":256,"expert_evaluations":2048,"prediction_checksum":"f230afa91a6fe2e0","prediction_samples":225,"prediction_sse_q20":381405092236,"reconstruction_checksum":"5fc4b49ba318ceff","reconstruction_sse_q20":61332581779,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"cf00b6b6e5f3135d","transition_correct":105,"transition_supported":225,"transition_unknown":31},"training_evaluations":2407336},"matched_expert_count_capacity":{"checkpoint_size_bytes":50054,"drift_holdout":{"classification_checksum":"a8fae2e5e60d3be8","correct":158,"expert_evaluations":4224,"prediction_checksum":"34e3767bf923e87c","prediction_samples":225,"prediction_sse_q20":939123260996,"reconstruction_checksum":"a442166dc6c90f70","reconstruction_sse_q20":134980776764,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":224,"samples":256,"transition_checksum":"1774ea9fa1dde3e9","transition_correct":56,"transition_supported":225,"transition_unknown":31},"expert_count":76,"planning":{"belief_set_target_reached":11,"cases":64,"checksum":"bcb38fb700d54cca","exact_world_state_target_reached":5,"executed_path_length":329,"expansions":2607,"goal_expert_reached":11,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":230,"path_found":64,"path_length_regret":2,"state_aliasing_failures":6,"transition_model_error_failures":53},"retention_holdout":{"classification_checksum":"dd16698676ed6c4a","correct":256,"expert_evaluations":2048,"prediction_checksum":"278058536f6767e4","prediction_samples":213,"prediction_sse_q20":371718871002,"reconstruction_checksum":"efee52c56647c50c","reconstruction_sse_q20":59146500450,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"b16a3a1c36fd966a","transition_correct":81,"transition_supported":213,"transition_unknown":43},"training_evaluations":3540992},"nearest_centroid_16_no_recursive_births":{"checkpoint_size_bytes":15854,"drift_holdout":{"classification_checksum":"f73189d9cda298c0","correct":78,"expert_evaluations":4096,"prediction_checksum":"127f2c7440b798c5","prediction_samples":256,"prediction_sse_q20":1122032249051,"reconstruction_checksum":"ae1c19bebc0709b6","reconstruction_sse_q20":394787051200,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"abcdf82e778160e1","transition_correct":152,"transition_supported":256,"transition_unknown":0},"expert_count":16,"planning":{"belief_set_target_reached":10,"cases":64,"checksum":"f085002e66bea23a","exact_world_state_target_reached":3,"executed_path_length":245,"expansions":594,"goal_expert_reached":10,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":230,"path_found":64,"path_length_regret":0,"state_aliasing_failures":7,"transition_model_error_failures":54},"retention_holdout":{"classification_checksum":"a74437bfd811ea25","correct":129,"expert_evaluations":4096,"prediction_checksum":"9b8446fe1c1c4e85","prediction_samples":256,"prediction_sse_q20":665331734559,"reconstruction_checksum":"fff4931a2ac4f135","reconstruction_sse_q20":312709292364,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"a15297b5bc15926d","transition_correct":182,"transition_supported":256,"transition_unknown":0},"training_evaluations":253952},"no_adaptation_static":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"c56179d4d8732630","correct":158,"expert_evaluations":3224,"prediction_checksum":"de4466fb9a2cb64a","prediction_samples":230,"prediction_sse_q20":907357087104,"reconstruction_checksum":"28824b17d3535e1c","reconstruction_sse_q20":136862010905,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":235,"samples":256,"transition_checksum":"99eedd6a6caf6f7c","transition_correct":88,"transition_supported":230,"transition_unknown":26},"expert_count":64,"planning":{"belief_set_target_reached":8,"cases":64,"checksum":"a359d315616cb7b1","exact_world_state_target_reached":4,"executed_path_length":290,"expansions":1722,"goal_expert_reached":8,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":230,"path_found":64,"path_length_regret":0,"state_aliasing_failures":4,"transition_model_error_failures":56},"retention_holdout":{"classification_checksum":"ac97c67d3458ace1","correct":256,"expert_evaluations":2048,"prediction_checksum":"f230afa91a6fe2e0","prediction_samples":225,"prediction_sse_q20":381405092236,"reconstruction_checksum":"5fc4b49ba318ceff","reconstruction_sse_q20":61332581779,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"cf00b6b6e5f3135d","transition_correct":105,"transition_supported":225,"transition_unknown":31},"training_evaluations":546472},"periodic_replay_policy":{"checkpoint_size_bytes":50054,"drift_holdout":{"classification_checksum":"9745211ec15fb32e","correct":233,"expert_evaluations":2388,"prediction_checksum":"cee73c7126d307a2","prediction_samples":209,"prediction_sse_q20":480751066391,"reconstruction_checksum":"ab89944db23b177e","reconstruction_sse_q20":100131826354,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":251,"samples":256,"transition_checksum":"7a2dad0ab1e03f32","transition_correct":93,"transition_supported":209,"transition_unknown":47},"expert_count":76,"planning":{"belief_set_target_reached":8,"cases":64,"checksum":"9045e9428b66fed2","exact_world_state_target_reached":4,"executed_path_length":200,"expansions":2145,"goal_expert_reached":8,"graph_disconnection_failures":0,"no_supported_edge_failures":17,"optimal_path_length":230,"path_found":47,"path_length_regret":0,"state_aliasing_failures":4,"transition_model_error_failures":39},"retention_holdout":{"classification_checksum":"41d029185a4381ab","correct":253,"expert_evaluations":2048,"prediction_checksum":"03b93e67bfd511fd","prediction_samples":224,"prediction_sse_q20":380248690092,"reconstruction_checksum":"0dad1b5d2dd022ab","reconstruction_sse_q20":61184191950,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"e648796b338ec47c","transition_correct":100,"transition_supported":224,"transition_unknown":32},"training_evaluations":2216788},"ravel_0_5_candidate":{"checkpoint_size_bytes":50054,"drift_holdout":{"classification_checksum":"9745211ec15fb32e","correct":233,"expert_evaluations":2388,"prediction_checksum":"11cbcfc83a3a3c65","prediction_samples":209,"prediction_sse_q20":480718706209,"reconstruction_checksum":"08de1b039aa01197","reconstruction_sse_q20":100109539336,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":251,"samples":256,"transition_checksum":"7a2dad0ab1e03f32","transition_correct":93,"transition_supported":209,"transition_unknown":47},"expert_count":76,"planning":{"belief_set_target_reached":8,"cases":64,"checksum":"9045e9428b66fed2","exact_world_state_target_reached":4,"executed_path_length":200,"expansions":2145,"goal_expert_reached":8,"graph_disconnection_failures":0,"no_supported_edge_failures":17,"optimal_path_length":230,"path_found":47,"path_length_regret":0,"state_aliasing_failures":4,"transition_model_error_failures":39},"retention_holdout":{"classification_checksum":"41d029185a4381ab","correct":253,"expert_evaluations":2048,"prediction_checksum":"03b93e67bfd511fd","prediction_samples":224,"prediction_sse_q20":380248690092,"reconstruction_checksum":"0dad1b5d2dd022ab","reconstruction_sse_q20":61184191950,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"e648796b338ec47c","transition_correct":100,"transition_supported":224,"transition_unknown":32},"training_evaluations":2215924},"ravel_complete_scan_without_certification":{"checkpoint_size_bytes":50054,"drift_holdout":{"classification_checksum":"9745211ec15fb32e","correct":233,"expert_evaluations":19456,"prediction_checksum":"11cbcfc83a3a3c65","prediction_samples":209,"prediction_sse_q20":480718706209,"reconstruction_checksum":"08de1b039aa01197","reconstruction_sse_q20":100109539336,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"7a2dad0ab1e03f32","transition_correct":93,"transition_supported":209,"transition_unknown":47},"expert_count":76,"planning":{"belief_set_target_reached":8,"cases":64,"checksum":"9045e9428b66fed2","exact_world_state_target_reached":4,"executed_path_length":200,"expansions":2145,"goal_expert_reached":8,"graph_disconnection_failures":0,"no_supported_edge_failures":17,"optimal_path_length":230,"path_found":47,"path_length_regret":0,"state_aliasing_failures":4,"transition_model_error_failures":39},"retention_holdout":{"classification_checksum":"41d029185a4381ab","correct":253,"expert_evaluations":19456,"prediction_checksum":"03b93e67bfd511fd","prediction_samples":224,"prediction_sse_q20":380248690092,"reconstruction_checksum":"0dad1b5d2dd022ab","reconstruction_sse_q20":61184191950,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"e648796b338ec47c","transition_correct":100,"transition_supported":224,"transition_unknown":32},"training_evaluations":2422708},"ravel_no_birth_same_replay_iterations":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"c56179d4d8732630","correct":158,"expert_evaluations":3224,"prediction_checksum":"de4466fb9a2cb64a","prediction_samples":230,"prediction_sse_q20":907357087104,"reconstruction_checksum":"28824b17d3535e1c","reconstruction_sse_q20":136862010905,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":235,"samples":256,"transition_checksum":"99eedd6a6caf6f7c","transition_correct":88,"transition_supported":230,"transition_unknown":26},"expert_count":64,"planning":{"belief_set_target_reached":8,"cases":64,"checksum":"a359d315616cb7b1","exact_world_state_target_reached":4,"executed_path_length":290,"expansions":1722,"goal_expert_reached":8,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":230,"path_found":64,"path_length_regret":0,"state_aliasing_failures":4,"transition_model_error_failures":56},"retention_holdout":{"classification_checksum":"ac97c67d3458ace1","correct":256,"expert_evaluations":2048,"prediction_checksum":"f230afa91a6fe2e0","prediction_samples":225,"prediction_sse_q20":381405092236,"reconstruction_checksum":"5fc4b49ba318ceff","reconstruction_sse_q20":61332581779,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"cf00b6b6e5f3135d","transition_correct":105,"transition_supported":225,"transition_unknown":31},"training_evaluations":779080},"ravel_random_births":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"c56179d4d8732630","correct":158,"expert_evaluations":3224,"prediction_checksum":"de4466fb9a2cb64a","prediction_samples":230,"prediction_sse_q20":907357087104,"reconstruction_checksum":"28824b17d3535e1c","reconstruction_sse_q20":136862010905,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":235,"samples":256,"transition_checksum":"99eedd6a6caf6f7c","transition_correct":88,"transition_supported":230,"transition_unknown":26},"expert_count":64,"planning":{"belief_set_target_reached":8,"cases":64,"checksum":"a359d315616cb7b1","exact_world_state_target_reached":4,"executed_path_length":290,"expansions":1722,"goal_expert_reached":8,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":230,"path_found":64,"path_length_regret":0,"state_aliasing_failures":4,"transition_model_error_failures":56},"retention_holdout":{"classification_checksum":"ac97c67d3458ace1","correct":256,"expert_evaluations":2048,"prediction_checksum":"f230afa91a6fe2e0","prediction_samples":225,"prediction_sse_q20":381405092236,"reconstruction_checksum":"5fc4b49ba318ceff","reconstruction_sse_q20":61332581779,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"cf00b6b6e5f3135d","transition_correct":105,"transition_supported":225,"transition_unknown":31},"training_evaluations":779080},"ravel_without_replay":{"checkpoint_size_bytes":52334,"drift_holdout":{"classification_checksum":"304d69073c466b87","correct":234,"expert_evaluations":3272,"prediction_checksum":"97c549cfd5c60d51","prediction_samples":207,"prediction_sse_q20":474240691090,"reconstruction_checksum":"739bf2cdab38ca16","reconstruction_sse_q20":99823261172,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":239,"samples":256,"transition_checksum":"6d75dfd408783568","transition_correct":92,"transition_supported":207,"transition_unknown":49},"expert_count":80,"planning":{"belief_set_target_reached":8,"cases":64,"checksum":"b1f78d078056f5f9","exact_world_state_target_reached":4,"executed_path_length":200,"expansions":2145,"goal_expert_reached":8,"graph_disconnection_failures":0,"no_supported_edge_failures":17,"optimal_path_length":230,"path_found":47,"path_length_regret":0,"state_aliasing_failures":4,"transition_model_error_failures":39},"retention_holdout":{"classification_checksum":"f09fdb0af5e30565","correct":251,"expert_evaluations":2552,"prediction_checksum":"ddcdd899749f609f","prediction_samples":222,"prediction_sse_q20":377336519574,"reconstruction_checksum":"a51c75690bfec6e2","reconstruction_sse_q20":61032292663,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":249,"samples":256,"transition_checksum":"3180b5567747b382","transition_correct":99,"transition_supported":222,"transition_unknown":34},"training_evaluations":1675508},"ravel_without_retirement_matched_work":{"checkpoint_size_bytes":52334,"drift_holdout":{"classification_checksum":"304d69073c466b87","correct":234,"expert_evaluations":3272,"prediction_checksum":"97c549cfd5c60d51","prediction_samples":207,"prediction_sse_q20":474240691090,"reconstruction_checksum":"739bf2cdab38ca16","reconstruction_sse_q20":99823261172,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":239,"samples":256,"transition_checksum":"6d75dfd408783568","transition_correct":92,"transition_supported":207,"transition_unknown":49},"expert_count":80,"planning":{"belief_set_target_reached":8,"cases":64,"checksum":"b1f78d078056f5f9","exact_world_state_target_reached":4,"executed_path_length":200,"expansions":2145,"goal_expert_reached":8,"graph_disconnection_failures":0,"no_supported_edge_failures":17,"optimal_path_length":230,"path_found":47,"path_length_regret":0,"state_aliasing_failures":4,"transition_model_error_failures":39},"retention_holdout":{"classification_checksum":"f09fdb0af5e30565","correct":251,"expert_evaluations":2552,"prediction_checksum":"ddcdd899749f609f","prediction_samples":222,"prediction_sse_q20":377336519574,"reconstruction_checksum":"a51c75690bfec6e2","reconstruction_sse_q20":61032292663,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":249,"samples":256,"transition_checksum":"3180b5567747b382","transition_correct":99,"transition_supported":222,"transition_unknown":34},"training_evaluations":2215924}},"dataset_seeds":{"base_holdout":"0x0d0c9a9f7be25d47","base_training":"0x74b704e65cba9980","drift_adaptation_training":"0xaafff9f9f17eddec","drift_holdout":"0x316b5c2bc6080eda","original_task_retention_holdout":"0x1992fcd1e40f99e3","planning_cases":"0x5d4e5496eb5852b3"},"dataset_sizes":{"base_holdout":256,"base_training":1024,"drift_adaptation_training":512,"drift_holdout":256,"original_task_retention_holdout":256,"planning_cases":64},"integrity":{"checkpoint_behavior_match":true,"checkpoint_identity_match":true,"checkpoint_mutations":{"anchored_status":true,"appended_unexpected_byte":true,"checkpoint_substitution":true,"checkpoint_truncation":true,"incorrect_schema_version":true,"label":true,"label_count":true,"lineage":true,"next_observation_component":true,"payload_byte":true,"reconstruction_component":true,"retrieval_key_component":true,"transition_graph_edge":true,"transition_support":true},"checkpoint_roundtrip":true,"lineage_invariants":{"deterministic_topology_reproduction":true,"lineage_uniqueness":true,"no_accidental_lineage_reuse":true,"parent_child_generation_increment":true,"repeated_descendant_splitting":true,"sibling_generation_equality":true},"unsupported_graph_edge_violations":0},"regime":"partially_observed_ambiguous","schema":"ravel-raw-trial/0.5","seed":"0xdad034619fabf595","trial_id":"validation-ambiguous-02"},{"candidate":{"adaptation_completed":true,"adaptation_training":{"classification_checksum":"e04743c308abd76a","correct":467,"expert_evaluations":5019,"prediction_checksum":"f6d084c1b2a8e15d","prediction_samples":469,"prediction_sse_q20":964029165380,"reconstruction_checksum":"b58bb88043968949","reconstruction_sse_q20":195475591122,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":499,"samples":512,"transition_checksum":"ffd21495a4f29de5","transition_correct":213,"transition_supported":469,"transition_unknown":43},"adaptation_training_evaluations":1651373,"adapted_model_drift_holdout":{"classification_checksum":"26c898aff18af629","correct":222,"expert_evaluations":2545,"prediction_checksum":"f4aa4de36974e192","prediction_samples":228,"prediction_sse_q20":553267745116,"reconstruction_checksum":"76c271efa027051f","reconstruction_sse_q20":104233104029,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":249,"samples":256,"transition_checksum":"51810fd8f99873da","transition_correct":110,"transition_supported":228,"transition_unknown":28},"base_holdout":{"classification_checksum":"cd636b0d2ec8023e","correct":256,"expert_evaluations":2048,"prediction_checksum":"eac411d944b704d9","prediction_samples":239,"prediction_sse_q20":475065192436,"reconstruction_checksum":"cebe34d9ed19ab7f","reconstruction_sse_q20":61937157606,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"770cfe9a78246df2","transition_correct":121,"transition_supported":239,"transition_unknown":17},"base_holdout_retention":{"classification_checksum":"375a8802bfc66af6","correct":256,"expert_evaluations":2048,"prediction_checksum":"46ddcef37d1dfdbc","prediction_samples":230,"prediction_sse_q20":391526294539,"reconstruction_checksum":"cec4aa424d7aa8da","reconstruction_sse_q20":61904309390,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"7121244966c5ba2a","transition_correct":120,"transition_supported":230,"transition_unknown":26},"base_training_evaluations":544672,"behavior_identity":"b32a2b9e8cd137975e2a8f8acbb2354c4810d361e0b5428d8450079bab35fef4","checkpoint_size_bytes":51764,"expert_count":79,"model_identity":"6b0d354acd56e0057e81eb063d15ca627cd847fe26333f1640ba8aa4a00cdc5a","planning":{"belief_set_target_reached":17,"cases":64,"checksum":"431f492de84c7601","exact_world_state_target_reached":10,"executed_path_length":280,"expansions":1773,"goal_expert_reached":17,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":215,"path_found":64,"path_length_regret":4,"state_aliasing_failures":7,"transition_model_error_failures":47},"replay":{"actions_covered":4,"assigned_experts_covered":60,"high_loss_cases_selected":30,"labels_covered":8,"rare_cases_selected":63,"selected":256,"selection_checksum":"1dbe693c8b6f08bc","states_covered":64,"transition_pairs_covered":254,"unique":256},"static_model_drift_holdout":{"classification_checksum":"523353264f756100","correct":164,"expert_evaluations":3504,"prediction_checksum":"54cd29dcde4639a6","prediction_samples":228,"prediction_sse_q20":802420697988,"reconstruction_checksum":"6679c9841ef5aded","reconstruction_sse_q20":134188690832,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":230,"samples":256,"transition_checksum":"c5714e848700bf98","transition_correct":93,"transition_supported":228,"transition_unknown":28},"topology":{"accepted_births":15,"accepted_retirements":0,"births":[{"dominant_channel":0,"event_index":11,"normalized_score_q20":814685},{"dominant_channel":0,"event_index":378,"normalized_score_q20":803831},{"dominant_channel":0,"event_index":153,"normalized_score_q20":590949},{"dominant_channel":0,"event_index":6,"normalized_score_q20":576269},{"dominant_channel":0,"event_index":16,"normalized_score_q20":575986},{"dominant_channel":0,"event_index":475,"normalized_score_q20":567667},{"dominant_channel":0,"event_index":352,"normalized_score_q20":557967},{"dominant_channel":0,"event_index":383,"normalized_score_q20":467533},{"dominant_channel":0,"event_index":160,"normalized_score_q20":459943},{"dominant_channel":0,"event_index":55,"normalized_score_q20":444935},{"dominant_channel":0,"event_index":206,"normalized_score_q20":429119},{"dominant_channel":0,"event_index":240,"normalized_score_q20":427417},{"dominant_channel":0,"event_index":339,"normalized_score_q20":422609},{"dominant_channel":0,"event_index":256,"normalized_score_q20":420864},{"dominant_channel":0,"event_index":54,"normalized_score_q20":418258}],"objective_after_q20":886625,"objective_before_q20":828580,"rejected_births":1,"rejected_retirements":1,"retired_lineages":[],"training_observations":{"births":15,"certified":19099,"expert_evaluations":1651373,"rejected_births":1,"rejected_retirements":1,"retired":0,"samples":19968}}},"checkpoint_format":{"byte_order":"big_endian","magic_hex":"524156454c303500","payload_digest":"sha256","real_encoding":"signed_q20_int64","schema_version":5,"transition_support_min":2,"transition_top_k":2},"comparisons":{"fixed_8_expert":{"checkpoint_size_bytes":11294,"drift_holdout":{"classification_checksum":"3eac29d8d7f0c88c","correct":54,"expert_evaluations":2048,"prediction_checksum":"b7007b2654c3db94","prediction_samples":256,"prediction_sse_q20":1193156023563,"reconstruction_checksum":"3233ca926cc2cc42","reconstruction_sse_q20":772714590443,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"f24595c255a73f23","transition_correct":141,"transition_supported":256,"transition_unknown":0},"expert_count":8,"planning":{"belief_set_target_reached":22,"cases":64,"checksum":"9d32a3c62e62099e","exact_world_state_target_reached":3,"executed_path_length":43,"expansions":181,"goal_expert_reached":22,"graph_disconnection_failures":29,"no_supported_edge_failures":0,"optimal_path_length":215,"path_found":35,"path_length_regret":0,"state_aliasing_failures":19,"transition_model_error_failures":13},"retention_holdout":{"classification_checksum":"79d2470cbbe14522","correct":86,"expert_evaluations":2048,"prediction_checksum":"374303f28dbb6d55","prediction_samples":256,"prediction_sse_q20":996385763106,"reconstruction_checksum":"bc51063ddad852d8","reconstruction_sse_q20":739555981182,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"a43596981e44294e","transition_correct":137,"transition_supported":256,"transition_unknown":0},"training_evaluations":94208},"fixed_topology_64_expert_routed":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"2c515ffd0c9ab3f0","correct":164,"expert_evaluations":3560,"prediction_checksum":"8241764037a13020","prediction_samples":240,"prediction_sse_q20":806767074836,"reconstruction_checksum":"ee293f6614ff71e1","reconstruction_sse_q20":132974646251,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":229,"samples":256,"transition_checksum":"d05f9bd051376827","transition_correct":86,"transition_supported":240,"transition_unknown":16},"expert_count":64,"planning":{"belief_set_target_reached":15,"cases":64,"checksum":"04caba4f7e30d974","exact_world_state_target_reached":4,"executed_path_length":282,"expansions":1725,"goal_expert_reached":15,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":215,"path_found":64,"path_length_regret":4,"state_aliasing_failures":11,"transition_model_error_failures":49},"retention_holdout":{"classification_checksum":"ee30fabdb4274afb","correct":256,"expert_evaluations":2048,"prediction_checksum":"ed2a20582f79db8b","prediction_samples":229,"prediction_sse_q20":442949417191,"reconstruction_checksum":"e87eacfd84c13884","reconstruction_sse_q20":60665226853,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"2335586c2ee94f9c","transition_correct":90,"transition_supported":229,"transition_unknown":27},"training_evaluations":2588672},"flat_64_expert_complete_scan":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"2c515ffd0c9ab3f0","correct":164,"expert_evaluations":16384,"prediction_checksum":"8241764037a13020","prediction_samples":240,"prediction_sse_q20":806767074836,"reconstruction_checksum":"ee293f6614ff71e1","reconstruction_sse_q20":132974646251,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"d05f9bd051376827","transition_correct":86,"transition_supported":240,"transition_unknown":16},"expert_count":64,"planning":{"belief_set_target_reached":15,"cases":64,"checksum":"04caba4f7e30d974","exact_world_state_target_reached":4,"executed_path_length":282,"expansions":1725,"goal_expert_reached":15,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":215,"path_found":64,"path_length_regret":4,"state_aliasing_failures":11,"transition_model_error_failures":49},"retention_holdout":{"classification_checksum":"ee30fabdb4274afb","correct":256,"expert_evaluations":16384,"prediction_checksum":"ed2a20582f79db8b","prediction_samples":229,"prediction_sse_q20":442949417191,"reconstruction_checksum":"e87eacfd84c13884","reconstruction_sse_q20":60665226853,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"2335586c2ee94f9c","transition_correct":90,"transition_supported":229,"transition_unknown":27},"training_evaluations":2588672},"matched_compute_fixed_topology":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"523353264f756100","correct":164,"expert_evaluations":3504,"prediction_checksum":"54cd29dcde4639a6","prediction_samples":228,"prediction_sse_q20":802420697988,"reconstruction_checksum":"6679c9841ef5aded","reconstruction_sse_q20":134188690832,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":230,"samples":256,"transition_checksum":"c5714e848700bf98","transition_correct":93,"transition_supported":228,"transition_unknown":28},"expert_count":64,"planning":{"belief_set_target_reached":14,"cases":64,"checksum":"e3b61a2ad5abf2a4","exact_world_state_target_reached":6,"executed_path_length":301,"expansions":1375,"goal_expert_reached":14,"graph_disconnection_failures":0,"no_supported_edge_failures":1,"optimal_path_length":215,"path_found":63,"path_length_regret":7,"state_aliasing_failures":8,"transition_model_error_failures":49},"retention_holdout":{"classification_checksum":"375a8802bfc66af6","correct":256,"expert_evaluations":2048,"prediction_checksum":"46ddcef37d1dfdbc","prediction_samples":230,"prediction_sse_q20":391526294539,"reconstruction_checksum":"cec4aa424d7aa8da","reconstruction_sse_q20":61904309390,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"5d9557469deed907","transition_correct":121,"transition_supported":230,"transition_unknown":26},"training_evaluations":2407328},"matched_expert_count_capacity":{"checkpoint_size_bytes":51764,"drift_holdout":{"classification_checksum":"9fa2806c999935d0","correct":164,"expert_evaluations":4462,"prediction_checksum":"c39330698ea704aa","prediction_samples":221,"prediction_sse_q20":789289433101,"reconstruction_checksum":"0d4240b2cf1524f4","reconstruction_sse_q20":129188248445,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":222,"samples":256,"transition_checksum":"682fdcae64d181d5","transition_correct":59,"transition_supported":221,"transition_unknown":35},"expert_count":79,"planning":{"belief_set_target_reached":12,"cases":64,"checksum":"581d8bca504fe400","exact_world_state_target_reached":3,"executed_path_length":283,"expansions":2035,"goal_expert_reached":12,"graph_disconnection_failures":0,"no_supported_edge_failures":2,"optimal_path_length":215,"path_found":62,"path_length_regret":2,"state_aliasing_failures":9,"transition_model_error_failures":50},"retention_holdout":{"classification_checksum":"a4f11a463f51d6b1","correct":256,"expert_evaluations":2048,"prediction_checksum":"e98903c71748a3c2","prediction_samples":218,"prediction_sse_q20":426767284111,"reconstruction_checksum":"03e3925d38c63123","reconstruction_sse_q20":58737542556,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"7dc0854f27cdbe07","transition_correct":66,"transition_supported":218,"transition_unknown":38},"training_evaluations":3802112},"nearest_centroid_16_no_recursive_births":{"checkpoint_size_bytes":15854,"drift_holdout":{"classification_checksum":"cc70ffcef9a2ac45","correct":64,"expert_evaluations":4096,"prediction_checksum":"167d91da0394a0d6","prediction_samples":256,"prediction_sse_q20":1045821748396,"reconstruction_checksum":"760c2e6ceaa48e6a","reconstruction_sse_q20":386798009446,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"e5c78cd5cd079727","transition_correct":157,"transition_supported":256,"transition_unknown":0},"expert_count":16,"planning":{"belief_set_target_reached":14,"cases":64,"checksum":"072b9f889feb0e41","exact_world_state_target_reached":2,"executed_path_length":166,"expansions":467,"goal_expert_reached":14,"graph_disconnection_failures":5,"no_supported_edge_failures":0,"optimal_path_length":215,"path_found":59,"path_length_regret":0,"state_aliasing_failures":12,"transition_model_error_failures":45},"retention_holdout":{"classification_checksum":"5af51a11545fe7b6","correct":131,"expert_evaluations":4096,"prediction_checksum":"e99ef0f482cb5fdb","prediction_samples":256,"prediction_sse_q20":636914716106,"reconstruction_checksum":"276970025263d67b","reconstruction_sse_q20":313391492139,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"f18a29501e9594b1","transition_correct":194,"transition_supported":256,"transition_unknown":0},"training_evaluations":253952},"no_adaptation_static":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"523353264f756100","correct":164,"expert_evaluations":3504,"prediction_checksum":"54cd29dcde4639a6","prediction_samples":228,"prediction_sse_q20":802420697988,"reconstruction_checksum":"6679c9841ef5aded","reconstruction_sse_q20":134188690832,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":230,"samples":256,"transition_checksum":"c5714e848700bf98","transition_correct":93,"transition_supported":228,"transition_unknown":28},"expert_count":64,"planning":{"belief_set_target_reached":14,"cases":64,"checksum":"e3b61a2ad5abf2a4","exact_world_state_target_reached":6,"executed_path_length":301,"expansions":1375,"goal_expert_reached":14,"graph_disconnection_failures":0,"no_supported_edge_failures":1,"optimal_path_length":215,"path_found":63,"path_length_regret":7,"state_aliasing_failures":8,"transition_model_error_failures":49},"retention_holdout":{"classification_checksum":"375a8802bfc66af6","correct":256,"expert_evaluations":2048,"prediction_checksum":"46ddcef37d1dfdbc","prediction_samples":230,"prediction_sse_q20":391526294539,"reconstruction_checksum":"cec4aa424d7aa8da","reconstruction_sse_q20":61904309390,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"5d9557469deed907","transition_correct":121,"transition_supported":230,"transition_unknown":26},"training_evaluations":544672},"periodic_replay_policy":{"checkpoint_size_bytes":51764,"drift_holdout":{"classification_checksum":"26c898aff18af629","correct":222,"expert_evaluations":2545,"prediction_checksum":"f4aa4de36974e192","prediction_samples":228,"prediction_sse_q20":553267745116,"reconstruction_checksum":"b8f7e144f4a53458","reconstruction_sse_q20":104191341590,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":249,"samples":256,"transition_checksum":"51810fd8f99873da","transition_correct":110,"transition_supported":228,"transition_unknown":28},"expert_count":79,"planning":{"belief_set_target_reached":17,"cases":64,"checksum":"431f492de84c7601","exact_world_state_target_reached":10,"executed_path_length":280,"expansions":1773,"goal_expert_reached":17,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":215,"path_found":64,"path_length_regret":4,"state_aliasing_failures":7,"transition_model_error_failures":47},"retention_holdout":{"classification_checksum":"375a8802bfc66af6","correct":256,"expert_evaluations":2048,"prediction_checksum":"46ddcef37d1dfdbc","prediction_samples":230,"prediction_sse_q20":391526294539,"reconstruction_checksum":"cec4aa424d7aa8da","reconstruction_sse_q20":61904309390,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"4d013ac9b54d83b3","transition_correct":120,"transition_supported":230,"transition_unknown":26},"training_evaluations":2196045},"ravel_0_5_candidate":{"checkpoint_size_bytes":51764,"drift_holdout":{"classification_checksum":"26c898aff18af629","correct":222,"expert_evaluations":2545,"prediction_checksum":"f4aa4de36974e192","prediction_samples":228,"prediction_sse_q20":553267745116,"reconstruction_checksum":"76c271efa027051f","reconstruction_sse_q20":104233104029,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":249,"samples":256,"transition_checksum":"51810fd8f99873da","transition_correct":110,"transition_supported":228,"transition_unknown":28},"expert_count":79,"planning":{"belief_set_target_reached":17,"cases":64,"checksum":"431f492de84c7601","exact_world_state_target_reached":10,"executed_path_length":280,"expansions":1773,"goal_expert_reached":17,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":215,"path_found":64,"path_length_regret":4,"state_aliasing_failures":7,"transition_model_error_failures":47},"retention_holdout":{"classification_checksum":"375a8802bfc66af6","correct":256,"expert_evaluations":2048,"prediction_checksum":"46ddcef37d1dfdbc","prediction_samples":230,"prediction_sse_q20":391526294539,"reconstruction_checksum":"cec4aa424d7aa8da","reconstruction_sse_q20":61904309390,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"7121244966c5ba2a","transition_correct":120,"transition_supported":230,"transition_unknown":26},"training_evaluations":2196045},"ravel_complete_scan_without_certification":{"checkpoint_size_bytes":51764,"drift_holdout":{"classification_checksum":"26c898aff18af629","correct":222,"expert_evaluations":20224,"prediction_checksum":"f4aa4de36974e192","prediction_samples":228,"prediction_sse_q20":553267745116,"reconstruction_checksum":"76c271efa027051f","reconstruction_sse_q20":104233104029,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"51810fd8f99873da","transition_correct":110,"transition_supported":228,"transition_unknown":28},"expert_count":79,"planning":{"belief_set_target_reached":17,"cases":64,"checksum":"431f492de84c7601","exact_world_state_target_reached":10,"executed_path_length":280,"expansions":1773,"goal_expert_reached":17,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":215,"path_found":64,"path_length_regret":4,"state_aliasing_failures":7,"transition_model_error_failures":47},"retention_holdout":{"classification_checksum":"375a8802bfc66af6","correct":256,"expert_evaluations":20224,"prediction_checksum":"46ddcef37d1dfdbc","prediction_samples":230,"prediction_sse_q20":391526294539,"reconstruction_checksum":"cec4aa424d7aa8da","reconstruction_sse_q20":61904309390,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"7121244966c5ba2a","transition_correct":120,"transition_supported":230,"transition_unknown":26},"training_evaluations":2410394},"ravel_no_birth_same_replay_iterations":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"523353264f756100","correct":164,"expert_evaluations":3504,"prediction_checksum":"54cd29dcde4639a6","prediction_samples":228,"prediction_sse_q20":802420697988,"reconstruction_checksum":"6679c9841ef5aded","reconstruction_sse_q20":134188690832,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":230,"samples":256,"transition_checksum":"c5714e848700bf98","transition_correct":93,"transition_supported":228,"transition_unknown":28},"expert_count":64,"planning":{"belief_set_target_reached":14,"cases":64,"checksum":"e3b61a2ad5abf2a4","exact_world_state_target_reached":6,"executed_path_length":301,"expansions":1375,"goal_expert_reached":14,"graph_disconnection_failures":0,"no_supported_edge_failures":1,"optimal_path_length":215,"path_found":63,"path_length_regret":7,"state_aliasing_failures":8,"transition_model_error_failures":49},"retention_holdout":{"classification_checksum":"375a8802bfc66af6","correct":256,"expert_evaluations":2048,"prediction_checksum":"46ddcef37d1dfdbc","prediction_samples":230,"prediction_sse_q20":391526294539,"reconstruction_checksum":"cec4aa424d7aa8da","reconstruction_sse_q20":61904309390,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"5d9557469deed907","transition_correct":121,"transition_supported":230,"transition_unknown":26},"training_evaluations":777504},"ravel_random_births":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"523353264f756100","correct":164,"expert_evaluations":3504,"prediction_checksum":"54cd29dcde4639a6","prediction_samples":228,"prediction_sse_q20":802420697988,"reconstruction_checksum":"6679c9841ef5aded","reconstruction_sse_q20":134188690832,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":230,"samples":256,"transition_checksum":"c5714e848700bf98","transition_correct":93,"transition_supported":228,"transition_unknown":28},"expert_count":64,"planning":{"belief_set_target_reached":14,"cases":64,"checksum":"e3b61a2ad5abf2a4","exact_world_state_target_reached":6,"executed_path_length":301,"expansions":1375,"goal_expert_reached":14,"graph_disconnection_failures":0,"no_supported_edge_failures":1,"optimal_path_length":215,"path_found":63,"path_length_regret":7,"state_aliasing_failures":8,"transition_model_error_failures":49},"retention_holdout":{"classification_checksum":"375a8802bfc66af6","correct":256,"expert_evaluations":2048,"prediction_checksum":"46ddcef37d1dfdbc","prediction_samples":230,"prediction_sse_q20":391526294539,"reconstruction_checksum":"cec4aa424d7aa8da","reconstruction_sse_q20":61904309390,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"5d9557469deed907","transition_correct":121,"transition_supported":230,"transition_unknown":26},"training_evaluations":777504},"ravel_without_replay":{"checkpoint_size_bytes":51764,"drift_holdout":{"classification_checksum":"26c898aff18af629","correct":222,"expert_evaluations":2545,"prediction_checksum":"f4aa4de36974e192","prediction_samples":228,"prediction_sse_q20":553267745116,"reconstruction_checksum":"b8f7e144f4a53458","reconstruction_sse_q20":104191341590,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":249,"samples":256,"transition_checksum":"51810fd8f99873da","transition_correct":110,"transition_supported":228,"transition_unknown":28},"expert_count":79,"planning":{"belief_set_target_reached":17,"cases":64,"checksum":"431f492de84c7601","exact_world_state_target_reached":10,"executed_path_length":280,"expansions":1773,"goal_expert_reached":17,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":215,"path_found":64,"path_length_regret":4,"state_aliasing_failures":7,"transition_model_error_failures":47},"retention_holdout":{"classification_checksum":"375a8802bfc66af6","correct":256,"expert_evaluations":2048,"prediction_checksum":"46ddcef37d1dfdbc","prediction_samples":230,"prediction_sse_q20":391526294539,"reconstruction_checksum":"cec4aa424d7aa8da","reconstruction_sse_q20":61904309390,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"4d013ac9b54d83b3","transition_correct":120,"transition_supported":230,"transition_unknown":26},"training_evaluations":1663565},"ravel_without_retirement_matched_work":{"checkpoint_size_bytes":51764,"drift_holdout":{"classification_checksum":"26c898aff18af629","correct":222,"expert_evaluations":2545,"prediction_checksum":"f4aa4de36974e192","prediction_samples":228,"prediction_sse_q20":553267745116,"reconstruction_checksum":"76c271efa027051f","reconstruction_sse_q20":104233104029,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":249,"samples":256,"transition_checksum":"51810fd8f99873da","transition_correct":110,"transition_supported":228,"transition_unknown":28},"expert_count":79,"planning":{"belief_set_target_reached":17,"cases":64,"checksum":"431f492de84c7601","exact_world_state_target_reached":10,"executed_path_length":280,"expansions":1773,"goal_expert_reached":17,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":215,"path_found":64,"path_length_regret":4,"state_aliasing_failures":7,"transition_model_error_failures":47},"retention_holdout":{"classification_checksum":"375a8802bfc66af6","correct":256,"expert_evaluations":2048,"prediction_checksum":"46ddcef37d1dfdbc","prediction_samples":230,"prediction_sse_q20":391526294539,"reconstruction_checksum":"cec4aa424d7aa8da","reconstruction_sse_q20":61904309390,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"7121244966c5ba2a","transition_correct":120,"transition_supported":230,"transition_unknown":26},"training_evaluations":2196045}},"dataset_seeds":{"base_holdout":"0x929126699ebfc0de","base_training":"0xa2be9a2395c57ed6","drift_adaptation_training":"0xbee84aa4e84bc8c1","drift_holdout":"0x6bcdcd1564131b92","original_task_retention_holdout":"0xcdcca22efdf79db1","planning_cases":"0x0ed986f264ee956c"},"dataset_sizes":{"base_holdout":256,"base_training":1024,"drift_adaptation_training":512,"drift_holdout":256,"original_task_retention_holdout":256,"planning_cases":64},"integrity":{"checkpoint_behavior_match":true,"checkpoint_identity_match":true,"checkpoint_mutations":{"anchored_status":true,"appended_unexpected_byte":true,"checkpoint_substitution":true,"checkpoint_truncation":true,"incorrect_schema_version":true,"label":true,"label_count":true,"lineage":true,"next_observation_component":true,"payload_byte":true,"reconstruction_component":true,"retrieval_key_component":true,"transition_graph_edge":true,"transition_support":true},"checkpoint_roundtrip":true,"lineage_invariants":{"deterministic_topology_reproduction":true,"lineage_uniqueness":true,"no_accidental_lineage_reuse":true,"parent_child_generation_increment":true,"repeated_descendant_splitting":true,"sibling_generation_equality":true},"unsupported_graph_edge_violations":0},"regime":"partially_observed_ambiguous","schema":"ravel-raw-trial/0.5","seed":"0x81024ac97a8edb6c","trial_id":"validation-ambiguous-03"},{"candidate":{"adaptation_completed":true,"adaptation_training":{"classification_checksum":"a08f71ed49355b9f","correct":467,"expert_evaluations":7876,"prediction_checksum":"312e96365fe1ba49","prediction_samples":459,"prediction_sse_q20":929582196982,"reconstruction_checksum":"8b0c3f6dcfebf05c","reconstruction_sse_q20":202162949398,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":458,"samples":512,"transition_checksum":"9c23192d67b7a405","transition_correct":213,"transition_supported":459,"transition_unknown":53},"adaptation_training_evaluations":1668744,"adapted_model_drift_holdout":{"classification_checksum":"a0c11c56337db81f","correct":219,"expert_evaluations":4148,"prediction_checksum":"3bc2bd65622bf7a4","prediction_samples":229,"prediction_sse_q20":599509167382,"reconstruction_checksum":"f3ba9309c586106f","reconstruction_sse_q20":107144054782,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":226,"samples":256,"transition_checksum":"f37d2a8b215b93b3","transition_correct":94,"transition_supported":229,"transition_unknown":27},"base_holdout":{"classification_checksum":"5573db10d5d9927a","correct":256,"expert_evaluations":2048,"prediction_checksum":"e17fdad226f90f1c","prediction_samples":229,"prediction_sse_q20":440043995470,"reconstruction_checksum":"97bc84c970598427","reconstruction_sse_q20":61571749750,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"c31b114aa0c0d915","transition_correct":108,"transition_supported":229,"transition_unknown":27},"base_holdout_retention":{"classification_checksum":"8c7b65578d0ce69a","correct":256,"expert_evaluations":2888,"prediction_checksum":"e43aa43de36e892b","prediction_samples":217,"prediction_sse_q20":384017629207,"reconstruction_checksum":"6960f836ed1d1ac8","reconstruction_sse_q20":63475827991,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":244,"samples":256,"transition_checksum":"31a2c3e5b8908d7e","transition_correct":101,"transition_supported":217,"transition_unknown":39},"base_training_evaluations":546056,"behavior_identity":"28bb2a8058b9fcf4f574611828248d8eac681b2bedc2b8889f1aa2dcfc1891d2","checkpoint_size_bytes":51194,"expert_count":78,"model_identity":"6486352dac860c78eaa6f40a099a68cf6fcdc8fe1eac6fa06115e84f3a184fbc","planning":{"belief_set_target_reached":16,"cases":64,"checksum":"bdf0445748d1bd3d","exact_world_state_target_reached":9,"executed_path_length":218,"expansions":2288,"goal_expert_reached":16,"graph_disconnection_failures":0,"no_supported_edge_failures":16,"optimal_path_length":224,"path_found":48,"path_length_regret":11,"state_aliasing_failures":7,"transition_model_error_failures":32},"replay":{"actions_covered":4,"assigned_experts_covered":61,"high_loss_cases_selected":30,"labels_covered":8,"rare_cases_selected":61,"selected":256,"selection_checksum":"57c28127103e9716","states_covered":64,"transition_pairs_covered":250,"unique":256},"static_model_drift_holdout":{"classification_checksum":"1732732887f18889","correct":164,"expert_evaluations":3280,"prediction_checksum":"bf186b425e6ae3f5","prediction_samples":229,"prediction_sse_q20":832089502766,"reconstruction_checksum":"cb11b20ab86f3011","reconstruction_sse_q20":133495203850,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":234,"samples":256,"transition_checksum":"290ac7497ef73e43","transition_correct":82,"transition_supported":229,"transition_unknown":27},"topology":{"accepted_births":14,"accepted_retirements":0,"births":[{"dominant_channel":0,"event_index":127,"normalized_score_q20":626651},{"dominant_channel":0,"event_index":405,"normalized_score_q20":614446},{"dominant_channel":0,"event_index":217,"normalized_score_q20":602015},{"dominant_channel":0,"event_index":371,"normalized_score_q20":592921},{"dominant_channel":0,"event_index":420,"normalized_score_q20":571366},{"dominant_channel":0,"event_index":295,"normalized_score_q20":561885},{"dominant_channel":0,"event_index":107,"normalized_score_q20":452014},{"dominant_channel":0,"event_index":469,"normalized_score_q20":436310},{"dominant_channel":0,"event_index":470,"normalized_score_q20":435913},{"dominant_channel":0,"event_index":49,"normalized_score_q20":429367},{"dominant_channel":0,"event_index":48,"normalized_score_q20":428186},{"dominant_channel":0,"event_index":316,"normalized_score_q20":420929},{"dominant_channel":0,"event_index":57,"normalized_score_q20":414964},{"dominant_channel":0,"event_index":195,"normalized_score_q20":413741}],"objective_after_q20":884092,"objective_before_q20":833347,"rejected_births":2,"rejected_retirements":1,"retired_lineages":[],"training_observations":{"births":14,"certified":18722,"expert_evaluations":1668744,"rejected_births":2,"rejected_retirements":1,"retired":0,"samples":19968}}},"checkpoint_format":{"byte_order":"big_endian","magic_hex":"524156454c303500","payload_digest":"sha256","real_encoding":"signed_q20_int64","schema_version":5,"transition_support_min":2,"transition_top_k":2},"comparisons":{"fixed_8_expert":{"checkpoint_size_bytes":11294,"drift_holdout":{"classification_checksum":"43fccd1e701ad8df","correct":62,"expert_evaluations":2048,"prediction_checksum":"a35aa134e020be17","prediction_samples":256,"prediction_sse_q20":1311573752275,"reconstruction_checksum":"30aef0975269703c","reconstruction_sse_q20":840584117062,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"4a0401e56101bf35","transition_correct":122,"transition_supported":256,"transition_unknown":0},"expert_count":8,"planning":{"belief_set_target_reached":9,"cases":64,"checksum":"9cdcc05985359a32","exact_world_state_target_reached":2,"executed_path_length":22,"expansions":142,"goal_expert_reached":9,"graph_disconnection_failures":46,"no_supported_edge_failures":0,"optimal_path_length":224,"path_found":18,"path_length_regret":0,"state_aliasing_failures":7,"transition_model_error_failures":9},"retention_holdout":{"classification_checksum":"8caa4b6c870bb478","correct":60,"expert_evaluations":2048,"prediction_checksum":"19483dcc8de85d6d","prediction_samples":256,"prediction_sse_q20":976642996074,"reconstruction_checksum":"74f47984062b7df5","reconstruction_sse_q20":691877116473,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"d7ed9918b5d8467d","transition_correct":141,"transition_supported":256,"transition_unknown":0},"training_evaluations":94208},"fixed_topology_64_expert_routed":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"e098f4ebaa104472","correct":164,"expert_evaluations":2888,"prediction_checksum":"7ce003451720826f","prediction_samples":213,"prediction_sse_q20":771413673216,"reconstruction_checksum":"55575bcf0c332bbe","reconstruction_sse_q20":126541438852,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":241,"samples":256,"transition_checksum":"b4f7df4b7618a70a","transition_correct":71,"transition_supported":213,"transition_unknown":43},"expert_count":64,"planning":{"belief_set_target_reached":12,"cases":64,"checksum":"93ded279f86c6f3d","exact_world_state_target_reached":7,"executed_path_length":251,"expansions":1838,"goal_expert_reached":12,"graph_disconnection_failures":0,"no_supported_edge_failures":1,"optimal_path_length":224,"path_found":63,"path_length_regret":2,"state_aliasing_failures":5,"transition_model_error_failures":51},"retention_holdout":{"classification_checksum":"c60ea8a0b3639443","correct":256,"expert_evaluations":2048,"prediction_checksum":"3393911921474532","prediction_samples":228,"prediction_sse_q20":420632296779,"reconstruction_checksum":"5b0819875a68fe5e","reconstruction_sse_q20":63883645652,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"a887b9c06bb5f9ad","transition_correct":88,"transition_supported":228,"transition_unknown":28},"training_evaluations":2588672},"flat_64_expert_complete_scan":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"e098f4ebaa104472","correct":164,"expert_evaluations":16384,"prediction_checksum":"7ce003451720826f","prediction_samples":213,"prediction_sse_q20":771413673216,"reconstruction_checksum":"55575bcf0c332bbe","reconstruction_sse_q20":126541438852,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"b4f7df4b7618a70a","transition_correct":71,"transition_supported":213,"transition_unknown":43},"expert_count":64,"planning":{"belief_set_target_reached":12,"cases":64,"checksum":"93ded279f86c6f3d","exact_world_state_target_reached":7,"executed_path_length":251,"expansions":1838,"goal_expert_reached":12,"graph_disconnection_failures":0,"no_supported_edge_failures":1,"optimal_path_length":224,"path_found":63,"path_length_regret":2,"state_aliasing_failures":5,"transition_model_error_failures":51},"retention_holdout":{"classification_checksum":"c60ea8a0b3639443","correct":256,"expert_evaluations":16384,"prediction_checksum":"3393911921474532","prediction_samples":228,"prediction_sse_q20":420632296779,"reconstruction_checksum":"5b0819875a68fe5e","reconstruction_sse_q20":63883645652,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"a887b9c06bb5f9ad","transition_correct":88,"transition_supported":228,"transition_unknown":28},"training_evaluations":2588672},"matched_compute_fixed_topology":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"1732732887f18889","correct":164,"expert_evaluations":3280,"prediction_checksum":"bf186b425e6ae3f5","prediction_samples":229,"prediction_sse_q20":832089502766,"reconstruction_checksum":"cb11b20ab86f3011","reconstruction_sse_q20":133495203850,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":234,"samples":256,"transition_checksum":"290ac7497ef73e43","transition_correct":82,"transition_supported":229,"transition_unknown":27},"expert_count":64,"planning":{"belief_set_target_reached":9,"cases":64,"checksum":"0980c16d114be696","exact_world_state_target_reached":5,"executed_path_length":305,"expansions":1711,"goal_expert_reached":9,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":224,"path_found":64,"path_length_regret":3,"state_aliasing_failures":4,"transition_model_error_failures":55},"retention_holdout":{"classification_checksum":"8c7b65578d0ce69a","correct":256,"expert_evaluations":2048,"prediction_checksum":"e43aa43de36e892b","prediction_samples":217,"prediction_sse_q20":384017629207,"reconstruction_checksum":"6960f836ed1d1ac8","reconstruction_sse_q20":63475827991,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"41eabb3db71f0bcd","transition_correct":102,"transition_supported":217,"transition_unknown":39},"training_evaluations":2430216},"matched_expert_count_capacity":{"checkpoint_size_bytes":51194,"drift_holdout":{"classification_checksum":"f57c32783ce8a470","correct":164,"expert_evaluations":3448,"prediction_checksum":"a51d4823c37de577","prediction_samples":203,"prediction_sse_q20":727642353671,"reconstruction_checksum":"c8d10ed8dcf774e2","reconstruction_sse_q20":122205177295,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":236,"samples":256,"transition_checksum":"809f03940f66c715","transition_correct":48,"transition_supported":203,"transition_unknown":53},"expert_count":78,"planning":{"belief_set_target_reached":11,"cases":64,"checksum":"8958a6ca2fd68f3c","exact_world_state_target_reached":6,"executed_path_length":259,"expansions":2162,"goal_expert_reached":11,"graph_disconnection_failures":0,"no_supported_edge_failures":4,"optimal_path_length":224,"path_found":60,"path_length_regret":0,"state_aliasing_failures":5,"transition_model_error_failures":49},"retention_holdout":{"classification_checksum":"7b28580e7acfa3ab","correct":256,"expert_evaluations":2048,"prediction_checksum":"fd1e0ccf85879e07","prediction_samples":210,"prediction_sse_q20":399119754507,"reconstruction_checksum":"b5ca7ad3da88bc98","reconstruction_sse_q20":63035897885,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"12c797bb5c125008","transition_correct":71,"transition_supported":210,"transition_unknown":46},"training_evaluations":3714048},"nearest_centroid_16_no_recursive_births":{"checkpoint_size_bytes":15854,"drift_holdout":{"classification_checksum":"ef9b2c0dd6fbef40","correct":96,"expert_evaluations":4096,"prediction_checksum":"b88fb5c0e20c15fe","prediction_samples":256,"prediction_sse_q20":1104910758879,"reconstruction_checksum":"120be4081574a371","reconstruction_sse_q20":415553945669,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"aa299104a7d9032b","transition_correct":141,"transition_supported":256,"transition_unknown":0},"expert_count":16,"planning":{"belief_set_target_reached":13,"cases":64,"checksum":"b6d3e4ca396359df","exact_world_state_target_reached":6,"executed_path_length":180,"expansions":533,"goal_expert_reached":13,"graph_disconnection_failures":7,"no_supported_edge_failures":0,"optimal_path_length":224,"path_found":57,"path_length_regret":1,"state_aliasing_failures":7,"transition_model_error_failures":44},"retention_holdout":{"classification_checksum":"d97a703e90808e89","correct":135,"expert_evaluations":4096,"prediction_checksum":"aca6239b7f08beed","prediction_samples":256,"prediction_sse_q20":655345723478,"reconstruction_checksum":"b9f9ea4d04ea66f9","reconstruction_sse_q20":312997730040,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"84b3a12ab363706d","transition_correct":187,"transition_supported":256,"transition_unknown":0},"training_evaluations":253952},"no_adaptation_static":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"1732732887f18889","correct":164,"expert_evaluations":3280,"prediction_checksum":"bf186b425e6ae3f5","prediction_samples":229,"prediction_sse_q20":832089502766,"reconstruction_checksum":"cb11b20ab86f3011","reconstruction_sse_q20":133495203850,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":234,"samples":256,"transition_checksum":"290ac7497ef73e43","transition_correct":82,"transition_supported":229,"transition_unknown":27},"expert_count":64,"planning":{"belief_set_target_reached":9,"cases":64,"checksum":"0980c16d114be696","exact_world_state_target_reached":5,"executed_path_length":305,"expansions":1711,"goal_expert_reached":9,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":224,"path_found":64,"path_length_regret":3,"state_aliasing_failures":4,"transition_model_error_failures":55},"retention_holdout":{"classification_checksum":"8c7b65578d0ce69a","correct":256,"expert_evaluations":2048,"prediction_checksum":"e43aa43de36e892b","prediction_samples":217,"prediction_sse_q20":384017629207,"reconstruction_checksum":"6960f836ed1d1ac8","reconstruction_sse_q20":63475827991,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"41eabb3db71f0bcd","transition_correct":102,"transition_supported":217,"transition_unknown":39},"training_evaluations":546056},"periodic_replay_policy":{"checkpoint_size_bytes":51194,"drift_holdout":{"classification_checksum":"a0c11c56337db81f","correct":219,"expert_evaluations":4148,"prediction_checksum":"3bc2bd65622bf7a4","prediction_samples":229,"prediction_sse_q20":599509167382,"reconstruction_checksum":"c359b3db8967d4fd","reconstruction_sse_q20":107181964334,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":226,"samples":256,"transition_checksum":"f37d2a8b215b93b3","transition_correct":94,"transition_supported":229,"transition_unknown":27},"expert_count":78,"planning":{"belief_set_target_reached":16,"cases":64,"checksum":"bdf0445748d1bd3d","exact_world_state_target_reached":9,"executed_path_length":218,"expansions":2288,"goal_expert_reached":16,"graph_disconnection_failures":0,"no_supported_edge_failures":16,"optimal_path_length":224,"path_found":48,"path_length_regret":11,"state_aliasing_failures":7,"transition_model_error_failures":32},"retention_holdout":{"classification_checksum":"8c7b65578d0ce69a","correct":256,"expert_evaluations":2888,"prediction_checksum":"e43aa43de36e892b","prediction_samples":217,"prediction_sse_q20":384017629207,"reconstruction_checksum":"6960f836ed1d1ac8","reconstruction_sse_q20":63475827991,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":244,"samples":256,"transition_checksum":"31a2c3e5b8908d7e","transition_correct":101,"transition_supported":217,"transition_unknown":39},"training_evaluations":2214870},"ravel_0_5_candidate":{"checkpoint_size_bytes":51194,"drift_holdout":{"classification_checksum":"a0c11c56337db81f","correct":219,"expert_evaluations":4148,"prediction_checksum":"3bc2bd65622bf7a4","prediction_samples":229,"prediction_sse_q20":599509167382,"reconstruction_checksum":"f3ba9309c586106f","reconstruction_sse_q20":107144054782,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":226,"samples":256,"transition_checksum":"f37d2a8b215b93b3","transition_correct":94,"transition_supported":229,"transition_unknown":27},"expert_count":78,"planning":{"belief_set_target_reached":16,"cases":64,"checksum":"bdf0445748d1bd3d","exact_world_state_target_reached":9,"executed_path_length":218,"expansions":2288,"goal_expert_reached":16,"graph_disconnection_failures":0,"no_supported_edge_failures":16,"optimal_path_length":224,"path_found":48,"path_length_regret":11,"state_aliasing_failures":7,"transition_model_error_failures":32},"retention_holdout":{"classification_checksum":"8c7b65578d0ce69a","correct":256,"expert_evaluations":2888,"prediction_checksum":"e43aa43de36e892b","prediction_samples":217,"prediction_sse_q20":384017629207,"reconstruction_checksum":"6960f836ed1d1ac8","reconstruction_sse_q20":63475827991,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":244,"samples":256,"transition_checksum":"31a2c3e5b8908d7e","transition_correct":101,"transition_supported":217,"transition_unknown":39},"training_evaluations":2214800},"ravel_complete_scan_without_certification":{"checkpoint_size_bytes":51194,"drift_holdout":{"classification_checksum":"a0c11c56337db81f","correct":219,"expert_evaluations":19968,"prediction_checksum":"3bc2bd65622bf7a4","prediction_samples":229,"prediction_sse_q20":599509167382,"reconstruction_checksum":"f3ba9309c586106f","reconstruction_sse_q20":107144054782,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"f37d2a8b215b93b3","transition_correct":94,"transition_supported":229,"transition_unknown":27},"expert_count":78,"planning":{"belief_set_target_reached":16,"cases":64,"checksum":"bdf0445748d1bd3d","exact_world_state_target_reached":9,"executed_path_length":218,"expansions":2288,"goal_expert_reached":16,"graph_disconnection_failures":0,"no_supported_edge_failures":16,"optimal_path_length":224,"path_found":48,"path_length_regret":11,"state_aliasing_failures":7,"transition_model_error_failures":32},"retention_holdout":{"classification_checksum":"8c7b65578d0ce69a","correct":256,"expert_evaluations":19968,"prediction_checksum":"e43aa43de36e892b","prediction_samples":217,"prediction_sse_q20":384017629207,"reconstruction_checksum":"6960f836ed1d1ac8","reconstruction_sse_q20":63475827991,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":0,"samples":256,"transition_checksum":"31a2c3e5b8908d7e","transition_correct":101,"transition_supported":217,"transition_unknown":39},"training_evaluations":2410940},"ravel_no_birth_same_replay_iterations":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"1732732887f18889","correct":164,"expert_evaluations":3280,"prediction_checksum":"bf186b425e6ae3f5","prediction_samples":229,"prediction_sse_q20":832089502766,"reconstruction_checksum":"cb11b20ab86f3011","reconstruction_sse_q20":133495203850,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":234,"samples":256,"transition_checksum":"290ac7497ef73e43","transition_correct":82,"transition_supported":229,"transition_unknown":27},"expert_count":64,"planning":{"belief_set_target_reached":9,"cases":64,"checksum":"0980c16d114be696","exact_world_state_target_reached":5,"executed_path_length":305,"expansions":1711,"goal_expert_reached":9,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":224,"path_found":64,"path_length_regret":3,"state_aliasing_failures":4,"transition_model_error_failures":55},"retention_holdout":{"classification_checksum":"8c7b65578d0ce69a","correct":256,"expert_evaluations":2048,"prediction_checksum":"e43aa43de36e892b","prediction_samples":217,"prediction_sse_q20":384017629207,"reconstruction_checksum":"6960f836ed1d1ac8","reconstruction_sse_q20":63475827991,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"41eabb3db71f0bcd","transition_correct":102,"transition_supported":217,"transition_unknown":39},"training_evaluations":781576},"ravel_random_births":{"checkpoint_size_bytes":43214,"drift_holdout":{"classification_checksum":"1732732887f18889","correct":164,"expert_evaluations":3280,"prediction_checksum":"bf186b425e6ae3f5","prediction_samples":229,"prediction_sse_q20":832089502766,"reconstruction_checksum":"cb11b20ab86f3011","reconstruction_sse_q20":133495203850,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":234,"samples":256,"transition_checksum":"290ac7497ef73e43","transition_correct":82,"transition_supported":229,"transition_unknown":27},"expert_count":64,"planning":{"belief_set_target_reached":9,"cases":64,"checksum":"0980c16d114be696","exact_world_state_target_reached":5,"executed_path_length":305,"expansions":1711,"goal_expert_reached":9,"graph_disconnection_failures":0,"no_supported_edge_failures":0,"optimal_path_length":224,"path_found":64,"path_length_regret":3,"state_aliasing_failures":4,"transition_model_error_failures":55},"retention_holdout":{"classification_checksum":"8c7b65578d0ce69a","correct":256,"expert_evaluations":2048,"prediction_checksum":"e43aa43de36e892b","prediction_samples":217,"prediction_sse_q20":384017629207,"reconstruction_checksum":"6960f836ed1d1ac8","reconstruction_sse_q20":63475827991,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":256,"samples":256,"transition_checksum":"41eabb3db71f0bcd","transition_correct":102,"transition_supported":217,"transition_unknown":39},"training_evaluations":781576},"ravel_without_replay":{"checkpoint_size_bytes":51194,"drift_holdout":{"classification_checksum":"a0c11c56337db81f","correct":219,"expert_evaluations":4148,"prediction_checksum":"3bc2bd65622bf7a4","prediction_samples":229,"prediction_sse_q20":599509167382,"reconstruction_checksum":"c359b3db8967d4fd","reconstruction_sse_q20":107181964334,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":226,"samples":256,"transition_checksum":"f37d2a8b215b93b3","transition_correct":94,"transition_supported":229,"transition_unknown":27},"expert_count":78,"planning":{"belief_set_target_reached":16,"cases":64,"checksum":"bdf0445748d1bd3d","exact_world_state_target_reached":9,"executed_path_length":218,"expansions":2288,"goal_expert_reached":16,"graph_disconnection_failures":0,"no_supported_edge_failures":16,"optimal_path_length":224,"path_found":48,"path_length_regret":11,"state_aliasing_failures":7,"transition_model_error_failures":32},"retention_holdout":{"classification_checksum":"8c7b65578d0ce69a","correct":256,"expert_evaluations":2888,"prediction_checksum":"e43aa43de36e892b","prediction_samples":217,"prediction_sse_q20":384017629207,"reconstruction_checksum":"6960f836ed1d1ac8","reconstruction_sse_q20":63475827991,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":244,"samples":256,"transition_checksum":"31a2c3e5b8908d7e","transition_correct":101,"transition_supported":217,"transition_unknown":39},"training_evaluations":1681030},"ravel_without_retirement_matched_work":{"checkpoint_size_bytes":51194,"drift_holdout":{"classification_checksum":"a0c11c56337db81f","correct":219,"expert_evaluations":4148,"prediction_checksum":"3bc2bd65622bf7a4","prediction_samples":229,"prediction_sse_q20":599509167382,"reconstruction_checksum":"f3ba9309c586106f","reconstruction_sse_q20":107144054782,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":226,"samples":256,"transition_checksum":"f37d2a8b215b93b3","transition_correct":94,"transition_supported":229,"transition_unknown":27},"expert_count":78,"planning":{"belief_set_target_reached":16,"cases":64,"checksum":"bdf0445748d1bd3d","exact_world_state_target_reached":9,"executed_path_length":218,"expansions":2288,"goal_expert_reached":16,"graph_disconnection_failures":0,"no_supported_edge_failures":16,"optimal_path_length":224,"path_found":48,"path_length_regret":11,"state_aliasing_failures":7,"transition_model_error_failures":32},"retention_holdout":{"classification_checksum":"8c7b65578d0ce69a","correct":256,"expert_evaluations":2888,"prediction_checksum":"e43aa43de36e892b","prediction_samples":217,"prediction_sse_q20":384017629207,"reconstruction_checksum":"6960f836ed1d1ac8","reconstruction_sse_q20":63475827991,"rejected":0,"routed_complete_mismatches":0,"routing_certification_count":244,"samples":256,"transition_checksum":"31a2c3e5b8908d7e","transition_correct":101,"transition_supported":217,"transition_unknown":39},"training_evaluations":2214800}},"dataset_seeds":{"base_holdout":"0x1e9afe44370a5e2f","base_training":"0x1514a98252b105f7","drift_adaptation_training":"0x71727904551c9d7d","drift_holdout":"0x433286e0b06617d4","original_task_retention_holdout":"0x78dd5234ea5b0350","planning_cases":"0xbd0936618451cfb8"},"dataset_sizes":{"base_holdout":256,"base_training":1024,"drift_adaptation_training":512,"drift_holdout":256,"original_task_retention_holdout":256,"planning_cases":64},"integrity":{"checkpoint_behavior_match":true,"checkpoint_identity_match":true,"checkpoint_mutations":{"anchored_status":true,"appended_unexpected_byte":true,"checkpoint_substitution":true,"checkpoint_truncation":true,"incorrect_schema_version":true,"label":true,"label_count":true,"lineage":true,"next_observation_component":true,"payload_byte":true,"reconstruction_component":true,"retrieval_key_component":true,"transition_graph_edge":true,"transition_support":true},"checkpoint_roundtrip":true,"lineage_invariants":{"deterministic_topology_reproduction":true,"lineage_uniqueness":true,"no_accidental_lineage_reuse":true,"parent_child_generation_increment":true,"repeated_descendant_splitting":true,"sibling_generation_equality":true},"unsupported_graph_edge_violations":0},"regime":"partially_observed_ambiguous","schema":"ravel-raw-trial/0.5","seed":"0x6a4bbee6ac7a2a32","trial_id":"validation-ambiguous-04"}]} diff --git a/ravel-0.5-source-and-execution-manifest.json b/ravel-0.5-source-and-execution-manifest.json new file mode 100644 index 0000000..81150d7 --- /dev/null +++ b/ravel-0.5-source-and-execution-manifest.json @@ -0,0 +1 @@ +{"build_configuration":{"canonical_compiler":"cc","canonical_flags":["-std=c11","-O3","-Wall","-Wextra","-Werror","-pedantic"],"language":"C","link_libraries":["m"],"standard":"C11"},"checkpoint_schema":{"byte_order":"big_endian","magic_hex":"524156454c303500","payload_digest":"sha256","real_encoding":"signed_q20_int64","version":5},"digest_algorithm":"sha256","digest_procedure":"For each ordered entry, hash uint32_be(path_utf8_length), path_utf8, uint64_be(content_length), and exact content bytes; concatenate frames into one SHA-256 stream.","entrypoint":"case-studies/ravel/ravel_0_5.c","evidence_schema_versions":["ravel-preregistration/0.5","ravel-raw-trial/0.5","ravel-raw-observations/0.5","ravel-self-test-observations/0.5","ravel-trial-evidence/0.5","ravel-negative-evidence/0.5","ravel-source-and-execution-manifest/0.5","ravel-assurance-case/0.5"],"generated_execution_shards":[],"generator_source":null,"maintained_execution_sources":["case-studies/ravel/ravel_0_5.c"],"ordered_files":[{"bytes":129796,"order":0,"path":"case-studies/ravel/ravel_0_5.c","role":"entrypoint","sha256":"1a8466ea1805811873c461fb891aaeaec18f6c9e7491b5ea7bd09bf698be102d"},{"bytes":4566,"order":1,"path":"case-studies/ravel/RAVEL_0_5_CONTRACT.md","role":"contract","sha256":"84fd9e1ebdfaadd813926415364ca0b71cf54d33419116cd6719a947de2c8751"},{"bytes":2153,"order":2,"path":"case-studies/ravel/RAVEL_0_5_SCOPE.md","role":"scope","sha256":"014dcce959d2163ad099567d16cbcd7ce80fc73c9ae8b4fd284a2c7e9f52eece"},{"bytes":3938,"order":3,"path":"case-studies/ravel/RAVEL_0_5_POSTMORTEM.md","role":"postmortem","sha256":"310e3b04282cea7a1771f7634c1abb0fd91188afa151242271988a4319a8c72d"},{"bytes":2017,"order":4,"path":"case-studies/ravel/ravel-0.5-development-corpus.json","role":"development_corpus","sha256":"b8505dd8cc56ac6291d2d973998394470cc1ee3c92bec9e3210485397383b95a"},{"bytes":29843,"order":5,"path":"case-studies/ravel/ravel-0.5-preregistration.json","role":"preregistration","sha256":"f240c391b92823471132ffce1eeed154b3f03dc2af1e3e1f789690a99eb4cfaa"},{"bytes":2873,"order":6,"path":"case-studies/ravel/ravel-0.5-threat-model.json","role":"threat_model","sha256":"6bad8dd77684da4d7024fa35adcc28e5c750b1bdf81d7fdb01ad301dd667bee1"},{"bytes":1441,"order":7,"path":"case-studies/ravel/ravel-0.5-limitations.md","role":"limitations","sha256":"7a0791c040ce78a1c2300cac4ccd69b7561395a4ae46e8c75b8e82c7b2459556"},{"bytes":47892,"order":8,"path":"case-studies/ravel/tools/ravel_0_5_evaluator.py","role":"independent_evaluator","sha256":"6d1c716b77c4b7615cd93cd52e67ba8073825cd68026b72d126c4faf561fd19f"},{"bytes":22461,"order":9,"path":"case-studies/ravel/tools/ravel_0_5_evidence.py","role":"evidence_generator","sha256":"9733b53bebe722bba6dc3d1df993ab8c20a03ee5b0486b8452b83586ffafccbe"},{"bytes":10132,"order":10,"path":"case-studies/ravel/tools/ravel_0_5_source_digest.py","role":"source_digest_utility","sha256":"5b79cb95c4da5c58ad68328f1a39d6d390d8796db7ea39c1297d798d191b5b7a"},{"bytes":3152,"order":11,"path":"case-studies/ravel/ravel-0.5-source-manifest-spec.json","role":"manifest_specification","sha256":"4e756fff03b2addb64544c1bd609df3ef9ae8c9de26bb2e296e3d3b49700f338"},{"bytes":8533,"order":12,"path":"case-studies/ravel/Makefile","role":"case_build_specification","sha256":"bcbac380293d3761ed9170ef9d35397827d121725deaaf4fbcfdd073f066bc4d"},{"bytes":6424,"order":13,"path":"Makefile","role":"root_build_specification","sha256":"ac20c500b4e136c0fb2e54aa9c72afde9a27cbf5693e390aab184bbef218f974"},{"bytes":3758,"order":14,"path":".github/workflows/ravel-0.5.yml","role":"ci_workflow","sha256":"a68a1fc5fcf72b9000f14c7235132dc57ac384a240eb56bf2d50f9e7ec80eaae"}],"schema":"ravel-source-and-execution-manifest/0.5","source_digest":"a182be923d77fb841905eb501e387440bcb64a3dee85ad4b60e65a1f881b816e","source_provenance":{"classification":"maintained_source","generator":null,"statement":"RAVEL 0.5 is directly maintained C11 source. No higher-level generator or generated execution shard exists."},"unexpected_execution_shards":[]} diff --git a/ravel-0.5-trial-evidence.json b/ravel-0.5-trial-evidence.json new file mode 100644 index 0000000..e74b3fb --- /dev/null +++ b/ravel-0.5-trial-evidence.json @@ -0,0 +1 @@ +{"aggregates":{"accepted_births":{"arithmetic_mean":8.46875,"maximum":16.0,"median":6.5,"minimum":1.0,"population_standard_deviation":5.024840638020274},"accepted_retirements":{"arithmetic_mean":0.25,"maximum":4.0,"median":0.0,"minimum":0.0,"population_standard_deviation":0.75},"adaptation_training_accuracy":{"arithmetic_mean":0.9158935546875,"maximum":1.0,"median":1.0,"minimum":0.595703125,"population_standard_deviation":0.12803302115066542},"adapted_drift_accuracy":{"arithmetic_mean":0.9144287109375,"maximum":1.0,"median":1.0,"minimum":0.6171875,"population_standard_deviation":0.12435118854646462},"adapted_prediction_rmse":{"arithmetic_mean":10.326103536240275,"maximum":25.383280703776748,"median":8.125751739946548,"minimum":3.5900440183122444,"population_standard_deviation":6.00535464955904},"adapted_reconstruction_rmse":{"arithmetic_mean":6.405238716725026,"maximum":11.969001999910333,"median":6.355208921476608,"minimum":3.2856226669640756,"population_standard_deviation":2.5341300026958735},"adapted_transition_accuracy":{"arithmetic_mean":0.8532377629926644,"maximum":0.9826086956521739,"median":0.92980311181148,"minimum":0.4104803493449782,"population_standard_deviation":0.16775075088559396},"balanced_vs_periodic_drift_accuracy_delta":{"arithmetic_mean":-0.000244140625,"maximum":0.00390625,"median":0.0,"minimum":-0.0078125,"population_standard_deviation":0.0016737437989260361},"balanced_vs_periodic_retention_delta":{"arithmetic_mean":-0.0003662109375,"maximum":0.0,"median":0.0,"minimum":-0.00390625,"population_standard_deviation":0.0011385960758165058},"base_accuracy":{"arithmetic_mean":0.952880859375,"maximum":1.0,"median":0.94921875,"minimum":0.859375,"population_standard_deviation":0.031643299884521955},"base_prediction_rmse":{"arithmetic_mean":8.035665853824069,"maximum":15.707376087994545,"median":6.879405436478091,"minimum":3.6242844903899787,"population_standard_deviation":3.2634284038852277},"base_reconstruction_rmse":{"arithmetic_mean":6.209146427682988,"maximum":9.782097633989205,"median":5.974031992546452,"minimum":3.2749318409045345,"population_standard_deviation":1.587813592330261},"belief_set_rate":{"arithmetic_mean":0.72021484375,"maximum":1.0,"median":0.75,"minimum":0.125,"population_standard_deviation":0.23193256578719565},"belief_set_rate_delta":{"arithmetic_mean":0.10400390625,"maximum":0.40625,"median":0.0859375,"minimum":-0.046875,"population_standard_deviation":0.10515066146170912},"checkpoint_size_bytes":{"arithmetic_mean":47898.6875,"maximum":52334.0,"median":46634.0,"minimum":43784.0,"population_standard_deviation":2769.5430403486694},"drift_accuracy_delta":{"arithmetic_mean":0.0989990234375,"maximum":0.3125,"median":0.068359375,"minimum":0.0,"population_standard_deviation":0.08401621725005963},"exact_state_rate":{"arithmetic_mean":0.69873046875,"maximum":1.0,"median":0.75,"minimum":0.0625,"population_standard_deviation":0.26709252169589853},"exact_state_rate_delta":{"arithmetic_mean":0.12890625,"maximum":0.421875,"median":0.125,"minimum":0.0,"population_standard_deviation":0.1081121289304535},"expert_count":{"arithmetic_mean":72.21875,"maximum":80.0,"median":70.0,"minimum":65.0,"population_standard_deviation":4.8588474392081915},"headroom_normalized_accuracy_improvement":{"arithmetic_mean":0.7478226571563209,"maximum":1.0,"median":1.0,"minimum":0.0,"population_standard_deviation":0.33510205214910416},"inference_evaluation_ratio_vs_flat64":{"arithmetic_mean":0.14559555053710938,"maximum":0.253173828125,"median":0.135986328125,"minimum":0.125,"population_standard_deviation":0.03009772427541619},"inference_expert_evaluations":{"arithmetic_mean":2385.4375,"maximum":4148.0,"median":2228.0,"minimum":2048.0,"population_standard_deviation":493.12111452841884},"matched_compute_drift_accuracy_delta":{"arithmetic_mean":0.0989990234375,"maximum":0.3125,"median":0.068359375,"minimum":0.0,"population_standard_deviation":0.08401621725005963},"matched_compute_retention_delta":{"arithmetic_mean":0.0313720703125,"maximum":0.08203125,"median":0.03515625,"minimum":-0.03515625,"population_standard_deviation":0.029996280042166947},"matched_compute_training_evaluation_ratio":{"arithmetic_mean":0.9274102740266711,"maximum":1.0404408588375842,"median":0.9246046324470696,"minimum":0.8570669021699949,"population_standard_deviation":0.037991684926851635},"no_birth_drift_accuracy_delta":{"arithmetic_mean":0.0989990234375,"maximum":0.3125,"median":0.068359375,"minimum":0.0,"population_standard_deviation":0.08401621725005963},"no_retirement_drift_accuracy_delta":{"arithmetic_mean":-0.0001220703125,"maximum":0.0,"median":0.0,"minimum":-0.00390625,"population_standard_deviation":0.0006796587356970241},"path_found_rate":{"arithmetic_mean":0.95947265625,"maximum":1.0,"median":1.0,"minimum":0.734375,"population_standard_deviation":0.07583150868438915},"prediction_improvement_ratio":{"arithmetic_mean":0.13645346515766818,"maximum":0.4124110766015486,"median":0.14530830320804186,"minimum":-0.011122411581629842,"population_standard_deviation":0.10111662741710703},"reconstruction_improvement_ratio":{"arithmetic_mean":0.16500070068112038,"maximum":0.45869993373131773,"median":0.13991151536462268,"minimum":0.0,"population_standard_deviation":0.11822428129495885},"replay_actions_covered":{"arithmetic_mean":4.0,"maximum":4.0,"median":4.0,"minimum":4.0,"population_standard_deviation":0.0},"replay_experts_covered":{"arithmetic_mean":62.65625,"maximum":64.0,"median":63.0,"minimum":60.0,"population_standard_deviation":1.1349387373334299},"replay_labels_covered":{"arithmetic_mean":8.0,"maximum":8.0,"median":8.0,"minimum":8.0,"population_standard_deviation":0.0},"replay_selected":{"arithmetic_mean":256.0,"maximum":256.0,"median":256.0,"minimum":256.0,"population_standard_deviation":0.0},"replay_states_covered":{"arithmetic_mean":64.0,"maximum":64.0,"median":64.0,"minimum":64.0,"population_standard_deviation":0.0},"replay_transition_pairs_covered":{"arithmetic_mean":251.21875,"maximum":255.0,"median":251.5,"minimum":247.0,"population_standard_deviation":2.1612261421470915},"replay_unique":{"arithmetic_mean":256.0,"maximum":256.0,"median":256.0,"minimum":256.0,"population_standard_deviation":0.0},"retention_accuracy":{"arithmetic_mean":0.9859619140625,"maximum":1.0,"median":1.0,"minimum":0.90625,"population_standard_deviation":0.02654489045698765},"retention_accuracy_delta_from_base":{"arithmetic_mean":0.0330810546875,"maximum":0.08984375,"median":0.04296875,"minimum":-0.0546875,"population_standard_deviation":0.03207802497413377},"retention_prediction_degradation":{"arithmetic_mean":-0.9370169210198359,"maximum":1.2630735338642944,"median":-1.0077258956513009,"minimum":-2.6921712887121405,"population_standard_deviation":0.9774411818329309},"retention_prediction_rmse":{"arithmetic_mean":7.098648932804234,"maximum":15.01370113678229,"median":5.617071040840802,"minimum":3.5944794681319023,"population_standard_deviation":3.2628165584490736},"retention_reconstruction_degradation_ratio":{"arithmetic_mean":-0.1546196888852096,"maximum":0.0828494880903982,"median":-0.12530770511092443,"minimum":-0.3902230706501599,"population_standard_deviation":0.13668668684156807},"retention_reconstruction_rmse":{"arithmetic_mean":5.199816268448509,"maximum":8.855846728797767,"median":4.738142618388693,"minimum":3.233877131378624,"population_standard_deviation":1.493952782375338},"retention_transition_accuracy_delta":{"arithmetic_mean":0.012450374349149753,"maximum":0.07204821477490642,"median":0.014167876944991165,"minimum":-0.05485232067510548,"population_standard_deviation":0.03275468634612175},"routing_mismatches":{"arithmetic_mean":0.0,"maximum":0.0,"median":0.0,"minimum":0.0,"population_standard_deviation":0.0},"static_belief_set_rate":{"arithmetic_mean":0.6162109375,"maximum":1.0,"median":0.65625,"minimum":0.125,"population_standard_deviation":0.20439572103840284},"static_drift_accuracy":{"arithmetic_mean":0.8154296875,"maximum":1.0,"median":0.921875,"minimum":0.55078125,"population_standard_deviation":0.1697506096313496},"static_exact_state_rate":{"arithmetic_mean":0.56982421875,"maximum":1.0,"median":0.609375,"minimum":0.0625,"population_standard_deviation":0.22517708061902836},"static_prediction_rmse":{"arithmetic_mean":11.885265919082508,"maximum":26.219407227171814,"median":9.675746697979875,"minimum":3.5900440183122444,"population_standard_deviation":6.534932141328717},"static_reconstruction_rmse":{"arithmetic_mean":7.617932954520243,"maximum":12.913145962262412,"median":7.529737633542483,"minimum":3.2856226669640756,"population_standard_deviation":2.5193725372975826},"static_transition_accuracy":{"arithmetic_mean":0.8361463288512723,"maximum":1.0,"median":0.9135742552079444,"minimum":0.3393665158371041,"population_standard_deviation":0.18808589459770805},"topology_objective_gain_q20":{"arithmetic_mean":25327.9375,"maximum":58045.0,"median":20193.0,"minimum":332.0,"population_standard_deviation":16814.93137240214},"training_evaluations":{"arithmetic_mean":1677835.6875,"maximum":2793900.0,"median":1567757.5,"minimum":887600.0,"population_standard_deviation":491899.23471056536},"transition_accuracy_delta":{"arithmetic_mean":0.017091434141392185,"maximum":0.09106826677159158,"median":0.019308355083173523,"minimum":-0.07753493904252151,"population_standard_deviation":0.03939775687882575},"transition_support_rate":{"arithmetic_mean":0.896484375,"maximum":0.9453125,"median":0.896484375,"minimum":0.81640625,"population_standard_deviation":0.027930370402490412},"unsupported_graph_edge_violations":{"arithmetic_mean":0.0,"maximum":0.0,"median":0.0,"minimum":0.0,"population_standard_deviation":0.0}},"development_result":"FAIL","evidence_reproduction":"PASS","formal_mncds_status":"UNKNOWN","formal_mncs_status":"UNKNOWN","preregistration_sha256":"30386a8d0c7e9a15fd8cb907f55e74b46a319e1f17102654eceda18699dce12f","promotion_authorized":false,"schema":"ravel-trial-evidence/0.5","study_id":"ravel.adaptive-mechanism-correction.epoch-1","trial_summary":{"declared":32,"failing":8,"minimum_passing_trials":32,"minimum_passing_trials_per_regime":4,"passing":24,"passing_by_regime":{"combined_observation_and_label_drift":3,"increased_observation_noise":4,"label_drift":1,"observation_drift":4,"partially_observed_ambiguous":1,"partially_overlapping_observations":4,"separated_state":4,"transition_drift":3}},"trials":[{"comparisons":{"fixed_8_expert":{"metrics":{"checkpoint_size_bytes":11294,"drift_accuracy":0.23046875,"expert_count":8,"expert_evaluations":2048,"planning_belief_set_rate":0.203125,"planning_exact_state_rate":0.0,"prediction_rmse":30.073611707920968,"reconstruction_rmse":28.576932862629246,"retention_accuracy":0.20703125,"training_evaluations":94208},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":34770,"drift_accuracy":0.76953125,"expert_count":61,"expert_evaluations":0,"planning_belief_set_rate":0.5625,"planning_exact_state_rate":0.765625,"prediction_rmse":-24.95262652961364,"reconstruction_rmse":-24.668258110749193,"retention_accuracy":0.79296875,"training_evaluations":1280824},"pareto_relation":"mixed"},"fixed_topology_64_expert_routed":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":1.0,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":3.5492058814865874,"reconstruction_rmse":3.228604229387965,"retention_accuracy":1.0,"training_evaluations":2588672},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":2850,"drift_accuracy":0.0,"expert_count":5,"expert_evaluations":0,"planning_belief_set_rate":-0.234375,"planning_exact_state_rate":-0.234375,"prediction_rmse":1.5717792968207425,"reconstruction_rmse":0.6800705224920898,"retention_accuracy":0.0,"training_evaluations":-1213640},"pareto_relation":"mixed"},"flat_64_expert_complete_scan":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":1.0,"expert_count":64,"expert_evaluations":16384,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":3.5492058814865874,"reconstruction_rmse":3.228604229387965,"retention_accuracy":1.0,"training_evaluations":2588672},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":2850,"drift_accuracy":0.0,"expert_count":5,"expert_evaluations":-14336,"planning_belief_set_rate":-0.234375,"planning_exact_state_rate":-0.234375,"prediction_rmse":1.5717792968207425,"reconstruction_rmse":0.6800705224920898,"retention_accuracy":0.0,"training_evaluations":-1213640},"pareto_relation":"mixed"},"matched_compute_fixed_topology":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.95703125,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":0.703125,"planning_exact_state_rate":0.640625,"prediction_rmse":6.206100241772684,"reconstruction_rmse":5.312795120695158,"retention_accuracy":0.953125,"training_evaluations":1447224},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":2850,"drift_accuracy":0.04296875,"expert_count":5,"expert_evaluations":0,"planning_belief_set_rate":0.0625,"planning_exact_state_rate":0.125,"prediction_rmse":-1.085115063465354,"reconstruction_rmse":-1.4041203688151036,"retention_accuracy":0.046875,"training_evaluations":-72192},"pareto_relation":"mixed"},"matched_expert_count_capacity":{"metrics":{"checkpoint_size_bytes":46064,"drift_accuracy":1.0,"expert_count":69,"expert_evaluations":2048,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":3.554972196436425,"reconstruction_rmse":3.2251216732317745,"retention_accuracy":1.0,"training_evaluations":2967552},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":-0.234375,"planning_exact_state_rate":-0.234375,"prediction_rmse":1.5660129818709048,"reconstruction_rmse":0.6835530786482802,"retention_accuracy":0.0,"training_evaluations":-1592520},"pareto_relation":"mixed"},"nearest_centroid_16_no_recursive_births":{"metrics":{"checkpoint_size_bytes":15854,"drift_accuracy":0.25,"expert_count":16,"expert_evaluations":4096,"planning_belief_set_rate":0.53125,"planning_exact_state_rate":0.09375,"prediction_rmse":23.444373411315166,"reconstruction_rmse":22.543983578386108,"retention_accuracy":0.24609375,"training_evaluations":253952},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":30210,"drift_accuracy":0.75,"expert_count":53,"expert_evaluations":-2048,"planning_belief_set_rate":0.234375,"planning_exact_state_rate":0.671875,"prediction_rmse":-18.323388233007837,"reconstruction_rmse":-18.635308826506055,"retention_accuracy":0.75390625,"training_evaluations":1121080},"pareto_relation":"mixed"},"no_adaptation_static":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.95703125,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":0.703125,"planning_exact_state_rate":0.640625,"prediction_rmse":6.206100241772684,"reconstruction_rmse":5.312795120695158,"retention_accuracy":0.953125,"training_evaluations":562488},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":2850,"drift_accuracy":0.04296875,"expert_count":5,"expert_evaluations":0,"planning_belief_set_rate":0.0625,"planning_exact_state_rate":0.125,"prediction_rmse":-1.085115063465354,"reconstruction_rmse":-1.4041203688151036,"retention_accuracy":0.046875,"training_evaluations":812544},"pareto_relation":"mixed"},"periodic_replay_policy":{"metrics":{"checkpoint_size_bytes":45494,"drift_accuracy":1.0,"expert_count":68,"expert_evaluations":2048,"planning_belief_set_rate":0.75,"planning_exact_state_rate":0.75,"prediction_rmse":5.126737172206762,"reconstruction_rmse":3.9072099132678906,"retention_accuracy":1.0,"training_evaluations":1253688},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":570,"drift_accuracy":0.0,"expert_count":1,"expert_evaluations":0,"planning_belief_set_rate":0.015625,"planning_exact_state_rate":0.015625,"prediction_rmse":-0.005751993899432151,"reconstruction_rmse":0.0014648386121640655,"retention_accuracy":0.0,"training_evaluations":121344},"pareto_relation":"mixed"},"ravel_0_5_candidate":{"metrics":{"checkpoint_size_bytes":46064,"drift_accuracy":1.0,"expert_count":69,"expert_evaluations":2048,"planning_belief_set_rate":0.765625,"planning_exact_state_rate":0.765625,"prediction_rmse":5.12098517830733,"reconstruction_rmse":3.9086747518800546,"retention_accuracy":1.0,"training_evaluations":1375032},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"equivalent"},"ravel_complete_scan_without_certification":{"metrics":{"checkpoint_size_bytes":46064,"drift_accuracy":1.0,"expert_count":69,"expert_evaluations":17664,"planning_belief_set_rate":0.765625,"planning_exact_state_rate":0.765625,"prediction_rmse":5.12098517830733,"reconstruction_rmse":3.9086747518800546,"retention_accuracy":1.0,"training_evaluations":1562424},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":-15616,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":-187392},"pareto_relation":"candidate_dominates"},"ravel_no_birth_same_replay_iterations":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.95703125,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":0.703125,"planning_exact_state_rate":0.640625,"prediction_rmse":6.206100241772684,"reconstruction_rmse":5.312795120695158,"retention_accuracy":0.953125,"training_evaluations":783672},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":2850,"drift_accuracy":0.04296875,"expert_count":5,"expert_evaluations":0,"planning_belief_set_rate":0.0625,"planning_exact_state_rate":0.125,"prediction_rmse":-1.085115063465354,"reconstruction_rmse":-1.4041203688151036,"retention_accuracy":0.046875,"training_evaluations":591360},"pareto_relation":"mixed"},"ravel_random_births":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.95703125,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":0.703125,"planning_exact_state_rate":0.640625,"prediction_rmse":6.206100241772684,"reconstruction_rmse":5.312795120695158,"retention_accuracy":0.953125,"training_evaluations":783672},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":2850,"drift_accuracy":0.04296875,"expert_count":5,"expert_evaluations":0,"planning_belief_set_rate":0.0625,"planning_exact_state_rate":0.125,"prediction_rmse":-1.085115063465354,"reconstruction_rmse":-1.4041203688151036,"retention_accuracy":0.046875,"training_evaluations":591360},"pareto_relation":"mixed"},"ravel_without_replay":{"metrics":{"checkpoint_size_bytes":46064,"drift_accuracy":1.0,"expert_count":69,"expert_evaluations":2048,"planning_belief_set_rate":0.75,"planning_exact_state_rate":0.75,"prediction_rmse":5.148758047499753,"reconstruction_rmse":3.9154634185659996,"retention_accuracy":1.0,"training_evaluations":951608},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.015625,"planning_exact_state_rate":0.015625,"prediction_rmse":-0.0277728691924235,"reconstruction_rmse":-0.006788666685944911,"retention_accuracy":0.0,"training_evaluations":423424},"pareto_relation":"mixed"},"ravel_without_retirement_matched_work":{"metrics":{"checkpoint_size_bytes":46064,"drift_accuracy":1.0,"expert_count":69,"expert_evaluations":2048,"planning_belief_set_rate":0.765625,"planning_exact_state_rate":0.765625,"prediction_rmse":5.12098517830733,"reconstruction_rmse":3.9086747518800546,"retention_accuracy":1.0,"training_evaluations":1375032},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"equivalent"}},"gates":[{"gate_id":"adaptation_completed","metric":"adaptation_completed","observed":true,"operator":"eq","pass":true,"rationale":"The bounded adaptation procedure must complete.","threshold":true},{"gate_id":"base_holdout_accuracy","metric":"base_accuracy","observed":0.94140625,"operator":"ge","pass":true,"rationale":"The base representation must establish the bounded task before drift.","threshold":0.85},{"gate_id":"base_holdout_retention","metric":"retention_accuracy","observed":1.0,"operator":"ge","pass":true,"rationale":"Anchored base behavior may lose at most ten percentage points in absolute retained accuracy.","threshold":0.9},{"gate_id":"routing_oracle_equivalence","metric":"routing_mismatches","observed":0,"operator":"eq","pass":true,"rationale":"Every routed classification must agree with complete scan.","threshold":0},{"gate_id":"checkpoint_roundtrip","metric":"checkpoint_roundtrip","observed":true,"operator":"eq","pass":true,"rationale":"Canonical in-memory restoration must succeed.","threshold":true},{"gate_id":"checkpoint_identity","metric":"checkpoint_identity","observed":true,"operator":"eq","pass":true,"rationale":"Restored complete model identity must match.","threshold":true},{"gate_id":"checkpoint_behavior","metric":"checkpoint_behavior","observed":true,"operator":"eq","pass":true,"rationale":"Restored evaluation and planning behavior must match.","threshold":true},{"gate_id":"checkpoint_mutation_rejection","metric":"checkpoint_mutations","observed":true,"operator":"eq","pass":true,"rationale":"Every declared behavioral and byte-level checkpoint mutation must be detected.","threshold":true},{"gate_id":"lineage_invariants","metric":"lineage_invariants","observed":true,"operator":"eq","pass":true,"rationale":"Generation, lineage uniqueness, descendant splitting, and deterministic topology invariants must hold.","threshold":true},{"gate_id":"unsupported_transitions_unknown","metric":"unsupported_graph_edge_violations","observed":0,"operator":"eq","pass":true,"rationale":"Unsupported actions cannot enter the planning graph.","threshold":0},{"gate_id":"replay_size","metric":"replay_selected","observed":256,"operator":"eq","pass":true,"rationale":"The declared replay budget must be filled on the non-sparse trial corpus.","threshold":256},{"gate_id":"replay_unique","metric":"replay_unique","observed":256,"operator":"eq","pass":true,"rationale":"Balanced replay cannot introduce accidental duplicates.","threshold":256},{"gate_id":"replay_label_coverage","metric":"replay_labels_covered","observed":8,"operator":"eq","pass":true,"rationale":"Replay must retain every declared label.","threshold":8},{"gate_id":"replay_action_coverage","metric":"replay_actions_covered","observed":4,"operator":"eq","pass":true,"rationale":"Replay must retain every declared action.","threshold":4},{"gate_id":"replay_state_coverage","metric":"replay_states_covered","observed":64,"operator":"ge","pass":true,"rationale":"Replay must cover at least 60 of 64 source states.","threshold":60},{"gate_id":"replay_expert_coverage","metric":"replay_experts_covered","observed":62,"operator":"ge","pass":true,"rationale":"Replay must retain broad assigned-expert coverage.","threshold":60},{"gate_id":"replay_transition_coverage","metric":"replay_transition_pairs_covered","observed":254,"operator":"ge","pass":true,"rationale":"Replay must preserve broad source-state/action transition support.","threshold":220},{"gate_id":"planning_path_found","metric":"path_found_rate","observed":1.0,"operator":"ge","pass":true,"rationale":"At least three quarters of bounded planning cases must have a supported path.","threshold":0.75},{"gate_id":"expert_capacity","metric":"expert_count","observed":69,"operator":"le","pass":true,"rationale":"Adaptation cannot exceed the declared expert capacity.","threshold":80},{"gate_id":"retirement_budget","metric":"accepted_retirements","observed":0,"operator":"le","pass":true,"rationale":"Retirement remains optional and bounded.","threshold":4},{"gate_id":"topology_objective_non_degradation","metric":"topology_objective_gain_q20","observed":16798,"operator":"ge","pass":true,"rationale":"Accepted adaptation-training topology decisions cannot reduce their declared objective.","threshold":0},{"gate_id":"matched_compute_budget","metric":"matched_compute_training_evaluation_ratio","observed":0.9501169134840218,"operator":"le","pass":true,"rationale":"Candidate training work may exceed the matched fixed-topology budget by at most ten percent.","threshold":1.1},{"gate_id":"conditional_inference_efficiency","metric":"inference_evaluation_ratio_vs_flat64","observed":0.125,"operator":"le","pass":true,"rationale":"Routed inference must use at most one quarter of flat complete-scan expert evaluations.","threshold":0.25},{"gate_id":"separated_accuracy","metric":"adapted_drift_accuracy","observed":1.0,"operator":"ge","pass":true,"rationale":"The separated-state task remains high-accuracy after adaptation.","threshold":0.9},{"gate_id":"separated_non_inferiority","metric":"drift_accuracy_delta","observed":0.04296875,"operator":"ge","pass":true,"rationale":"An already strong static model must not lose more than two points.","threshold":-0.02},{"gate_id":"separated_headroom","metric":"headroom_normalized_accuracy_improvement","observed":1.0,"operator":"ge","pass":true,"rationale":"Available accuracy headroom cannot worsen.","threshold":0},{"gate_id":"separated_reconstruction","metric":"reconstruction_improvement_ratio","observed":0.26429032870956637,"operator":"ge","pass":true,"rationale":"Adaptation cannot worsen separated-state reconstruction.","threshold":0},{"gate_id":"separated_prediction","metric":"prediction_improvement_ratio","observed":0.17484652538506312,"operator":"ge","pass":true,"rationale":"Adaptation cannot worsen separated-state prediction.","threshold":0},{"gate_id":"separated_exact_planning","metric":"exact_state_rate","observed":0.765625,"operator":"ge","pass":true,"rationale":"Separated observations support an exact-state capability gate.","threshold":0.65},{"gate_id":"separated_bounded_births","metric":"accepted_births","observed":5,"operator":"le","pass":true,"rationale":"The low-drift regime cannot consume the full topology budget.","threshold":12}],"metrics":{"accepted_births":5,"accepted_retirements":0,"adaptation_completed":true,"adaptation_training_accuracy":1.0,"adapted_drift_accuracy":1.0,"adapted_prediction_rmse":5.12098517830733,"adapted_reconstruction_rmse":3.9086747518800546,"adapted_transition_accuracy":0.9282700421940928,"balanced_vs_periodic_drift_accuracy_delta":0.0,"balanced_vs_periodic_retention_delta":0.0,"base_accuracy":0.94140625,"base_prediction_rmse":6.720511477406212,"base_reconstruction_rmse":6.182406830948617,"belief_set_rate":0.765625,"belief_set_rate_delta":0.0625,"checkpoint_behavior":true,"checkpoint_identity":true,"checkpoint_mutations":true,"checkpoint_roundtrip":true,"checkpoint_size_bytes":46064,"drift_accuracy_delta":0.04296875,"exact_state_rate":0.765625,"exact_state_rate_delta":0.125,"expert_count":69,"headroom_normalized_accuracy_improvement":1.0,"inference_evaluation_ratio_vs_flat64":0.125,"inference_expert_evaluations":2048,"lineage_invariants":true,"matched_compute_drift_accuracy_delta":0.04296875,"matched_compute_retention_delta":0.046875,"matched_compute_training_evaluation_ratio":0.9501169134840218,"no_birth_drift_accuracy_delta":0.04296875,"no_retirement_drift_accuracy_delta":0.0,"path_found_rate":1.0,"prediction_improvement_ratio":0.17484652538506312,"reconstruction_improvement_ratio":0.26429032870956637,"replay_actions_covered":4,"replay_experts_covered":62,"replay_labels_covered":8,"replay_selected":256,"replay_states_covered":64,"replay_transition_pairs_covered":254,"replay_unique":256,"retention_accuracy":1.0,"retention_accuracy_delta_from_base":0.05859375,"retention_prediction_degradation":-0.7143196901780398,"retention_prediction_rmse":6.006191787228172,"retention_reconstruction_degradation_ratio":-0.25408854787329843,"retention_reconstruction_rmse":4.611528056910922,"retention_transition_accuracy_delta":0.0036807612891641694,"routing_mismatches":0,"static_belief_set_rate":0.703125,"static_drift_accuracy":0.95703125,"static_exact_state_rate":0.640625,"static_prediction_rmse":6.206100241772684,"static_reconstruction_rmse":5.312795120695158,"static_transition_accuracy":0.9159663865546218,"topology_objective_gain_q20":16798,"training_evaluations":1375032,"transition_accuracy_delta":0.012303655639471,"transition_support_rate":0.92578125,"unsupported_graph_edge_violations":0},"regime":"separated_state","seed":"0xd61698008d192310","trial_id":"validation-separated-01","trial_result":"PASS"},{"comparisons":{"fixed_8_expert":{"metrics":{"checkpoint_size_bytes":11294,"drift_accuracy":0.234375,"expert_count":8,"expert_evaluations":2048,"planning_belief_set_rate":0.234375,"planning_exact_state_rate":0.03125,"prediction_rmse":30.424421258151646,"reconstruction_rmse":28.724459611655707,"retention_accuracy":0.1953125,"training_evaluations":94208},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":32490,"drift_accuracy":0.765625,"expert_count":57,"expert_evaluations":0,"planning_belief_set_rate":0.765625,"planning_exact_state_rate":0.96875,"prediction_rmse":-26.8343772398394,"reconstruction_rmse":-25.43883694469163,"retention_accuracy":0.8046875,"training_evaluations":793392},"pareto_relation":"mixed"},"fixed_topology_64_expert_routed":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":1.0,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":3.5900440183122444,"reconstruction_rmse":3.2856226669640756,"retention_accuracy":1.0,"training_evaluations":2588672},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":570,"drift_accuracy":0.0,"expert_count":1,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":-1701072},"pareto_relation":"mixed"},"flat_64_expert_complete_scan":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":1.0,"expert_count":64,"expert_evaluations":16384,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":3.5900440183122444,"reconstruction_rmse":3.2856226669640756,"retention_accuracy":1.0,"training_evaluations":2588672},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":570,"drift_accuracy":0.0,"expert_count":1,"expert_evaluations":-14336,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":-1701072},"pareto_relation":"mixed"},"matched_compute_fixed_topology":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":1.0,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":3.5900440183122444,"reconstruction_rmse":3.2856226669640756,"retention_accuracy":1.0,"training_evaluations":993584},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":570,"drift_accuracy":0.0,"expert_count":1,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":-105984},"pareto_relation":"mixed"},"matched_expert_count_capacity":{"metrics":{"checkpoint_size_bytes":43784,"drift_accuracy":1.0,"expert_count":65,"expert_evaluations":2048,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":3.590656648833075,"reconstruction_rmse":3.2832453494956444,"retention_accuracy":1.0,"training_evaluations":2662400},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":-0.0006126305208304927,"reconstruction_rmse":0.0023773174684311726,"retention_accuracy":0.0,"training_evaluations":-1774800},"pareto_relation":"mixed"},"nearest_centroid_16_no_recursive_births":{"metrics":{"checkpoint_size_bytes":15854,"drift_accuracy":0.2578125,"expert_count":16,"expert_evaluations":4096,"planning_belief_set_rate":0.546875,"planning_exact_state_rate":0.140625,"prediction_rmse":25.62746875890853,"reconstruction_rmse":22.897830303052963,"retention_accuracy":0.24609375,"training_evaluations":253952},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":27930,"drift_accuracy":0.7421875,"expert_count":49,"expert_evaluations":-2048,"planning_belief_set_rate":0.453125,"planning_exact_state_rate":0.859375,"prediction_rmse":-22.037424740596286,"reconstruction_rmse":-19.612207636088886,"retention_accuracy":0.75390625,"training_evaluations":633648},"pareto_relation":"mixed"},"no_adaptation_static":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":1.0,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":3.5900440183122444,"reconstruction_rmse":3.2856226669640756,"retention_accuracy":1.0,"training_evaluations":551216},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":570,"drift_accuracy":0.0,"expert_count":1,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":336384},"pareto_relation":"variant_dominates"},"periodic_replay_policy":{"metrics":{"checkpoint_size_bytes":43784,"drift_accuracy":1.0,"expert_count":65,"expert_evaluations":2048,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":3.5900440183122444,"reconstruction_rmse":3.2856226669640756,"retention_accuracy":1.0,"training_evaluations":887600},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"equivalent"},"ravel_0_5_candidate":{"metrics":{"checkpoint_size_bytes":43784,"drift_accuracy":1.0,"expert_count":65,"expert_evaluations":2048,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":3.5900440183122444,"reconstruction_rmse":3.2856226669640756,"retention_accuracy":1.0,"training_evaluations":887600},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"equivalent"},"ravel_complete_scan_without_certification":{"metrics":{"checkpoint_size_bytes":43784,"drift_accuracy":1.0,"expert_count":65,"expert_evaluations":16640,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":3.5900440183122444,"reconstruction_rmse":3.2856226669640756,"retention_accuracy":1.0,"training_evaluations":1062704},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":-14592,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":-175104},"pareto_relation":"candidate_dominates"},"ravel_no_birth_same_replay_iterations":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":1.0,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":3.5900440183122444,"reconstruction_rmse":3.2856226669640756,"retention_accuracy":1.0,"training_evaluations":772400},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":570,"drift_accuracy":0.0,"expert_count":1,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":115200},"pareto_relation":"variant_dominates"},"ravel_random_births":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":1.0,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":3.5900440183122444,"reconstruction_rmse":3.2856226669640756,"retention_accuracy":1.0,"training_evaluations":772400},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":570,"drift_accuracy":0.0,"expert_count":1,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":115200},"pareto_relation":"variant_dominates"},"ravel_without_replay":{"metrics":{"checkpoint_size_bytes":44924,"drift_accuracy":1.0,"expert_count":67,"expert_evaluations":2048,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":3.597169667987297,"reconstruction_rmse":3.2802309633703755,"retention_accuracy":1.0,"training_evaluations":932144},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":-1140,"drift_accuracy":0.0,"expert_count":-2,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":-0.007125649675052692,"reconstruction_rmse":0.0053917035937001145,"retention_accuracy":0.0,"training_evaluations":-44544},"pareto_relation":"mixed"},"ravel_without_retirement_matched_work":{"metrics":{"checkpoint_size_bytes":43784,"drift_accuracy":1.0,"expert_count":65,"expert_evaluations":2048,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":3.5900440183122444,"reconstruction_rmse":3.2856226669640756,"retention_accuracy":1.0,"training_evaluations":887600},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"equivalent"}},"gates":[{"gate_id":"adaptation_completed","metric":"adaptation_completed","observed":true,"operator":"eq","pass":true,"rationale":"The bounded adaptation procedure must complete.","threshold":true},{"gate_id":"base_holdout_accuracy","metric":"base_accuracy","observed":1.0,"operator":"ge","pass":true,"rationale":"The base representation must establish the bounded task before drift.","threshold":0.85},{"gate_id":"base_holdout_retention","metric":"retention_accuracy","observed":1.0,"operator":"ge","pass":true,"rationale":"Anchored base behavior may lose at most ten percentage points in absolute retained accuracy.","threshold":0.9},{"gate_id":"routing_oracle_equivalence","metric":"routing_mismatches","observed":0,"operator":"eq","pass":true,"rationale":"Every routed classification must agree with complete scan.","threshold":0},{"gate_id":"checkpoint_roundtrip","metric":"checkpoint_roundtrip","observed":true,"operator":"eq","pass":true,"rationale":"Canonical in-memory restoration must succeed.","threshold":true},{"gate_id":"checkpoint_identity","metric":"checkpoint_identity","observed":true,"operator":"eq","pass":true,"rationale":"Restored complete model identity must match.","threshold":true},{"gate_id":"checkpoint_behavior","metric":"checkpoint_behavior","observed":true,"operator":"eq","pass":true,"rationale":"Restored evaluation and planning behavior must match.","threshold":true},{"gate_id":"checkpoint_mutation_rejection","metric":"checkpoint_mutations","observed":true,"operator":"eq","pass":true,"rationale":"Every declared behavioral and byte-level checkpoint mutation must be detected.","threshold":true},{"gate_id":"lineage_invariants","metric":"lineage_invariants","observed":true,"operator":"eq","pass":true,"rationale":"Generation, lineage uniqueness, descendant splitting, and deterministic topology invariants must hold.","threshold":true},{"gate_id":"unsupported_transitions_unknown","metric":"unsupported_graph_edge_violations","observed":0,"operator":"eq","pass":true,"rationale":"Unsupported actions cannot enter the planning graph.","threshold":0},{"gate_id":"replay_size","metric":"replay_selected","observed":256,"operator":"eq","pass":true,"rationale":"The declared replay budget must be filled on the non-sparse trial corpus.","threshold":256},{"gate_id":"replay_unique","metric":"replay_unique","observed":256,"operator":"eq","pass":true,"rationale":"Balanced replay cannot introduce accidental duplicates.","threshold":256},{"gate_id":"replay_label_coverage","metric":"replay_labels_covered","observed":8,"operator":"eq","pass":true,"rationale":"Replay must retain every declared label.","threshold":8},{"gate_id":"replay_action_coverage","metric":"replay_actions_covered","observed":4,"operator":"eq","pass":true,"rationale":"Replay must retain every declared action.","threshold":4},{"gate_id":"replay_state_coverage","metric":"replay_states_covered","observed":64,"operator":"ge","pass":true,"rationale":"Replay must cover at least 60 of 64 source states.","threshold":60},{"gate_id":"replay_expert_coverage","metric":"replay_experts_covered","observed":64,"operator":"ge","pass":true,"rationale":"Replay must retain broad assigned-expert coverage.","threshold":60},{"gate_id":"replay_transition_coverage","metric":"replay_transition_pairs_covered","observed":247,"operator":"ge","pass":true,"rationale":"Replay must preserve broad source-state/action transition support.","threshold":220},{"gate_id":"planning_path_found","metric":"path_found_rate","observed":1.0,"operator":"ge","pass":true,"rationale":"At least three quarters of bounded planning cases must have a supported path.","threshold":0.75},{"gate_id":"expert_capacity","metric":"expert_count","observed":65,"operator":"le","pass":true,"rationale":"Adaptation cannot exceed the declared expert capacity.","threshold":80},{"gate_id":"retirement_budget","metric":"accepted_retirements","observed":0,"operator":"le","pass":true,"rationale":"Retirement remains optional and bounded.","threshold":4},{"gate_id":"topology_objective_non_degradation","metric":"topology_objective_gain_q20","observed":332,"operator":"ge","pass":true,"rationale":"Accepted adaptation-training topology decisions cannot reduce their declared objective.","threshold":0},{"gate_id":"matched_compute_budget","metric":"matched_compute_training_evaluation_ratio","observed":0.8933316156459846,"operator":"le","pass":true,"rationale":"Candidate training work may exceed the matched fixed-topology budget by at most ten percent.","threshold":1.1},{"gate_id":"conditional_inference_efficiency","metric":"inference_evaluation_ratio_vs_flat64","observed":0.125,"operator":"le","pass":true,"rationale":"Routed inference must use at most one quarter of flat complete-scan expert evaluations.","threshold":0.25},{"gate_id":"separated_accuracy","metric":"adapted_drift_accuracy","observed":1.0,"operator":"ge","pass":true,"rationale":"The separated-state task remains high-accuracy after adaptation.","threshold":0.9},{"gate_id":"separated_non_inferiority","metric":"drift_accuracy_delta","observed":0.0,"operator":"ge","pass":true,"rationale":"An already strong static model must not lose more than two points.","threshold":-0.02},{"gate_id":"separated_headroom","metric":"headroom_normalized_accuracy_improvement","observed":0.0,"operator":"ge","pass":true,"rationale":"Available accuracy headroom cannot worsen.","threshold":0},{"gate_id":"separated_reconstruction","metric":"reconstruction_improvement_ratio","observed":0.0,"operator":"ge","pass":true,"rationale":"Adaptation cannot worsen separated-state reconstruction.","threshold":0},{"gate_id":"separated_prediction","metric":"prediction_improvement_ratio","observed":0.0,"operator":"ge","pass":true,"rationale":"Adaptation cannot worsen separated-state prediction.","threshold":0},{"gate_id":"separated_exact_planning","metric":"exact_state_rate","observed":1.0,"operator":"ge","pass":true,"rationale":"Separated observations support an exact-state capability gate.","threshold":0.65},{"gate_id":"separated_bounded_births","metric":"accepted_births","observed":1,"operator":"le","pass":true,"rationale":"The low-drift regime cannot consume the full topology budget.","threshold":12}],"metrics":{"accepted_births":1,"accepted_retirements":0,"adaptation_completed":true,"adaptation_training_accuracy":1.0,"adapted_drift_accuracy":1.0,"adapted_prediction_rmse":3.5900440183122444,"adapted_reconstruction_rmse":3.2856226669640756,"adapted_transition_accuracy":0.9826086956521739,"balanced_vs_periodic_drift_accuracy_delta":0.0,"balanced_vs_periodic_retention_delta":0.0,"base_accuracy":1.0,"base_prediction_rmse":3.6242844903899787,"base_reconstruction_rmse":3.2749318409045345,"belief_set_rate":1.0,"belief_set_rate_delta":0.0,"checkpoint_behavior":true,"checkpoint_identity":true,"checkpoint_mutations":true,"checkpoint_roundtrip":true,"checkpoint_size_bytes":43784,"drift_accuracy_delta":0.0,"exact_state_rate":1.0,"exact_state_rate_delta":0.0,"expert_count":65,"headroom_normalized_accuracy_improvement":0.0,"inference_evaluation_ratio_vs_flat64":0.125,"inference_expert_evaluations":2048,"lineage_invariants":true,"matched_compute_drift_accuracy_delta":0.0,"matched_compute_retention_delta":0.0,"matched_compute_training_evaluation_ratio":0.8933316156459846,"no_birth_drift_accuracy_delta":0.0,"no_retirement_drift_accuracy_delta":0.0,"path_found_rate":1.0,"prediction_improvement_ratio":0.0,"reconstruction_improvement_ratio":0.0,"replay_actions_covered":4,"replay_experts_covered":64,"replay_labels_covered":8,"replay_selected":256,"replay_states_covered":64,"replay_transition_pairs_covered":247,"replay_unique":256,"retention_accuracy":1.0,"retention_accuracy_delta_from_base":0.0,"retention_prediction_degradation":-0.029805022258076352,"retention_prediction_rmse":3.5944794681319023,"retention_reconstruction_degradation_ratio":-0.012536050067708006,"retention_reconstruction_rmse":3.233877131378624,"retention_transition_accuracy_delta":-0.008583690987124415,"routing_mismatches":0,"static_belief_set_rate":1.0,"static_drift_accuracy":1.0,"static_exact_state_rate":1.0,"static_prediction_rmse":3.5900440183122444,"static_reconstruction_rmse":3.2856226669640756,"static_transition_accuracy":1.0,"topology_objective_gain_q20":332,"training_evaluations":887600,"transition_accuracy_delta":-0.017391304347826098,"transition_support_rate":0.8984375,"unsupported_graph_edge_violations":0},"regime":"separated_state","seed":"0xaf704736a9144c08","trial_id":"validation-separated-02","trial_result":"PASS"},{"comparisons":{"fixed_8_expert":{"metrics":{"checkpoint_size_bytes":11294,"drift_accuracy":0.24609375,"expert_count":8,"expert_evaluations":2048,"planning_belief_set_rate":0.265625,"planning_exact_state_rate":0.046875,"prediction_rmse":31.22058818707684,"reconstruction_rmse":28.888650190458605,"retention_accuracy":0.25390625,"training_evaluations":94208},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":33060,"drift_accuracy":0.75390625,"expert_count":58,"expert_evaluations":0,"planning_belief_set_rate":0.734375,"planning_exact_state_rate":0.953125,"prediction_rmse":-26.919551591050116,"reconstruction_rmse":-25.02942235085804,"retention_accuracy":0.74609375,"training_evaluations":803224},"pareto_relation":"mixed"},"fixed_topology_64_expert_routed":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":1.0,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":3.6280543948909187,"reconstruction_rmse":3.3137821609029983,"retention_accuracy":1.0,"training_evaluations":2588672},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":1140,"drift_accuracy":0.0,"expert_count":2,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.6729822011358033,"reconstruction_rmse":0.5454456786975652,"retention_accuracy":0.0,"training_evaluations":-1691240},"pareto_relation":"mixed"},"flat_64_expert_complete_scan":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":1.0,"expert_count":64,"expert_evaluations":16384,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":3.6280543948909187,"reconstruction_rmse":3.3137821609029983,"retention_accuracy":1.0,"training_evaluations":2588672},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":1140,"drift_accuracy":0.0,"expert_count":2,"expert_evaluations":-14336,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.6729822011358033,"reconstruction_rmse":0.5454456786975652,"retention_accuracy":0.0,"training_evaluations":-1691240},"pareto_relation":"mixed"},"matched_compute_fixed_topology":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.96875,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":0.796875,"planning_exact_state_rate":0.796875,"prediction_rmse":5.8634664885381,"reconstruction_rmse":5.345064728931394,"retention_accuracy":0.98046875,"training_evaluations":998808},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":1140,"drift_accuracy":0.03125,"expert_count":2,"expert_evaluations":0,"planning_belief_set_rate":0.203125,"planning_exact_state_rate":0.203125,"prediction_rmse":-1.5624298925113775,"reconstruction_rmse":-1.4858368893308307,"retention_accuracy":0.01953125,"training_evaluations":-101376},"pareto_relation":"mixed"},"matched_expert_count_capacity":{"metrics":{"checkpoint_size_bytes":44354,"drift_accuracy":1.0,"expert_count":66,"expert_evaluations":2048,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":3.6391094626293756,"reconstruction_rmse":3.3019226444048786,"retention_accuracy":1.0,"training_evaluations":2737152},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.6619271333973464,"reconstruction_rmse":0.5573051951956849,"retention_accuracy":0.0,"training_evaluations":-1839720},"pareto_relation":"mixed"},"nearest_centroid_16_no_recursive_births":{"metrics":{"checkpoint_size_bytes":15854,"drift_accuracy":0.29296875,"expert_count":16,"expert_evaluations":4096,"planning_belief_set_rate":0.453125,"planning_exact_state_rate":0.125,"prediction_rmse":25.672595842513108,"reconstruction_rmse":23.849566970604275,"retention_accuracy":0.296875,"training_evaluations":253952},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":28500,"drift_accuracy":0.70703125,"expert_count":50,"expert_evaluations":-2048,"planning_belief_set_rate":0.546875,"planning_exact_state_rate":0.875,"prediction_rmse":-21.371559246486385,"reconstruction_rmse":-19.99033913100371,"retention_accuracy":0.703125,"training_evaluations":643480},"pareto_relation":"mixed"},"no_adaptation_static":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.96875,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":0.796875,"planning_exact_state_rate":0.796875,"prediction_rmse":5.8634664885381,"reconstruction_rmse":5.345064728931394,"retention_accuracy":0.98046875,"training_evaluations":556440},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":1140,"drift_accuracy":0.03125,"expert_count":2,"expert_evaluations":0,"planning_belief_set_rate":0.203125,"planning_exact_state_rate":0.203125,"prediction_rmse":-1.5624298925113775,"reconstruction_rmse":-1.4858368893308307,"retention_accuracy":0.01953125,"training_evaluations":340992},"pareto_relation":"mixed"},"periodic_replay_policy":{"metrics":{"checkpoint_size_bytes":44354,"drift_accuracy":1.0,"expert_count":66,"expert_evaluations":2048,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":4.300402508592013,"reconstruction_rmse":3.8607771716899504,"retention_accuracy":1.0,"training_evaluations":1009560},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0006340874347090519,"reconstruction_rmse":-0.0015493320893869011,"retention_accuracy":0.0,"training_evaluations":-112128},"pareto_relation":"mixed"},"ravel_0_5_candidate":{"metrics":{"checkpoint_size_bytes":44354,"drift_accuracy":1.0,"expert_count":66,"expert_evaluations":2048,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":4.301036596026722,"reconstruction_rmse":3.8592278396005635,"retention_accuracy":1.0,"training_evaluations":897432},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"equivalent"},"ravel_complete_scan_without_certification":{"metrics":{"checkpoint_size_bytes":44354,"drift_accuracy":1.0,"expert_count":66,"expert_evaluations":16896,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":4.301036596026722,"reconstruction_rmse":3.8592278396005635,"retention_accuracy":1.0,"training_evaluations":1075608},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":-14848,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":-178176},"pareto_relation":"candidate_dominates"},"ravel_no_birth_same_replay_iterations":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.96875,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":0.796875,"planning_exact_state_rate":0.796875,"prediction_rmse":5.8634664885381,"reconstruction_rmse":5.345064728931394,"retention_accuracy":0.98046875,"training_evaluations":777624},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":1140,"drift_accuracy":0.03125,"expert_count":2,"expert_evaluations":0,"planning_belief_set_rate":0.203125,"planning_exact_state_rate":0.203125,"prediction_rmse":-1.5624298925113775,"reconstruction_rmse":-1.4858368893308307,"retention_accuracy":0.01953125,"training_evaluations":119808},"pareto_relation":"mixed"},"ravel_random_births":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.96875,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":0.796875,"planning_exact_state_rate":0.796875,"prediction_rmse":5.8634664885381,"reconstruction_rmse":5.345064728931394,"retention_accuracy":0.98046875,"training_evaluations":777624},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":1140,"drift_accuracy":0.03125,"expert_count":2,"expert_evaluations":0,"planning_belief_set_rate":0.203125,"planning_exact_state_rate":0.203125,"prediction_rmse":-1.5624298925113775,"reconstruction_rmse":-1.4858368893308307,"retention_accuracy":0.01953125,"training_evaluations":119808},"pareto_relation":"mixed"},"ravel_without_replay":{"metrics":{"checkpoint_size_bytes":44354,"drift_accuracy":1.0,"expert_count":66,"expert_evaluations":2048,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":4.301243950676882,"reconstruction_rmse":3.869808846871856,"retention_accuracy":1.0,"training_evaluations":858520},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":-0.00020735465015953025,"reconstruction_rmse":-0.01058100727129263,"retention_accuracy":0.0,"training_evaluations":38912},"pareto_relation":"mixed"},"ravel_without_retirement_matched_work":{"metrics":{"checkpoint_size_bytes":44354,"drift_accuracy":1.0,"expert_count":66,"expert_evaluations":2048,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":4.301036596026722,"reconstruction_rmse":3.8592278396005635,"retention_accuracy":1.0,"training_evaluations":897432},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"equivalent"}},"gates":[{"gate_id":"adaptation_completed","metric":"adaptation_completed","observed":true,"operator":"eq","pass":true,"rationale":"The bounded adaptation procedure must complete.","threshold":true},{"gate_id":"base_holdout_accuracy","metric":"base_accuracy","observed":0.96875,"operator":"ge","pass":true,"rationale":"The base representation must establish the bounded task before drift.","threshold":0.85},{"gate_id":"base_holdout_retention","metric":"retention_accuracy","observed":1.0,"operator":"ge","pass":true,"rationale":"Anchored base behavior may lose at most ten percentage points in absolute retained accuracy.","threshold":0.9},{"gate_id":"routing_oracle_equivalence","metric":"routing_mismatches","observed":0,"operator":"eq","pass":true,"rationale":"Every routed classification must agree with complete scan.","threshold":0},{"gate_id":"checkpoint_roundtrip","metric":"checkpoint_roundtrip","observed":true,"operator":"eq","pass":true,"rationale":"Canonical in-memory restoration must succeed.","threshold":true},{"gate_id":"checkpoint_identity","metric":"checkpoint_identity","observed":true,"operator":"eq","pass":true,"rationale":"Restored complete model identity must match.","threshold":true},{"gate_id":"checkpoint_behavior","metric":"checkpoint_behavior","observed":true,"operator":"eq","pass":true,"rationale":"Restored evaluation and planning behavior must match.","threshold":true},{"gate_id":"checkpoint_mutation_rejection","metric":"checkpoint_mutations","observed":true,"operator":"eq","pass":true,"rationale":"Every declared behavioral and byte-level checkpoint mutation must be detected.","threshold":true},{"gate_id":"lineage_invariants","metric":"lineage_invariants","observed":true,"operator":"eq","pass":true,"rationale":"Generation, lineage uniqueness, descendant splitting, and deterministic topology invariants must hold.","threshold":true},{"gate_id":"unsupported_transitions_unknown","metric":"unsupported_graph_edge_violations","observed":0,"operator":"eq","pass":true,"rationale":"Unsupported actions cannot enter the planning graph.","threshold":0},{"gate_id":"replay_size","metric":"replay_selected","observed":256,"operator":"eq","pass":true,"rationale":"The declared replay budget must be filled on the non-sparse trial corpus.","threshold":256},{"gate_id":"replay_unique","metric":"replay_unique","observed":256,"operator":"eq","pass":true,"rationale":"Balanced replay cannot introduce accidental duplicates.","threshold":256},{"gate_id":"replay_label_coverage","metric":"replay_labels_covered","observed":8,"operator":"eq","pass":true,"rationale":"Replay must retain every declared label.","threshold":8},{"gate_id":"replay_action_coverage","metric":"replay_actions_covered","observed":4,"operator":"eq","pass":true,"rationale":"Replay must retain every declared action.","threshold":4},{"gate_id":"replay_state_coverage","metric":"replay_states_covered","observed":64,"operator":"ge","pass":true,"rationale":"Replay must cover at least 60 of 64 source states.","threshold":60},{"gate_id":"replay_expert_coverage","metric":"replay_experts_covered","observed":63,"operator":"ge","pass":true,"rationale":"Replay must retain broad assigned-expert coverage.","threshold":60},{"gate_id":"replay_transition_coverage","metric":"replay_transition_pairs_covered","observed":255,"operator":"ge","pass":true,"rationale":"Replay must preserve broad source-state/action transition support.","threshold":220},{"gate_id":"planning_path_found","metric":"path_found_rate","observed":1.0,"operator":"ge","pass":true,"rationale":"At least three quarters of bounded planning cases must have a supported path.","threshold":0.75},{"gate_id":"expert_capacity","metric":"expert_count","observed":66,"operator":"le","pass":true,"rationale":"Adaptation cannot exceed the declared expert capacity.","threshold":80},{"gate_id":"retirement_budget","metric":"accepted_retirements","observed":0,"operator":"le","pass":true,"rationale":"Retirement remains optional and bounded.","threshold":4},{"gate_id":"topology_objective_non_degradation","metric":"topology_objective_gain_q20","observed":8915,"operator":"ge","pass":true,"rationale":"Accepted adaptation-training topology decisions cannot reduce their declared objective.","threshold":0},{"gate_id":"matched_compute_budget","metric":"matched_compute_training_evaluation_ratio","observed":0.8985030155945888,"operator":"le","pass":true,"rationale":"Candidate training work may exceed the matched fixed-topology budget by at most ten percent.","threshold":1.1},{"gate_id":"conditional_inference_efficiency","metric":"inference_evaluation_ratio_vs_flat64","observed":0.125,"operator":"le","pass":true,"rationale":"Routed inference must use at most one quarter of flat complete-scan expert evaluations.","threshold":0.25},{"gate_id":"separated_accuracy","metric":"adapted_drift_accuracy","observed":1.0,"operator":"ge","pass":true,"rationale":"The separated-state task remains high-accuracy after adaptation.","threshold":0.9},{"gate_id":"separated_non_inferiority","metric":"drift_accuracy_delta","observed":0.03125,"operator":"ge","pass":true,"rationale":"An already strong static model must not lose more than two points.","threshold":-0.02},{"gate_id":"separated_headroom","metric":"headroom_normalized_accuracy_improvement","observed":1.0,"operator":"ge","pass":true,"rationale":"Available accuracy headroom cannot worsen.","threshold":0},{"gate_id":"separated_reconstruction","metric":"reconstruction_improvement_ratio","observed":0.2779829552462473,"operator":"ge","pass":true,"rationale":"Adaptation cannot worsen separated-state reconstruction.","threshold":0},{"gate_id":"separated_prediction","metric":"prediction_improvement_ratio","observed":0.2664686317497703,"operator":"ge","pass":true,"rationale":"Adaptation cannot worsen separated-state prediction.","threshold":0},{"gate_id":"separated_exact_planning","metric":"exact_state_rate","observed":1.0,"operator":"ge","pass":true,"rationale":"Separated observations support an exact-state capability gate.","threshold":0.65},{"gate_id":"separated_bounded_births","metric":"accepted_births","observed":2,"operator":"le","pass":true,"rationale":"The low-drift regime cannot consume the full topology budget.","threshold":12}],"metrics":{"accepted_births":2,"accepted_retirements":0,"adaptation_completed":true,"adaptation_training_accuracy":1.0,"adapted_drift_accuracy":1.0,"adapted_prediction_rmse":4.301036596026722,"adapted_reconstruction_rmse":3.8592278396005635,"adapted_transition_accuracy":0.9694323144104804,"balanced_vs_periodic_drift_accuracy_delta":0.0,"balanced_vs_periodic_retention_delta":0.0,"base_accuracy":0.96875,"base_prediction_rmse":5.349123153719768,"base_reconstruction_rmse":4.925789999916267,"belief_set_rate":1.0,"belief_set_rate_delta":0.203125,"checkpoint_behavior":true,"checkpoint_identity":true,"checkpoint_mutations":true,"checkpoint_roundtrip":true,"checkpoint_size_bytes":44354,"drift_accuracy_delta":0.03125,"exact_state_rate":1.0,"exact_state_rate_delta":0.203125,"expert_count":66,"headroom_normalized_accuracy_improvement":1.0,"inference_evaluation_ratio_vs_flat64":0.125,"inference_expert_evaluations":2048,"lineage_invariants":true,"matched_compute_drift_accuracy_delta":0.03125,"matched_compute_retention_delta":0.01953125,"matched_compute_training_evaluation_ratio":0.8985030155945888,"no_birth_drift_accuracy_delta":0.03125,"no_retirement_drift_accuracy_delta":0.0,"path_found_rate":1.0,"prediction_improvement_ratio":0.2664686317497703,"reconstruction_improvement_ratio":0.2779829552462473,"replay_actions_covered":4,"replay_experts_covered":63,"replay_labels_covered":8,"replay_selected":256,"replay_states_covered":64,"replay_transition_pairs_covered":255,"replay_unique":256,"retention_accuracy":1.0,"retention_accuracy_delta_from_base":0.03125,"retention_prediction_degradation":-1.467872502285855,"retention_prediction_rmse":3.881250651433913,"retention_reconstruction_degradation_ratio":-0.27251173884261676,"retention_reconstruction_rmse":3.583454401865512,"retention_transition_accuracy_delta":0.008438360133275369,"routing_mismatches":0,"static_belief_set_rate":0.796875,"static_drift_accuracy":0.96875,"static_exact_state_rate":0.796875,"static_prediction_rmse":5.8634664885381,"static_reconstruction_rmse":5.345064728931394,"static_transition_accuracy":0.9523809523809523,"topology_objective_gain_q20":8915,"training_evaluations":897432,"transition_accuracy_delta":0.01705136202952806,"transition_support_rate":0.89453125,"unsupported_graph_edge_violations":0},"regime":"separated_state","seed":"0x45894249803b385a","trial_id":"validation-separated-03","trial_result":"PASS"},{"comparisons":{"fixed_8_expert":{"metrics":{"checkpoint_size_bytes":11294,"drift_accuracy":0.2734375,"expert_count":8,"expert_evaluations":2048,"planning_belief_set_rate":0.390625,"planning_exact_state_rate":0.09375,"prediction_rmse":31.430408198491687,"reconstruction_rmse":29.484334777726954,"retention_accuracy":0.24609375,"training_evaluations":94208},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":35910,"drift_accuracy":0.7265625,"expert_count":63,"expert_evaluations":0,"planning_belief_set_rate":0.53125,"planning_exact_state_rate":0.828125,"prediction_rmse":-26.71173573167293,"reconstruction_rmse":-25.266076469255427,"retention_accuracy":0.75390625,"training_evaluations":1519968},"pareto_relation":"mixed"},"fixed_topology_64_expert_routed":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":1.0,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":3.5186377304047984,"reconstruction_rmse":3.3155326158729337,"retention_accuracy":1.0,"training_evaluations":2588672},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":3990,"drift_accuracy":0.0,"expert_count":7,"expert_evaluations":0,"planning_belief_set_rate":-0.078125,"planning_exact_state_rate":-0.078125,"prediction_rmse":1.2000347364139565,"reconstruction_rmse":0.9027256925985934,"retention_accuracy":0.0,"training_evaluations":-974496},"pareto_relation":"mixed"},"flat_64_expert_complete_scan":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":1.0,"expert_count":64,"expert_evaluations":16384,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":3.5186377304047984,"reconstruction_rmse":3.3155326158729337,"retention_accuracy":1.0,"training_evaluations":2588672},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":3990,"drift_accuracy":0.0,"expert_count":7,"expert_evaluations":-14336,"planning_belief_set_rate":-0.078125,"planning_exact_state_rate":-0.078125,"prediction_rmse":1.2000347364139565,"reconstruction_rmse":0.9027256925985934,"retention_accuracy":0.0,"training_evaluations":-974496},"pareto_relation":"mixed"},"matched_compute_fixed_topology":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.921875,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":0.515625,"planning_exact_state_rate":0.5,"prediction_rmse":7.6014724292752875,"reconstruction_rmse":7.1750888943733875,"retention_accuracy":0.9375,"training_evaluations":1660256},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":3990,"drift_accuracy":0.078125,"expert_count":7,"expert_evaluations":0,"planning_belief_set_rate":0.40625,"planning_exact_state_rate":0.421875,"prediction_rmse":-2.8827999624565326,"reconstruction_rmse":-2.9568305859018604,"retention_accuracy":0.0625,"training_evaluations":-46080},"pareto_relation":"mixed"},"matched_expert_count_capacity":{"metrics":{"checkpoint_size_bytes":47204,"drift_accuracy":1.0,"expert_count":71,"expert_evaluations":2048,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":3.5315866626154437,"reconstruction_rmse":3.309837134907444,"retention_accuracy":1.0,"training_evaluations":3126272},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":-0.078125,"planning_exact_state_rate":-0.078125,"prediction_rmse":1.1870858042033112,"reconstruction_rmse":0.9084211735640833,"retention_accuracy":0.0,"training_evaluations":-1512096},"pareto_relation":"mixed"},"nearest_centroid_16_no_recursive_births":{"metrics":{"checkpoint_size_bytes":15854,"drift_accuracy":0.28515625,"expert_count":16,"expert_evaluations":4096,"planning_belief_set_rate":0.3125,"planning_exact_state_rate":0.078125,"prediction_rmse":26.330013326699643,"reconstruction_rmse":24.161483452924116,"retention_accuracy":0.3046875,"training_evaluations":253952},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":31350,"drift_accuracy":0.71484375,"expert_count":55,"expert_evaluations":-2048,"planning_belief_set_rate":0.609375,"planning_exact_state_rate":0.84375,"prediction_rmse":-21.611340859880887,"reconstruction_rmse":-19.94322514445259,"retention_accuracy":0.6953125,"training_evaluations":1360224},"pareto_relation":"mixed"},"no_adaptation_static":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.921875,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":0.515625,"planning_exact_state_rate":0.5,"prediction_rmse":7.6014724292752875,"reconstruction_rmse":7.1750888943733875,"retention_accuracy":0.9375,"training_evaluations":554336},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":3990,"drift_accuracy":0.078125,"expert_count":7,"expert_evaluations":0,"planning_belief_set_rate":0.40625,"planning_exact_state_rate":0.421875,"prediction_rmse":-2.8827999624565326,"reconstruction_rmse":-2.9568305859018604,"retention_accuracy":0.0625,"training_evaluations":1059840},"pareto_relation":"mixed"},"periodic_replay_policy":{"metrics":{"checkpoint_size_bytes":47774,"drift_accuracy":1.0,"expert_count":72,"expert_evaluations":2048,"planning_belief_set_rate":0.921875,"planning_exact_state_rate":0.921875,"prediction_rmse":4.720537537206336,"reconstruction_rmse":4.222948304479186,"retention_accuracy":1.0,"training_evaluations":1867616},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":-570,"drift_accuracy":0.0,"expert_count":-1,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":-0.0018650703875806585,"reconstruction_rmse":-0.0046899960076585145,"retention_accuracy":0.0,"training_evaluations":-253440},"pareto_relation":"candidate_dominates"},"ravel_0_5_candidate":{"metrics":{"checkpoint_size_bytes":47204,"drift_accuracy":1.0,"expert_count":71,"expert_evaluations":2048,"planning_belief_set_rate":0.921875,"planning_exact_state_rate":0.921875,"prediction_rmse":4.718672466818755,"reconstruction_rmse":4.218258308471527,"retention_accuracy":1.0,"training_evaluations":1614176},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"equivalent"},"ravel_complete_scan_without_certification":{"metrics":{"checkpoint_size_bytes":47204,"drift_accuracy":1.0,"expert_count":71,"expert_evaluations":18176,"planning_belief_set_rate":0.921875,"planning_exact_state_rate":0.921875,"prediction_rmse":4.718672466818755,"reconstruction_rmse":4.218258308471527,"retention_accuracy":1.0,"training_evaluations":1807712},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":-16128,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":-193536},"pareto_relation":"candidate_dominates"},"ravel_no_birth_same_replay_iterations":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.921875,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":0.515625,"planning_exact_state_rate":0.5,"prediction_rmse":7.6014724292752875,"reconstruction_rmse":7.1750888943733875,"retention_accuracy":0.9375,"training_evaluations":775520},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":3990,"drift_accuracy":0.078125,"expert_count":7,"expert_evaluations":0,"planning_belief_set_rate":0.40625,"planning_exact_state_rate":0.421875,"prediction_rmse":-2.8827999624565326,"reconstruction_rmse":-2.9568305859018604,"retention_accuracy":0.0625,"training_evaluations":838656},"pareto_relation":"mixed"},"ravel_random_births":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.921875,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":0.515625,"planning_exact_state_rate":0.5,"prediction_rmse":7.6014724292752875,"reconstruction_rmse":7.1750888943733875,"retention_accuracy":0.9375,"training_evaluations":775520},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":3990,"drift_accuracy":0.078125,"expert_count":7,"expert_evaluations":0,"planning_belief_set_rate":0.40625,"planning_exact_state_rate":0.421875,"prediction_rmse":-2.8827999624565326,"reconstruction_rmse":-2.9568305859018604,"retention_accuracy":0.0625,"training_evaluations":838656},"pareto_relation":"mixed"},"ravel_without_replay":{"metrics":{"checkpoint_size_bytes":47774,"drift_accuracy":1.0,"expert_count":72,"expert_evaluations":2048,"planning_belief_set_rate":0.921875,"planning_exact_state_rate":0.921875,"prediction_rmse":4.756649507051139,"reconstruction_rmse":4.225961049865905,"retention_accuracy":1.0,"training_evaluations":1344864},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":-570,"drift_accuracy":0.0,"expert_count":-1,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":-0.03797704023238424,"reconstruction_rmse":-0.007702741394377988,"retention_accuracy":0.0,"training_evaluations":269312},"pareto_relation":"mixed"},"ravel_without_retirement_matched_work":{"metrics":{"checkpoint_size_bytes":47204,"drift_accuracy":1.0,"expert_count":71,"expert_evaluations":2048,"planning_belief_set_rate":0.921875,"planning_exact_state_rate":0.921875,"prediction_rmse":4.718672466818755,"reconstruction_rmse":4.218258308471527,"retention_accuracy":1.0,"training_evaluations":1614176},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"equivalent"}},"gates":[{"gate_id":"adaptation_completed","metric":"adaptation_completed","observed":true,"operator":"eq","pass":true,"rationale":"The bounded adaptation procedure must complete.","threshold":true},{"gate_id":"base_holdout_accuracy","metric":"base_accuracy","observed":0.91015625,"operator":"ge","pass":true,"rationale":"The base representation must establish the bounded task before drift.","threshold":0.85},{"gate_id":"base_holdout_retention","metric":"retention_accuracy","observed":1.0,"operator":"ge","pass":true,"rationale":"Anchored base behavior may lose at most ten percentage points in absolute retained accuracy.","threshold":0.9},{"gate_id":"routing_oracle_equivalence","metric":"routing_mismatches","observed":0,"operator":"eq","pass":true,"rationale":"Every routed classification must agree with complete scan.","threshold":0},{"gate_id":"checkpoint_roundtrip","metric":"checkpoint_roundtrip","observed":true,"operator":"eq","pass":true,"rationale":"Canonical in-memory restoration must succeed.","threshold":true},{"gate_id":"checkpoint_identity","metric":"checkpoint_identity","observed":true,"operator":"eq","pass":true,"rationale":"Restored complete model identity must match.","threshold":true},{"gate_id":"checkpoint_behavior","metric":"checkpoint_behavior","observed":true,"operator":"eq","pass":true,"rationale":"Restored evaluation and planning behavior must match.","threshold":true},{"gate_id":"checkpoint_mutation_rejection","metric":"checkpoint_mutations","observed":true,"operator":"eq","pass":true,"rationale":"Every declared behavioral and byte-level checkpoint mutation must be detected.","threshold":true},{"gate_id":"lineage_invariants","metric":"lineage_invariants","observed":true,"operator":"eq","pass":true,"rationale":"Generation, lineage uniqueness, descendant splitting, and deterministic topology invariants must hold.","threshold":true},{"gate_id":"unsupported_transitions_unknown","metric":"unsupported_graph_edge_violations","observed":0,"operator":"eq","pass":true,"rationale":"Unsupported actions cannot enter the planning graph.","threshold":0},{"gate_id":"replay_size","metric":"replay_selected","observed":256,"operator":"eq","pass":true,"rationale":"The declared replay budget must be filled on the non-sparse trial corpus.","threshold":256},{"gate_id":"replay_unique","metric":"replay_unique","observed":256,"operator":"eq","pass":true,"rationale":"Balanced replay cannot introduce accidental duplicates.","threshold":256},{"gate_id":"replay_label_coverage","metric":"replay_labels_covered","observed":8,"operator":"eq","pass":true,"rationale":"Replay must retain every declared label.","threshold":8},{"gate_id":"replay_action_coverage","metric":"replay_actions_covered","observed":4,"operator":"eq","pass":true,"rationale":"Replay must retain every declared action.","threshold":4},{"gate_id":"replay_state_coverage","metric":"replay_states_covered","observed":64,"operator":"ge","pass":true,"rationale":"Replay must cover at least 60 of 64 source states.","threshold":60},{"gate_id":"replay_expert_coverage","metric":"replay_experts_covered","observed":64,"operator":"ge","pass":true,"rationale":"Replay must retain broad assigned-expert coverage.","threshold":60},{"gate_id":"replay_transition_coverage","metric":"replay_transition_pairs_covered","observed":250,"operator":"ge","pass":true,"rationale":"Replay must preserve broad source-state/action transition support.","threshold":220},{"gate_id":"planning_path_found","metric":"path_found_rate","observed":1.0,"operator":"ge","pass":true,"rationale":"At least three quarters of bounded planning cases must have a supported path.","threshold":0.75},{"gate_id":"expert_capacity","metric":"expert_count","observed":71,"operator":"le","pass":true,"rationale":"Adaptation cannot exceed the declared expert capacity.","threshold":80},{"gate_id":"retirement_budget","metric":"accepted_retirements","observed":0,"operator":"le","pass":true,"rationale":"Retirement remains optional and bounded.","threshold":4},{"gate_id":"topology_objective_non_degradation","metric":"topology_objective_gain_q20","observed":34218,"operator":"ge","pass":true,"rationale":"Accepted adaptation-training topology decisions cannot reduce their declared objective.","threshold":0},{"gate_id":"matched_compute_budget","metric":"matched_compute_training_evaluation_ratio","observed":0.9722452441069329,"operator":"le","pass":true,"rationale":"Candidate training work may exceed the matched fixed-topology budget by at most ten percent.","threshold":1.1},{"gate_id":"conditional_inference_efficiency","metric":"inference_evaluation_ratio_vs_flat64","observed":0.125,"operator":"le","pass":true,"rationale":"Routed inference must use at most one quarter of flat complete-scan expert evaluations.","threshold":0.25},{"gate_id":"separated_accuracy","metric":"adapted_drift_accuracy","observed":1.0,"operator":"ge","pass":true,"rationale":"The separated-state task remains high-accuracy after adaptation.","threshold":0.9},{"gate_id":"separated_non_inferiority","metric":"drift_accuracy_delta","observed":0.078125,"operator":"ge","pass":true,"rationale":"An already strong static model must not lose more than two points.","threshold":-0.02},{"gate_id":"separated_headroom","metric":"headroom_normalized_accuracy_improvement","observed":1.0,"operator":"ge","pass":true,"rationale":"Available accuracy headroom cannot worsen.","threshold":0},{"gate_id":"separated_reconstruction","metric":"reconstruction_improvement_ratio","observed":0.41209671816339016,"operator":"ge","pass":true,"rationale":"Adaptation cannot worsen separated-state reconstruction.","threshold":0},{"gate_id":"separated_prediction","metric":"prediction_improvement_ratio","observed":0.3792423098654025,"operator":"ge","pass":true,"rationale":"Adaptation cannot worsen separated-state prediction.","threshold":0},{"gate_id":"separated_exact_planning","metric":"exact_state_rate","observed":0.921875,"operator":"ge","pass":true,"rationale":"Separated observations support an exact-state capability gate.","threshold":0.65},{"gate_id":"separated_bounded_births","metric":"accepted_births","observed":7,"operator":"le","pass":true,"rationale":"The low-drift regime cannot consume the full topology budget.","threshold":12}],"metrics":{"accepted_births":7,"accepted_retirements":0,"adaptation_completed":true,"adaptation_training_accuracy":1.0,"adapted_drift_accuracy":1.0,"adapted_prediction_rmse":4.718672466818755,"adapted_reconstruction_rmse":4.218258308471527,"adapted_transition_accuracy":0.9344978165938864,"balanced_vs_periodic_drift_accuracy_delta":0.0,"balanced_vs_periodic_retention_delta":0.0,"base_accuracy":0.91015625,"base_prediction_rmse":8.167591816882357,"base_reconstruction_rmse":7.750454963890528,"belief_set_rate":0.921875,"belief_set_rate_delta":0.40625,"checkpoint_behavior":true,"checkpoint_identity":true,"checkpoint_mutations":true,"checkpoint_roundtrip":true,"checkpoint_size_bytes":47204,"drift_accuracy_delta":0.078125,"exact_state_rate":0.921875,"exact_state_rate_delta":0.421875,"expert_count":71,"headroom_normalized_accuracy_improvement":1.0,"inference_evaluation_ratio_vs_flat64":0.125,"inference_expert_evaluations":2048,"lineage_invariants":true,"matched_compute_drift_accuracy_delta":0.078125,"matched_compute_retention_delta":0.0625,"matched_compute_training_evaluation_ratio":0.9722452441069329,"no_birth_drift_accuracy_delta":0.078125,"no_retirement_drift_accuracy_delta":0.0,"path_found_rate":1.0,"prediction_improvement_ratio":0.3792423098654025,"reconstruction_improvement_ratio":0.41209671816339016,"replay_actions_covered":4,"replay_experts_covered":64,"replay_labels_covered":8,"replay_selected":256,"replay_states_covered":64,"replay_transition_pairs_covered":250,"replay_unique":256,"retention_accuracy":1.0,"retention_accuracy_delta_from_base":0.08984375,"retention_prediction_degradation":-2.6921712887121405,"retention_prediction_rmse":5.475420528170217,"retention_reconstruction_degradation_ratio":-0.3902230706501599,"retention_reconstruction_rmse":4.726048628945392,"retention_transition_accuracy_delta":0.0448160535117057,"routing_mismatches":0,"static_belief_set_rate":0.515625,"static_drift_accuracy":0.921875,"static_exact_state_rate":0.5,"static_prediction_rmse":7.6014724292752875,"static_reconstruction_rmse":7.1750888943733875,"static_transition_accuracy":0.896551724137931,"topology_objective_gain_q20":34218,"training_evaluations":1614176,"transition_accuracy_delta":0.03794609245595537,"transition_support_rate":0.89453125,"unsupported_graph_edge_violations":0},"regime":"separated_state","seed":"0x6b14192d06857894","trial_id":"validation-separated-04","trial_result":"PASS"},{"comparisons":{"fixed_8_expert":{"metrics":{"checkpoint_size_bytes":11294,"drift_accuracy":0.17578125,"expert_count":8,"expert_evaluations":2048,"planning_belief_set_rate":0.609375,"planning_exact_state_rate":0.03125,"prediction_rmse":17.489545522396163,"reconstruction_rmse":16.28604032428515,"retention_accuracy":0.13671875,"training_evaluations":94208},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":35910,"drift_accuracy":0.82421875,"expert_count":63,"expert_evaluations":693,"planning_belief_set_rate":0.390625,"planning_exact_state_rate":0.96875,"prediction_rmse":-11.94825371559542,"reconstruction_rmse":-11.391916209161165,"retention_accuracy":0.86328125,"training_evaluations":1627120},"pareto_relation":"mixed"},"fixed_topology_64_expert_routed":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":1.0,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":4.79028270046684,"reconstruction_rmse":4.4520462896820625,"retention_accuracy":1.0,"training_evaluations":2588672},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":3990,"drift_accuracy":0.0,"expert_count":7,"expert_evaluations":693,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.7510091063339042,"reconstruction_rmse":0.4420778254419222,"retention_accuracy":0.0,"training_evaluations":-867344},"pareto_relation":"mixed"},"flat_64_expert_complete_scan":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":1.0,"expert_count":64,"expert_evaluations":16384,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":4.79028270046684,"reconstruction_rmse":4.4520462896820625,"retention_accuracy":1.0,"training_evaluations":2588672},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":3990,"drift_accuracy":0.0,"expert_count":7,"expert_evaluations":-13643,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.7510091063339042,"reconstruction_rmse":0.4420778254419222,"retention_accuracy":0.0,"training_evaluations":-867344},"pareto_relation":"mixed"},"matched_compute_fixed_topology":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.94140625,"expert_count":64,"expert_evaluations":3504,"planning_belief_set_rate":0.6875,"planning_exact_state_rate":0.65625,"prediction_rmse":6.439104575734127,"reconstruction_rmse":5.469963279826349,"retention_accuracy":0.93359375,"training_evaluations":1805608},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":3990,"drift_accuracy":0.05859375,"expert_count":7,"expert_evaluations":-763,"planning_belief_set_rate":0.3125,"planning_exact_state_rate":0.34375,"prediction_rmse":-0.8978127689333837,"reconstruction_rmse":-0.575839164702364,"retention_accuracy":0.06640625,"training_evaluations":-84280},"pareto_relation":"mixed"},"matched_expert_count_capacity":{"metrics":{"checkpoint_size_bytes":47204,"drift_accuracy":1.0,"expert_count":71,"expert_evaluations":2048,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":4.828509592476432,"reconstruction_rmse":4.452478561464295,"retention_accuracy":1.0,"training_evaluations":3126272},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":693,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.7127822143243119,"reconstruction_rmse":0.44164555365968994,"retention_accuracy":0.0,"training_evaluations":-1404944},"pareto_relation":"mixed"},"nearest_centroid_16_no_recursive_births":{"metrics":{"checkpoint_size_bytes":15854,"drift_accuracy":0.28515625,"expert_count":16,"expert_evaluations":4096,"planning_belief_set_rate":1.0,"planning_exact_state_rate":0.3125,"prediction_rmse":12.066407149433863,"reconstruction_rmse":11.85779000159169,"retention_accuracy":0.22265625,"training_evaluations":253952},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":31350,"drift_accuracy":0.71484375,"expert_count":55,"expert_evaluations":-1355,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.6875,"prediction_rmse":-6.525115342633119,"reconstruction_rmse":-6.963665886467705,"retention_accuracy":0.77734375,"training_evaluations":1467376},"pareto_relation":"mixed"},"no_adaptation_static":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.94140625,"expert_count":64,"expert_evaluations":3504,"planning_belief_set_rate":0.6875,"planning_exact_state_rate":0.65625,"prediction_rmse":6.439104575734127,"reconstruction_rmse":5.469963279826349,"retention_accuracy":0.93359375,"training_evaluations":623528},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":3990,"drift_accuracy":0.05859375,"expert_count":7,"expert_evaluations":-763,"planning_belief_set_rate":0.3125,"planning_exact_state_rate":0.34375,"prediction_rmse":-0.8978127689333837,"reconstruction_rmse":-0.575839164702364,"retention_accuracy":0.06640625,"training_evaluations":1097800},"pareto_relation":"mixed"},"periodic_replay_policy":{"metrics":{"checkpoint_size_bytes":47204,"drift_accuracy":1.0,"expert_count":71,"expert_evaluations":2741,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":5.542778120152196,"reconstruction_rmse":4.889288776393222,"retention_accuracy":1.0,"training_evaluations":1719610},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":-0.0014863133514522175,"reconstruction_rmse":0.004835338730762473,"retention_accuracy":0.0,"training_evaluations":1718},"pareto_relation":"mixed"},"ravel_0_5_candidate":{"metrics":{"checkpoint_size_bytes":47204,"drift_accuracy":1.0,"expert_count":71,"expert_evaluations":2741,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":5.541291806800744,"reconstruction_rmse":4.894124115123985,"retention_accuracy":1.0,"training_evaluations":1721328},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"equivalent"},"ravel_complete_scan_without_certification":{"metrics":{"checkpoint_size_bytes":47204,"drift_accuracy":1.0,"expert_count":71,"expert_evaluations":18176,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":5.541291806800744,"reconstruction_rmse":4.894124115123985,"retention_accuracy":1.0,"training_evaluations":1907808},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":-15435,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":-186480},"pareto_relation":"candidate_dominates"},"ravel_no_birth_same_replay_iterations":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.94140625,"expert_count":64,"expert_evaluations":3504,"planning_belief_set_rate":0.6875,"planning_exact_state_rate":0.65625,"prediction_rmse":6.439104575734127,"reconstruction_rmse":5.469963279826349,"retention_accuracy":0.93359375,"training_evaluations":859944},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":3990,"drift_accuracy":0.05859375,"expert_count":7,"expert_evaluations":-763,"planning_belief_set_rate":0.3125,"planning_exact_state_rate":0.34375,"prediction_rmse":-0.8978127689333837,"reconstruction_rmse":-0.575839164702364,"retention_accuracy":0.06640625,"training_evaluations":861384},"pareto_relation":"mixed"},"ravel_random_births":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.94140625,"expert_count":64,"expert_evaluations":3504,"planning_belief_set_rate":0.6875,"planning_exact_state_rate":0.65625,"prediction_rmse":6.439104575734127,"reconstruction_rmse":5.469963279826349,"retention_accuracy":0.93359375,"training_evaluations":859944},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":3990,"drift_accuracy":0.05859375,"expert_count":7,"expert_evaluations":-763,"planning_belief_set_rate":0.3125,"planning_exact_state_rate":0.34375,"prediction_rmse":-0.8978127689333837,"reconstruction_rmse":-0.575839164702364,"retention_accuracy":0.06640625,"training_evaluations":861384},"pareto_relation":"mixed"},"ravel_without_replay":{"metrics":{"checkpoint_size_bytes":47204,"drift_accuracy":1.0,"expert_count":71,"expert_evaluations":2741,"planning_belief_set_rate":0.984375,"planning_exact_state_rate":0.984375,"prediction_rmse":5.541728844038701,"reconstruction_rmse":4.89709640388984,"retention_accuracy":1.0,"training_evaluations":1355172},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.015625,"planning_exact_state_rate":0.015625,"prediction_rmse":-0.000437037237957405,"reconstruction_rmse":-0.0029722887658554242,"retention_accuracy":0.0,"training_evaluations":366156},"pareto_relation":"mixed"},"ravel_without_retirement_matched_work":{"metrics":{"checkpoint_size_bytes":47204,"drift_accuracy":1.0,"expert_count":71,"expert_evaluations":2741,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":5.541291806800744,"reconstruction_rmse":4.894124115123985,"retention_accuracy":1.0,"training_evaluations":1721328},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"equivalent"}},"gates":[{"gate_id":"adaptation_completed","metric":"adaptation_completed","observed":true,"operator":"eq","pass":true,"rationale":"The bounded adaptation procedure must complete.","threshold":true},{"gate_id":"base_holdout_accuracy","metric":"base_accuracy","observed":0.9453125,"operator":"ge","pass":true,"rationale":"The base representation must establish the bounded task before drift.","threshold":0.85},{"gate_id":"base_holdout_retention","metric":"retention_accuracy","observed":1.0,"operator":"ge","pass":true,"rationale":"Anchored base behavior may lose at most ten percentage points in absolute retained accuracy.","threshold":0.9},{"gate_id":"routing_oracle_equivalence","metric":"routing_mismatches","observed":0,"operator":"eq","pass":true,"rationale":"Every routed classification must agree with complete scan.","threshold":0},{"gate_id":"checkpoint_roundtrip","metric":"checkpoint_roundtrip","observed":true,"operator":"eq","pass":true,"rationale":"Canonical in-memory restoration must succeed.","threshold":true},{"gate_id":"checkpoint_identity","metric":"checkpoint_identity","observed":true,"operator":"eq","pass":true,"rationale":"Restored complete model identity must match.","threshold":true},{"gate_id":"checkpoint_behavior","metric":"checkpoint_behavior","observed":true,"operator":"eq","pass":true,"rationale":"Restored evaluation and planning behavior must match.","threshold":true},{"gate_id":"checkpoint_mutation_rejection","metric":"checkpoint_mutations","observed":true,"operator":"eq","pass":true,"rationale":"Every declared behavioral and byte-level checkpoint mutation must be detected.","threshold":true},{"gate_id":"lineage_invariants","metric":"lineage_invariants","observed":true,"operator":"eq","pass":true,"rationale":"Generation, lineage uniqueness, descendant splitting, and deterministic topology invariants must hold.","threshold":true},{"gate_id":"unsupported_transitions_unknown","metric":"unsupported_graph_edge_violations","observed":0,"operator":"eq","pass":true,"rationale":"Unsupported actions cannot enter the planning graph.","threshold":0},{"gate_id":"replay_size","metric":"replay_selected","observed":256,"operator":"eq","pass":true,"rationale":"The declared replay budget must be filled on the non-sparse trial corpus.","threshold":256},{"gate_id":"replay_unique","metric":"replay_unique","observed":256,"operator":"eq","pass":true,"rationale":"Balanced replay cannot introduce accidental duplicates.","threshold":256},{"gate_id":"replay_label_coverage","metric":"replay_labels_covered","observed":8,"operator":"eq","pass":true,"rationale":"Replay must retain every declared label.","threshold":8},{"gate_id":"replay_action_coverage","metric":"replay_actions_covered","observed":4,"operator":"eq","pass":true,"rationale":"Replay must retain every declared action.","threshold":4},{"gate_id":"replay_state_coverage","metric":"replay_states_covered","observed":64,"operator":"ge","pass":true,"rationale":"Replay must cover at least 60 of 64 source states.","threshold":60},{"gate_id":"replay_expert_coverage","metric":"replay_experts_covered","observed":64,"operator":"ge","pass":true,"rationale":"Replay must retain broad assigned-expert coverage.","threshold":60},{"gate_id":"replay_transition_coverage","metric":"replay_transition_pairs_covered","observed":247,"operator":"ge","pass":true,"rationale":"Replay must preserve broad source-state/action transition support.","threshold":220},{"gate_id":"planning_path_found","metric":"path_found_rate","observed":1.0,"operator":"ge","pass":true,"rationale":"At least three quarters of bounded planning cases must have a supported path.","threshold":0.75},{"gate_id":"expert_capacity","metric":"expert_count","observed":71,"operator":"le","pass":true,"rationale":"Adaptation cannot exceed the declared expert capacity.","threshold":80},{"gate_id":"retirement_budget","metric":"accepted_retirements","observed":0,"operator":"le","pass":true,"rationale":"Retirement remains optional and bounded.","threshold":4},{"gate_id":"topology_objective_non_degradation","metric":"topology_objective_gain_q20","observed":17094,"operator":"ge","pass":true,"rationale":"Accepted adaptation-training topology decisions cannot reduce their declared objective.","threshold":0},{"gate_id":"matched_compute_budget","metric":"matched_compute_training_evaluation_ratio","observed":0.9533232019353037,"operator":"le","pass":true,"rationale":"Candidate training work may exceed the matched fixed-topology budget by at most ten percent.","threshold":1.1},{"gate_id":"conditional_inference_efficiency","metric":"inference_evaluation_ratio_vs_flat64","observed":0.16729736328125,"operator":"le","pass":true,"rationale":"Routed inference must use at most one quarter of flat complete-scan expert evaluations.","threshold":0.25},{"gate_id":"overlap_accuracy","metric":"adapted_drift_accuracy","observed":1.0,"operator":"ge","pass":true,"rationale":"Overlap must retain high adapted classification.","threshold":0.9},{"gate_id":"overlap_non_inferiority","metric":"drift_accuracy_delta","observed":0.05859375,"operator":"ge","pass":true,"rationale":"Limited headroom uses non-inferiority rather than a fixed gain.","threshold":-0.02},{"gate_id":"overlap_headroom","metric":"headroom_normalized_accuracy_improvement","observed":1.0,"operator":"ge","pass":true,"rationale":"Available accuracy headroom cannot worsen.","threshold":0},{"gate_id":"overlap_reconstruction","metric":"reconstruction_improvement_ratio","observed":0.10527294887446571,"operator":"ge","pass":true,"rationale":"Adaptation cannot worsen overlapping-observation reconstruction.","threshold":0},{"gate_id":"overlap_prediction","metric":"prediction_improvement_ratio","observed":0.1394313073151205,"operator":"ge","pass":true,"rationale":"Adaptation cannot worsen overlapping-observation prediction.","threshold":0},{"gate_id":"overlap_exact_planning","metric":"exact_state_rate","observed":1.0,"operator":"ge","pass":true,"rationale":"Partial overlap remains distinguishable enough for exact-state planning.","threshold":0.65},{"gate_id":"overlap_bounded_births","metric":"accepted_births","observed":7,"operator":"le","pass":true,"rationale":"The low-drift regime cannot consume the full topology budget.","threshold":12}],"metrics":{"accepted_births":7,"accepted_retirements":0,"adaptation_completed":true,"adaptation_training_accuracy":1.0,"adapted_drift_accuracy":1.0,"adapted_prediction_rmse":5.541291806800744,"adapted_reconstruction_rmse":4.894124115123985,"adapted_transition_accuracy":0.9444444444444444,"balanced_vs_periodic_drift_accuracy_delta":0.0,"balanced_vs_periodic_retention_delta":0.0,"base_accuracy":0.9453125,"base_prediction_rmse":5.861040096794043,"base_reconstruction_rmse":5.40792361349456,"belief_set_rate":1.0,"belief_set_rate_delta":0.3125,"checkpoint_behavior":true,"checkpoint_identity":true,"checkpoint_mutations":true,"checkpoint_roundtrip":true,"checkpoint_size_bytes":47204,"drift_accuracy_delta":0.05859375,"exact_state_rate":1.0,"exact_state_rate_delta":0.34375,"expert_count":71,"headroom_normalized_accuracy_improvement":1.0,"inference_evaluation_ratio_vs_flat64":0.16729736328125,"inference_expert_evaluations":2741,"lineage_invariants":true,"matched_compute_drift_accuracy_delta":0.05859375,"matched_compute_retention_delta":0.06640625,"matched_compute_training_evaluation_ratio":0.9533232019353037,"no_birth_drift_accuracy_delta":0.05859375,"no_retirement_drift_accuracy_delta":0.0,"path_found_rate":1.0,"prediction_improvement_ratio":0.1394313073151205,"reconstruction_improvement_ratio":0.10527294887446571,"replay_actions_covered":4,"replay_experts_covered":64,"replay_labels_covered":8,"replay_selected":256,"replay_states_covered":64,"replay_transition_pairs_covered":247,"replay_unique":256,"retention_accuracy":1.0,"retention_accuracy_delta_from_base":0.0546875,"retention_prediction_degradation":-0.4776945507482937,"retention_prediction_rmse":5.383345546045749,"retention_reconstruction_degradation_ratio":-0.1345680754689125,"retention_reconstruction_rmse":4.68018974054371,"retention_transition_accuracy_delta":0.02438937166970645,"routing_mismatches":0,"static_belief_set_rate":0.6875,"static_drift_accuracy":0.94140625,"static_exact_state_rate":0.65625,"static_prediction_rmse":6.439104575734127,"static_reconstruction_rmse":5.469963279826349,"static_transition_accuracy":0.9079497907949791,"topology_objective_gain_q20":17094,"training_evaluations":1721328,"transition_accuracy_delta":0.03649465364946536,"transition_support_rate":0.9140625,"unsupported_graph_edge_violations":0},"regime":"partially_overlapping_observations","seed":"0xb8c7841518d48d8c","trial_id":"validation-overlap-01","trial_result":"PASS"},{"comparisons":{"fixed_8_expert":{"metrics":{"checkpoint_size_bytes":11294,"drift_accuracy":0.125,"expert_count":8,"expert_evaluations":2048,"planning_belief_set_rate":0.53125,"planning_exact_state_rate":0.0625,"prediction_rmse":17.604762303679262,"reconstruction_rmse":16.397886480033577,"retention_accuracy":0.1640625,"training_evaluations":94208},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":35340,"drift_accuracy":0.875,"expert_count":62,"expert_evaluations":124,"planning_belief_set_rate":0.21875,"planning_exact_state_rate":0.6875,"prediction_rmse":-12.385934868233605,"reconstruction_rmse":-11.743234456591235,"retention_accuracy":0.8359375,"training_evaluations":1624028},"pareto_relation":"mixed"},"fixed_topology_64_expert_routed":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":1.0,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":4.804758570043027,"reconstruction_rmse":4.5301206674615155,"retention_accuracy":1.0,"training_evaluations":2588672},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":3420,"drift_accuracy":0.0,"expert_count":6,"expert_evaluations":124,"planning_belief_set_rate":-0.25,"planning_exact_state_rate":-0.25,"prediction_rmse":0.41406886540263166,"reconstruction_rmse":0.12453135598082721,"retention_accuracy":0.0,"training_evaluations":-870436},"pareto_relation":"mixed"},"flat_64_expert_complete_scan":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":1.0,"expert_count":64,"expert_evaluations":16384,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":4.804758570043027,"reconstruction_rmse":4.5301206674615155,"retention_accuracy":1.0,"training_evaluations":2588672},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":3420,"drift_accuracy":0.0,"expert_count":6,"expert_evaluations":-14212,"planning_belief_set_rate":-0.25,"planning_exact_state_rate":-0.25,"prediction_rmse":0.41406886540263166,"reconstruction_rmse":0.12453135598082721,"retention_accuracy":0.0,"training_evaluations":-870436},"pareto_relation":"mixed"},"matched_compute_fixed_topology":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.92578125,"expert_count":64,"expert_evaluations":3168,"planning_belief_set_rate":0.65625,"planning_exact_state_rate":0.640625,"prediction_rmse":6.031950860444725,"reconstruction_rmse":5.381594051981367,"retention_accuracy":0.9453125,"training_evaluations":1811960},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":3420,"drift_accuracy":0.07421875,"expert_count":6,"expert_evaluations":-996,"planning_belief_set_rate":0.09375,"planning_exact_state_rate":0.109375,"prediction_rmse":-0.8131234249990671,"reconstruction_rmse":-0.7269420285390247,"retention_accuracy":0.0546875,"training_evaluations":-93724},"pareto_relation":"mixed"},"matched_expert_count_capacity":{"metrics":{"checkpoint_size_bytes":46634,"drift_accuracy":1.0,"expert_count":70,"expert_evaluations":2048,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":4.8321048382552885,"reconstruction_rmse":4.512863272141829,"retention_accuracy":1.0,"training_evaluations":3046400},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":124,"planning_belief_set_rate":-0.25,"planning_exact_state_rate":-0.25,"prediction_rmse":0.38672259719036983,"reconstruction_rmse":0.14178875130051338,"retention_accuracy":0.0,"training_evaluations":-1328164},"pareto_relation":"mixed"},"nearest_centroid_16_no_recursive_births":{"metrics":{"checkpoint_size_bytes":15854,"drift_accuracy":0.25,"expert_count":16,"expert_evaluations":4096,"planning_belief_set_rate":0.65625,"planning_exact_state_rate":0.1875,"prediction_rmse":13.542345710270974,"reconstruction_rmse":12.70163490689724,"retention_accuracy":0.25,"training_evaluations":253952},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":30780,"drift_accuracy":0.75,"expert_count":54,"expert_evaluations":-1924,"planning_belief_set_rate":0.09375,"planning_exact_state_rate":0.5625,"prediction_rmse":-8.323518274825314,"reconstruction_rmse":-8.046982883454898,"retention_accuracy":0.75,"training_evaluations":1464284},"pareto_relation":"mixed"},"no_adaptation_static":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.92578125,"expert_count":64,"expert_evaluations":3168,"planning_belief_set_rate":0.65625,"planning_exact_state_rate":0.640625,"prediction_rmse":6.031950860444725,"reconstruction_rmse":5.381594051981367,"retention_accuracy":0.9453125,"training_evaluations":620920},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":3420,"drift_accuracy":0.07421875,"expert_count":6,"expert_evaluations":-996,"planning_belief_set_rate":0.09375,"planning_exact_state_rate":0.109375,"prediction_rmse":-0.8131234249990671,"reconstruction_rmse":-0.7269420285390247,"retention_accuracy":0.0546875,"training_evaluations":1097316},"pareto_relation":"mixed"},"periodic_replay_policy":{"metrics":{"checkpoint_size_bytes":47204,"drift_accuracy":1.0,"expert_count":71,"expert_evaluations":2174,"planning_belief_set_rate":0.75,"planning_exact_state_rate":0.75,"prediction_rmse":5.2421153207528,"reconstruction_rmse":4.665003473362915,"retention_accuracy":1.0,"training_evaluations":1714426},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":-570,"drift_accuracy":0.0,"expert_count":-1,"expert_evaluations":-2,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":-0.023287885307142098,"reconstruction_rmse":-0.010351449920571909,"retention_accuracy":0.0,"training_evaluations":3810},"pareto_relation":"mixed"},"ravel_0_5_candidate":{"metrics":{"checkpoint_size_bytes":46634,"drift_accuracy":1.0,"expert_count":70,"expert_evaluations":2172,"planning_belief_set_rate":0.75,"planning_exact_state_rate":0.75,"prediction_rmse":5.218827435445658,"reconstruction_rmse":4.654652023442343,"retention_accuracy":1.0,"training_evaluations":1718236},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"equivalent"},"ravel_complete_scan_without_certification":{"metrics":{"checkpoint_size_bytes":46634,"drift_accuracy":1.0,"expert_count":70,"expert_evaluations":17920,"planning_belief_set_rate":0.75,"planning_exact_state_rate":0.75,"prediction_rmse":5.218827435445658,"reconstruction_rmse":4.654652023442343,"retention_accuracy":1.0,"training_evaluations":1904716},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":-15748,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":-186480},"pareto_relation":"candidate_dominates"},"ravel_no_birth_same_replay_iterations":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.92578125,"expert_count":64,"expert_evaluations":3168,"planning_belief_set_rate":0.65625,"planning_exact_state_rate":0.640625,"prediction_rmse":6.031950860444725,"reconstruction_rmse":5.381594051981367,"retention_accuracy":0.9453125,"training_evaluations":859128},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":3420,"drift_accuracy":0.07421875,"expert_count":6,"expert_evaluations":-996,"planning_belief_set_rate":0.09375,"planning_exact_state_rate":0.109375,"prediction_rmse":-0.8131234249990671,"reconstruction_rmse":-0.7269420285390247,"retention_accuracy":0.0546875,"training_evaluations":859108},"pareto_relation":"mixed"},"ravel_random_births":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.92578125,"expert_count":64,"expert_evaluations":3168,"planning_belief_set_rate":0.65625,"planning_exact_state_rate":0.640625,"prediction_rmse":6.031950860444725,"reconstruction_rmse":5.381594051981367,"retention_accuracy":0.9453125,"training_evaluations":859128},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":3420,"drift_accuracy":0.07421875,"expert_count":6,"expert_evaluations":-996,"planning_belief_set_rate":0.09375,"planning_exact_state_rate":0.109375,"prediction_rmse":-0.8131234249990671,"reconstruction_rmse":-0.7269420285390247,"retention_accuracy":0.0546875,"training_evaluations":859108},"pareto_relation":"mixed"},"ravel_without_replay":{"metrics":{"checkpoint_size_bytes":46634,"drift_accuracy":1.0,"expert_count":70,"expert_evaluations":2172,"planning_belief_set_rate":0.75,"planning_exact_state_rate":0.75,"prediction_rmse":5.260112311774595,"reconstruction_rmse":4.665997641178666,"retention_accuracy":1.0,"training_evaluations":1266507},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":-0.041284876328936626,"reconstruction_rmse":-0.011345617736322922,"retention_accuracy":0.0,"training_evaluations":451729},"pareto_relation":"mixed"},"ravel_without_retirement_matched_work":{"metrics":{"checkpoint_size_bytes":47204,"drift_accuracy":1.0,"expert_count":71,"expert_evaluations":2174,"planning_belief_set_rate":0.75,"planning_exact_state_rate":0.75,"prediction_rmse":5.218827435445658,"reconstruction_rmse":4.654652023442343,"retention_accuracy":1.0,"training_evaluations":1718236},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":-570,"drift_accuracy":0.0,"expert_count":-1,"expert_evaluations":-2,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"candidate_dominates"}},"gates":[{"gate_id":"adaptation_completed","metric":"adaptation_completed","observed":true,"operator":"eq","pass":true,"rationale":"The bounded adaptation procedure must complete.","threshold":true},{"gate_id":"base_holdout_accuracy","metric":"base_accuracy","observed":0.95703125,"operator":"ge","pass":true,"rationale":"The base representation must establish the bounded task before drift.","threshold":0.85},{"gate_id":"base_holdout_retention","metric":"retention_accuracy","observed":1.0,"operator":"ge","pass":true,"rationale":"Anchored base behavior may lose at most ten percentage points in absolute retained accuracy.","threshold":0.9},{"gate_id":"routing_oracle_equivalence","metric":"routing_mismatches","observed":0,"operator":"eq","pass":true,"rationale":"Every routed classification must agree with complete scan.","threshold":0},{"gate_id":"checkpoint_roundtrip","metric":"checkpoint_roundtrip","observed":true,"operator":"eq","pass":true,"rationale":"Canonical in-memory restoration must succeed.","threshold":true},{"gate_id":"checkpoint_identity","metric":"checkpoint_identity","observed":true,"operator":"eq","pass":true,"rationale":"Restored complete model identity must match.","threshold":true},{"gate_id":"checkpoint_behavior","metric":"checkpoint_behavior","observed":true,"operator":"eq","pass":true,"rationale":"Restored evaluation and planning behavior must match.","threshold":true},{"gate_id":"checkpoint_mutation_rejection","metric":"checkpoint_mutations","observed":true,"operator":"eq","pass":true,"rationale":"Every declared behavioral and byte-level checkpoint mutation must be detected.","threshold":true},{"gate_id":"lineage_invariants","metric":"lineage_invariants","observed":true,"operator":"eq","pass":true,"rationale":"Generation, lineage uniqueness, descendant splitting, and deterministic topology invariants must hold.","threshold":true},{"gate_id":"unsupported_transitions_unknown","metric":"unsupported_graph_edge_violations","observed":0,"operator":"eq","pass":true,"rationale":"Unsupported actions cannot enter the planning graph.","threshold":0},{"gate_id":"replay_size","metric":"replay_selected","observed":256,"operator":"eq","pass":true,"rationale":"The declared replay budget must be filled on the non-sparse trial corpus.","threshold":256},{"gate_id":"replay_unique","metric":"replay_unique","observed":256,"operator":"eq","pass":true,"rationale":"Balanced replay cannot introduce accidental duplicates.","threshold":256},{"gate_id":"replay_label_coverage","metric":"replay_labels_covered","observed":8,"operator":"eq","pass":true,"rationale":"Replay must retain every declared label.","threshold":8},{"gate_id":"replay_action_coverage","metric":"replay_actions_covered","observed":4,"operator":"eq","pass":true,"rationale":"Replay must retain every declared action.","threshold":4},{"gate_id":"replay_state_coverage","metric":"replay_states_covered","observed":64,"operator":"ge","pass":true,"rationale":"Replay must cover at least 60 of 64 source states.","threshold":60},{"gate_id":"replay_expert_coverage","metric":"replay_experts_covered","observed":64,"operator":"ge","pass":true,"rationale":"Replay must retain broad assigned-expert coverage.","threshold":60},{"gate_id":"replay_transition_coverage","metric":"replay_transition_pairs_covered","observed":252,"operator":"ge","pass":true,"rationale":"Replay must preserve broad source-state/action transition support.","threshold":220},{"gate_id":"planning_path_found","metric":"path_found_rate","observed":1.0,"operator":"ge","pass":true,"rationale":"At least three quarters of bounded planning cases must have a supported path.","threshold":0.75},{"gate_id":"expert_capacity","metric":"expert_count","observed":70,"operator":"le","pass":true,"rationale":"Adaptation cannot exceed the declared expert capacity.","threshold":80},{"gate_id":"retirement_budget","metric":"accepted_retirements","observed":1,"operator":"le","pass":true,"rationale":"Retirement remains optional and bounded.","threshold":4},{"gate_id":"topology_objective_non_degradation","metric":"topology_objective_gain_q20","observed":24055,"operator":"ge","pass":true,"rationale":"Accepted adaptation-training topology decisions cannot reduce their declared objective.","threshold":0},{"gate_id":"matched_compute_budget","metric":"matched_compute_training_evaluation_ratio","observed":0.9482747963531204,"operator":"le","pass":true,"rationale":"Candidate training work may exceed the matched fixed-topology budget by at most ten percent.","threshold":1.1},{"gate_id":"conditional_inference_efficiency","metric":"inference_evaluation_ratio_vs_flat64","observed":0.132568359375,"operator":"le","pass":true,"rationale":"Routed inference must use at most one quarter of flat complete-scan expert evaluations.","threshold":0.25},{"gate_id":"overlap_accuracy","metric":"adapted_drift_accuracy","observed":1.0,"operator":"ge","pass":true,"rationale":"Overlap must retain high adapted classification.","threshold":0.9},{"gate_id":"overlap_non_inferiority","metric":"drift_accuracy_delta","observed":0.07421875,"operator":"ge","pass":true,"rationale":"Limited headroom uses non-inferiority rather than a fixed gain.","threshold":-0.02},{"gate_id":"overlap_headroom","metric":"headroom_normalized_accuracy_improvement","observed":1.0,"operator":"ge","pass":true,"rationale":"Available accuracy headroom cannot worsen.","threshold":0},{"gate_id":"overlap_reconstruction","metric":"reconstruction_improvement_ratio","observed":0.135079313214155,"operator":"ge","pass":true,"rationale":"Adaptation cannot worsen overlapping-observation reconstruction.","threshold":0},{"gate_id":"overlap_prediction","metric":"prediction_improvement_ratio","observed":0.1348027269802919,"operator":"ge","pass":true,"rationale":"Adaptation cannot worsen overlapping-observation prediction.","threshold":0},{"gate_id":"overlap_exact_planning","metric":"exact_state_rate","observed":0.75,"operator":"ge","pass":true,"rationale":"Partial overlap remains distinguishable enough for exact-state planning.","threshold":0.65},{"gate_id":"overlap_bounded_births","metric":"accepted_births","observed":7,"operator":"le","pass":true,"rationale":"The low-drift regime cannot consume the full topology budget.","threshold":12}],"metrics":{"accepted_births":7,"accepted_retirements":1,"adaptation_completed":true,"adaptation_training_accuracy":1.0,"adapted_drift_accuracy":1.0,"adapted_prediction_rmse":5.218827435445658,"adapted_reconstruction_rmse":4.654652023442343,"adapted_transition_accuracy":0.9385964912280702,"balanced_vs_periodic_drift_accuracy_delta":0.0,"balanced_vs_periodic_retention_delta":0.0,"base_accuracy":0.95703125,"base_prediction_rmse":5.4208563707678215,"base_reconstruction_rmse":4.99847906997336,"belief_set_rate":0.75,"belief_set_rate_delta":0.09375,"checkpoint_behavior":true,"checkpoint_identity":true,"checkpoint_mutations":true,"checkpoint_roundtrip":true,"checkpoint_size_bytes":46634,"drift_accuracy_delta":0.07421875,"exact_state_rate":0.75,"exact_state_rate_delta":0.109375,"expert_count":70,"headroom_normalized_accuracy_improvement":1.0,"inference_evaluation_ratio_vs_flat64":0.132568359375,"inference_expert_evaluations":2172,"lineage_invariants":true,"matched_compute_drift_accuracy_delta":0.07421875,"matched_compute_retention_delta":0.0546875,"matched_compute_training_evaluation_ratio":0.9482747963531204,"no_birth_drift_accuracy_delta":0.07421875,"no_retirement_drift_accuracy_delta":0.0,"path_found_rate":1.0,"prediction_improvement_ratio":0.1348027269802919,"reconstruction_improvement_ratio":0.135079313214155,"replay_actions_covered":4,"replay_experts_covered":64,"replay_labels_covered":8,"replay_selected":256,"replay_states_covered":64,"replay_transition_pairs_covered":252,"replay_unique":256,"retention_accuracy":1.0,"retention_accuracy_delta_from_base":0.04296875,"retention_prediction_degradation":-0.3810034591313993,"retention_prediction_rmse":5.039852911636422,"retention_reconstruction_degradation_ratio":-0.04966359940018503,"retention_reconstruction_rmse":4.750236607831994,"retention_transition_accuracy_delta":-0.016063369254858628,"routing_mismatches":0,"static_belief_set_rate":0.65625,"static_drift_accuracy":0.92578125,"static_exact_state_rate":0.640625,"static_prediction_rmse":6.031950860444725,"static_reconstruction_rmse":5.381594051981367,"static_transition_accuracy":0.9043478260869565,"topology_objective_gain_q20":24055,"training_evaluations":1718236,"transition_accuracy_delta":0.03424866514111369,"transition_support_rate":0.890625,"unsupported_graph_edge_violations":0},"regime":"partially_overlapping_observations","seed":"0x3cfbef3be50fce38","trial_id":"validation-overlap-02","trial_result":"PASS"},{"comparisons":{"fixed_8_expert":{"metrics":{"checkpoint_size_bytes":11294,"drift_accuracy":0.1875,"expert_count":8,"expert_evaluations":2048,"planning_belief_set_rate":0.515625,"planning_exact_state_rate":0.046875,"prediction_rmse":17.736629698624572,"reconstruction_rmse":16.032358746838504,"retention_accuracy":0.20703125,"training_evaluations":94208},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":33630,"drift_accuracy":0.8125,"expert_count":59,"expert_evaluations":236,"planning_belief_set_rate":0.328125,"planning_exact_state_rate":0.796875,"prediction_rmse":-12.704246757272344,"reconstruction_rmse":-11.515153509815502,"retention_accuracy":0.79296875,"training_evaluations":1100625},"pareto_relation":"mixed"},"fixed_topology_64_expert_routed":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":1.0,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":4.818255096710795,"reconstruction_rmse":4.405490979859265,"retention_accuracy":1.0,"training_evaluations":2588672},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":1710,"drift_accuracy":0.0,"expert_count":3,"expert_evaluations":236,"planning_belief_set_rate":-0.15625,"planning_exact_state_rate":-0.15625,"prediction_rmse":0.21412784464143453,"reconstruction_rmse":0.1117142571637384,"retention_accuracy":0.0,"training_evaluations":-1393839},"pareto_relation":"mixed"},"flat_64_expert_complete_scan":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":1.0,"expert_count":64,"expert_evaluations":16384,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":4.818255096710795,"reconstruction_rmse":4.405490979859265,"retention_accuracy":1.0,"training_evaluations":2588672},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":1710,"drift_accuracy":0.0,"expert_count":3,"expert_evaluations":-14100,"planning_belief_set_rate":-0.15625,"planning_exact_state_rate":-0.15625,"prediction_rmse":0.21412784464143453,"reconstruction_rmse":0.1117142571637384,"retention_accuracy":0.0,"training_evaluations":-1393839},"pareto_relation":"mixed"},"matched_compute_fixed_topology":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.96875,"expert_count":64,"expert_evaluations":2720,"planning_belief_set_rate":0.734375,"planning_exact_state_rate":0.6875,"prediction_rmse":5.3065512755141295,"reconstruction_rmse":4.821365181171552,"retention_accuracy":0.953125,"training_evaluations":1302400},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":1710,"drift_accuracy":0.03125,"expert_count":3,"expert_evaluations":-436,"planning_belief_set_rate":0.109375,"planning_exact_state_rate":0.15625,"prediction_rmse":-0.27416833416190034,"reconstruction_rmse":-0.3041599441485481,"retention_accuracy":0.046875,"training_evaluations":-107567},"pareto_relation":"mixed"},"matched_expert_count_capacity":{"metrics":{"checkpoint_size_bytes":44924,"drift_accuracy":1.0,"expert_count":67,"expert_evaluations":2048,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":4.8536260205905215,"reconstruction_rmse":4.406065413706202,"retention_accuracy":1.0,"training_evaluations":2812928},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":236,"planning_belief_set_rate":-0.15625,"planning_exact_state_rate":-0.15625,"prediction_rmse":0.17875692076170768,"reconstruction_rmse":0.11113982331680194,"retention_accuracy":0.0,"training_evaluations":-1618095},"pareto_relation":"mixed"},"nearest_centroid_16_no_recursive_births":{"metrics":{"checkpoint_size_bytes":15854,"drift_accuracy":0.24609375,"expert_count":16,"expert_evaluations":4096,"planning_belief_set_rate":0.90625,"planning_exact_state_rate":0.1875,"prediction_rmse":13.28292080782945,"reconstruction_rmse":12.129472605122022,"retention_accuracy":0.28125,"training_evaluations":253952},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":29070,"drift_accuracy":0.75390625,"expert_count":51,"expert_evaluations":-1812,"planning_belief_set_rate":-0.0625,"planning_exact_state_rate":0.65625,"prediction_rmse":-8.25053786647722,"reconstruction_rmse":-7.612267368099018,"retention_accuracy":0.71875,"training_evaluations":940881},"pareto_relation":"mixed"},"no_adaptation_static":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.96875,"expert_count":64,"expert_evaluations":2720,"planning_belief_set_rate":0.734375,"planning_exact_state_rate":0.6875,"prediction_rmse":5.3065512755141295,"reconstruction_rmse":4.821365181171552,"retention_accuracy":0.953125,"training_evaluations":617344},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":1710,"drift_accuracy":0.03125,"expert_count":3,"expert_evaluations":-436,"planning_belief_set_rate":0.109375,"planning_exact_state_rate":0.15625,"prediction_rmse":-0.27416833416190034,"reconstruction_rmse":-0.3041599441485481,"retention_accuracy":0.046875,"training_evaluations":577489},"pareto_relation":"mixed"},"periodic_replay_policy":{"metrics":{"checkpoint_size_bytes":44924,"drift_accuracy":1.0,"expert_count":67,"expert_evaluations":2284,"planning_belief_set_rate":0.84375,"planning_exact_state_rate":0.84375,"prediction_rmse":4.999688047762236,"reconstruction_rmse":4.511613266039991,"retention_accuracy":1.0,"training_evaluations":1193850},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.032694893589993335,"reconstruction_rmse":0.005591970983013006,"retention_accuracy":0.0,"training_evaluations":983},"pareto_relation":"variant_dominates"},"ravel_0_5_candidate":{"metrics":{"checkpoint_size_bytes":44924,"drift_accuracy":1.0,"expert_count":67,"expert_evaluations":2284,"planning_belief_set_rate":0.84375,"planning_exact_state_rate":0.84375,"prediction_rmse":5.032382941352229,"reconstruction_rmse":4.517205237023004,"retention_accuracy":1.0,"training_evaluations":1194833},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"equivalent"},"ravel_complete_scan_without_certification":{"metrics":{"checkpoint_size_bytes":44924,"drift_accuracy":1.0,"expert_count":67,"expert_evaluations":17152,"planning_belief_set_rate":0.84375,"planning_exact_state_rate":0.84375,"prediction_rmse":5.032382941352229,"reconstruction_rmse":4.517205237023004,"retention_accuracy":1.0,"training_evaluations":1374193},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":-14868,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":-179360},"pareto_relation":"candidate_dominates"},"ravel_no_birth_same_replay_iterations":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.96875,"expert_count":64,"expert_evaluations":2720,"planning_belief_set_rate":0.734375,"planning_exact_state_rate":0.6875,"prediction_rmse":5.3065512755141295,"reconstruction_rmse":4.821365181171552,"retention_accuracy":0.953125,"training_evaluations":845696},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":1710,"drift_accuracy":0.03125,"expert_count":3,"expert_evaluations":-436,"planning_belief_set_rate":0.109375,"planning_exact_state_rate":0.15625,"prediction_rmse":-0.27416833416190034,"reconstruction_rmse":-0.3041599441485481,"retention_accuracy":0.046875,"training_evaluations":349137},"pareto_relation":"mixed"},"ravel_random_births":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.96875,"expert_count":64,"expert_evaluations":2720,"planning_belief_set_rate":0.734375,"planning_exact_state_rate":0.6875,"prediction_rmse":5.3065512755141295,"reconstruction_rmse":4.821365181171552,"retention_accuracy":0.953125,"training_evaluations":845696},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":1710,"drift_accuracy":0.03125,"expert_count":3,"expert_evaluations":-436,"planning_belief_set_rate":0.109375,"planning_exact_state_rate":0.15625,"prediction_rmse":-0.27416833416190034,"reconstruction_rmse":-0.3041599441485481,"retention_accuracy":0.046875,"training_evaluations":349137},"pareto_relation":"mixed"},"ravel_without_replay":{"metrics":{"checkpoint_size_bytes":45494,"drift_accuracy":1.0,"expert_count":68,"expert_evaluations":2288,"planning_belief_set_rate":0.84375,"planning_exact_state_rate":0.84375,"prediction_rmse":5.010575151955184,"reconstruction_rmse":4.509588356063338,"retention_accuracy":1.0,"training_evaluations":1081066},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":-570,"drift_accuracy":0.0,"expert_count":-1,"expert_evaluations":-4,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.02180778939704542,"reconstruction_rmse":0.007616880959665728,"retention_accuracy":0.0,"training_evaluations":113767},"pareto_relation":"mixed"},"ravel_without_retirement_matched_work":{"metrics":{"checkpoint_size_bytes":44924,"drift_accuracy":1.0,"expert_count":67,"expert_evaluations":2284,"planning_belief_set_rate":0.84375,"planning_exact_state_rate":0.84375,"prediction_rmse":5.032382941352229,"reconstruction_rmse":4.517205237023004,"retention_accuracy":1.0,"training_evaluations":1194833},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"equivalent"}},"gates":[{"gate_id":"adaptation_completed","metric":"adaptation_completed","observed":true,"operator":"eq","pass":true,"rationale":"The bounded adaptation procedure must complete.","threshold":true},{"gate_id":"base_holdout_accuracy","metric":"base_accuracy","observed":0.9765625,"operator":"ge","pass":true,"rationale":"The base representation must establish the bounded task before drift.","threshold":0.85},{"gate_id":"base_holdout_retention","metric":"retention_accuracy","observed":1.0,"operator":"ge","pass":true,"rationale":"Anchored base behavior may lose at most ten percentage points in absolute retained accuracy.","threshold":0.9},{"gate_id":"routing_oracle_equivalence","metric":"routing_mismatches","observed":0,"operator":"eq","pass":true,"rationale":"Every routed classification must agree with complete scan.","threshold":0},{"gate_id":"checkpoint_roundtrip","metric":"checkpoint_roundtrip","observed":true,"operator":"eq","pass":true,"rationale":"Canonical in-memory restoration must succeed.","threshold":true},{"gate_id":"checkpoint_identity","metric":"checkpoint_identity","observed":true,"operator":"eq","pass":true,"rationale":"Restored complete model identity must match.","threshold":true},{"gate_id":"checkpoint_behavior","metric":"checkpoint_behavior","observed":true,"operator":"eq","pass":true,"rationale":"Restored evaluation and planning behavior must match.","threshold":true},{"gate_id":"checkpoint_mutation_rejection","metric":"checkpoint_mutations","observed":true,"operator":"eq","pass":true,"rationale":"Every declared behavioral and byte-level checkpoint mutation must be detected.","threshold":true},{"gate_id":"lineage_invariants","metric":"lineage_invariants","observed":true,"operator":"eq","pass":true,"rationale":"Generation, lineage uniqueness, descendant splitting, and deterministic topology invariants must hold.","threshold":true},{"gate_id":"unsupported_transitions_unknown","metric":"unsupported_graph_edge_violations","observed":0,"operator":"eq","pass":true,"rationale":"Unsupported actions cannot enter the planning graph.","threshold":0},{"gate_id":"replay_size","metric":"replay_selected","observed":256,"operator":"eq","pass":true,"rationale":"The declared replay budget must be filled on the non-sparse trial corpus.","threshold":256},{"gate_id":"replay_unique","metric":"replay_unique","observed":256,"operator":"eq","pass":true,"rationale":"Balanced replay cannot introduce accidental duplicates.","threshold":256},{"gate_id":"replay_label_coverage","metric":"replay_labels_covered","observed":8,"operator":"eq","pass":true,"rationale":"Replay must retain every declared label.","threshold":8},{"gate_id":"replay_action_coverage","metric":"replay_actions_covered","observed":4,"operator":"eq","pass":true,"rationale":"Replay must retain every declared action.","threshold":4},{"gate_id":"replay_state_coverage","metric":"replay_states_covered","observed":64,"operator":"ge","pass":true,"rationale":"Replay must cover at least 60 of 64 source states.","threshold":60},{"gate_id":"replay_expert_coverage","metric":"replay_experts_covered","observed":63,"operator":"ge","pass":true,"rationale":"Replay must retain broad assigned-expert coverage.","threshold":60},{"gate_id":"replay_transition_coverage","metric":"replay_transition_pairs_covered","observed":248,"operator":"ge","pass":true,"rationale":"Replay must preserve broad source-state/action transition support.","threshold":220},{"gate_id":"planning_path_found","metric":"path_found_rate","observed":0.984375,"operator":"ge","pass":true,"rationale":"At least three quarters of bounded planning cases must have a supported path.","threshold":0.75},{"gate_id":"expert_capacity","metric":"expert_count","observed":67,"operator":"le","pass":true,"rationale":"Adaptation cannot exceed the declared expert capacity.","threshold":80},{"gate_id":"retirement_budget","metric":"accepted_retirements","observed":0,"operator":"le","pass":true,"rationale":"Retirement remains optional and bounded.","threshold":4},{"gate_id":"topology_objective_non_degradation","metric":"topology_objective_gain_q20","observed":11131,"operator":"ge","pass":true,"rationale":"Accepted adaptation-training topology decisions cannot reduce their declared objective.","threshold":0},{"gate_id":"matched_compute_budget","metric":"matched_compute_training_evaluation_ratio","observed":0.9174086302211302,"operator":"le","pass":true,"rationale":"Candidate training work may exceed the matched fixed-topology budget by at most ten percent.","threshold":1.1},{"gate_id":"conditional_inference_efficiency","metric":"inference_evaluation_ratio_vs_flat64","observed":0.139404296875,"operator":"le","pass":true,"rationale":"Routed inference must use at most one quarter of flat complete-scan expert evaluations.","threshold":0.25},{"gate_id":"overlap_accuracy","metric":"adapted_drift_accuracy","observed":1.0,"operator":"ge","pass":true,"rationale":"Overlap must retain high adapted classification.","threshold":0.9},{"gate_id":"overlap_non_inferiority","metric":"drift_accuracy_delta","observed":0.03125,"operator":"ge","pass":true,"rationale":"Limited headroom uses non-inferiority rather than a fixed gain.","threshold":-0.02},{"gate_id":"overlap_headroom","metric":"headroom_normalized_accuracy_improvement","observed":1.0,"operator":"ge","pass":true,"rationale":"Available accuracy headroom cannot worsen.","threshold":0},{"gate_id":"overlap_reconstruction","metric":"reconstruction_improvement_ratio","observed":0.06308585488117699,"operator":"ge","pass":true,"rationale":"Adaptation cannot worsen overlapping-observation reconstruction.","threshold":0},{"gate_id":"overlap_prediction","metric":"prediction_improvement_ratio","observed":0.05166601054567918,"operator":"ge","pass":true,"rationale":"Adaptation cannot worsen overlapping-observation prediction.","threshold":0},{"gate_id":"overlap_exact_planning","metric":"exact_state_rate","observed":0.84375,"operator":"ge","pass":true,"rationale":"Partial overlap remains distinguishable enough for exact-state planning.","threshold":0.65},{"gate_id":"overlap_bounded_births","metric":"accepted_births","observed":3,"operator":"le","pass":true,"rationale":"The low-drift regime cannot consume the full topology budget.","threshold":12}],"metrics":{"accepted_births":3,"accepted_retirements":0,"adaptation_completed":true,"adaptation_training_accuracy":1.0,"adapted_drift_accuracy":1.0,"adapted_prediction_rmse":5.032382941352229,"adapted_reconstruction_rmse":4.517205237023004,"adapted_transition_accuracy":0.9662447257383966,"balanced_vs_periodic_drift_accuracy_delta":0.0,"balanced_vs_periodic_retention_delta":0.0,"base_accuracy":0.9765625,"base_prediction_rmse":5.3952846297715125,"base_reconstruction_rmse":4.749848326452343,"belief_set_rate":0.84375,"belief_set_rate_delta":0.109375,"checkpoint_behavior":true,"checkpoint_identity":true,"checkpoint_mutations":true,"checkpoint_roundtrip":true,"checkpoint_size_bytes":44924,"drift_accuracy_delta":0.03125,"exact_state_rate":0.84375,"exact_state_rate_delta":0.15625,"expert_count":67,"headroom_normalized_accuracy_improvement":1.0,"inference_evaluation_ratio_vs_flat64":0.139404296875,"inference_expert_evaluations":2284,"lineage_invariants":true,"matched_compute_drift_accuracy_delta":0.03125,"matched_compute_retention_delta":0.046875,"matched_compute_training_evaluation_ratio":0.9174086302211302,"no_birth_drift_accuracy_delta":0.03125,"no_retirement_drift_accuracy_delta":0.0,"path_found_rate":0.984375,"prediction_improvement_ratio":0.05166601054567918,"reconstruction_improvement_ratio":0.06308585488117699,"replay_actions_covered":4,"replay_experts_covered":63,"replay_labels_covered":8,"replay_selected":256,"replay_states_covered":64,"replay_transition_pairs_covered":248,"replay_unique":256,"retention_accuracy":1.0,"retention_accuracy_delta_from_base":0.0234375,"retention_prediction_degradation":-0.245818650847494,"retention_prediction_rmse":5.1494659789240185,"retention_reconstruction_degradation_ratio":-0.035501018705549184,"retention_reconstruction_rmse":4.5812238721664365,"retention_transition_accuracy_delta":-0.007941636623358894,"routing_mismatches":0,"static_belief_set_rate":0.734375,"static_drift_accuracy":0.96875,"static_exact_state_rate":0.6875,"static_prediction_rmse":5.3065512755141295,"static_reconstruction_rmse":4.821365181171552,"static_transition_accuracy":0.9535864978902954,"topology_objective_gain_q20":11131,"training_evaluations":1194833,"transition_accuracy_delta":0.012658227848101222,"transition_support_rate":0.92578125,"unsupported_graph_edge_violations":0},"regime":"partially_overlapping_observations","seed":"0xe38c303e80ef16a9","trial_id":"validation-overlap-03","trial_result":"PASS"},{"comparisons":{"fixed_8_expert":{"metrics":{"checkpoint_size_bytes":11294,"drift_accuracy":0.17578125,"expert_count":8,"expert_evaluations":2048,"planning_belief_set_rate":0.515625,"planning_exact_state_rate":0.015625,"prediction_rmse":17.134094164616723,"reconstruction_rmse":15.906097408127888,"retention_accuracy":0.2265625,"training_evaluations":94208},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":34200,"drift_accuracy":0.82421875,"expert_count":60,"expert_evaluations":360,"planning_belief_set_rate":0.40625,"planning_exact_state_rate":0.90625,"prediction_rmse":-12.068947646930816,"reconstruction_rmse":-11.22763852541769,"retention_accuracy":0.7734375,"training_evaluations":1237290},"pareto_relation":"mixed"},"fixed_topology_64_expert_routed":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":1.0,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":4.9128216923388,"reconstruction_rmse":4.507180955653788,"retention_accuracy":1.0,"training_evaluations":2588672},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":2280,"drift_accuracy":0.0,"expert_count":4,"expert_evaluations":360,"planning_belief_set_rate":-0.078125,"planning_exact_state_rate":-0.078125,"prediction_rmse":0.15232482534710723,"reconstruction_rmse":0.17127792705640932,"retention_accuracy":0.0,"training_evaluations":-1257174},"pareto_relation":"mixed"},"flat_64_expert_complete_scan":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":1.0,"expert_count":64,"expert_evaluations":16384,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":4.9128216923388,"reconstruction_rmse":4.507180955653788,"retention_accuracy":1.0,"training_evaluations":2588672},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":2280,"drift_accuracy":0.0,"expert_count":4,"expert_evaluations":-13976,"planning_belief_set_rate":-0.078125,"planning_exact_state_rate":-0.078125,"prediction_rmse":0.15232482534710723,"reconstruction_rmse":0.17127792705640932,"retention_accuracy":0.0,"training_evaluations":-1257174},"pareto_relation":"mixed"},"matched_compute_fixed_topology":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.91015625,"expert_count":64,"expert_evaluations":3616,"planning_belief_set_rate":0.8125,"planning_exact_state_rate":0.765625,"prediction_rmse":6.0460468654377015,"reconstruction_rmse":5.402515121453251,"retention_accuracy":0.95703125,"training_evaluations":1553552},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":2280,"drift_accuracy":0.08984375,"expert_count":4,"expert_evaluations":-1208,"planning_belief_set_rate":0.109375,"planning_exact_state_rate":0.15625,"prediction_rmse":-0.9809003477517946,"reconstruction_rmse":-0.7240562387430538,"retention_accuracy":0.04296875,"training_evaluations":-222054},"pareto_relation":"mixed"},"matched_expert_count_capacity":{"metrics":{"checkpoint_size_bytes":45494,"drift_accuracy":1.0,"expert_count":68,"expert_evaluations":2048,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":4.9378675246475465,"reconstruction_rmse":4.492838213635258,"retention_accuracy":1.0,"training_evaluations":2889728},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":360,"planning_belief_set_rate":-0.078125,"planning_exact_state_rate":-0.078125,"prediction_rmse":0.12727899303836043,"reconstruction_rmse":0.18562066907493957,"retention_accuracy":0.0,"training_evaluations":-1558230},"pareto_relation":"mixed"},"nearest_centroid_16_no_recursive_births":{"metrics":{"checkpoint_size_bytes":15854,"drift_accuracy":0.1875,"expert_count":16,"expert_evaluations":4096,"planning_belief_set_rate":1.0,"planning_exact_state_rate":0.34375,"prediction_rmse":12.53528975087719,"reconstruction_rmse":12.034100766144881,"retention_accuracy":0.2265625,"training_evaluations":253952},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":29640,"drift_accuracy":0.8125,"expert_count":52,"expert_evaluations":-1688,"planning_belief_set_rate":-0.078125,"planning_exact_state_rate":0.578125,"prediction_rmse":-7.470143233191283,"reconstruction_rmse":-7.355641883434684,"retention_accuracy":0.7734375,"training_evaluations":1077546},"pareto_relation":"mixed"},"no_adaptation_static":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.91015625,"expert_count":64,"expert_evaluations":3616,"planning_belief_set_rate":0.8125,"planning_exact_state_rate":0.765625,"prediction_rmse":6.0460468654377015,"reconstruction_rmse":5.402515121453251,"retention_accuracy":0.95703125,"training_evaluations":624016},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":2280,"drift_accuracy":0.08984375,"expert_count":4,"expert_evaluations":-1208,"planning_belief_set_rate":0.109375,"planning_exact_state_rate":0.15625,"prediction_rmse":-0.9809003477517946,"reconstruction_rmse":-0.7240562387430538,"retention_accuracy":0.04296875,"training_evaluations":707482},"pareto_relation":"mixed"},"periodic_replay_policy":{"metrics":{"checkpoint_size_bytes":44924,"drift_accuracy":1.0,"expert_count":67,"expert_evaluations":2402,"planning_belief_set_rate":0.9375,"planning_exact_state_rate":0.9375,"prediction_rmse":5.080402601765877,"reconstruction_rmse":4.697935662690226,"retention_accuracy":1.0,"training_evaluations":1207370},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":570,"drift_accuracy":0.0,"expert_count":1,"expert_evaluations":6,"planning_belief_set_rate":-0.015625,"planning_exact_state_rate":-0.015625,"prediction_rmse":-0.015256084079970478,"reconstruction_rmse":-0.019476779980029058,"retention_accuracy":0.0,"training_evaluations":124128},"pareto_relation":"mixed"},"ravel_0_5_candidate":{"metrics":{"checkpoint_size_bytes":45494,"drift_accuracy":1.0,"expert_count":68,"expert_evaluations":2408,"planning_belief_set_rate":0.921875,"planning_exact_state_rate":0.921875,"prediction_rmse":5.065146517685907,"reconstruction_rmse":4.678458882710197,"retention_accuracy":1.0,"training_evaluations":1331498},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"equivalent"},"ravel_complete_scan_without_certification":{"metrics":{"checkpoint_size_bytes":45494,"drift_accuracy":1.0,"expert_count":68,"expert_evaluations":17408,"planning_belief_set_rate":0.921875,"planning_exact_state_rate":0.921875,"prediction_rmse":5.065146517685907,"reconstruction_rmse":4.678458882710197,"retention_accuracy":1.0,"training_evaluations":1511738},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":-15000,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":-180240},"pareto_relation":"candidate_dominates"},"ravel_no_birth_same_replay_iterations":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.91015625,"expert_count":64,"expert_evaluations":3616,"planning_belief_set_rate":0.8125,"planning_exact_state_rate":0.765625,"prediction_rmse":6.0460468654377015,"reconstruction_rmse":5.402515121453251,"retention_accuracy":0.95703125,"training_evaluations":856400},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":2280,"drift_accuracy":0.08984375,"expert_count":4,"expert_evaluations":-1208,"planning_belief_set_rate":0.109375,"planning_exact_state_rate":0.15625,"prediction_rmse":-0.9809003477517946,"reconstruction_rmse":-0.7240562387430538,"retention_accuracy":0.04296875,"training_evaluations":475098},"pareto_relation":"mixed"},"ravel_random_births":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.91015625,"expert_count":64,"expert_evaluations":3616,"planning_belief_set_rate":0.8125,"planning_exact_state_rate":0.765625,"prediction_rmse":6.0460468654377015,"reconstruction_rmse":5.402515121453251,"retention_accuracy":0.95703125,"training_evaluations":856400},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":2280,"drift_accuracy":0.08984375,"expert_count":4,"expert_evaluations":-1208,"planning_belief_set_rate":0.109375,"planning_exact_state_rate":0.15625,"prediction_rmse":-0.9809003477517946,"reconstruction_rmse":-0.7240562387430538,"retention_accuracy":0.04296875,"training_evaluations":475098},"pareto_relation":"mixed"},"ravel_without_replay":{"metrics":{"checkpoint_size_bytes":45494,"drift_accuracy":1.0,"expert_count":68,"expert_evaluations":2408,"planning_belief_set_rate":0.921875,"planning_exact_state_rate":0.921875,"prediction_rmse":5.094246711626574,"reconstruction_rmse":4.678318029577596,"retention_accuracy":1.0,"training_evaluations":1095940},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":-0.029100193940666763,"reconstruction_rmse":0.0001408531326010376,"retention_accuracy":0.0,"training_evaluations":235558},"pareto_relation":"mixed"},"ravel_without_retirement_matched_work":{"metrics":{"checkpoint_size_bytes":45494,"drift_accuracy":1.0,"expert_count":68,"expert_evaluations":2408,"planning_belief_set_rate":0.921875,"planning_exact_state_rate":0.921875,"prediction_rmse":5.065146517685907,"reconstruction_rmse":4.678458882710197,"retention_accuracy":1.0,"training_evaluations":1331498},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"equivalent"}},"gates":[{"gate_id":"adaptation_completed","metric":"adaptation_completed","observed":true,"operator":"eq","pass":true,"rationale":"The bounded adaptation procedure must complete.","threshold":true},{"gate_id":"base_holdout_accuracy","metric":"base_accuracy","observed":0.9453125,"operator":"ge","pass":true,"rationale":"The base representation must establish the bounded task before drift.","threshold":0.85},{"gate_id":"base_holdout_retention","metric":"retention_accuracy","observed":1.0,"operator":"ge","pass":true,"rationale":"Anchored base behavior may lose at most ten percentage points in absolute retained accuracy.","threshold":0.9},{"gate_id":"routing_oracle_equivalence","metric":"routing_mismatches","observed":0,"operator":"eq","pass":true,"rationale":"Every routed classification must agree with complete scan.","threshold":0},{"gate_id":"checkpoint_roundtrip","metric":"checkpoint_roundtrip","observed":true,"operator":"eq","pass":true,"rationale":"Canonical in-memory restoration must succeed.","threshold":true},{"gate_id":"checkpoint_identity","metric":"checkpoint_identity","observed":true,"operator":"eq","pass":true,"rationale":"Restored complete model identity must match.","threshold":true},{"gate_id":"checkpoint_behavior","metric":"checkpoint_behavior","observed":true,"operator":"eq","pass":true,"rationale":"Restored evaluation and planning behavior must match.","threshold":true},{"gate_id":"checkpoint_mutation_rejection","metric":"checkpoint_mutations","observed":true,"operator":"eq","pass":true,"rationale":"Every declared behavioral and byte-level checkpoint mutation must be detected.","threshold":true},{"gate_id":"lineage_invariants","metric":"lineage_invariants","observed":true,"operator":"eq","pass":true,"rationale":"Generation, lineage uniqueness, descendant splitting, and deterministic topology invariants must hold.","threshold":true},{"gate_id":"unsupported_transitions_unknown","metric":"unsupported_graph_edge_violations","observed":0,"operator":"eq","pass":true,"rationale":"Unsupported actions cannot enter the planning graph.","threshold":0},{"gate_id":"replay_size","metric":"replay_selected","observed":256,"operator":"eq","pass":true,"rationale":"The declared replay budget must be filled on the non-sparse trial corpus.","threshold":256},{"gate_id":"replay_unique","metric":"replay_unique","observed":256,"operator":"eq","pass":true,"rationale":"Balanced replay cannot introduce accidental duplicates.","threshold":256},{"gate_id":"replay_label_coverage","metric":"replay_labels_covered","observed":8,"operator":"eq","pass":true,"rationale":"Replay must retain every declared label.","threshold":8},{"gate_id":"replay_action_coverage","metric":"replay_actions_covered","observed":4,"operator":"eq","pass":true,"rationale":"Replay must retain every declared action.","threshold":4},{"gate_id":"replay_state_coverage","metric":"replay_states_covered","observed":64,"operator":"ge","pass":true,"rationale":"Replay must cover at least 60 of 64 source states.","threshold":60},{"gate_id":"replay_expert_coverage","metric":"replay_experts_covered","observed":64,"operator":"ge","pass":true,"rationale":"Replay must retain broad assigned-expert coverage.","threshold":60},{"gate_id":"replay_transition_coverage","metric":"replay_transition_pairs_covered","observed":252,"operator":"ge","pass":true,"rationale":"Replay must preserve broad source-state/action transition support.","threshold":220},{"gate_id":"planning_path_found","metric":"path_found_rate","observed":1.0,"operator":"ge","pass":true,"rationale":"At least three quarters of bounded planning cases must have a supported path.","threshold":0.75},{"gate_id":"expert_capacity","metric":"expert_count","observed":68,"operator":"le","pass":true,"rationale":"Adaptation cannot exceed the declared expert capacity.","threshold":80},{"gate_id":"retirement_budget","metric":"accepted_retirements","observed":0,"operator":"le","pass":true,"rationale":"Retirement remains optional and bounded.","threshold":4},{"gate_id":"topology_objective_non_degradation","metric":"topology_objective_gain_q20","observed":17982,"operator":"ge","pass":true,"rationale":"Accepted adaptation-training topology decisions cannot reduce their declared objective.","threshold":0},{"gate_id":"matched_compute_budget","metric":"matched_compute_training_evaluation_ratio","observed":0.8570669021699949,"operator":"le","pass":true,"rationale":"Candidate training work may exceed the matched fixed-topology budget by at most ten percent.","threshold":1.1},{"gate_id":"conditional_inference_efficiency","metric":"inference_evaluation_ratio_vs_flat64","observed":0.14697265625,"operator":"le","pass":true,"rationale":"Routed inference must use at most one quarter of flat complete-scan expert evaluations.","threshold":0.25},{"gate_id":"overlap_accuracy","metric":"adapted_drift_accuracy","observed":1.0,"operator":"ge","pass":true,"rationale":"Overlap must retain high adapted classification.","threshold":0.9},{"gate_id":"overlap_non_inferiority","metric":"drift_accuracy_delta","observed":0.08984375,"operator":"ge","pass":true,"rationale":"Limited headroom uses non-inferiority rather than a fixed gain.","threshold":-0.02},{"gate_id":"overlap_headroom","metric":"headroom_normalized_accuracy_improvement","observed":1.0,"operator":"ge","pass":true,"rationale":"Available accuracy headroom cannot worsen.","threshold":0},{"gate_id":"overlap_reconstruction","metric":"reconstruction_improvement_ratio","observed":0.1340220661054413,"operator":"ge","pass":true,"rationale":"Adaptation cannot worsen overlapping-observation reconstruction.","threshold":0},{"gate_id":"overlap_prediction","metric":"prediction_improvement_ratio","observed":0.16223829711925045,"operator":"ge","pass":true,"rationale":"Adaptation cannot worsen overlapping-observation prediction.","threshold":0},{"gate_id":"overlap_exact_planning","metric":"exact_state_rate","observed":0.921875,"operator":"ge","pass":true,"rationale":"Partial overlap remains distinguishable enough for exact-state planning.","threshold":0.65},{"gate_id":"overlap_bounded_births","metric":"accepted_births","observed":4,"operator":"le","pass":true,"rationale":"The low-drift regime cannot consume the full topology budget.","threshold":12}],"metrics":{"accepted_births":4,"accepted_retirements":0,"adaptation_completed":true,"adaptation_training_accuracy":1.0,"adapted_drift_accuracy":1.0,"adapted_prediction_rmse":5.065146517685907,"adapted_reconstruction_rmse":4.678458882710197,"adapted_transition_accuracy":0.9638009049773756,"balanced_vs_periodic_drift_accuracy_delta":0.0,"balanced_vs_periodic_retention_delta":0.0,"base_accuracy":0.9453125,"base_prediction_rmse":5.857395949002684,"base_reconstruction_rmse":5.1792725870918925,"belief_set_rate":0.921875,"belief_set_rate_delta":0.109375,"checkpoint_behavior":true,"checkpoint_identity":true,"checkpoint_mutations":true,"checkpoint_roundtrip":true,"checkpoint_size_bytes":45494,"drift_accuracy_delta":0.08984375,"exact_state_rate":0.921875,"exact_state_rate_delta":0.15625,"expert_count":68,"headroom_normalized_accuracy_improvement":1.0,"inference_evaluation_ratio_vs_flat64":0.14697265625,"inference_expert_evaluations":2408,"lineage_invariants":true,"matched_compute_drift_accuracy_delta":0.08984375,"matched_compute_retention_delta":0.04296875,"matched_compute_training_evaluation_ratio":0.8570669021699949,"no_birth_drift_accuracy_delta":0.08984375,"no_retirement_drift_accuracy_delta":0.0,"path_found_rate":1.0,"prediction_improvement_ratio":0.16223829711925045,"reconstruction_improvement_ratio":0.1340220661054413,"replay_actions_covered":4,"replay_experts_covered":64,"replay_labels_covered":8,"replay_selected":256,"replay_states_covered":64,"replay_transition_pairs_covered":252,"replay_unique":256,"retention_accuracy":1.0,"retention_accuracy_delta_from_base":0.0546875,"retention_prediction_degradation":-0.7056247801087352,"retention_prediction_rmse":5.151771168893949,"retention_reconstruction_degradation_ratio":-0.10150621242662429,"retention_reconstruction_rmse":4.653544243651151,"retention_transition_accuracy_delta":0.037178214311041735,"routing_mismatches":0,"static_belief_set_rate":0.8125,"static_drift_accuracy":0.91015625,"static_exact_state_rate":0.765625,"static_prediction_rmse":6.0460468654377015,"static_reconstruction_rmse":5.402515121453251,"static_transition_accuracy":0.9118942731277533,"topology_objective_gain_q20":17982,"training_evaluations":1331498,"transition_accuracy_delta":0.0519066318496223,"transition_support_rate":0.86328125,"unsupported_graph_edge_violations":0},"regime":"partially_overlapping_observations","seed":"0xb240684596a68108","trial_id":"validation-overlap-04","trial_result":"PASS"},{"comparisons":{"fixed_8_expert":{"metrics":{"checkpoint_size_bytes":11294,"drift_accuracy":0.1875,"expert_count":8,"expert_evaluations":2048,"planning_belief_set_rate":0.34375,"planning_exact_state_rate":0.046875,"prediction_rmse":32.733791647764065,"reconstruction_rmse":29.858608468464084,"retention_accuracy":0.21875,"training_evaluations":94208},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":34770,"drift_accuracy":0.8125,"expert_count":61,"expert_evaluations":305,"planning_belief_set_rate":0.375,"planning_exact_state_rate":0.671875,"prediction_rmse":-20.138139738792006,"reconstruction_rmse":-18.131648369376855,"retention_accuracy":0.78125,"training_evaluations":1292696},"pareto_relation":"mixed"},"fixed_topology_64_expert_routed":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":1.0,"expert_count":64,"expert_evaluations":2160,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":12.009158254380988,"reconstruction_rmse":11.374322289676282,"retention_accuracy":1.0,"training_evaluations":2588672},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":2850,"drift_accuracy":0.0,"expert_count":5,"expert_evaluations":193,"planning_belief_set_rate":-0.28125,"planning_exact_state_rate":-0.28125,"prediction_rmse":0.586493654591072,"reconstruction_rmse":0.352637809410945,"retention_accuracy":0.0,"training_evaluations":-1201768},"pareto_relation":"mixed"},"flat_64_expert_complete_scan":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":1.0,"expert_count":64,"expert_evaluations":16384,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":12.009158254380988,"reconstruction_rmse":11.374322289676282,"retention_accuracy":1.0,"training_evaluations":2588672},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":2850,"drift_accuracy":0.0,"expert_count":5,"expert_evaluations":-14031,"planning_belief_set_rate":-0.28125,"planning_exact_state_rate":-0.28125,"prediction_rmse":0.586493654591072,"reconstruction_rmse":0.352637809410945,"retention_accuracy":0.0,"training_evaluations":-1201768},"pareto_relation":"mixed"},"matched_compute_fixed_topology":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.90234375,"expert_count":64,"expert_evaluations":2608,"planning_belief_set_rate":0.65625,"planning_exact_state_rate":0.578125,"prediction_rmse":13.859491572661979,"reconstruction_rmse":12.913145962262412,"retention_accuracy":0.92578125,"training_evaluations":1465184},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":2850,"drift_accuracy":0.09765625,"expert_count":5,"expert_evaluations":-255,"planning_belief_set_rate":0.0625,"planning_exact_state_rate":0.140625,"prediction_rmse":-1.263839663689918,"reconstruction_rmse":-1.1861858631751847,"retention_accuracy":0.07421875,"training_evaluations":-78280},"pareto_relation":"mixed"},"matched_expert_count_capacity":{"metrics":{"checkpoint_size_bytes":46064,"drift_accuracy":1.0,"expert_count":69,"expert_evaluations":2231,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":12.039416362442042,"reconstruction_rmse":11.313390448571386,"retention_accuracy":1.0,"training_evaluations":2967552},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":122,"planning_belief_set_rate":-0.28125,"planning_exact_state_rate":-0.28125,"prediction_rmse":0.5562355465300186,"reconstruction_rmse":0.41356965051584105,"retention_accuracy":0.0,"training_evaluations":-1580648},"pareto_relation":"mixed"},"nearest_centroid_16_no_recursive_births":{"metrics":{"checkpoint_size_bytes":15854,"drift_accuracy":0.3125,"expert_count":16,"expert_evaluations":4096,"planning_belief_set_rate":0.421875,"planning_exact_state_rate":0.140625,"prediction_rmse":27.499142373289533,"reconstruction_rmse":24.958068994334113,"retention_accuracy":0.3046875,"training_evaluations":253952},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":30210,"drift_accuracy":0.6875,"expert_count":53,"expert_evaluations":-1743,"planning_belief_set_rate":0.296875,"planning_exact_state_rate":0.578125,"prediction_rmse":-14.903490464317473,"reconstruction_rmse":-13.231108895246885,"retention_accuracy":0.6953125,"training_evaluations":1132952},"pareto_relation":"mixed"},"no_adaptation_static":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.90234375,"expert_count":64,"expert_evaluations":2608,"planning_belief_set_rate":0.65625,"planning_exact_state_rate":0.578125,"prediction_rmse":13.859491572661979,"reconstruction_rmse":12.913145962262412,"retention_accuracy":0.92578125,"training_evaluations":565216},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":2850,"drift_accuracy":0.09765625,"expert_count":5,"expert_evaluations":-255,"planning_belief_set_rate":0.0625,"planning_exact_state_rate":0.140625,"prediction_rmse":-1.263839663689918,"reconstruction_rmse":-1.1861858631751847,"retention_accuracy":0.07421875,"training_evaluations":821688},"pareto_relation":"mixed"},"periodic_replay_policy":{"metrics":{"checkpoint_size_bytes":45494,"drift_accuracy":1.0,"expert_count":68,"expert_evaluations":2348,"planning_belief_set_rate":0.71875,"planning_exact_state_rate":0.71875,"prediction_rmse":12.596758948412727,"reconstruction_rmse":11.740055496498819,"retention_accuracy":1.0,"training_evaluations":1146264},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":570,"drift_accuracy":0.0,"expert_count":1,"expert_evaluations":5,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":-0.0011070394406669237,"reconstruction_rmse":-0.013095397411591492,"retention_accuracy":0.0,"training_evaluations":240640},"pareto_relation":"mixed"},"ravel_0_5_candidate":{"metrics":{"checkpoint_size_bytes":46064,"drift_accuracy":1.0,"expert_count":69,"expert_evaluations":2353,"planning_belief_set_rate":0.71875,"planning_exact_state_rate":0.71875,"prediction_rmse":12.59565190897206,"reconstruction_rmse":11.726960099087227,"retention_accuracy":1.0,"training_evaluations":1386904},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"equivalent"},"ravel_complete_scan_without_certification":{"metrics":{"checkpoint_size_bytes":46064,"drift_accuracy":1.0,"expert_count":69,"expert_evaluations":17664,"planning_belief_set_rate":0.71875,"planning_exact_state_rate":0.71875,"prediction_rmse":12.59565190897206,"reconstruction_rmse":11.726960099087227,"retention_accuracy":1.0,"training_evaluations":1571856},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":-15311,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":-184952},"pareto_relation":"candidate_dominates"},"ravel_no_birth_same_replay_iterations":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.90234375,"expert_count":64,"expert_evaluations":2608,"planning_belief_set_rate":0.65625,"planning_exact_state_rate":0.578125,"prediction_rmse":13.859491572661979,"reconstruction_rmse":12.913145962262412,"retention_accuracy":0.92578125,"training_evaluations":790208},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":2850,"drift_accuracy":0.09765625,"expert_count":5,"expert_evaluations":-255,"planning_belief_set_rate":0.0625,"planning_exact_state_rate":0.140625,"prediction_rmse":-1.263839663689918,"reconstruction_rmse":-1.1861858631751847,"retention_accuracy":0.07421875,"training_evaluations":596696},"pareto_relation":"mixed"},"ravel_random_births":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.90234375,"expert_count":64,"expert_evaluations":2608,"planning_belief_set_rate":0.65625,"planning_exact_state_rate":0.578125,"prediction_rmse":13.859491572661979,"reconstruction_rmse":12.913145962262412,"retention_accuracy":0.92578125,"training_evaluations":790208},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":2850,"drift_accuracy":0.09765625,"expert_count":5,"expert_evaluations":-255,"planning_belief_set_rate":0.0625,"planning_exact_state_rate":0.140625,"prediction_rmse":-1.263839663689918,"reconstruction_rmse":-1.1861858631751847,"retention_accuracy":0.07421875,"training_evaluations":596696},"pareto_relation":"mixed"},"ravel_without_replay":{"metrics":{"checkpoint_size_bytes":46064,"drift_accuracy":1.0,"expert_count":69,"expert_evaluations":2414,"planning_belief_set_rate":0.71875,"planning_exact_state_rate":0.71875,"prediction_rmse":12.56714825957557,"reconstruction_rmse":11.738365645886741,"retention_accuracy":1.0,"training_evaluations":1035812},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":-61,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.02850364939649097,"reconstruction_rmse":-0.011405546799514,"retention_accuracy":0.0,"training_evaluations":351092},"pareto_relation":"mixed"},"ravel_without_retirement_matched_work":{"metrics":{"checkpoint_size_bytes":46064,"drift_accuracy":1.0,"expert_count":69,"expert_evaluations":2353,"planning_belief_set_rate":0.71875,"planning_exact_state_rate":0.71875,"prediction_rmse":12.59565190897206,"reconstruction_rmse":11.726960099087227,"retention_accuracy":1.0,"training_evaluations":1386904},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"equivalent"}},"gates":[{"gate_id":"adaptation_completed","metric":"adaptation_completed","observed":true,"operator":"eq","pass":true,"rationale":"The bounded adaptation procedure must complete.","threshold":true},{"gate_id":"base_holdout_accuracy","metric":"base_accuracy","observed":0.9296875,"operator":"ge","pass":true,"rationale":"The base representation must establish the bounded task before drift.","threshold":0.85},{"gate_id":"base_holdout_retention","metric":"retention_accuracy","observed":1.0,"operator":"ge","pass":true,"rationale":"Anchored base behavior may lose at most ten percentage points in absolute retained accuracy.","threshold":0.9},{"gate_id":"routing_oracle_equivalence","metric":"routing_mismatches","observed":0,"operator":"eq","pass":true,"rationale":"Every routed classification must agree with complete scan.","threshold":0},{"gate_id":"checkpoint_roundtrip","metric":"checkpoint_roundtrip","observed":true,"operator":"eq","pass":true,"rationale":"Canonical in-memory restoration must succeed.","threshold":true},{"gate_id":"checkpoint_identity","metric":"checkpoint_identity","observed":true,"operator":"eq","pass":true,"rationale":"Restored complete model identity must match.","threshold":true},{"gate_id":"checkpoint_behavior","metric":"checkpoint_behavior","observed":true,"operator":"eq","pass":true,"rationale":"Restored evaluation and planning behavior must match.","threshold":true},{"gate_id":"checkpoint_mutation_rejection","metric":"checkpoint_mutations","observed":true,"operator":"eq","pass":true,"rationale":"Every declared behavioral and byte-level checkpoint mutation must be detected.","threshold":true},{"gate_id":"lineage_invariants","metric":"lineage_invariants","observed":true,"operator":"eq","pass":true,"rationale":"Generation, lineage uniqueness, descendant splitting, and deterministic topology invariants must hold.","threshold":true},{"gate_id":"unsupported_transitions_unknown","metric":"unsupported_graph_edge_violations","observed":0,"operator":"eq","pass":true,"rationale":"Unsupported actions cannot enter the planning graph.","threshold":0},{"gate_id":"replay_size","metric":"replay_selected","observed":256,"operator":"eq","pass":true,"rationale":"The declared replay budget must be filled on the non-sparse trial corpus.","threshold":256},{"gate_id":"replay_unique","metric":"replay_unique","observed":256,"operator":"eq","pass":true,"rationale":"Balanced replay cannot introduce accidental duplicates.","threshold":256},{"gate_id":"replay_label_coverage","metric":"replay_labels_covered","observed":8,"operator":"eq","pass":true,"rationale":"Replay must retain every declared label.","threshold":8},{"gate_id":"replay_action_coverage","metric":"replay_actions_covered","observed":4,"operator":"eq","pass":true,"rationale":"Replay must retain every declared action.","threshold":4},{"gate_id":"replay_state_coverage","metric":"replay_states_covered","observed":64,"operator":"ge","pass":true,"rationale":"Replay must cover at least 60 of 64 source states.","threshold":60},{"gate_id":"replay_expert_coverage","metric":"replay_experts_covered","observed":63,"operator":"ge","pass":true,"rationale":"Replay must retain broad assigned-expert coverage.","threshold":60},{"gate_id":"replay_transition_coverage","metric":"replay_transition_pairs_covered","observed":252,"operator":"ge","pass":true,"rationale":"Replay must preserve broad source-state/action transition support.","threshold":220},{"gate_id":"planning_path_found","metric":"path_found_rate","observed":1.0,"operator":"ge","pass":true,"rationale":"At least three quarters of bounded planning cases must have a supported path.","threshold":0.75},{"gate_id":"expert_capacity","metric":"expert_count","observed":69,"operator":"le","pass":true,"rationale":"Adaptation cannot exceed the declared expert capacity.","threshold":80},{"gate_id":"retirement_budget","metric":"accepted_retirements","observed":0,"operator":"le","pass":true,"rationale":"Retirement remains optional and bounded.","threshold":4},{"gate_id":"topology_objective_non_degradation","metric":"topology_objective_gain_q20","observed":21271,"operator":"ge","pass":true,"rationale":"Accepted adaptation-training topology decisions cannot reduce their declared objective.","threshold":0},{"gate_id":"matched_compute_budget","metric":"matched_compute_training_evaluation_ratio","observed":0.9465732631532968,"operator":"le","pass":true,"rationale":"Candidate training work may exceed the matched fixed-topology budget by at most ten percent.","threshold":1.1},{"gate_id":"conditional_inference_efficiency","metric":"inference_evaluation_ratio_vs_flat64","observed":0.14361572265625,"operator":"le","pass":true,"rationale":"Routed inference must use at most one quarter of flat complete-scan expert evaluations.","threshold":0.25},{"gate_id":"noise_accuracy","metric":"adapted_drift_accuracy","observed":1.0,"operator":"ge","pass":true,"rationale":"Noisy observations must retain high adapted classification.","threshold":0.9},{"gate_id":"noise_non_inferiority","metric":"drift_accuracy_delta","observed":0.09765625,"operator":"ge","pass":true,"rationale":"Limited headroom uses non-inferiority rather than a fixed gain.","threshold":-0.02},{"gate_id":"noise_headroom","metric":"headroom_normalized_accuracy_improvement","observed":1.0,"operator":"ge","pass":true,"rationale":"Available accuracy headroom cannot worsen.","threshold":0},{"gate_id":"noise_reconstruction","metric":"reconstruction_improvement_ratio","observed":0.09185878225505338,"operator":"ge","pass":true,"rationale":"Adaptation cannot worsen reconstruction under increased noise.","threshold":0},{"gate_id":"noise_prediction","metric":"prediction_improvement_ratio","observed":0.09118946803090942,"operator":"ge","pass":true,"rationale":"Adaptation cannot worsen prediction under increased noise.","threshold":0},{"gate_id":"noise_exact_planning","metric":"exact_state_rate","observed":0.71875,"operator":"ge","pass":true,"rationale":"Noise permits a lower but explicit exact-state planning floor.","threshold":0.5},{"gate_id":"noise_bounded_births","metric":"accepted_births","observed":5,"operator":"le","pass":true,"rationale":"The low-drift regime cannot consume the full topology budget.","threshold":12}],"metrics":{"accepted_births":5,"accepted_retirements":0,"adaptation_completed":true,"adaptation_training_accuracy":1.0,"adapted_drift_accuracy":1.0,"adapted_prediction_rmse":12.59565190897206,"adapted_reconstruction_rmse":11.726960099087227,"adapted_transition_accuracy":0.9288702928870293,"balanced_vs_periodic_drift_accuracy_delta":0.0,"balanced_vs_periodic_retention_delta":0.0,"base_accuracy":0.9296875,"base_prediction_rmse":10.438817583774997,"base_reconstruction_rmse":9.354676876072835,"belief_set_rate":0.71875,"belief_set_rate_delta":0.0625,"checkpoint_behavior":true,"checkpoint_identity":true,"checkpoint_mutations":true,"checkpoint_roundtrip":true,"checkpoint_size_bytes":46064,"drift_accuracy_delta":0.09765625,"exact_state_rate":0.71875,"exact_state_rate_delta":0.140625,"expert_count":69,"headroom_normalized_accuracy_improvement":1.0,"inference_evaluation_ratio_vs_flat64":0.14361572265625,"inference_expert_evaluations":2353,"lineage_invariants":true,"matched_compute_drift_accuracy_delta":0.09765625,"matched_compute_retention_delta":0.07421875,"matched_compute_training_evaluation_ratio":0.9465732631532968,"no_birth_drift_accuracy_delta":0.09765625,"no_retirement_drift_accuracy_delta":0.0,"path_found_rate":1.0,"prediction_improvement_ratio":0.09118946803090942,"reconstruction_improvement_ratio":0.09185878225505338,"replay_actions_covered":4,"replay_experts_covered":63,"replay_labels_covered":8,"replay_selected":256,"replay_states_covered":64,"replay_transition_pairs_covered":252,"replay_unique":256,"retention_accuracy":1.0,"retention_accuracy_delta_from_base":0.0703125,"retention_prediction_degradation":-0.548441690271785,"retention_prediction_rmse":9.890375893503212,"retention_reconstruction_degradation_ratio":-0.05332414511835936,"retention_reconstruction_rmse":8.855846728797767,"retention_transition_accuracy_delta":0.033575380359612716,"routing_mismatches":0,"static_belief_set_rate":0.65625,"static_drift_accuracy":0.90234375,"static_exact_state_rate":0.578125,"static_prediction_rmse":13.859491572661979,"static_reconstruction_rmse":12.913145962262412,"static_transition_accuracy":0.891213389121339,"topology_objective_gain_q20":21271,"training_evaluations":1386904,"transition_accuracy_delta":0.03765690376569031,"transition_support_rate":0.93359375,"unsupported_graph_edge_violations":0},"regime":"increased_observation_noise","seed":"0x44ed3e5b3038b65f","trial_id":"validation-noise-01","trial_result":"PASS"},{"comparisons":{"fixed_8_expert":{"metrics":{"checkpoint_size_bytes":11294,"drift_accuracy":0.1953125,"expert_count":8,"expert_evaluations":2048,"planning_belief_set_rate":0.25,"planning_exact_state_rate":0.0,"prediction_rmse":32.3346031893323,"reconstruction_rmse":30.564855922254804,"retention_accuracy":0.16796875,"training_evaluations":94208},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":34770,"drift_accuracy":0.8046875,"expert_count":61,"expert_evaluations":244,"planning_belief_set_rate":0.671875,"planning_exact_state_rate":0.921875,"prediction_rmse":-19.89395021485757,"reconstruction_rmse":-18.769406946151026,"retention_accuracy":0.83203125,"training_evaluations":1427131},"pareto_relation":"mixed"},"fixed_topology_64_expert_routed":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":1.0,"expert_count":64,"expert_evaluations":2216,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":12.008293121307155,"reconstruction_rmse":11.636376321859839,"retention_accuracy":1.0,"training_evaluations":2588672},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":2850,"drift_accuracy":0.0,"expert_count":5,"expert_evaluations":76,"planning_belief_set_rate":-0.078125,"planning_exact_state_rate":-0.078125,"prediction_rmse":0.43235985316757386,"reconstruction_rmse":0.15907265424393913,"retention_accuracy":0.0,"training_evaluations":-1067333},"pareto_relation":"mixed"},"flat_64_expert_complete_scan":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":1.0,"expert_count":64,"expert_evaluations":16384,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":12.008293121307155,"reconstruction_rmse":11.636376321859839,"retention_accuracy":1.0,"training_evaluations":2588672},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":2850,"drift_accuracy":0.0,"expert_count":5,"expert_evaluations":-14092,"planning_belief_set_rate":-0.078125,"planning_exact_state_rate":-0.078125,"prediction_rmse":0.43235985316757386,"reconstruction_rmse":0.15907265424393913,"retention_accuracy":0.0,"training_evaluations":-1067333},"pareto_relation":"mixed"},"matched_compute_fixed_topology":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.96484375,"expert_count":64,"expert_evaluations":2440,"planning_belief_set_rate":0.71875,"planning_exact_state_rate":0.65625,"prediction_rmse":13.140813261827056,"reconstruction_rmse":12.41277751589341,"retention_accuracy":0.9609375,"training_evaluations":1704088},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":2850,"drift_accuracy":0.03515625,"expert_count":5,"expert_evaluations":-148,"planning_belief_set_rate":0.203125,"planning_exact_state_rate":0.265625,"prediction_rmse":-0.7001602873523272,"reconstruction_rmse":-0.6173285397896322,"retention_accuracy":0.0390625,"training_evaluations":-182749},"pareto_relation":"mixed"},"matched_expert_count_capacity":{"metrics":{"checkpoint_size_bytes":46064,"drift_accuracy":1.0,"expert_count":69,"expert_evaluations":2231,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":12.039184016486749,"reconstruction_rmse":11.580259596931107,"retention_accuracy":1.0,"training_evaluations":2967552},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":61,"planning_belief_set_rate":-0.078125,"planning_exact_state_rate":-0.078125,"prediction_rmse":0.40146895798798,"reconstruction_rmse":0.21518937917267067,"retention_accuracy":0.0,"training_evaluations":-1446213},"pareto_relation":"mixed"},"nearest_centroid_16_no_recursive_births":{"metrics":{"checkpoint_size_bytes":15854,"drift_accuracy":0.2421875,"expert_count":16,"expert_evaluations":4096,"planning_belief_set_rate":0.421875,"planning_exact_state_rate":0.046875,"prediction_rmse":27.441369370829417,"reconstruction_rmse":25.644013884272624,"retention_accuracy":0.21875,"training_evaluations":253952},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":30210,"drift_accuracy":0.7578125,"expert_count":53,"expert_evaluations":-1804,"planning_belief_set_rate":0.5,"planning_exact_state_rate":0.875,"prediction_rmse":-15.000716396354688,"reconstruction_rmse":-13.848564908168846,"retention_accuracy":0.78125,"training_evaluations":1267387},"pareto_relation":"mixed"},"no_adaptation_static":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.96484375,"expert_count":64,"expert_evaluations":2440,"planning_belief_set_rate":0.71875,"planning_exact_state_rate":0.65625,"prediction_rmse":13.140813261827056,"reconstruction_rmse":12.41277751589341,"retention_accuracy":0.9609375,"training_evaluations":574648},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":2850,"drift_accuracy":0.03515625,"expert_count":5,"expert_evaluations":-148,"planning_belief_set_rate":0.203125,"planning_exact_state_rate":0.265625,"prediction_rmse":-0.7001602873523272,"reconstruction_rmse":-0.6173285397896322,"retention_accuracy":0.0390625,"training_evaluations":946691},"pareto_relation":"mixed"},"periodic_replay_policy":{"metrics":{"checkpoint_size_bytes":45494,"drift_accuracy":1.0,"expert_count":68,"expert_evaluations":2288,"planning_belief_set_rate":0.921875,"planning_exact_state_rate":0.921875,"prediction_rmse":12.566567116987278,"reconstruction_rmse":11.857537865464135,"retention_accuracy":1.0,"training_evaluations":1273398},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":570,"drift_accuracy":0.0,"expert_count":1,"expert_evaluations":4,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":-0.12591414251254918,"reconstruction_rmse":-0.06208888936035706,"retention_accuracy":0.0,"training_evaluations":247941},"pareto_relation":"mixed"},"ravel_0_5_candidate":{"metrics":{"checkpoint_size_bytes":46064,"drift_accuracy":1.0,"expert_count":69,"expert_evaluations":2292,"planning_belief_set_rate":0.921875,"planning_exact_state_rate":0.921875,"prediction_rmse":12.440652974474729,"reconstruction_rmse":11.795448976103778,"retention_accuracy":1.0,"training_evaluations":1521339},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"equivalent"},"ravel_complete_scan_without_certification":{"metrics":{"checkpoint_size_bytes":46064,"drift_accuracy":1.0,"expert_count":69,"expert_evaluations":17664,"planning_belief_set_rate":0.921875,"planning_exact_state_rate":0.921875,"prediction_rmse":12.440652974474729,"reconstruction_rmse":11.795448976103778,"retention_accuracy":1.0,"training_evaluations":1709571},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":-15372,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":-188232},"pareto_relation":"candidate_dominates"},"ravel_no_birth_same_replay_iterations":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.96484375,"expert_count":64,"expert_evaluations":2440,"planning_belief_set_rate":0.71875,"planning_exact_state_rate":0.65625,"prediction_rmse":13.140813261827056,"reconstruction_rmse":12.41277751589341,"retention_accuracy":0.9609375,"training_evaluations":800536},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":2850,"drift_accuracy":0.03515625,"expert_count":5,"expert_evaluations":-148,"planning_belief_set_rate":0.203125,"planning_exact_state_rate":0.265625,"prediction_rmse":-0.7001602873523272,"reconstruction_rmse":-0.6173285397896322,"retention_accuracy":0.0390625,"training_evaluations":720803},"pareto_relation":"mixed"},"ravel_random_births":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.96484375,"expert_count":64,"expert_evaluations":2440,"planning_belief_set_rate":0.71875,"planning_exact_state_rate":0.65625,"prediction_rmse":13.140813261827056,"reconstruction_rmse":12.41277751589341,"retention_accuracy":0.9609375,"training_evaluations":800536},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":2850,"drift_accuracy":0.03515625,"expert_count":5,"expert_evaluations":-148,"planning_belief_set_rate":0.203125,"planning_exact_state_rate":0.265625,"prediction_rmse":-0.7001602873523272,"reconstruction_rmse":-0.6173285397896322,"retention_accuracy":0.0390625,"training_evaluations":720803},"pareto_relation":"mixed"},"ravel_without_replay":{"metrics":{"checkpoint_size_bytes":45494,"drift_accuracy":1.0,"expert_count":68,"expert_evaluations":2348,"planning_belief_set_rate":0.9375,"planning_exact_state_rate":0.9375,"prediction_rmse":12.578463170746682,"reconstruction_rmse":11.86122651298469,"retention_accuracy":1.0,"training_evaluations":1041833},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":570,"drift_accuracy":0.0,"expert_count":1,"expert_evaluations":-56,"planning_belief_set_rate":-0.015625,"planning_exact_state_rate":-0.015625,"prediction_rmse":-0.13781019627195334,"reconstruction_rmse":-0.06577753688091192,"retention_accuracy":0.0,"training_evaluations":479506},"pareto_relation":"mixed"},"ravel_without_retirement_matched_work":{"metrics":{"checkpoint_size_bytes":46634,"drift_accuracy":1.0,"expert_count":70,"expert_evaluations":2296,"planning_belief_set_rate":0.921875,"planning_exact_state_rate":0.921875,"prediction_rmse":12.440652974474729,"reconstruction_rmse":11.792364590768793,"retention_accuracy":1.0,"training_evaluations":1521339},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":-570,"drift_accuracy":0.0,"expert_count":-1,"expert_evaluations":-4,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.003084385334984674,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"mixed"}},"gates":[{"gate_id":"adaptation_completed","metric":"adaptation_completed","observed":true,"operator":"eq","pass":true,"rationale":"The bounded adaptation procedure must complete.","threshold":true},{"gate_id":"base_holdout_accuracy","metric":"base_accuracy","observed":0.94921875,"operator":"ge","pass":true,"rationale":"The base representation must establish the bounded task before drift.","threshold":0.85},{"gate_id":"base_holdout_retention","metric":"retention_accuracy","observed":1.0,"operator":"ge","pass":true,"rationale":"Anchored base behavior may lose at most ten percentage points in absolute retained accuracy.","threshold":0.9},{"gate_id":"routing_oracle_equivalence","metric":"routing_mismatches","observed":0,"operator":"eq","pass":true,"rationale":"Every routed classification must agree with complete scan.","threshold":0},{"gate_id":"checkpoint_roundtrip","metric":"checkpoint_roundtrip","observed":true,"operator":"eq","pass":true,"rationale":"Canonical in-memory restoration must succeed.","threshold":true},{"gate_id":"checkpoint_identity","metric":"checkpoint_identity","observed":true,"operator":"eq","pass":true,"rationale":"Restored complete model identity must match.","threshold":true},{"gate_id":"checkpoint_behavior","metric":"checkpoint_behavior","observed":true,"operator":"eq","pass":true,"rationale":"Restored evaluation and planning behavior must match.","threshold":true},{"gate_id":"checkpoint_mutation_rejection","metric":"checkpoint_mutations","observed":true,"operator":"eq","pass":true,"rationale":"Every declared behavioral and byte-level checkpoint mutation must be detected.","threshold":true},{"gate_id":"lineage_invariants","metric":"lineage_invariants","observed":true,"operator":"eq","pass":true,"rationale":"Generation, lineage uniqueness, descendant splitting, and deterministic topology invariants must hold.","threshold":true},{"gate_id":"unsupported_transitions_unknown","metric":"unsupported_graph_edge_violations","observed":0,"operator":"eq","pass":true,"rationale":"Unsupported actions cannot enter the planning graph.","threshold":0},{"gate_id":"replay_size","metric":"replay_selected","observed":256,"operator":"eq","pass":true,"rationale":"The declared replay budget must be filled on the non-sparse trial corpus.","threshold":256},{"gate_id":"replay_unique","metric":"replay_unique","observed":256,"operator":"eq","pass":true,"rationale":"Balanced replay cannot introduce accidental duplicates.","threshold":256},{"gate_id":"replay_label_coverage","metric":"replay_labels_covered","observed":8,"operator":"eq","pass":true,"rationale":"Replay must retain every declared label.","threshold":8},{"gate_id":"replay_action_coverage","metric":"replay_actions_covered","observed":4,"operator":"eq","pass":true,"rationale":"Replay must retain every declared action.","threshold":4},{"gate_id":"replay_state_coverage","metric":"replay_states_covered","observed":64,"operator":"ge","pass":true,"rationale":"Replay must cover at least 60 of 64 source states.","threshold":60},{"gate_id":"replay_expert_coverage","metric":"replay_experts_covered","observed":64,"operator":"ge","pass":true,"rationale":"Replay must retain broad assigned-expert coverage.","threshold":60},{"gate_id":"replay_transition_coverage","metric":"replay_transition_pairs_covered","observed":251,"operator":"ge","pass":true,"rationale":"Replay must preserve broad source-state/action transition support.","threshold":220},{"gate_id":"planning_path_found","metric":"path_found_rate","observed":1.0,"operator":"ge","pass":true,"rationale":"At least three quarters of bounded planning cases must have a supported path.","threshold":0.75},{"gate_id":"expert_capacity","metric":"expert_count","observed":69,"operator":"le","pass":true,"rationale":"Adaptation cannot exceed the declared expert capacity.","threshold":80},{"gate_id":"retirement_budget","metric":"accepted_retirements","observed":1,"operator":"le","pass":true,"rationale":"Retirement remains optional and bounded.","threshold":4},{"gate_id":"topology_objective_non_degradation","metric":"topology_objective_gain_q20","observed":20833,"operator":"ge","pass":true,"rationale":"Accepted adaptation-training topology decisions cannot reduce their declared objective.","threshold":0},{"gate_id":"matched_compute_budget","metric":"matched_compute_training_evaluation_ratio","observed":0.8927584725671445,"operator":"le","pass":true,"rationale":"Candidate training work may exceed the matched fixed-topology budget by at most ten percent.","threshold":1.1},{"gate_id":"conditional_inference_efficiency","metric":"inference_evaluation_ratio_vs_flat64","observed":0.139892578125,"operator":"le","pass":true,"rationale":"Routed inference must use at most one quarter of flat complete-scan expert evaluations.","threshold":0.25},{"gate_id":"noise_accuracy","metric":"adapted_drift_accuracy","observed":1.0,"operator":"ge","pass":true,"rationale":"Noisy observations must retain high adapted classification.","threshold":0.9},{"gate_id":"noise_non_inferiority","metric":"drift_accuracy_delta","observed":0.03515625,"operator":"ge","pass":true,"rationale":"Limited headroom uses non-inferiority rather than a fixed gain.","threshold":-0.02},{"gate_id":"noise_headroom","metric":"headroom_normalized_accuracy_improvement","observed":1.0,"operator":"ge","pass":true,"rationale":"Available accuracy headroom cannot worsen.","threshold":0},{"gate_id":"noise_reconstruction","metric":"reconstruction_improvement_ratio","observed":0.04973331222598651,"operator":"ge","pass":true,"rationale":"Adaptation cannot worsen reconstruction under increased noise.","threshold":0},{"gate_id":"noise_prediction","metric":"prediction_improvement_ratio","observed":0.05328135126813142,"operator":"ge","pass":true,"rationale":"Adaptation cannot worsen prediction under increased noise.","threshold":0},{"gate_id":"noise_exact_planning","metric":"exact_state_rate","observed":0.921875,"operator":"ge","pass":true,"rationale":"Noise permits a lower but explicit exact-state planning floor.","threshold":0.5},{"gate_id":"noise_bounded_births","metric":"accepted_births","observed":6,"operator":"le","pass":true,"rationale":"The low-drift regime cannot consume the full topology budget.","threshold":12}],"metrics":{"accepted_births":6,"accepted_retirements":1,"adaptation_completed":true,"adaptation_training_accuracy":1.0,"adapted_drift_accuracy":1.0,"adapted_prediction_rmse":12.440652974474729,"adapted_reconstruction_rmse":11.795448976103778,"adapted_transition_accuracy":0.9594594594594594,"balanced_vs_periodic_drift_accuracy_delta":0.0,"balanced_vs_periodic_retention_delta":0.0,"base_accuracy":0.94921875,"base_prediction_rmse":10.554364295548776,"base_reconstruction_rmse":9.665219863925534,"belief_set_rate":0.921875,"belief_set_rate_delta":0.203125,"checkpoint_behavior":true,"checkpoint_identity":true,"checkpoint_mutations":true,"checkpoint_roundtrip":true,"checkpoint_size_bytes":46064,"drift_accuracy_delta":0.03515625,"exact_state_rate":0.921875,"exact_state_rate_delta":0.265625,"expert_count":69,"headroom_normalized_accuracy_improvement":1.0,"inference_evaluation_ratio_vs_flat64":0.139892578125,"inference_expert_evaluations":2292,"lineage_invariants":true,"matched_compute_drift_accuracy_delta":0.03515625,"matched_compute_retention_delta":0.0390625,"matched_compute_training_evaluation_ratio":0.8927584725671445,"no_birth_drift_accuracy_delta":0.03515625,"no_retirement_drift_accuracy_delta":0.0,"path_found_rate":1.0,"prediction_improvement_ratio":0.05328135126813142,"reconstruction_improvement_ratio":0.04973331222598651,"replay_actions_covered":4,"replay_experts_covered":64,"replay_labels_covered":8,"replay_selected":256,"replay_states_covered":64,"replay_transition_pairs_covered":251,"replay_unique":256,"retention_accuracy":1.0,"retention_accuracy_delta_from_base":0.05078125,"retention_prediction_degradation":-1.311504440619947,"retention_prediction_rmse":9.24285985492883,"retention_reconstruction_degradation_ratio":-0.11632592003235168,"retention_reconstruction_rmse":8.540904270939436,"retention_transition_accuracy_delta":0.06848128905955875,"routing_mismatches":0,"static_belief_set_rate":0.71875,"static_drift_accuracy":0.96484375,"static_exact_state_rate":0.65625,"static_prediction_rmse":13.140813261827056,"static_reconstruction_rmse":12.41277751589341,"static_transition_accuracy":0.9336283185840708,"topology_objective_gain_q20":20833,"training_evaluations":1521339,"transition_accuracy_delta":0.025831140875388625,"transition_support_rate":0.8671875,"unsupported_graph_edge_violations":0},"regime":"increased_observation_noise","seed":"0xe8de8b800dc18a66","trial_id":"validation-noise-02","trial_result":"PASS"},{"comparisons":{"fixed_8_expert":{"metrics":{"checkpoint_size_bytes":11294,"drift_accuracy":0.171875,"expert_count":8,"expert_evaluations":2048,"planning_belief_set_rate":0.265625,"planning_exact_state_rate":0.015625,"prediction_rmse":32.99421400795676,"reconstruction_rmse":30.547452310309012,"retention_accuracy":0.16796875,"training_evaluations":94208},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":34770,"drift_accuracy":0.8203125,"expert_count":61,"expert_evaluations":488,"planning_belief_set_rate":0.6875,"planning_exact_state_rate":0.9375,"prediction_rmse":-20.385575011932346,"reconstruction_rmse":-18.57845031039868,"retention_accuracy":0.83203125,"training_evaluations":1293271},"pareto_relation":"mixed"},"fixed_topology_64_expert_routed":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":1.0,"expert_count":64,"expert_evaluations":2272,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":12.288272635760586,"reconstruction_rmse":11.678735146121433,"retention_accuracy":1.0,"training_evaluations":2588672},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":2850,"drift_accuracy":-0.0078125,"expert_count":5,"expert_evaluations":264,"planning_belief_set_rate":-0.046875,"planning_exact_state_rate":-0.046875,"prediction_rmse":0.3203663602638258,"reconstruction_rmse":0.29026685378889994,"retention_accuracy":0.0,"training_evaluations":-1201193},"pareto_relation":"mixed"},"flat_64_expert_complete_scan":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":1.0,"expert_count":64,"expert_evaluations":16384,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":12.288272635760586,"reconstruction_rmse":11.678735146121433,"retention_accuracy":1.0,"training_evaluations":2588672},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":2850,"drift_accuracy":-0.0078125,"expert_count":5,"expert_evaluations":-13848,"planning_belief_set_rate":-0.046875,"planning_exact_state_rate":-0.046875,"prediction_rmse":0.3203663602638258,"reconstruction_rmse":0.29026685378889994,"retention_accuracy":0.0,"training_evaluations":-1201193},"pareto_relation":"mixed"},"matched_compute_fixed_topology":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.96875,"expert_count":64,"expert_evaluations":2608,"planning_belief_set_rate":0.8125,"planning_exact_state_rate":0.78125,"prediction_rmse":12.869783573421376,"reconstruction_rmse":12.29429321117256,"retention_accuracy":0.96875,"training_evaluations":1462304},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":2850,"drift_accuracy":0.0234375,"expert_count":5,"expert_evaluations":-72,"planning_belief_set_rate":0.140625,"planning_exact_state_rate":0.171875,"prediction_rmse":-0.26114457739696384,"reconstruction_rmse":-0.32529121126222726,"retention_accuracy":0.03125,"training_evaluations":-74825},"pareto_relation":"mixed"},"matched_expert_count_capacity":{"metrics":{"checkpoint_size_bytes":46064,"drift_accuracy":1.0,"expert_count":69,"expert_evaluations":2353,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":12.336193687372367,"reconstruction_rmse":11.65434846344007,"retention_accuracy":1.0,"training_evaluations":2967552},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":-0.0078125,"expert_count":0,"expert_evaluations":183,"planning_belief_set_rate":-0.046875,"planning_exact_state_rate":-0.046875,"prediction_rmse":0.2724453086520455,"reconstruction_rmse":0.3146535364702636,"retention_accuracy":0.0,"training_evaluations":-1580073},"pareto_relation":"mixed"},"nearest_centroid_16_no_recursive_births":{"metrics":{"checkpoint_size_bytes":15854,"drift_accuracy":0.26171875,"expert_count":16,"expert_evaluations":4096,"planning_belief_set_rate":0.546875,"planning_exact_state_rate":0.109375,"prediction_rmse":28.13184161550654,"reconstruction_rmse":25.512761997035366,"retention_accuracy":0.27734375,"training_evaluations":253952},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":30210,"drift_accuracy":0.73046875,"expert_count":53,"expert_evaluations":-1560,"planning_belief_set_rate":0.40625,"planning_exact_state_rate":0.84375,"prediction_rmse":-15.523202619482129,"reconstruction_rmse":-13.543759997125033,"retention_accuracy":0.72265625,"training_evaluations":1133527},"pareto_relation":"mixed"},"no_adaptation_static":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.96875,"expert_count":64,"expert_evaluations":2608,"planning_belief_set_rate":0.8125,"planning_exact_state_rate":0.78125,"prediction_rmse":12.869783573421376,"reconstruction_rmse":12.29429321117256,"retention_accuracy":0.96875,"training_evaluations":568608},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":2850,"drift_accuracy":0.0234375,"expert_count":5,"expert_evaluations":-72,"planning_belief_set_rate":0.140625,"planning_exact_state_rate":0.171875,"prediction_rmse":-0.26114457739696384,"reconstruction_rmse":-0.32529121126222726,"retention_accuracy":0.03125,"training_evaluations":818871},"pareto_relation":"mixed"},"periodic_replay_policy":{"metrics":{"checkpoint_size_bytes":45494,"drift_accuracy":0.9921875,"expert_count":68,"expert_evaluations":2528,"planning_belief_set_rate":0.921875,"planning_exact_state_rate":0.921875,"prediction_rmse":12.599844686846147,"reconstruction_rmse":11.985244514780184,"retention_accuracy":1.0,"training_evaluations":1150766},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":570,"drift_accuracy":0.0,"expert_count":1,"expert_evaluations":8,"planning_belief_set_rate":0.03125,"planning_exact_state_rate":0.03125,"prediction_rmse":0.00879430917826518,"reconstruction_rmse":-0.016242514869851732,"retention_accuracy":0.0,"training_evaluations":236713},"pareto_relation":"mixed"},"ravel_0_5_candidate":{"metrics":{"checkpoint_size_bytes":46064,"drift_accuracy":0.9921875,"expert_count":69,"expert_evaluations":2536,"planning_belief_set_rate":0.953125,"planning_exact_state_rate":0.953125,"prediction_rmse":12.608638996024412,"reconstruction_rmse":11.969001999910333,"retention_accuracy":1.0,"training_evaluations":1387479},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"equivalent"},"ravel_complete_scan_without_certification":{"metrics":{"checkpoint_size_bytes":46064,"drift_accuracy":0.9921875,"expert_count":69,"expert_evaluations":17664,"planning_belief_set_rate":0.953125,"planning_exact_state_rate":0.953125,"prediction_rmse":12.608638996024412,"reconstruction_rmse":11.969001999910333,"retention_accuracy":1.0,"training_evaluations":1573407},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":-15128,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":-185928},"pareto_relation":"candidate_dominates"},"ravel_no_birth_same_replay_iterations":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.96875,"expert_count":64,"expert_evaluations":2608,"planning_belief_set_rate":0.8125,"planning_exact_state_rate":0.78125,"prediction_rmse":12.869783573421376,"reconstruction_rmse":12.29429321117256,"retention_accuracy":0.96875,"training_evaluations":792032},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":2850,"drift_accuracy":0.0234375,"expert_count":5,"expert_evaluations":-72,"planning_belief_set_rate":0.140625,"planning_exact_state_rate":0.171875,"prediction_rmse":-0.26114457739696384,"reconstruction_rmse":-0.32529121126222726,"retention_accuracy":0.03125,"training_evaluations":595447},"pareto_relation":"mixed"},"ravel_random_births":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.96875,"expert_count":64,"expert_evaluations":2608,"planning_belief_set_rate":0.8125,"planning_exact_state_rate":0.78125,"prediction_rmse":12.869783573421376,"reconstruction_rmse":12.29429321117256,"retention_accuracy":0.96875,"training_evaluations":792032},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":2850,"drift_accuracy":0.0234375,"expert_count":5,"expert_evaluations":-72,"planning_belief_set_rate":0.140625,"planning_exact_state_rate":0.171875,"prediction_rmse":-0.26114457739696384,"reconstruction_rmse":-0.32529121126222726,"retention_accuracy":0.03125,"training_evaluations":595447},"pareto_relation":"mixed"},"ravel_without_replay":{"metrics":{"checkpoint_size_bytes":46064,"drift_accuracy":0.9921875,"expert_count":69,"expert_evaluations":2597,"planning_belief_set_rate":0.921875,"planning_exact_state_rate":0.921875,"prediction_rmse":12.59531862625493,"reconstruction_rmse":11.994183488495757,"retention_accuracy":1.0,"training_evaluations":1039012},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":-61,"planning_belief_set_rate":0.03125,"planning_exact_state_rate":0.03125,"prediction_rmse":0.01332036976948281,"reconstruction_rmse":-0.02518148858542446,"retention_accuracy":0.0,"training_evaluations":348467},"pareto_relation":"mixed"},"ravel_without_retirement_matched_work":{"metrics":{"checkpoint_size_bytes":46064,"drift_accuracy":0.9921875,"expert_count":69,"expert_evaluations":2536,"planning_belief_set_rate":0.953125,"planning_exact_state_rate":0.953125,"prediction_rmse":12.608638996024412,"reconstruction_rmse":11.969001999910333,"retention_accuracy":1.0,"training_evaluations":1387479},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"equivalent"}},"gates":[{"gate_id":"adaptation_completed","metric":"adaptation_completed","observed":true,"operator":"eq","pass":true,"rationale":"The bounded adaptation procedure must complete.","threshold":true},{"gate_id":"base_holdout_accuracy","metric":"base_accuracy","observed":0.95703125,"operator":"ge","pass":true,"rationale":"The base representation must establish the bounded task before drift.","threshold":0.85},{"gate_id":"base_holdout_retention","metric":"retention_accuracy","observed":1.0,"operator":"ge","pass":true,"rationale":"Anchored base behavior may lose at most ten percentage points in absolute retained accuracy.","threshold":0.9},{"gate_id":"routing_oracle_equivalence","metric":"routing_mismatches","observed":0,"operator":"eq","pass":true,"rationale":"Every routed classification must agree with complete scan.","threshold":0},{"gate_id":"checkpoint_roundtrip","metric":"checkpoint_roundtrip","observed":true,"operator":"eq","pass":true,"rationale":"Canonical in-memory restoration must succeed.","threshold":true},{"gate_id":"checkpoint_identity","metric":"checkpoint_identity","observed":true,"operator":"eq","pass":true,"rationale":"Restored complete model identity must match.","threshold":true},{"gate_id":"checkpoint_behavior","metric":"checkpoint_behavior","observed":true,"operator":"eq","pass":true,"rationale":"Restored evaluation and planning behavior must match.","threshold":true},{"gate_id":"checkpoint_mutation_rejection","metric":"checkpoint_mutations","observed":true,"operator":"eq","pass":true,"rationale":"Every declared behavioral and byte-level checkpoint mutation must be detected.","threshold":true},{"gate_id":"lineage_invariants","metric":"lineage_invariants","observed":true,"operator":"eq","pass":true,"rationale":"Generation, lineage uniqueness, descendant splitting, and deterministic topology invariants must hold.","threshold":true},{"gate_id":"unsupported_transitions_unknown","metric":"unsupported_graph_edge_violations","observed":0,"operator":"eq","pass":true,"rationale":"Unsupported actions cannot enter the planning graph.","threshold":0},{"gate_id":"replay_size","metric":"replay_selected","observed":256,"operator":"eq","pass":true,"rationale":"The declared replay budget must be filled on the non-sparse trial corpus.","threshold":256},{"gate_id":"replay_unique","metric":"replay_unique","observed":256,"operator":"eq","pass":true,"rationale":"Balanced replay cannot introduce accidental duplicates.","threshold":256},{"gate_id":"replay_label_coverage","metric":"replay_labels_covered","observed":8,"operator":"eq","pass":true,"rationale":"Replay must retain every declared label.","threshold":8},{"gate_id":"replay_action_coverage","metric":"replay_actions_covered","observed":4,"operator":"eq","pass":true,"rationale":"Replay must retain every declared action.","threshold":4},{"gate_id":"replay_state_coverage","metric":"replay_states_covered","observed":64,"operator":"ge","pass":true,"rationale":"Replay must cover at least 60 of 64 source states.","threshold":60},{"gate_id":"replay_expert_coverage","metric":"replay_experts_covered","observed":62,"operator":"ge","pass":true,"rationale":"Replay must retain broad assigned-expert coverage.","threshold":60},{"gate_id":"replay_transition_coverage","metric":"replay_transition_pairs_covered","observed":252,"operator":"ge","pass":true,"rationale":"Replay must preserve broad source-state/action transition support.","threshold":220},{"gate_id":"planning_path_found","metric":"path_found_rate","observed":1.0,"operator":"ge","pass":true,"rationale":"At least three quarters of bounded planning cases must have a supported path.","threshold":0.75},{"gate_id":"expert_capacity","metric":"expert_count","observed":69,"operator":"le","pass":true,"rationale":"Adaptation cannot exceed the declared expert capacity.","threshold":80},{"gate_id":"retirement_budget","metric":"accepted_retirements","observed":0,"operator":"le","pass":true,"rationale":"Retirement remains optional and bounded.","threshold":4},{"gate_id":"topology_objective_non_degradation","metric":"topology_objective_gain_q20","observed":7907,"operator":"ge","pass":true,"rationale":"Accepted adaptation-training topology decisions cannot reduce their declared objective.","threshold":0},{"gate_id":"matched_compute_budget","metric":"matched_compute_training_evaluation_ratio","observed":0.9488307492833228,"operator":"le","pass":true,"rationale":"Candidate training work may exceed the matched fixed-topology budget by at most ten percent.","threshold":1.1},{"gate_id":"conditional_inference_efficiency","metric":"inference_evaluation_ratio_vs_flat64","observed":0.15478515625,"operator":"le","pass":true,"rationale":"Routed inference must use at most one quarter of flat complete-scan expert evaluations.","threshold":0.25},{"gate_id":"noise_accuracy","metric":"adapted_drift_accuracy","observed":0.9921875,"operator":"ge","pass":true,"rationale":"Noisy observations must retain high adapted classification.","threshold":0.9},{"gate_id":"noise_non_inferiority","metric":"drift_accuracy_delta","observed":0.0234375,"operator":"ge","pass":true,"rationale":"Limited headroom uses non-inferiority rather than a fixed gain.","threshold":-0.02},{"gate_id":"noise_headroom","metric":"headroom_normalized_accuracy_improvement","observed":0.75,"operator":"ge","pass":true,"rationale":"Available accuracy headroom cannot worsen.","threshold":0},{"gate_id":"noise_reconstruction","metric":"reconstruction_improvement_ratio","observed":0.026458715899716437,"operator":"ge","pass":true,"rationale":"Adaptation cannot worsen reconstruction under increased noise.","threshold":0},{"gate_id":"noise_prediction","metric":"prediction_improvement_ratio","observed":0.02029129518046275,"operator":"ge","pass":true,"rationale":"Adaptation cannot worsen prediction under increased noise.","threshold":0},{"gate_id":"noise_exact_planning","metric":"exact_state_rate","observed":0.953125,"operator":"ge","pass":true,"rationale":"Noise permits a lower but explicit exact-state planning floor.","threshold":0.5},{"gate_id":"noise_bounded_births","metric":"accepted_births","observed":5,"operator":"le","pass":true,"rationale":"The low-drift regime cannot consume the full topology budget.","threshold":12}],"metrics":{"accepted_births":5,"accepted_retirements":0,"adaptation_completed":true,"adaptation_training_accuracy":1.0,"adapted_drift_accuracy":0.9921875,"adapted_prediction_rmse":12.608638996024412,"adapted_reconstruction_rmse":11.969001999910333,"adapted_transition_accuracy":0.9732142857142857,"balanced_vs_periodic_drift_accuracy_delta":0.0,"balanced_vs_periodic_retention_delta":0.0,"base_accuracy":0.95703125,"base_prediction_rmse":10.190957038442242,"base_reconstruction_rmse":9.417042259125518,"belief_set_rate":0.953125,"belief_set_rate_delta":0.140625,"checkpoint_behavior":true,"checkpoint_identity":true,"checkpoint_mutations":true,"checkpoint_roundtrip":true,"checkpoint_size_bytes":46064,"drift_accuracy_delta":0.0234375,"exact_state_rate":0.953125,"exact_state_rate_delta":0.171875,"expert_count":69,"headroom_normalized_accuracy_improvement":0.75,"inference_evaluation_ratio_vs_flat64":0.15478515625,"inference_expert_evaluations":2536,"lineage_invariants":true,"matched_compute_drift_accuracy_delta":0.0234375,"matched_compute_retention_delta":0.03125,"matched_compute_training_evaluation_ratio":0.9488307492833228,"no_birth_drift_accuracy_delta":0.0234375,"no_retirement_drift_accuracy_delta":0.0,"path_found_rate":1.0,"prediction_improvement_ratio":0.02029129518046275,"reconstruction_improvement_ratio":0.026458715899716437,"replay_actions_covered":4,"replay_experts_covered":62,"replay_labels_covered":8,"replay_selected":256,"replay_states_covered":64,"replay_transition_pairs_covered":252,"replay_unique":256,"retention_accuracy":1.0,"retention_accuracy_delta_from_base":0.04296875,"retention_prediction_degradation":-0.913467257187774,"retention_prediction_rmse":9.277489781254468,"retention_reconstruction_degradation_ratio":-0.11158484391105508,"retention_reconstruction_rmse":8.366243068537187,"retention_transition_accuracy_delta":0.03225867269984917,"routing_mismatches":0,"static_belief_set_rate":0.8125,"static_drift_accuracy":0.96875,"static_exact_state_rate":0.78125,"static_prediction_rmse":12.869783573421376,"static_reconstruction_rmse":12.29429321117256,"static_transition_accuracy":0.9642857142857143,"topology_objective_gain_q20":7907,"training_evaluations":1387479,"transition_accuracy_delta":0.008928571428571397,"transition_support_rate":0.875,"unsupported_graph_edge_violations":0},"regime":"increased_observation_noise","seed":"0x0f5d03772bddb16f","trial_id":"validation-noise-03","trial_result":"PASS"},{"comparisons":{"fixed_8_expert":{"metrics":{"checkpoint_size_bytes":11294,"drift_accuracy":0.23828125,"expert_count":8,"expert_evaluations":2048,"planning_belief_set_rate":0.28125,"planning_exact_state_rate":0.03125,"prediction_rmse":33.1271624756149,"reconstruction_rmse":30.981199044721045,"retention_accuracy":0.1953125,"training_evaluations":94208},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":34770,"drift_accuracy":0.76171875,"expert_count":61,"expert_evaluations":366,"planning_belief_set_rate":0.40625,"planning_exact_state_rate":0.65625,"prediction_rmse":-20.6426864349977,"reconstruction_rmse":-19.202196526929594,"retention_accuracy":0.8046875,"training_evaluations":1305010},"pareto_relation":"mixed"},"fixed_topology_64_expert_routed":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":1.0,"expert_count":64,"expert_evaluations":2216,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":12.00092396143413,"reconstruction_rmse":11.504561005775365,"retention_accuracy":1.0,"training_evaluations":2588672},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":2850,"drift_accuracy":0.0,"expert_count":5,"expert_evaluations":198,"planning_belief_set_rate":-0.3125,"planning_exact_state_rate":-0.3125,"prediction_rmse":0.48355207918307386,"reconstruction_rmse":0.2744415120160859,"retention_accuracy":0.0,"training_evaluations":-1189454},"pareto_relation":"mixed"},"flat_64_expert_complete_scan":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":1.0,"expert_count":64,"expert_evaluations":16384,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":12.00092396143413,"reconstruction_rmse":11.504561005775365,"retention_accuracy":1.0,"training_evaluations":2588672},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":2850,"drift_accuracy":0.0,"expert_count":5,"expert_evaluations":-13970,"planning_belief_set_rate":-0.3125,"planning_exact_state_rate":-0.3125,"prediction_rmse":0.48355207918307386,"reconstruction_rmse":0.2744415120160859,"retention_accuracy":0.0,"training_evaluations":-1189454},"pareto_relation":"mixed"},"matched_compute_fixed_topology":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.9296875,"expert_count":64,"expert_evaluations":2944,"planning_belief_set_rate":0.625,"planning_exact_state_rate":0.5625,"prediction_rmse":13.882657510831256,"reconstruction_rmse":12.686881978757864,"retention_accuracy":0.94921875,"training_evaluations":1484960},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":2850,"drift_accuracy":0.0703125,"expert_count":5,"expert_evaluations":-530,"planning_belief_set_rate":0.0625,"planning_exact_state_rate":0.125,"prediction_rmse":-1.3981814702140518,"reconstruction_rmse":-0.9078794609664129,"retention_accuracy":0.05078125,"training_evaluations":-85742},"pareto_relation":"mixed"},"matched_expert_count_capacity":{"metrics":{"checkpoint_size_bytes":46064,"drift_accuracy":1.0,"expert_count":69,"expert_evaluations":2231,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":12.035548448692763,"reconstruction_rmse":11.46781947767366,"retention_accuracy":1.0,"training_evaluations":2967552},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":183,"planning_belief_set_rate":-0.3125,"planning_exact_state_rate":-0.3125,"prediction_rmse":0.4489275919244413,"reconstruction_rmse":0.3111830401177915,"retention_accuracy":0.0,"training_evaluations":-1568334},"pareto_relation":"mixed"},"nearest_centroid_16_no_recursive_births":{"metrics":{"checkpoint_size_bytes":15854,"drift_accuracy":0.26953125,"expert_count":16,"expert_evaluations":4096,"planning_belief_set_rate":0.515625,"planning_exact_state_rate":0.21875,"prediction_rmse":26.886397338392854,"reconstruction_rmse":25.301585790513244,"retention_accuracy":0.26171875,"training_evaluations":253952},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":30210,"drift_accuracy":0.73046875,"expert_count":53,"expert_evaluations":-1682,"planning_belief_set_rate":0.171875,"planning_exact_state_rate":0.46875,"prediction_rmse":-14.40192129777565,"reconstruction_rmse":-13.522583272721793,"retention_accuracy":0.73828125,"training_evaluations":1145266},"pareto_relation":"mixed"},"no_adaptation_static":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.9296875,"expert_count":64,"expert_evaluations":2944,"planning_belief_set_rate":0.625,"planning_exact_state_rate":0.5625,"prediction_rmse":13.882657510831256,"reconstruction_rmse":12.686881978757864,"retention_accuracy":0.94921875,"training_evaluations":572448},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":2850,"drift_accuracy":0.0703125,"expert_count":5,"expert_evaluations":-530,"planning_belief_set_rate":0.0625,"planning_exact_state_rate":0.125,"prediction_rmse":-1.3981814702140518,"reconstruction_rmse":-0.9078794609664129,"retention_accuracy":0.05078125,"training_evaluations":826770},"pareto_relation":"mixed"},"periodic_replay_policy":{"metrics":{"checkpoint_size_bytes":46064,"drift_accuracy":1.0,"expert_count":69,"expert_evaluations":2414,"planning_belief_set_rate":0.6875,"planning_exact_state_rate":0.6875,"prediction_rmse":12.489401001044648,"reconstruction_rmse":11.774342263743101,"retention_accuracy":1.0,"training_evaluations":1398326},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":-0.004924960427443281,"reconstruction_rmse":0.004660254048349799,"retention_accuracy":0.0,"training_evaluations":892},"pareto_relation":"mixed"},"ravel_0_5_candidate":{"metrics":{"checkpoint_size_bytes":46064,"drift_accuracy":1.0,"expert_count":69,"expert_evaluations":2414,"planning_belief_set_rate":0.6875,"planning_exact_state_rate":0.6875,"prediction_rmse":12.484476040617205,"reconstruction_rmse":11.77900251779145,"retention_accuracy":1.0,"training_evaluations":1399218},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"equivalent"},"ravel_complete_scan_without_certification":{"metrics":{"checkpoint_size_bytes":46064,"drift_accuracy":1.0,"expert_count":69,"expert_evaluations":17664,"planning_belief_set_rate":0.6875,"planning_exact_state_rate":0.6875,"prediction_rmse":12.484476040617205,"reconstruction_rmse":11.77900251779145,"retention_accuracy":1.0,"training_evaluations":1583682},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":-15250,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":-184464},"pareto_relation":"candidate_dominates"},"ravel_no_birth_same_replay_iterations":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.9296875,"expert_count":64,"expert_evaluations":2944,"planning_belief_set_rate":0.625,"planning_exact_state_rate":0.5625,"prediction_rmse":13.882657510831256,"reconstruction_rmse":12.686881978757864,"retention_accuracy":0.94921875,"training_evaluations":800576},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":2850,"drift_accuracy":0.0703125,"expert_count":5,"expert_evaluations":-530,"planning_belief_set_rate":0.0625,"planning_exact_state_rate":0.125,"prediction_rmse":-1.3981814702140518,"reconstruction_rmse":-0.9078794609664129,"retention_accuracy":0.05078125,"training_evaluations":598642},"pareto_relation":"mixed"},"ravel_random_births":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.9296875,"expert_count":64,"expert_evaluations":2944,"planning_belief_set_rate":0.625,"planning_exact_state_rate":0.5625,"prediction_rmse":13.882657510831256,"reconstruction_rmse":12.686881978757864,"retention_accuracy":0.94921875,"training_evaluations":800576},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":2850,"drift_accuracy":0.0703125,"expert_count":5,"expert_evaluations":-530,"planning_belief_set_rate":0.0625,"planning_exact_state_rate":0.125,"prediction_rmse":-1.3981814702140518,"reconstruction_rmse":-0.9078794609664129,"retention_accuracy":0.05078125,"training_evaluations":598642},"pareto_relation":"mixed"},"ravel_without_replay":{"metrics":{"checkpoint_size_bytes":46064,"drift_accuracy":1.0,"expert_count":69,"expert_evaluations":2414,"planning_belief_set_rate":0.6875,"planning_exact_state_rate":0.6875,"prediction_rmse":12.507016161593489,"reconstruction_rmse":11.776633263009261,"retention_accuracy":1.0,"training_evaluations":1126182},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":-0.022540120976284328,"reconstruction_rmse":0.0023692547821898557,"retention_accuracy":0.0,"training_evaluations":273036},"pareto_relation":"mixed"},"ravel_without_retirement_matched_work":{"metrics":{"checkpoint_size_bytes":46064,"drift_accuracy":1.0,"expert_count":69,"expert_evaluations":2414,"planning_belief_set_rate":0.6875,"planning_exact_state_rate":0.6875,"prediction_rmse":12.484476040617205,"reconstruction_rmse":11.77900251779145,"retention_accuracy":1.0,"training_evaluations":1399218},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"equivalent"}},"gates":[{"gate_id":"adaptation_completed","metric":"adaptation_completed","observed":true,"operator":"eq","pass":true,"rationale":"The bounded adaptation procedure must complete.","threshold":true},{"gate_id":"base_holdout_accuracy","metric":"base_accuracy","observed":0.94921875,"operator":"ge","pass":true,"rationale":"The base representation must establish the bounded task before drift.","threshold":0.85},{"gate_id":"base_holdout_retention","metric":"retention_accuracy","observed":1.0,"operator":"ge","pass":true,"rationale":"Anchored base behavior may lose at most ten percentage points in absolute retained accuracy.","threshold":0.9},{"gate_id":"routing_oracle_equivalence","metric":"routing_mismatches","observed":0,"operator":"eq","pass":true,"rationale":"Every routed classification must agree with complete scan.","threshold":0},{"gate_id":"checkpoint_roundtrip","metric":"checkpoint_roundtrip","observed":true,"operator":"eq","pass":true,"rationale":"Canonical in-memory restoration must succeed.","threshold":true},{"gate_id":"checkpoint_identity","metric":"checkpoint_identity","observed":true,"operator":"eq","pass":true,"rationale":"Restored complete model identity must match.","threshold":true},{"gate_id":"checkpoint_behavior","metric":"checkpoint_behavior","observed":true,"operator":"eq","pass":true,"rationale":"Restored evaluation and planning behavior must match.","threshold":true},{"gate_id":"checkpoint_mutation_rejection","metric":"checkpoint_mutations","observed":true,"operator":"eq","pass":true,"rationale":"Every declared behavioral and byte-level checkpoint mutation must be detected.","threshold":true},{"gate_id":"lineage_invariants","metric":"lineage_invariants","observed":true,"operator":"eq","pass":true,"rationale":"Generation, lineage uniqueness, descendant splitting, and deterministic topology invariants must hold.","threshold":true},{"gate_id":"unsupported_transitions_unknown","metric":"unsupported_graph_edge_violations","observed":0,"operator":"eq","pass":true,"rationale":"Unsupported actions cannot enter the planning graph.","threshold":0},{"gate_id":"replay_size","metric":"replay_selected","observed":256,"operator":"eq","pass":true,"rationale":"The declared replay budget must be filled on the non-sparse trial corpus.","threshold":256},{"gate_id":"replay_unique","metric":"replay_unique","observed":256,"operator":"eq","pass":true,"rationale":"Balanced replay cannot introduce accidental duplicates.","threshold":256},{"gate_id":"replay_label_coverage","metric":"replay_labels_covered","observed":8,"operator":"eq","pass":true,"rationale":"Replay must retain every declared label.","threshold":8},{"gate_id":"replay_action_coverage","metric":"replay_actions_covered","observed":4,"operator":"eq","pass":true,"rationale":"Replay must retain every declared action.","threshold":4},{"gate_id":"replay_state_coverage","metric":"replay_states_covered","observed":64,"operator":"ge","pass":true,"rationale":"Replay must cover at least 60 of 64 source states.","threshold":60},{"gate_id":"replay_expert_coverage","metric":"replay_experts_covered","observed":63,"operator":"ge","pass":true,"rationale":"Replay must retain broad assigned-expert coverage.","threshold":60},{"gate_id":"replay_transition_coverage","metric":"replay_transition_pairs_covered","observed":251,"operator":"ge","pass":true,"rationale":"Replay must preserve broad source-state/action transition support.","threshold":220},{"gate_id":"planning_path_found","metric":"path_found_rate","observed":1.0,"operator":"ge","pass":true,"rationale":"At least three quarters of bounded planning cases must have a supported path.","threshold":0.75},{"gate_id":"expert_capacity","metric":"expert_count","observed":69,"operator":"le","pass":true,"rationale":"Adaptation cannot exceed the declared expert capacity.","threshold":80},{"gate_id":"retirement_budget","metric":"accepted_retirements","observed":0,"operator":"le","pass":true,"rationale":"Retirement remains optional and bounded.","threshold":4},{"gate_id":"topology_objective_non_degradation","metric":"topology_objective_gain_q20","observed":28826,"operator":"ge","pass":true,"rationale":"Accepted adaptation-training topology decisions cannot reduce their declared objective.","threshold":0},{"gate_id":"matched_compute_budget","metric":"matched_compute_training_evaluation_ratio","observed":0.9422597241676544,"operator":"le","pass":true,"rationale":"Candidate training work may exceed the matched fixed-topology budget by at most ten percent.","threshold":1.1},{"gate_id":"conditional_inference_efficiency","metric":"inference_evaluation_ratio_vs_flat64","observed":0.1473388671875,"operator":"le","pass":true,"rationale":"Routed inference must use at most one quarter of flat complete-scan expert evaluations.","threshold":0.25},{"gate_id":"noise_accuracy","metric":"adapted_drift_accuracy","observed":1.0,"operator":"ge","pass":true,"rationale":"Noisy observations must retain high adapted classification.","threshold":0.9},{"gate_id":"noise_non_inferiority","metric":"drift_accuracy_delta","observed":0.0703125,"operator":"ge","pass":true,"rationale":"Limited headroom uses non-inferiority rather than a fixed gain.","threshold":-0.02},{"gate_id":"noise_headroom","metric":"headroom_normalized_accuracy_improvement","observed":1.0,"operator":"ge","pass":true,"rationale":"Available accuracy headroom cannot worsen.","threshold":0},{"gate_id":"noise_reconstruction","metric":"reconstruction_improvement_ratio","observed":0.07156048763490593,"operator":"ge","pass":true,"rationale":"Adaptation cannot worsen reconstruction under increased noise.","threshold":0},{"gate_id":"noise_prediction","metric":"prediction_improvement_ratio","observed":0.10071425223327665,"operator":"ge","pass":true,"rationale":"Adaptation cannot worsen prediction under increased noise.","threshold":0},{"gate_id":"noise_exact_planning","metric":"exact_state_rate","observed":0.6875,"operator":"ge","pass":true,"rationale":"Noise permits a lower but explicit exact-state planning floor.","threshold":0.5},{"gate_id":"noise_bounded_births","metric":"accepted_births","observed":5,"operator":"le","pass":true,"rationale":"The low-drift regime cannot consume the full topology budget.","threshold":12}],"metrics":{"accepted_births":5,"accepted_retirements":0,"adaptation_completed":true,"adaptation_training_accuracy":1.0,"adapted_drift_accuracy":1.0,"adapted_prediction_rmse":12.484476040617205,"adapted_reconstruction_rmse":11.77900251779145,"adapted_transition_accuracy":0.9703389830508474,"balanced_vs_periodic_drift_accuracy_delta":0.0,"balanced_vs_periodic_retention_delta":0.0,"base_accuracy":0.94921875,"base_prediction_rmse":11.038057809712829,"base_reconstruction_rmse":9.782097633989205,"belief_set_rate":0.6875,"belief_set_rate_delta":0.0625,"checkpoint_behavior":true,"checkpoint_identity":true,"checkpoint_mutations":true,"checkpoint_roundtrip":true,"checkpoint_size_bytes":46064,"drift_accuracy_delta":0.0703125,"exact_state_rate":0.6875,"exact_state_rate_delta":0.125,"expert_count":69,"headroom_normalized_accuracy_improvement":1.0,"inference_evaluation_ratio_vs_flat64":0.1473388671875,"inference_expert_evaluations":2414,"lineage_invariants":true,"matched_compute_drift_accuracy_delta":0.0703125,"matched_compute_retention_delta":0.05078125,"matched_compute_training_evaluation_ratio":0.9422597241676544,"no_birth_drift_accuracy_delta":0.0703125,"no_retirement_drift_accuracy_delta":0.0,"path_found_rate":1.0,"prediction_improvement_ratio":0.10071425223327665,"reconstruction_improvement_ratio":0.07156048763490593,"replay_actions_covered":4,"replay_experts_covered":63,"replay_labels_covered":8,"replay_selected":256,"replay_states_covered":64,"replay_transition_pairs_covered":251,"replay_unique":256,"retention_accuracy":1.0,"retention_accuracy_delta_from_base":0.05078125,"retention_prediction_degradation":-1.346101030079561,"retention_prediction_rmse":9.691956779633268,"retention_reconstruction_degradation_ratio":-0.1189320304835271,"retention_reconstruction_rmse":8.618692899990762,"retention_transition_accuracy_delta":0.07204821477490642,"routing_mismatches":0,"static_belief_set_rate":0.625,"static_drift_accuracy":0.9296875,"static_exact_state_rate":0.5625,"static_prediction_rmse":13.882657510831256,"static_reconstruction_rmse":12.686881978757864,"static_transition_accuracy":0.9037656903765691,"topology_objective_gain_q20":28826,"training_evaluations":1399218,"transition_accuracy_delta":0.06657329267427836,"transition_support_rate":0.921875,"unsupported_graph_edge_violations":0},"regime":"increased_observation_noise","seed":"0x8737c70577b4fdf1","trial_id":"validation-noise-04","trial_result":"PASS"},{"comparisons":{"fixed_8_expert":{"metrics":{"checkpoint_size_bytes":11294,"drift_accuracy":0.1796875,"expert_count":8,"expert_evaluations":2048,"planning_belief_set_rate":0.46875,"planning_exact_state_rate":0.046875,"prediction_rmse":29.84011507165318,"reconstruction_rmse":28.699638932248526,"retention_accuracy":0.18359375,"training_evaluations":94208},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":38190,"drift_accuracy":0.515625,"expert_count":67,"expert_evaluations":0,"planning_belief_set_rate":0.40625,"planning_exact_state_rate":0.828125,"prediction_rmse":-25.99118214044496,"reconstruction_rmse":-25.180963877584624,"retention_accuracy":0.78515625,"training_evaluations":1799880},"pareto_relation":"mixed"},"fixed_topology_64_expert_routed":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.625,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":3.5368340467767285,"reconstruction_rmse":3.2703928758529814,"retention_accuracy":1.0,"training_evaluations":2588672},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":6270,"drift_accuracy":0.0703125,"expert_count":11,"expert_evaluations":0,"planning_belief_set_rate":-0.125,"planning_exact_state_rate":-0.125,"prediction_rmse":0.31209888443149136,"reconstruction_rmse":0.2482821788109204,"retention_accuracy":-0.03125,"training_evaluations":-694584},"pareto_relation":"mixed"},"flat_64_expert_complete_scan":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.625,"expert_count":64,"expert_evaluations":16384,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":3.5368340467767285,"reconstruction_rmse":3.2703928758529814,"retention_accuracy":1.0,"training_evaluations":2588672},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":6270,"drift_accuracy":0.0703125,"expert_count":11,"expert_evaluations":-14336,"planning_belief_set_rate":-0.125,"planning_exact_state_rate":-0.125,"prediction_rmse":0.31209888443149136,"reconstruction_rmse":0.2482821788109204,"retention_accuracy":-0.03125,"training_evaluations":-694584},"pareto_relation":"mixed"},"matched_compute_fixed_topology":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.55078125,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":0.703125,"planning_exact_state_rate":0.671875,"prediction_rmse":6.550383742680272,"reconstruction_rmse":6.500414971161957,"retention_accuracy":0.90625,"training_evaluations":2106056},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":6270,"drift_accuracy":0.14453125,"expert_count":11,"expert_evaluations":0,"planning_belief_set_rate":0.171875,"planning_exact_state_rate":0.203125,"prediction_rmse":-2.701450811472052,"reconstruction_rmse":-2.9817399164980554,"retention_accuracy":0.0625,"training_evaluations":-211968},"pareto_relation":"mixed"},"matched_expert_count_capacity":{"metrics":{"checkpoint_size_bytes":49484,"drift_accuracy":0.625,"expert_count":75,"expert_evaluations":2048,"planning_belief_set_rate":0.984375,"planning_exact_state_rate":0.984375,"prediction_rmse":3.547691234869292,"reconstruction_rmse":3.2580684978230754,"retention_accuracy":1.0,"training_evaluations":3456000},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0703125,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":-0.109375,"planning_exact_state_rate":-0.109375,"prediction_rmse":0.30124169633892794,"reconstruction_rmse":0.26060655684082645,"retention_accuracy":-0.03125,"training_evaluations":-1561912},"pareto_relation":"mixed"},"nearest_centroid_16_no_recursive_births":{"metrics":{"checkpoint_size_bytes":15854,"drift_accuracy":0.21875,"expert_count":16,"expert_evaluations":4096,"planning_belief_set_rate":0.625,"planning_exact_state_rate":0.171875,"prediction_rmse":24.521629827135232,"reconstruction_rmse":22.884334556181194,"retention_accuracy":0.31640625,"training_evaluations":253952},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":33630,"drift_accuracy":0.4765625,"expert_count":59,"expert_evaluations":-2048,"planning_belief_set_rate":0.25,"planning_exact_state_rate":0.703125,"prediction_rmse":-20.67269689592701,"reconstruction_rmse":-19.365659501517293,"retention_accuracy":0.65234375,"training_evaluations":1640136},"pareto_relation":"mixed"},"no_adaptation_static":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.55078125,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":0.703125,"planning_exact_state_rate":0.671875,"prediction_rmse":6.550383742680272,"reconstruction_rmse":6.500414971161957,"retention_accuracy":0.90625,"training_evaluations":557768},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":6270,"drift_accuracy":0.14453125,"expert_count":11,"expert_evaluations":0,"planning_belief_set_rate":0.171875,"planning_exact_state_rate":0.203125,"prediction_rmse":-2.701450811472052,"reconstruction_rmse":-2.9817399164980554,"retention_accuracy":0.0625,"training_evaluations":1336320},"pareto_relation":"mixed"},"periodic_replay_policy":{"metrics":{"checkpoint_size_bytes":51764,"drift_accuracy":0.703125,"expert_count":79,"expert_evaluations":3113,"planning_belief_set_rate":0.875,"planning_exact_state_rate":0.875,"prediction_rmse":3.842064110451089,"reconstruction_rmse":3.503264524575293,"retention_accuracy":0.96875,"training_evaluations":2168388},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":-2280,"drift_accuracy":-0.0078125,"expert_count":-4,"expert_evaluations":-1065,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.006868820757131022,"reconstruction_rmse":0.01541053008860871,"retention_accuracy":0.0,"training_evaluations":-274300},"pareto_relation":"mixed"},"ravel_0_5_candidate":{"metrics":{"checkpoint_size_bytes":49484,"drift_accuracy":0.6953125,"expert_count":75,"expert_evaluations":2048,"planning_belief_set_rate":0.875,"planning_exact_state_rate":0.875,"prediction_rmse":3.84893293120822,"reconstruction_rmse":3.518675054663902,"retention_accuracy":0.96875,"training_evaluations":1894088},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"equivalent"},"ravel_complete_scan_without_certification":{"metrics":{"checkpoint_size_bytes":49484,"drift_accuracy":0.6953125,"expert_count":75,"expert_evaluations":19200,"planning_belief_set_rate":0.875,"planning_exact_state_rate":0.875,"prediction_rmse":3.84893293120822,"reconstruction_rmse":3.518675054663902,"retention_accuracy":0.96875,"training_evaluations":2102984},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":-17152,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":-208896},"pareto_relation":"candidate_dominates"},"ravel_no_birth_same_replay_iterations":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.55078125,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":0.703125,"planning_exact_state_rate":0.671875,"prediction_rmse":6.550383742680272,"reconstruction_rmse":6.500414971161957,"retention_accuracy":0.90625,"training_evaluations":778952},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":6270,"drift_accuracy":0.14453125,"expert_count":11,"expert_evaluations":0,"planning_belief_set_rate":0.171875,"planning_exact_state_rate":0.203125,"prediction_rmse":-2.701450811472052,"reconstruction_rmse":-2.9817399164980554,"retention_accuracy":0.0625,"training_evaluations":1115136},"pareto_relation":"mixed"},"ravel_random_births":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.55078125,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":0.703125,"planning_exact_state_rate":0.671875,"prediction_rmse":6.550383742680272,"reconstruction_rmse":6.500414971161957,"retention_accuracy":0.90625,"training_evaluations":778952},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":6270,"drift_accuracy":0.14453125,"expert_count":11,"expert_evaluations":0,"planning_belief_set_rate":0.171875,"planning_exact_state_rate":0.203125,"prediction_rmse":-2.701450811472052,"reconstruction_rmse":-2.9817399164980554,"retention_accuracy":0.0625,"training_evaluations":1115136},"pareto_relation":"mixed"},"ravel_without_replay":{"metrics":{"checkpoint_size_bytes":52334,"drift_accuracy":0.703125,"expert_count":80,"expert_evaluations":3128,"planning_belief_set_rate":0.890625,"planning_exact_state_rate":0.890625,"prediction_rmse":3.8671259783857863,"reconstruction_rmse":3.533240726796989,"retention_accuracy":0.96484375,"training_evaluations":1751560},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":-2850,"drift_accuracy":-0.0078125,"expert_count":-5,"expert_evaluations":-1080,"planning_belief_set_rate":-0.015625,"planning_exact_state_rate":-0.015625,"prediction_rmse":-0.018193047177566424,"reconstruction_rmse":-0.014565672133087126,"retention_accuracy":0.00390625,"training_evaluations":142528},"pareto_relation":"mixed"},"ravel_without_retirement_matched_work":{"metrics":{"checkpoint_size_bytes":50054,"drift_accuracy":0.6953125,"expert_count":76,"expert_evaluations":2048,"planning_belief_set_rate":0.875,"planning_exact_state_rate":0.875,"prediction_rmse":3.84893293120822,"reconstruction_rmse":3.518675054663902,"retention_accuracy":0.96875,"training_evaluations":1894088},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":-570,"drift_accuracy":0.0,"expert_count":-1,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"candidate_dominates"}},"gates":[{"gate_id":"adaptation_completed","metric":"adaptation_completed","observed":true,"operator":"eq","pass":true,"rationale":"The bounded adaptation procedure must complete.","threshold":true},{"gate_id":"base_holdout_accuracy","metric":"base_accuracy","observed":0.94921875,"operator":"ge","pass":true,"rationale":"The base representation must establish the bounded task before drift.","threshold":0.85},{"gate_id":"base_holdout_retention","metric":"retention_accuracy","observed":0.96875,"operator":"ge","pass":true,"rationale":"Anchored base behavior may lose at most ten percentage points in absolute retained accuracy.","threshold":0.9},{"gate_id":"routing_oracle_equivalence","metric":"routing_mismatches","observed":0,"operator":"eq","pass":true,"rationale":"Every routed classification must agree with complete scan.","threshold":0},{"gate_id":"checkpoint_roundtrip","metric":"checkpoint_roundtrip","observed":true,"operator":"eq","pass":true,"rationale":"Canonical in-memory restoration must succeed.","threshold":true},{"gate_id":"checkpoint_identity","metric":"checkpoint_identity","observed":true,"operator":"eq","pass":true,"rationale":"Restored complete model identity must match.","threshold":true},{"gate_id":"checkpoint_behavior","metric":"checkpoint_behavior","observed":true,"operator":"eq","pass":true,"rationale":"Restored evaluation and planning behavior must match.","threshold":true},{"gate_id":"checkpoint_mutation_rejection","metric":"checkpoint_mutations","observed":true,"operator":"eq","pass":true,"rationale":"Every declared behavioral and byte-level checkpoint mutation must be detected.","threshold":true},{"gate_id":"lineage_invariants","metric":"lineage_invariants","observed":true,"operator":"eq","pass":true,"rationale":"Generation, lineage uniqueness, descendant splitting, and deterministic topology invariants must hold.","threshold":true},{"gate_id":"unsupported_transitions_unknown","metric":"unsupported_graph_edge_violations","observed":0,"operator":"eq","pass":true,"rationale":"Unsupported actions cannot enter the planning graph.","threshold":0},{"gate_id":"replay_size","metric":"replay_selected","observed":256,"operator":"eq","pass":true,"rationale":"The declared replay budget must be filled on the non-sparse trial corpus.","threshold":256},{"gate_id":"replay_unique","metric":"replay_unique","observed":256,"operator":"eq","pass":true,"rationale":"Balanced replay cannot introduce accidental duplicates.","threshold":256},{"gate_id":"replay_label_coverage","metric":"replay_labels_covered","observed":8,"operator":"eq","pass":true,"rationale":"Replay must retain every declared label.","threshold":8},{"gate_id":"replay_action_coverage","metric":"replay_actions_covered","observed":4,"operator":"eq","pass":true,"rationale":"Replay must retain every declared action.","threshold":4},{"gate_id":"replay_state_coverage","metric":"replay_states_covered","observed":64,"operator":"ge","pass":true,"rationale":"Replay must cover at least 60 of 64 source states.","threshold":60},{"gate_id":"replay_expert_coverage","metric":"replay_experts_covered","observed":61,"operator":"ge","pass":true,"rationale":"Replay must retain broad assigned-expert coverage.","threshold":60},{"gate_id":"replay_transition_coverage","metric":"replay_transition_pairs_covered","observed":253,"operator":"ge","pass":true,"rationale":"Replay must preserve broad source-state/action transition support.","threshold":220},{"gate_id":"planning_path_found","metric":"path_found_rate","observed":1.0,"operator":"ge","pass":true,"rationale":"At least three quarters of bounded planning cases must have a supported path.","threshold":0.75},{"gate_id":"expert_capacity","metric":"expert_count","observed":75,"operator":"le","pass":true,"rationale":"Adaptation cannot exceed the declared expert capacity.","threshold":80},{"gate_id":"retirement_budget","metric":"accepted_retirements","observed":1,"operator":"le","pass":true,"rationale":"Retirement remains optional and bounded.","threshold":4},{"gate_id":"topology_objective_non_degradation","metric":"topology_objective_gain_q20","observed":24843,"operator":"ge","pass":true,"rationale":"Accepted adaptation-training topology decisions cannot reduce their declared objective.","threshold":0},{"gate_id":"matched_compute_budget","metric":"matched_compute_training_evaluation_ratio","observed":0.8993531036211763,"operator":"le","pass":true,"rationale":"Candidate training work may exceed the matched fixed-topology budget by at most ten percent.","threshold":1.1},{"gate_id":"conditional_inference_efficiency","metric":"inference_evaluation_ratio_vs_flat64","observed":0.125,"operator":"le","pass":true,"rationale":"Routed inference must use at most one quarter of flat complete-scan expert evaluations.","threshold":0.25},{"gate_id":"label_adaptation","metric":"adapted_drift_accuracy","observed":0.6953125,"operator":"ge","pass":true,"rationale":"Changed labels must be learned above the bounded floor.","threshold":0.6},{"gate_id":"label_gain","metric":"drift_accuracy_delta","observed":0.14453125,"operator":"ge","pass":true,"rationale":"Label adaptation must improve untouched drift accuracy by at least four points.","threshold":0.04},{"gate_id":"old_label_retention","metric":"retention_accuracy_delta_from_base","observed":0.01953125,"operator":"ge","pass":true,"rationale":"Old-label accuracy cannot fall more than ten points from base holdout.","threshold":-0.1},{"gate_id":"label_planning_non_inferiority","metric":"exact_state_rate_delta","observed":0.203125,"operator":"ge","pass":true,"rationale":"Unchanged observations and transitions should not materially damage exact planning.","threshold":-0.05}],"metrics":{"accepted_births":12,"accepted_retirements":1,"adaptation_completed":true,"adaptation_training_accuracy":0.630859375,"adapted_drift_accuracy":0.6953125,"adapted_prediction_rmse":3.84893293120822,"adapted_reconstruction_rmse":3.518675054663902,"adapted_transition_accuracy":0.9692982456140351,"balanced_vs_periodic_drift_accuracy_delta":-0.0078125,"balanced_vs_periodic_retention_delta":0.0,"base_accuracy":0.94921875,"base_prediction_rmse":7.35357933706324,"base_reconstruction_rmse":6.277314653741622,"belief_set_rate":0.875,"belief_set_rate_delta":0.171875,"checkpoint_behavior":true,"checkpoint_identity":true,"checkpoint_mutations":true,"checkpoint_roundtrip":true,"checkpoint_size_bytes":49484,"drift_accuracy_delta":0.14453125,"exact_state_rate":0.875,"exact_state_rate_delta":0.203125,"expert_count":75,"headroom_normalized_accuracy_improvement":0.3217391304347826,"inference_evaluation_ratio_vs_flat64":0.125,"inference_expert_evaluations":2048,"lineage_invariants":true,"matched_compute_drift_accuracy_delta":0.14453125,"matched_compute_retention_delta":0.0625,"matched_compute_training_evaluation_ratio":0.8993531036211763,"no_birth_drift_accuracy_delta":0.14453125,"no_retirement_drift_accuracy_delta":0.0,"path_found_rate":1.0,"prediction_improvement_ratio":0.4124110766015486,"reconstruction_improvement_ratio":0.45869993373131773,"replay_actions_covered":4,"replay_experts_covered":61,"replay_labels_covered":8,"replay_selected":256,"replay_states_covered":64,"replay_transition_pairs_covered":253,"replay_unique":256,"retention_accuracy":0.96875,"retention_accuracy_delta_from_base":0.01953125,"retention_prediction_degradation":-2.1674365190243456,"retention_prediction_rmse":5.186142818038895,"retention_reconstruction_degradation_ratio":-0.36864106095872845,"retention_reconstruction_rmse":3.9632387198145373,"retention_transition_accuracy_delta":0.012872774082814842,"routing_mismatches":0,"static_belief_set_rate":0.703125,"static_drift_accuracy":0.55078125,"static_exact_state_rate":0.671875,"static_prediction_rmse":6.550383742680272,"static_reconstruction_rmse":6.500414971161957,"static_transition_accuracy":0.9531914893617022,"topology_objective_gain_q20":24843,"training_evaluations":1894088,"transition_accuracy_delta":0.016106756252332932,"transition_support_rate":0.890625,"unsupported_graph_edge_violations":0},"regime":"label_drift","seed":"0xc5c651d456b06744","trial_id":"validation-label-01","trial_result":"PASS"},{"comparisons":{"fixed_8_expert":{"metrics":{"checkpoint_size_bytes":11294,"drift_accuracy":0.203125,"expert_count":8,"expert_evaluations":2048,"planning_belief_set_rate":0.421875,"planning_exact_state_rate":0.046875,"prediction_rmse":30.618988549186426,"reconstruction_rmse":28.516231953484418,"retention_accuracy":0.2109375,"training_evaluations":94208},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":39330,"drift_accuracy":0.453125,"expert_count":69,"expert_evaluations":0,"planning_belief_set_rate":0.46875,"planning_exact_state_rate":0.828125,"prediction_rmse":-24.589167326955874,"reconstruction_rmse":-22.95669572644423,"retention_accuracy":0.69921875,"training_evaluations":1702680},"pareto_relation":"mixed"},"fixed_topology_64_expert_routed":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.65625,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":3.6755978255213746,"reconstruction_rmse":3.2540626513335162,"retention_accuracy":1.0,"training_evaluations":2588672},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":7410,"drift_accuracy":0.0,"expert_count":13,"expert_evaluations":0,"planning_belief_set_rate":-0.109375,"planning_exact_state_rate":-0.125,"prediction_rmse":2.354223396709177,"reconstruction_rmse":2.3054735757066718,"retention_accuracy":-0.08984375,"training_evaluations":-791784},"pareto_relation":"mixed"},"flat_64_expert_complete_scan":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.65625,"expert_count":64,"expert_evaluations":16384,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":3.6755978255213746,"reconstruction_rmse":3.2540626513335162,"retention_accuracy":1.0,"training_evaluations":2588672},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":7410,"drift_accuracy":0.0,"expert_count":13,"expert_evaluations":-14336,"planning_belief_set_rate":-0.109375,"planning_exact_state_rate":-0.125,"prediction_rmse":2.354223396709177,"reconstruction_rmse":2.3054735757066718,"retention_accuracy":-0.08984375,"training_evaluations":-791784},"pareto_relation":"mixed"},"matched_compute_fixed_topology":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.62109375,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":0.875,"planning_exact_state_rate":0.859375,"prediction_rmse":5.963492800835572,"reconstruction_rmse":5.575191220126485,"retention_accuracy":0.92578125,"training_evaluations":1879832},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":7410,"drift_accuracy":0.03515625,"expert_count":13,"expert_evaluations":0,"planning_belief_set_rate":0.015625,"planning_exact_state_rate":0.015625,"prediction_rmse":0.06632842139497974,"reconstruction_rmse":-0.015654993086297253,"retention_accuracy":-0.015625,"training_evaluations":-82944},"pareto_relation":"mixed"},"matched_expert_count_capacity":{"metrics":{"checkpoint_size_bytes":50624,"drift_accuracy":0.65625,"expert_count":77,"expert_evaluations":2048,"planning_belief_set_rate":0.984375,"planning_exact_state_rate":0.984375,"prediction_rmse":3.697834980344853,"reconstruction_rmse":3.218941793280141,"retention_accuracy":1.0,"training_evaluations":3627008},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":-0.09375,"planning_exact_state_rate":-0.109375,"prediction_rmse":2.3319862418856983,"reconstruction_rmse":2.340594433760047,"retention_accuracy":-0.08984375,"training_evaluations":-1830120},"pareto_relation":"mixed"},"nearest_centroid_16_no_recursive_births":{"metrics":{"checkpoint_size_bytes":15854,"drift_accuracy":0.26953125,"expert_count":16,"expert_evaluations":4096,"planning_belief_set_rate":0.46875,"planning_exact_state_rate":0.140625,"prediction_rmse":25.659283392657603,"reconstruction_rmse":22.74090676370041,"retention_accuracy":0.26171875,"training_evaluations":253952},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":34770,"drift_accuracy":0.38671875,"expert_count":61,"expert_evaluations":-2048,"planning_belief_set_rate":0.421875,"planning_exact_state_rate":0.734375,"prediction_rmse":-19.62946217042705,"reconstruction_rmse":-17.18137053666022,"retention_accuracy":0.6484375,"training_evaluations":1542936},"pareto_relation":"mixed"},"no_adaptation_static":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.62109375,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":0.875,"planning_exact_state_rate":0.859375,"prediction_rmse":5.963492800835572,"reconstruction_rmse":5.575191220126485,"retention_accuracy":0.92578125,"training_evaluations":552728},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":7410,"drift_accuracy":0.03515625,"expert_count":13,"expert_evaluations":0,"planning_belief_set_rate":0.015625,"planning_exact_state_rate":0.015625,"prediction_rmse":0.06632842139497974,"reconstruction_rmse":-0.015654993086297253,"retention_accuracy":-0.015625,"training_evaluations":1244160},"pareto_relation":"mixed"},"periodic_replay_policy":{"metrics":{"checkpoint_size_bytes":51194,"drift_accuracy":0.65625,"expert_count":78,"expert_evaluations":2048,"planning_belief_set_rate":0.890625,"planning_exact_state_rate":0.875,"prediction_rmse":6.029821222230551,"reconstruction_rmse":5.5623097820018215,"retention_accuracy":0.91015625,"training_evaluations":1893656},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":-570,"drift_accuracy":0.0,"expert_count":-1,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":-0.002773554961633451,"retention_accuracy":0.0,"training_evaluations":-96768},"pareto_relation":"candidate_dominates"},"ravel_0_5_candidate":{"metrics":{"checkpoint_size_bytes":50624,"drift_accuracy":0.65625,"expert_count":77,"expert_evaluations":2048,"planning_belief_set_rate":0.890625,"planning_exact_state_rate":0.875,"prediction_rmse":6.029821222230551,"reconstruction_rmse":5.559536227040188,"retention_accuracy":0.91015625,"training_evaluations":1796888},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"equivalent"},"ravel_complete_scan_without_certification":{"metrics":{"checkpoint_size_bytes":50624,"drift_accuracy":0.65625,"expert_count":77,"expert_evaluations":19712,"planning_belief_set_rate":0.890625,"planning_exact_state_rate":0.875,"prediction_rmse":6.029821222230551,"reconstruction_rmse":5.559536227040188,"retention_accuracy":0.91015625,"training_evaluations":2008856},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":-17664,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":-211968},"pareto_relation":"candidate_dominates"},"ravel_no_birth_same_replay_iterations":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.62109375,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":0.875,"planning_exact_state_rate":0.859375,"prediction_rmse":5.963492800835572,"reconstruction_rmse":5.575191220126485,"retention_accuracy":0.92578125,"training_evaluations":773912},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":7410,"drift_accuracy":0.03515625,"expert_count":13,"expert_evaluations":0,"planning_belief_set_rate":0.015625,"planning_exact_state_rate":0.015625,"prediction_rmse":0.06632842139497974,"reconstruction_rmse":-0.015654993086297253,"retention_accuracy":-0.015625,"training_evaluations":1022976},"pareto_relation":"mixed"},"ravel_random_births":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.62109375,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":0.875,"planning_exact_state_rate":0.859375,"prediction_rmse":5.963492800835572,"reconstruction_rmse":5.575191220126485,"retention_accuracy":0.92578125,"training_evaluations":773912},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":7410,"drift_accuracy":0.03515625,"expert_count":13,"expert_evaluations":0,"planning_belief_set_rate":0.015625,"planning_exact_state_rate":0.015625,"prediction_rmse":0.06632842139497974,"reconstruction_rmse":-0.015654993086297253,"retention_accuracy":-0.015625,"training_evaluations":1022976},"pareto_relation":"mixed"},"ravel_without_replay":{"metrics":{"checkpoint_size_bytes":52334,"drift_accuracy":0.65625,"expert_count":80,"expert_evaluations":3848,"planning_belief_set_rate":0.890625,"planning_exact_state_rate":0.875,"prediction_rmse":6.029821222230551,"reconstruction_rmse":5.559809767124314,"retention_accuracy":0.90234375,"training_evaluations":1583848},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":-1710,"drift_accuracy":0.0,"expert_count":-3,"expert_evaluations":-1800,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":-0.00027354008412583397,"retention_accuracy":0.0078125,"training_evaluations":213040},"pareto_relation":"mixed"},"ravel_without_retirement_matched_work":{"metrics":{"checkpoint_size_bytes":50624,"drift_accuracy":0.65625,"expert_count":77,"expert_evaluations":2048,"planning_belief_set_rate":0.890625,"planning_exact_state_rate":0.875,"prediction_rmse":6.029821222230551,"reconstruction_rmse":5.559536227040188,"retention_accuracy":0.91015625,"training_evaluations":1796888},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"equivalent"}},"gates":[{"gate_id":"adaptation_completed","metric":"adaptation_completed","observed":true,"operator":"eq","pass":true,"rationale":"The bounded adaptation procedure must complete.","threshold":true},{"gate_id":"base_holdout_accuracy","metric":"base_accuracy","observed":0.921875,"operator":"ge","pass":true,"rationale":"The base representation must establish the bounded task before drift.","threshold":0.85},{"gate_id":"base_holdout_retention","metric":"retention_accuracy","observed":0.91015625,"operator":"ge","pass":true,"rationale":"Anchored base behavior may lose at most ten percentage points in absolute retained accuracy.","threshold":0.9},{"gate_id":"routing_oracle_equivalence","metric":"routing_mismatches","observed":0,"operator":"eq","pass":true,"rationale":"Every routed classification must agree with complete scan.","threshold":0},{"gate_id":"checkpoint_roundtrip","metric":"checkpoint_roundtrip","observed":true,"operator":"eq","pass":true,"rationale":"Canonical in-memory restoration must succeed.","threshold":true},{"gate_id":"checkpoint_identity","metric":"checkpoint_identity","observed":true,"operator":"eq","pass":true,"rationale":"Restored complete model identity must match.","threshold":true},{"gate_id":"checkpoint_behavior","metric":"checkpoint_behavior","observed":true,"operator":"eq","pass":true,"rationale":"Restored evaluation and planning behavior must match.","threshold":true},{"gate_id":"checkpoint_mutation_rejection","metric":"checkpoint_mutations","observed":true,"operator":"eq","pass":true,"rationale":"Every declared behavioral and byte-level checkpoint mutation must be detected.","threshold":true},{"gate_id":"lineage_invariants","metric":"lineage_invariants","observed":true,"operator":"eq","pass":true,"rationale":"Generation, lineage uniqueness, descendant splitting, and deterministic topology invariants must hold.","threshold":true},{"gate_id":"unsupported_transitions_unknown","metric":"unsupported_graph_edge_violations","observed":0,"operator":"eq","pass":true,"rationale":"Unsupported actions cannot enter the planning graph.","threshold":0},{"gate_id":"replay_size","metric":"replay_selected","observed":256,"operator":"eq","pass":true,"rationale":"The declared replay budget must be filled on the non-sparse trial corpus.","threshold":256},{"gate_id":"replay_unique","metric":"replay_unique","observed":256,"operator":"eq","pass":true,"rationale":"Balanced replay cannot introduce accidental duplicates.","threshold":256},{"gate_id":"replay_label_coverage","metric":"replay_labels_covered","observed":8,"operator":"eq","pass":true,"rationale":"Replay must retain every declared label.","threshold":8},{"gate_id":"replay_action_coverage","metric":"replay_actions_covered","observed":4,"operator":"eq","pass":true,"rationale":"Replay must retain every declared action.","threshold":4},{"gate_id":"replay_state_coverage","metric":"replay_states_covered","observed":64,"operator":"ge","pass":true,"rationale":"Replay must cover at least 60 of 64 source states.","threshold":60},{"gate_id":"replay_expert_coverage","metric":"replay_experts_covered","observed":63,"operator":"ge","pass":true,"rationale":"Replay must retain broad assigned-expert coverage.","threshold":60},{"gate_id":"replay_transition_coverage","metric":"replay_transition_pairs_covered","observed":252,"operator":"ge","pass":true,"rationale":"Replay must preserve broad source-state/action transition support.","threshold":220},{"gate_id":"planning_path_found","metric":"path_found_rate","observed":1.0,"operator":"ge","pass":true,"rationale":"At least three quarters of bounded planning cases must have a supported path.","threshold":0.75},{"gate_id":"expert_capacity","metric":"expert_count","observed":77,"operator":"le","pass":true,"rationale":"Adaptation cannot exceed the declared expert capacity.","threshold":80},{"gate_id":"retirement_budget","metric":"accepted_retirements","observed":0,"operator":"le","pass":true,"rationale":"Retirement remains optional and bounded.","threshold":4},{"gate_id":"topology_objective_non_degradation","metric":"topology_objective_gain_q20","observed":5572,"operator":"ge","pass":true,"rationale":"Accepted adaptation-training topology decisions cannot reduce their declared objective.","threshold":0},{"gate_id":"matched_compute_budget","metric":"matched_compute_training_evaluation_ratio","observed":0.9558769081492389,"operator":"le","pass":true,"rationale":"Candidate training work may exceed the matched fixed-topology budget by at most ten percent.","threshold":1.1},{"gate_id":"conditional_inference_efficiency","metric":"inference_evaluation_ratio_vs_flat64","observed":0.125,"operator":"le","pass":true,"rationale":"Routed inference must use at most one quarter of flat complete-scan expert evaluations.","threshold":0.25},{"gate_id":"label_adaptation","metric":"adapted_drift_accuracy","observed":0.65625,"operator":"ge","pass":true,"rationale":"Changed labels must be learned above the bounded floor.","threshold":0.6},{"gate_id":"label_gain","metric":"drift_accuracy_delta","observed":0.03515625,"operator":"ge","pass":false,"rationale":"Label adaptation must improve untouched drift accuracy by at least four points.","threshold":0.04},{"gate_id":"old_label_retention","metric":"retention_accuracy_delta_from_base","observed":-0.01171875,"operator":"ge","pass":true,"rationale":"Old-label accuracy cannot fall more than ten points from base holdout.","threshold":-0.1},{"gate_id":"label_planning_non_inferiority","metric":"exact_state_rate_delta","observed":0.015625,"operator":"ge","pass":true,"rationale":"Unchanged observations and transitions should not materially damage exact planning.","threshold":-0.05}],"metrics":{"accepted_births":13,"accepted_retirements":0,"adaptation_completed":true,"adaptation_training_accuracy":0.66796875,"adapted_drift_accuracy":0.65625,"adapted_prediction_rmse":6.029821222230551,"adapted_reconstruction_rmse":5.559536227040188,"adapted_transition_accuracy":0.9154929577464789,"balanced_vs_periodic_drift_accuracy_delta":0.0,"balanced_vs_periodic_retention_delta":0.0,"base_accuracy":0.921875,"base_prediction_rmse":7.0430824337762115,"base_reconstruction_rmse":6.872830633535235,"belief_set_rate":0.890625,"belief_set_rate_delta":0.015625,"checkpoint_behavior":true,"checkpoint_identity":true,"checkpoint_mutations":true,"checkpoint_roundtrip":true,"checkpoint_size_bytes":50624,"drift_accuracy_delta":0.03515625,"exact_state_rate":0.875,"exact_state_rate_delta":0.015625,"expert_count":77,"headroom_normalized_accuracy_improvement":0.09278350515463918,"inference_evaluation_ratio_vs_flat64":0.125,"inference_expert_evaluations":2048,"lineage_invariants":true,"matched_compute_drift_accuracy_delta":0.03515625,"matched_compute_retention_delta":-0.015625,"matched_compute_training_evaluation_ratio":0.9558769081492389,"no_birth_drift_accuracy_delta":0.03515625,"no_retirement_drift_accuracy_delta":0.0,"path_found_rate":1.0,"prediction_improvement_ratio":-0.011122411581629842,"reconstruction_improvement_ratio":0.002807974196433407,"replay_actions_covered":4,"replay_experts_covered":63,"replay_labels_covered":8,"replay_selected":256,"replay_states_covered":64,"replay_transition_pairs_covered":252,"replay_unique":256,"retention_accuracy":0.91015625,"retention_accuracy_delta_from_base":-0.01171875,"retention_prediction_degradation":-0.1708829543560224,"retention_prediction_rmse":6.872199479420189,"retention_reconstruction_degradation_ratio":-0.058411816428623045,"retention_reconstruction_rmse":6.471376112224158,"retention_transition_accuracy_delta":-0.009344012204424157,"routing_mismatches":0,"static_belief_set_rate":0.875,"static_drift_accuracy":0.62109375,"static_exact_state_rate":0.859375,"static_prediction_rmse":5.963492800835572,"static_reconstruction_rmse":5.575191220126485,"static_transition_accuracy":0.9409090909090909,"topology_objective_gain_q20":5572,"training_evaluations":1796888,"transition_accuracy_delta":-0.025416133162612042,"transition_support_rate":0.83203125,"unsupported_graph_edge_violations":0},"regime":"label_drift","seed":"0xbca063ccfee7e743","trial_id":"validation-label-02","trial_result":"FAIL"},{"comparisons":{"fixed_8_expert":{"metrics":{"checkpoint_size_bytes":11294,"drift_accuracy":0.2109375,"expert_count":8,"expert_evaluations":2048,"planning_belief_set_rate":0.125,"planning_exact_state_rate":0.015625,"prediction_rmse":31.604248857900767,"reconstruction_rmse":28.75265340721228,"retention_accuracy":0.27734375,"training_evaluations":94208},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":40470,"drift_accuracy":0.40625,"expert_count":71,"expert_evaluations":0,"planning_belief_set_rate":0.5,"planning_exact_state_rate":0.484375,"prediction_rmse":-24.51658819088311,"reconstruction_rmse":-22.22147917531516,"retention_accuracy":0.62890625,"training_evaluations":1706744},"pareto_relation":"mixed"},"fixed_topology_64_expert_routed":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.65625,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":3.585453855492208,"reconstruction_rmse":3.2963066175394213,"retention_accuracy":1.0,"training_evaluations":2588672},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":8550,"drift_accuracy":-0.0390625,"expert_count":15,"expert_evaluations":0,"planning_belief_set_rate":-0.375,"planning_exact_state_rate":-0.5,"prediction_rmse":3.5022068115254514,"reconstruction_rmse":3.234867614357699,"retention_accuracy":-0.09375,"training_evaluations":-787720},"pareto_relation":"mixed"},"flat_64_expert_complete_scan":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.65625,"expert_count":64,"expert_evaluations":16384,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":3.585453855492208,"reconstruction_rmse":3.2963066175394213,"retention_accuracy":1.0,"training_evaluations":2588672},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":8550,"drift_accuracy":-0.0390625,"expert_count":15,"expert_evaluations":-14336,"planning_belief_set_rate":-0.375,"planning_exact_state_rate":-0.5,"prediction_rmse":3.5022068115254514,"reconstruction_rmse":3.234867614357699,"retention_accuracy":-0.09375,"training_evaluations":-787720},"pareto_relation":"mixed"},"matched_compute_fixed_topology":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.5859375,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":0.625,"planning_exact_state_rate":0.5,"prediction_rmse":7.031932762729521,"reconstruction_rmse":6.5384731958994635,"retention_accuracy":0.94140625,"training_evaluations":1882360},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":8550,"drift_accuracy":0.03125,"expert_count":15,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.055727904288138674,"reconstruction_rmse":-0.007298964002343311,"retention_accuracy":-0.03515625,"training_evaluations":-81408},"pareto_relation":"mixed"},"matched_expert_count_capacity":{"metrics":{"checkpoint_size_bytes":51764,"drift_accuracy":0.65625,"expert_count":79,"expert_evaluations":2048,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":3.623505986560002,"reconstruction_rmse":3.2913976339357145,"retention_accuracy":1.0,"training_evaluations":3802112},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":-0.0390625,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":-0.375,"planning_exact_state_rate":-0.5,"prediction_rmse":3.4641546804576575,"reconstruction_rmse":3.2397765979614057,"retention_accuracy":-0.09375,"training_evaluations":-2001160},"pareto_relation":"mixed"},"nearest_centroid_16_no_recursive_births":{"metrics":{"checkpoint_size_bytes":15854,"drift_accuracy":0.2578125,"expert_count":16,"expert_evaluations":4096,"planning_belief_set_rate":0.453125,"planning_exact_state_rate":0.109375,"prediction_rmse":24.699280181818853,"reconstruction_rmse":22.87177275275608,"retention_accuracy":0.2421875,"training_evaluations":253952},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":35910,"drift_accuracy":0.359375,"expert_count":63,"expert_evaluations":-2048,"planning_belief_set_rate":0.171875,"planning_exact_state_rate":0.390625,"prediction_rmse":-17.611619514801195,"reconstruction_rmse":-16.34059852085896,"retention_accuracy":0.6640625,"training_evaluations":1547000},"pareto_relation":"mixed"},"no_adaptation_static":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.5859375,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":0.625,"planning_exact_state_rate":0.5,"prediction_rmse":7.031932762729521,"reconstruction_rmse":6.5384731958994635,"retention_accuracy":0.94140625,"training_evaluations":555256},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":8550,"drift_accuracy":0.03125,"expert_count":15,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.055727904288138674,"reconstruction_rmse":-0.007298964002343311,"retention_accuracy":-0.03515625,"training_evaluations":1245696},"pareto_relation":"mixed"},"periodic_replay_policy":{"metrics":{"checkpoint_size_bytes":50624,"drift_accuracy":0.61328125,"expert_count":77,"expert_evaluations":2048,"planning_belief_set_rate":0.625,"planning_exact_state_rate":0.5,"prediction_rmse":7.082742727734855,"reconstruction_rmse":6.532161126377185,"retention_accuracy":0.91015625,"training_evaluations":1172728},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":1140,"drift_accuracy":0.00390625,"expert_count":2,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.004917939282804262,"reconstruction_rmse":-0.000986894480064393,"retention_accuracy":-0.00390625,"training_evaluations":628224},"pareto_relation":"mixed"},"ravel_0_5_candidate":{"metrics":{"checkpoint_size_bytes":51764,"drift_accuracy":0.6171875,"expert_count":79,"expert_evaluations":2048,"planning_belief_set_rate":0.625,"planning_exact_state_rate":0.5,"prediction_rmse":7.087660667017659,"reconstruction_rmse":6.53117423189712,"retention_accuracy":0.90625,"training_evaluations":1800952},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"equivalent"},"ravel_complete_scan_without_certification":{"metrics":{"checkpoint_size_bytes":51764,"drift_accuracy":0.6171875,"expert_count":79,"expert_evaluations":20224,"planning_belief_set_rate":0.625,"planning_exact_state_rate":0.5,"prediction_rmse":7.087660667017659,"reconstruction_rmse":6.53117423189712,"retention_accuracy":0.90625,"training_evaluations":2019064},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":-18176,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":-218112},"pareto_relation":"candidate_dominates"},"ravel_no_birth_same_replay_iterations":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.5859375,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":0.625,"planning_exact_state_rate":0.5,"prediction_rmse":7.031932762729521,"reconstruction_rmse":6.5384731958994635,"retention_accuracy":0.94140625,"training_evaluations":776440},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":8550,"drift_accuracy":0.03125,"expert_count":15,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.055727904288138674,"reconstruction_rmse":-0.007298964002343311,"retention_accuracy":-0.03515625,"training_evaluations":1024512},"pareto_relation":"mixed"},"ravel_random_births":{"metrics":{"checkpoint_size_bytes":44354,"drift_accuracy":0.58984375,"expert_count":66,"expert_evaluations":2048,"planning_belief_set_rate":0.625,"planning_exact_state_rate":0.5,"prediction_rmse":7.0438941133169495,"reconstruction_rmse":6.537949260831463,"retention_accuracy":0.93359375,"training_evaluations":900856},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":7410,"drift_accuracy":0.02734375,"expert_count":13,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.04376655370070992,"reconstruction_rmse":-0.006775028934343119,"retention_accuracy":-0.02734375,"training_evaluations":900096},"pareto_relation":"mixed"},"ravel_without_replay":{"metrics":{"checkpoint_size_bytes":52334,"drift_accuracy":0.62109375,"expert_count":80,"expert_evaluations":2048,"planning_belief_set_rate":0.625,"planning_exact_state_rate":0.5,"prediction_rmse":7.094324965202743,"reconstruction_rmse":6.529518233270386,"retention_accuracy":0.90625,"training_evaluations":1728760},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":-570,"drift_accuracy":-0.00390625,"expert_count":-1,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":-0.006664298185083517,"reconstruction_rmse":0.0016559986267346005,"retention_accuracy":0.0,"training_evaluations":72192},"pareto_relation":"mixed"},"ravel_without_retirement_matched_work":{"metrics":{"checkpoint_size_bytes":51764,"drift_accuracy":0.6171875,"expert_count":79,"expert_evaluations":2048,"planning_belief_set_rate":0.625,"planning_exact_state_rate":0.5,"prediction_rmse":7.087660667017659,"reconstruction_rmse":6.53117423189712,"retention_accuracy":0.90625,"training_evaluations":1800952},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"equivalent"}},"gates":[{"gate_id":"adaptation_completed","metric":"adaptation_completed","observed":true,"operator":"eq","pass":true,"rationale":"The bounded adaptation procedure must complete.","threshold":true},{"gate_id":"base_holdout_accuracy","metric":"base_accuracy","observed":0.9609375,"operator":"ge","pass":true,"rationale":"The base representation must establish the bounded task before drift.","threshold":0.85},{"gate_id":"base_holdout_retention","metric":"retention_accuracy","observed":0.90625,"operator":"ge","pass":true,"rationale":"Anchored base behavior may lose at most ten percentage points in absolute retained accuracy.","threshold":0.9},{"gate_id":"routing_oracle_equivalence","metric":"routing_mismatches","observed":0,"operator":"eq","pass":true,"rationale":"Every routed classification must agree with complete scan.","threshold":0},{"gate_id":"checkpoint_roundtrip","metric":"checkpoint_roundtrip","observed":true,"operator":"eq","pass":true,"rationale":"Canonical in-memory restoration must succeed.","threshold":true},{"gate_id":"checkpoint_identity","metric":"checkpoint_identity","observed":true,"operator":"eq","pass":true,"rationale":"Restored complete model identity must match.","threshold":true},{"gate_id":"checkpoint_behavior","metric":"checkpoint_behavior","observed":true,"operator":"eq","pass":true,"rationale":"Restored evaluation and planning behavior must match.","threshold":true},{"gate_id":"checkpoint_mutation_rejection","metric":"checkpoint_mutations","observed":true,"operator":"eq","pass":true,"rationale":"Every declared behavioral and byte-level checkpoint mutation must be detected.","threshold":true},{"gate_id":"lineage_invariants","metric":"lineage_invariants","observed":true,"operator":"eq","pass":true,"rationale":"Generation, lineage uniqueness, descendant splitting, and deterministic topology invariants must hold.","threshold":true},{"gate_id":"unsupported_transitions_unknown","metric":"unsupported_graph_edge_violations","observed":0,"operator":"eq","pass":true,"rationale":"Unsupported actions cannot enter the planning graph.","threshold":0},{"gate_id":"replay_size","metric":"replay_selected","observed":256,"operator":"eq","pass":true,"rationale":"The declared replay budget must be filled on the non-sparse trial corpus.","threshold":256},{"gate_id":"replay_unique","metric":"replay_unique","observed":256,"operator":"eq","pass":true,"rationale":"Balanced replay cannot introduce accidental duplicates.","threshold":256},{"gate_id":"replay_label_coverage","metric":"replay_labels_covered","observed":8,"operator":"eq","pass":true,"rationale":"Replay must retain every declared label.","threshold":8},{"gate_id":"replay_action_coverage","metric":"replay_actions_covered","observed":4,"operator":"eq","pass":true,"rationale":"Replay must retain every declared action.","threshold":4},{"gate_id":"replay_state_coverage","metric":"replay_states_covered","observed":64,"operator":"ge","pass":true,"rationale":"Replay must cover at least 60 of 64 source states.","threshold":60},{"gate_id":"replay_expert_coverage","metric":"replay_experts_covered","observed":63,"operator":"ge","pass":true,"rationale":"Replay must retain broad assigned-expert coverage.","threshold":60},{"gate_id":"replay_transition_coverage","metric":"replay_transition_pairs_covered","observed":251,"operator":"ge","pass":true,"rationale":"Replay must preserve broad source-state/action transition support.","threshold":220},{"gate_id":"planning_path_found","metric":"path_found_rate","observed":1.0,"operator":"ge","pass":true,"rationale":"At least three quarters of bounded planning cases must have a supported path.","threshold":0.75},{"gate_id":"expert_capacity","metric":"expert_count","observed":79,"operator":"le","pass":true,"rationale":"Adaptation cannot exceed the declared expert capacity.","threshold":80},{"gate_id":"retirement_budget","metric":"accepted_retirements","observed":0,"operator":"le","pass":true,"rationale":"Retirement remains optional and bounded.","threshold":4},{"gate_id":"topology_objective_non_degradation","metric":"topology_objective_gain_q20","observed":5761,"operator":"ge","pass":true,"rationale":"Accepted adaptation-training topology decisions cannot reduce their declared objective.","threshold":0},{"gate_id":"matched_compute_budget","metric":"matched_compute_training_evaluation_ratio","observed":0.9567521621793919,"operator":"le","pass":true,"rationale":"Candidate training work may exceed the matched fixed-topology budget by at most ten percent.","threshold":1.1},{"gate_id":"conditional_inference_efficiency","metric":"inference_evaluation_ratio_vs_flat64","observed":0.125,"operator":"le","pass":true,"rationale":"Routed inference must use at most one quarter of flat complete-scan expert evaluations.","threshold":0.25},{"gate_id":"label_adaptation","metric":"adapted_drift_accuracy","observed":0.6171875,"operator":"ge","pass":true,"rationale":"Changed labels must be learned above the bounded floor.","threshold":0.6},{"gate_id":"label_gain","metric":"drift_accuracy_delta","observed":0.03125,"operator":"ge","pass":false,"rationale":"Label adaptation must improve untouched drift accuracy by at least four points.","threshold":0.04},{"gate_id":"old_label_retention","metric":"retention_accuracy_delta_from_base","observed":-0.0546875,"operator":"ge","pass":true,"rationale":"Old-label accuracy cannot fall more than ten points from base holdout.","threshold":-0.1},{"gate_id":"label_planning_non_inferiority","metric":"exact_state_rate_delta","observed":0.0,"operator":"ge","pass":true,"rationale":"Unchanged observations and transitions should not materially damage exact planning.","threshold":-0.05}],"metrics":{"accepted_births":15,"accepted_retirements":0,"adaptation_completed":true,"adaptation_training_accuracy":0.595703125,"adapted_drift_accuracy":0.6171875,"adapted_prediction_rmse":7.087660667017659,"adapted_reconstruction_rmse":6.53117423189712,"adapted_transition_accuracy":0.9030837004405287,"balanced_vs_periodic_drift_accuracy_delta":0.00390625,"balanced_vs_periodic_retention_delta":-0.00390625,"base_accuracy":0.9609375,"base_prediction_rmse":6.2605371611525555,"base_reconstruction_rmse":5.876737338833624,"belief_set_rate":0.625,"belief_set_rate_delta":0.0,"checkpoint_behavior":true,"checkpoint_identity":true,"checkpoint_mutations":true,"checkpoint_roundtrip":true,"checkpoint_size_bytes":51764,"drift_accuracy_delta":0.03125,"exact_state_rate":0.5,"exact_state_rate_delta":0.0,"expert_count":79,"headroom_normalized_accuracy_improvement":0.07547169811320754,"inference_evaluation_ratio_vs_flat64":0.125,"inference_expert_evaluations":2048,"lineage_invariants":true,"matched_compute_drift_accuracy_delta":0.03125,"matched_compute_retention_delta":-0.03515625,"matched_compute_training_evaluation_ratio":0.9567521621793919,"no_birth_drift_accuracy_delta":0.03125,"no_retirement_drift_accuracy_delta":0.0,"path_found_rate":1.0,"prediction_improvement_ratio":-0.007924976840436582,"reconstruction_improvement_ratio":0.0011163101512629556,"replay_actions_covered":4,"replay_experts_covered":63,"replay_labels_covered":8,"replay_selected":256,"replay_states_covered":64,"replay_transition_pairs_covered":251,"replay_unique":256,"retention_accuracy":0.90625,"retention_accuracy_delta_from_base":-0.0546875,"retention_prediction_degradation":0.7032263251281874,"retention_prediction_rmse":6.963763486280743,"retention_reconstruction_degradation_ratio":0.0828494880903982,"retention_reconstruction_rmse":6.363622018997718,"retention_transition_accuracy_delta":-0.04501926252063837,"routing_mismatches":0,"static_belief_set_rate":0.625,"static_drift_accuracy":0.5859375,"static_exact_state_rate":0.5,"static_prediction_rmse":7.031932762729521,"static_reconstruction_rmse":6.5384731958994635,"static_transition_accuracy":0.9267241379310345,"topology_objective_gain_q20":5761,"training_evaluations":1800952,"transition_accuracy_delta":-0.023640437490505817,"transition_support_rate":0.88671875,"unsupported_graph_edge_violations":0},"regime":"label_drift","seed":"0x27b73cba3e16bfb3","trial_id":"validation-label-03","trial_result":"FAIL"},{"comparisons":{"fixed_8_expert":{"metrics":{"checkpoint_size_bytes":11294,"drift_accuracy":0.14453125,"expert_count":8,"expert_evaluations":2048,"planning_belief_set_rate":0.21875,"planning_exact_state_rate":0.0,"prediction_rmse":30.565103700865617,"reconstruction_rmse":28.764987196341615,"retention_accuracy":0.18359375,"training_evaluations":94208},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":38760,"drift_accuracy":0.515625,"expert_count":68,"expert_evaluations":884,"planning_belief_set_rate":0.65625,"planning_exact_state_rate":0.875,"prediction_rmse":-26.34717182480464,"reconstruction_rmse":-24.6270850703744,"retention_accuracy":0.78125,"training_evaluations":1574386},"pareto_relation":"mixed"},"fixed_topology_64_expert_routed":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.65234375,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":3.400205007092993,"reconstruction_rmse":3.2872126605414986,"retention_accuracy":1.0,"training_evaluations":2588672},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":6840,"drift_accuracy":0.0078125,"expert_count":12,"expert_evaluations":884,"planning_belief_set_rate":-0.125,"planning_exact_state_rate":-0.125,"prediction_rmse":0.8177268689679837,"reconstruction_rmse":0.8506894654257189,"retention_accuracy":-0.03515625,"training_evaluations":-920078},"pareto_relation":"mixed"},"flat_64_expert_complete_scan":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.65234375,"expert_count":64,"expert_evaluations":16384,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":3.400205007092993,"reconstruction_rmse":3.2872126605414986,"retention_accuracy":1.0,"training_evaluations":2588672},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":6840,"drift_accuracy":0.0078125,"expert_count":12,"expert_evaluations":-13452,"planning_belief_set_rate":-0.125,"planning_exact_state_rate":-0.125,"prediction_rmse":0.8177268689679837,"reconstruction_rmse":0.8506894654257189,"retention_accuracy":-0.03515625,"training_evaluations":-920078},"pareto_relation":"mixed"},"matched_compute_fixed_topology":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.640625,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":0.875,"planning_exact_state_rate":0.875,"prediction_rmse":4.203453761079668,"reconstruction_rmse":4.141651363631061,"retention_accuracy":0.98828125,"training_evaluations":1881440},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":6840,"drift_accuracy":0.01953125,"expert_count":12,"expert_evaluations":884,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.014478114981308465,"reconstruction_rmse":-0.0037492376638432745,"retention_accuracy":-0.0234375,"training_evaluations":-212846},"pareto_relation":"mixed"},"matched_expert_count_capacity":{"metrics":{"checkpoint_size_bytes":50054,"drift_accuracy":0.65234375,"expert_count":76,"expert_evaluations":2048,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":3.375507256980933,"reconstruction_rmse":3.277986096748165,"retention_accuracy":1.0,"training_evaluations":3540992},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0078125,"expert_count":0,"expert_evaluations":884,"planning_belief_set_rate":-0.125,"planning_exact_state_rate":-0.125,"prediction_rmse":0.842424619080044,"reconstruction_rmse":0.8599160292190526,"retention_accuracy":-0.03515625,"training_evaluations":-1872398},"pareto_relation":"mixed"},"nearest_centroid_16_no_recursive_births":{"metrics":{"checkpoint_size_bytes":15854,"drift_accuracy":0.19140625,"expert_count":16,"expert_evaluations":4096,"planning_belief_set_rate":0.515625,"planning_exact_state_rate":0.078125,"prediction_rmse":24.659957259321875,"reconstruction_rmse":23.015325551023672,"retention_accuracy":0.2421875,"training_evaluations":253952},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":34200,"drift_accuracy":0.46875,"expert_count":60,"expert_evaluations":-1164,"planning_belief_set_rate":0.359375,"planning_exact_state_rate":0.796875,"prediction_rmse":-20.442025383260898,"reconstruction_rmse":-18.877423425056456,"retention_accuracy":0.72265625,"training_evaluations":1414642},"pareto_relation":"mixed"},"no_adaptation_static":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.640625,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":0.875,"planning_exact_state_rate":0.875,"prediction_rmse":4.203453761079668,"reconstruction_rmse":4.141651363631061,"retention_accuracy":0.98828125,"training_evaluations":554336},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":6840,"drift_accuracy":0.01953125,"expert_count":12,"expert_evaluations":884,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.014478114981308465,"reconstruction_rmse":-0.0037492376638432745,"retention_accuracy":-0.0234375,"training_evaluations":1114258},"pareto_relation":"mixed"},"periodic_replay_policy":{"metrics":{"checkpoint_size_bytes":51764,"drift_accuracy":0.66015625,"expert_count":79,"expert_evaluations":2971,"planning_belief_set_rate":0.875,"planning_exact_state_rate":0.875,"prediction_rmse":4.217931876060977,"reconstruction_rmse":4.137405962895965,"retention_accuracy":0.96484375,"training_evaluations":2364032},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":-1710,"drift_accuracy":0.0,"expert_count":-3,"expert_evaluations":-39,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0004961630712525533,"retention_accuracy":0.0,"training_evaluations":-695438},"pareto_relation":"mixed"},"ravel_0_5_candidate":{"metrics":{"checkpoint_size_bytes":50054,"drift_accuracy":0.66015625,"expert_count":76,"expert_evaluations":2932,"planning_belief_set_rate":0.875,"planning_exact_state_rate":0.875,"prediction_rmse":4.217931876060977,"reconstruction_rmse":4.1379021259672175,"retention_accuracy":0.96484375,"training_evaluations":1668594},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"equivalent"},"ravel_complete_scan_without_certification":{"metrics":{"checkpoint_size_bytes":50054,"drift_accuracy":0.66015625,"expert_count":76,"expert_evaluations":19456,"planning_belief_set_rate":0.875,"planning_exact_state_rate":0.875,"prediction_rmse":4.217931876060977,"reconstruction_rmse":4.1379021259672175,"retention_accuracy":0.96484375,"training_evaluations":1863074},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":-16524,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":-194480},"pareto_relation":"candidate_dominates"},"ravel_no_birth_same_replay_iterations":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.640625,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":0.875,"planning_exact_state_rate":0.875,"prediction_rmse":4.203453761079668,"reconstruction_rmse":4.141651363631061,"retention_accuracy":0.98828125,"training_evaluations":775520},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":6840,"drift_accuracy":0.01953125,"expert_count":12,"expert_evaluations":884,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.014478114981308465,"reconstruction_rmse":-0.0037492376638432745,"retention_accuracy":-0.0234375,"training_evaluations":893074},"pareto_relation":"mixed"},"ravel_random_births":{"metrics":{"checkpoint_size_bytes":44354,"drift_accuracy":0.6484375,"expert_count":66,"expert_evaluations":2048,"planning_belief_set_rate":0.84375,"planning_exact_state_rate":0.84375,"prediction_rmse":4.1985457048413055,"reconstruction_rmse":4.131939064617393,"retention_accuracy":0.98046875,"training_evaluations":1125728},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":5700,"drift_accuracy":0.01171875,"expert_count":10,"expert_evaluations":884,"planning_belief_set_rate":0.03125,"planning_exact_state_rate":0.03125,"prediction_rmse":0.019386171219671233,"reconstruction_rmse":0.005963061349824272,"retention_accuracy":-0.015625,"training_evaluations":542866},"pareto_relation":"mixed"},"ravel_without_replay":{"metrics":{"checkpoint_size_bytes":52334,"drift_accuracy":0.65625,"expert_count":80,"expert_evaluations":4496,"planning_belief_set_rate":0.84375,"planning_exact_state_rate":0.84375,"prediction_rmse":4.209527598200847,"reconstruction_rmse":4.137718845928037,"retention_accuracy":0.9609375,"training_evaluations":1968450},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":-2280,"drift_accuracy":0.00390625,"expert_count":-4,"expert_evaluations":-1564,"planning_belief_set_rate":0.03125,"planning_exact_state_rate":0.03125,"prediction_rmse":0.008404277860130094,"reconstruction_rmse":0.0001832800391801115,"retention_accuracy":0.00390625,"training_evaluations":-299856},"pareto_relation":"mixed"},"ravel_without_retirement_matched_work":{"metrics":{"checkpoint_size_bytes":50054,"drift_accuracy":0.66015625,"expert_count":76,"expert_evaluations":2932,"planning_belief_set_rate":0.875,"planning_exact_state_rate":0.875,"prediction_rmse":4.217931876060977,"reconstruction_rmse":4.1379021259672175,"retention_accuracy":0.96484375,"training_evaluations":1668594},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"equivalent"}},"gates":[{"gate_id":"adaptation_completed","metric":"adaptation_completed","observed":true,"operator":"eq","pass":true,"rationale":"The bounded adaptation procedure must complete.","threshold":true},{"gate_id":"base_holdout_accuracy","metric":"base_accuracy","observed":0.98046875,"operator":"ge","pass":true,"rationale":"The base representation must establish the bounded task before drift.","threshold":0.85},{"gate_id":"base_holdout_retention","metric":"retention_accuracy","observed":0.96484375,"operator":"ge","pass":true,"rationale":"Anchored base behavior may lose at most ten percentage points in absolute retained accuracy.","threshold":0.9},{"gate_id":"routing_oracle_equivalence","metric":"routing_mismatches","observed":0,"operator":"eq","pass":true,"rationale":"Every routed classification must agree with complete scan.","threshold":0},{"gate_id":"checkpoint_roundtrip","metric":"checkpoint_roundtrip","observed":true,"operator":"eq","pass":true,"rationale":"Canonical in-memory restoration must succeed.","threshold":true},{"gate_id":"checkpoint_identity","metric":"checkpoint_identity","observed":true,"operator":"eq","pass":true,"rationale":"Restored complete model identity must match.","threshold":true},{"gate_id":"checkpoint_behavior","metric":"checkpoint_behavior","observed":true,"operator":"eq","pass":true,"rationale":"Restored evaluation and planning behavior must match.","threshold":true},{"gate_id":"checkpoint_mutation_rejection","metric":"checkpoint_mutations","observed":true,"operator":"eq","pass":true,"rationale":"Every declared behavioral and byte-level checkpoint mutation must be detected.","threshold":true},{"gate_id":"lineage_invariants","metric":"lineage_invariants","observed":true,"operator":"eq","pass":true,"rationale":"Generation, lineage uniqueness, descendant splitting, and deterministic topology invariants must hold.","threshold":true},{"gate_id":"unsupported_transitions_unknown","metric":"unsupported_graph_edge_violations","observed":0,"operator":"eq","pass":true,"rationale":"Unsupported actions cannot enter the planning graph.","threshold":0},{"gate_id":"replay_size","metric":"replay_selected","observed":256,"operator":"eq","pass":true,"rationale":"The declared replay budget must be filled on the non-sparse trial corpus.","threshold":256},{"gate_id":"replay_unique","metric":"replay_unique","observed":256,"operator":"eq","pass":true,"rationale":"Balanced replay cannot introduce accidental duplicates.","threshold":256},{"gate_id":"replay_label_coverage","metric":"replay_labels_covered","observed":8,"operator":"eq","pass":true,"rationale":"Replay must retain every declared label.","threshold":8},{"gate_id":"replay_action_coverage","metric":"replay_actions_covered","observed":4,"operator":"eq","pass":true,"rationale":"Replay must retain every declared action.","threshold":4},{"gate_id":"replay_state_coverage","metric":"replay_states_covered","observed":64,"operator":"ge","pass":true,"rationale":"Replay must cover at least 60 of 64 source states.","threshold":60},{"gate_id":"replay_expert_coverage","metric":"replay_experts_covered","observed":64,"operator":"ge","pass":true,"rationale":"Replay must retain broad assigned-expert coverage.","threshold":60},{"gate_id":"replay_transition_coverage","metric":"replay_transition_pairs_covered","observed":250,"operator":"ge","pass":true,"rationale":"Replay must preserve broad source-state/action transition support.","threshold":220},{"gate_id":"planning_path_found","metric":"path_found_rate","observed":1.0,"operator":"ge","pass":true,"rationale":"At least three quarters of bounded planning cases must have a supported path.","threshold":0.75},{"gate_id":"expert_capacity","metric":"expert_count","observed":76,"operator":"le","pass":true,"rationale":"Adaptation cannot exceed the declared expert capacity.","threshold":80},{"gate_id":"retirement_budget","metric":"accepted_retirements","observed":0,"operator":"le","pass":true,"rationale":"Retirement remains optional and bounded.","threshold":4},{"gate_id":"topology_objective_non_degradation","metric":"topology_objective_gain_q20","observed":6319,"operator":"ge","pass":true,"rationale":"Accepted adaptation-training topology decisions cannot reduce their declared objective.","threshold":0},{"gate_id":"matched_compute_budget","metric":"matched_compute_training_evaluation_ratio","observed":0.8868706947869717,"operator":"le","pass":true,"rationale":"Candidate training work may exceed the matched fixed-topology budget by at most ten percent.","threshold":1.1},{"gate_id":"conditional_inference_efficiency","metric":"inference_evaluation_ratio_vs_flat64","observed":0.178955078125,"operator":"le","pass":true,"rationale":"Routed inference must use at most one quarter of flat complete-scan expert evaluations.","threshold":0.25},{"gate_id":"label_adaptation","metric":"adapted_drift_accuracy","observed":0.66015625,"operator":"ge","pass":true,"rationale":"Changed labels must be learned above the bounded floor.","threshold":0.6},{"gate_id":"label_gain","metric":"drift_accuracy_delta","observed":0.01953125,"operator":"ge","pass":false,"rationale":"Label adaptation must improve untouched drift accuracy by at least four points.","threshold":0.04},{"gate_id":"old_label_retention","metric":"retention_accuracy_delta_from_base","observed":-0.015625,"operator":"ge","pass":true,"rationale":"Old-label accuracy cannot fall more than ten points from base holdout.","threshold":-0.1},{"gate_id":"label_planning_non_inferiority","metric":"exact_state_rate_delta","observed":0.0,"operator":"ge","pass":true,"rationale":"Unchanged observations and transitions should not materially damage exact planning.","threshold":-0.05}],"metrics":{"accepted_births":12,"accepted_retirements":0,"adaptation_completed":true,"adaptation_training_accuracy":0.697265625,"adapted_drift_accuracy":0.66015625,"adapted_prediction_rmse":4.217931876060977,"adapted_reconstruction_rmse":4.1379021259672175,"adapted_transition_accuracy":0.9307359307359307,"balanced_vs_periodic_drift_accuracy_delta":0.0,"balanced_vs_periodic_retention_delta":0.0,"base_accuracy":0.98046875,"base_prediction_rmse":4.813547842849856,"base_reconstruction_rmse":4.388381819557791,"belief_set_rate":0.875,"belief_set_rate_delta":0.0,"checkpoint_behavior":true,"checkpoint_identity":true,"checkpoint_mutations":true,"checkpoint_roundtrip":true,"checkpoint_size_bytes":50054,"drift_accuracy_delta":0.01953125,"exact_state_rate":0.875,"exact_state_rate_delta":0.0,"expert_count":76,"headroom_normalized_accuracy_improvement":0.05434782608695652,"inference_evaluation_ratio_vs_flat64":0.178955078125,"inference_expert_evaluations":2932,"lineage_invariants":true,"matched_compute_drift_accuracy_delta":0.01953125,"matched_compute_retention_delta":-0.0234375,"matched_compute_training_evaluation_ratio":0.8868706947869717,"no_birth_drift_accuracy_delta":0.01953125,"no_retirement_drift_accuracy_delta":0.0,"path_found_rate":1.0,"prediction_improvement_ratio":-0.0034443378717194982,"reconstruction_improvement_ratio":0.0009052518753187013,"replay_actions_covered":4,"replay_experts_covered":64,"replay_labels_covered":8,"replay_selected":256,"replay_states_covered":64,"replay_transition_pairs_covered":250,"replay_unique":256,"retention_accuracy":0.96484375,"retention_accuracy_delta_from_base":-0.015625,"retention_prediction_degradation":-0.13944211135457607,"retention_prediction_rmse":4.67410573149528,"retention_reconstruction_degradation_ratio":-0.08724680956010053,"retention_reconstruction_rmse":4.005509506669825,"retention_transition_accuracy_delta":-0.04928635147190008,"routing_mismatches":0,"static_belief_set_rate":0.875,"static_drift_accuracy":0.640625,"static_exact_state_rate":0.875,"static_prediction_rmse":4.203453761079668,"static_reconstruction_rmse":4.141651363631061,"static_transition_accuracy":0.974025974025974,"topology_objective_gain_q20":6319,"training_evaluations":1668594,"transition_accuracy_delta":-0.04329004329004327,"transition_support_rate":0.90234375,"unsupported_graph_edge_violations":0},"regime":"label_drift","seed":"0x8ad341ed9d31e4b2","trial_id":"validation-label-04","trial_result":"FAIL"},{"comparisons":{"fixed_8_expert":{"metrics":{"checkpoint_size_bytes":11294,"drift_accuracy":0.13671875,"expert_count":8,"expert_evaluations":2048,"planning_belief_set_rate":0.359375,"planning_exact_state_rate":0.03125,"prediction_rmse":30.977954293546073,"reconstruction_rmse":28.963043574367234,"retention_accuracy":0.20703125,"training_evaluations":94208},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":34200,"drift_accuracy":0.86328125,"expert_count":60,"expert_evaluations":0,"planning_belief_set_rate":0.546875,"planning_exact_state_rate":0.875,"prediction_rmse":-23.365818510294613,"reconstruction_rmse":-21.89473338218169,"retention_accuracy":0.79296875,"training_evaluations":1148376},"pareto_relation":"mixed"},"fixed_topology_64_expert_routed":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":1.0,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":6.9491270363418876,"reconstruction_rmse":6.644833961604582,"retention_accuracy":1.0,"training_evaluations":2588672},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":2280,"drift_accuracy":0.0,"expert_count":4,"expert_evaluations":0,"planning_belief_set_rate":-0.09375,"planning_exact_state_rate":-0.09375,"prediction_rmse":0.6630087469095738,"reconstruction_rmse":0.4234762305809596,"retention_accuracy":0.0,"training_evaluations":-1346088},"pareto_relation":"mixed"},"flat_64_expert_complete_scan":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":1.0,"expert_count":64,"expert_evaluations":16384,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":6.9491270363418876,"reconstruction_rmse":6.644833961604582,"retention_accuracy":1.0,"training_evaluations":2588672},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":2280,"drift_accuracy":0.0,"expert_count":4,"expert_evaluations":-14336,"planning_belief_set_rate":-0.09375,"planning_exact_state_rate":-0.09375,"prediction_rmse":0.6630087469095738,"reconstruction_rmse":0.4234762305809596,"retention_accuracy":0.0,"training_evaluations":-1346088},"pareto_relation":"mixed"},"matched_compute_fixed_topology":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.93359375,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":0.75,"planning_exact_state_rate":0.71875,"prediction_rmse":9.265365809082173,"reconstruction_rmse":8.582996537157422,"retention_accuracy":0.96875,"training_evaluations":1436120},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":2280,"drift_accuracy":0.06640625,"expert_count":4,"expert_evaluations":0,"planning_belief_set_rate":0.15625,"planning_exact_state_rate":0.1875,"prediction_rmse":-1.6532300258307115,"reconstruction_rmse":-1.5146863449718806,"retention_accuracy":0.03125,"training_evaluations":-193536},"pareto_relation":"mixed"},"matched_expert_count_capacity":{"metrics":{"checkpoint_size_bytes":45494,"drift_accuracy":1.0,"expert_count":68,"expert_evaluations":2048,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":7.010493978000023,"reconstruction_rmse":6.642840457369666,"retention_accuracy":1.0,"training_evaluations":2889728},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":-0.09375,"planning_exact_state_rate":-0.09375,"prediction_rmse":0.6016418052514387,"reconstruction_rmse":0.42546973481587536,"retention_accuracy":0.0,"training_evaluations":-1647144},"pareto_relation":"mixed"},"nearest_centroid_16_no_recursive_births":{"metrics":{"checkpoint_size_bytes":15854,"drift_accuracy":0.21484375,"expert_count":16,"expert_evaluations":4096,"planning_belief_set_rate":0.4375,"planning_exact_state_rate":0.046875,"prediction_rmse":25.420648270672565,"reconstruction_rmse":23.42072807748582,"retention_accuracy":0.2421875,"training_evaluations":253952},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":29640,"drift_accuracy":0.78515625,"expert_count":52,"expert_evaluations":-2048,"planning_belief_set_rate":0.46875,"planning_exact_state_rate":0.859375,"prediction_rmse":-17.808512487421105,"reconstruction_rmse":-16.352417885300277,"retention_accuracy":0.7578125,"training_evaluations":988632},"pareto_relation":"mixed"},"no_adaptation_static":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.93359375,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":0.75,"planning_exact_state_rate":0.71875,"prediction_rmse":9.265365809082173,"reconstruction_rmse":8.582996537157422,"retention_accuracy":0.96875,"training_evaluations":551384},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":2280,"drift_accuracy":0.06640625,"expert_count":4,"expert_evaluations":0,"planning_belief_set_rate":0.15625,"planning_exact_state_rate":0.1875,"prediction_rmse":-1.6532300258307115,"reconstruction_rmse":-1.5146863449718806,"retention_accuracy":0.03125,"training_evaluations":691200},"pareto_relation":"mixed"},"periodic_replay_policy":{"metrics":{"checkpoint_size_bytes":45494,"drift_accuracy":1.0,"expert_count":68,"expert_evaluations":2048,"planning_belief_set_rate":0.90625,"planning_exact_state_rate":0.90625,"prediction_rmse":7.62585252711033,"reconstruction_rmse":7.06326606783086,"retention_accuracy":1.0,"training_evaluations":1242584},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":-0.013716743858868341,"reconstruction_rmse":0.005044124354681934,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"mixed"},"ravel_0_5_candidate":{"metrics":{"checkpoint_size_bytes":45494,"drift_accuracy":1.0,"expert_count":68,"expert_evaluations":2048,"planning_belief_set_rate":0.90625,"planning_exact_state_rate":0.90625,"prediction_rmse":7.612135783251461,"reconstruction_rmse":7.068310192185542,"retention_accuracy":1.0,"training_evaluations":1242584},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"equivalent"},"ravel_complete_scan_without_certification":{"metrics":{"checkpoint_size_bytes":45494,"drift_accuracy":1.0,"expert_count":68,"expert_evaluations":17408,"planning_belief_set_rate":0.90625,"planning_exact_state_rate":0.90625,"prediction_rmse":7.612135783251461,"reconstruction_rmse":7.068310192185542,"retention_accuracy":1.0,"training_evaluations":1426904},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":-15360,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":-184320},"pareto_relation":"candidate_dominates"},"ravel_no_birth_same_replay_iterations":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.93359375,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":0.75,"planning_exact_state_rate":0.71875,"prediction_rmse":9.265365809082173,"reconstruction_rmse":8.582996537157422,"retention_accuracy":0.96875,"training_evaluations":772568},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":2280,"drift_accuracy":0.06640625,"expert_count":4,"expert_evaluations":0,"planning_belief_set_rate":0.15625,"planning_exact_state_rate":0.1875,"prediction_rmse":-1.6532300258307115,"reconstruction_rmse":-1.5146863449718806,"retention_accuracy":0.03125,"training_evaluations":470016},"pareto_relation":"mixed"},"ravel_random_births":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.93359375,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":0.75,"planning_exact_state_rate":0.71875,"prediction_rmse":9.265365809082173,"reconstruction_rmse":8.582996537157422,"retention_accuracy":0.96875,"training_evaluations":772568},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":2280,"drift_accuracy":0.06640625,"expert_count":4,"expert_evaluations":0,"planning_belief_set_rate":0.15625,"planning_exact_state_rate":0.1875,"prediction_rmse":-1.6532300258307115,"reconstruction_rmse":-1.5146863449718806,"retention_accuracy":0.03125,"training_evaluations":470016},"pareto_relation":"mixed"},"ravel_without_replay":{"metrics":{"checkpoint_size_bytes":45494,"drift_accuracy":1.0,"expert_count":68,"expert_evaluations":2048,"planning_belief_set_rate":0.90625,"planning_exact_state_rate":0.90625,"prediction_rmse":7.649256044535592,"reconstruction_rmse":7.057154133605842,"retention_accuracy":1.0,"training_evaluations":1012184},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":-0.03712026128413104,"reconstruction_rmse":0.011156058579699923,"retention_accuracy":0.0,"training_evaluations":230400},"pareto_relation":"mixed"},"ravel_without_retirement_matched_work":{"metrics":{"checkpoint_size_bytes":45494,"drift_accuracy":1.0,"expert_count":68,"expert_evaluations":2048,"planning_belief_set_rate":0.90625,"planning_exact_state_rate":0.90625,"prediction_rmse":7.612135783251461,"reconstruction_rmse":7.068310192185542,"retention_accuracy":1.0,"training_evaluations":1242584},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"equivalent"}},"gates":[{"gate_id":"adaptation_completed","metric":"adaptation_completed","observed":true,"operator":"eq","pass":true,"rationale":"The bounded adaptation procedure must complete.","threshold":true},{"gate_id":"base_holdout_accuracy","metric":"base_accuracy","observed":0.93359375,"operator":"ge","pass":true,"rationale":"The base representation must establish the bounded task before drift.","threshold":0.85},{"gate_id":"base_holdout_retention","metric":"retention_accuracy","observed":1.0,"operator":"ge","pass":true,"rationale":"Anchored base behavior may lose at most ten percentage points in absolute retained accuracy.","threshold":0.9},{"gate_id":"routing_oracle_equivalence","metric":"routing_mismatches","observed":0,"operator":"eq","pass":true,"rationale":"Every routed classification must agree with complete scan.","threshold":0},{"gate_id":"checkpoint_roundtrip","metric":"checkpoint_roundtrip","observed":true,"operator":"eq","pass":true,"rationale":"Canonical in-memory restoration must succeed.","threshold":true},{"gate_id":"checkpoint_identity","metric":"checkpoint_identity","observed":true,"operator":"eq","pass":true,"rationale":"Restored complete model identity must match.","threshold":true},{"gate_id":"checkpoint_behavior","metric":"checkpoint_behavior","observed":true,"operator":"eq","pass":true,"rationale":"Restored evaluation and planning behavior must match.","threshold":true},{"gate_id":"checkpoint_mutation_rejection","metric":"checkpoint_mutations","observed":true,"operator":"eq","pass":true,"rationale":"Every declared behavioral and byte-level checkpoint mutation must be detected.","threshold":true},{"gate_id":"lineage_invariants","metric":"lineage_invariants","observed":true,"operator":"eq","pass":true,"rationale":"Generation, lineage uniqueness, descendant splitting, and deterministic topology invariants must hold.","threshold":true},{"gate_id":"unsupported_transitions_unknown","metric":"unsupported_graph_edge_violations","observed":0,"operator":"eq","pass":true,"rationale":"Unsupported actions cannot enter the planning graph.","threshold":0},{"gate_id":"replay_size","metric":"replay_selected","observed":256,"operator":"eq","pass":true,"rationale":"The declared replay budget must be filled on the non-sparse trial corpus.","threshold":256},{"gate_id":"replay_unique","metric":"replay_unique","observed":256,"operator":"eq","pass":true,"rationale":"Balanced replay cannot introduce accidental duplicates.","threshold":256},{"gate_id":"replay_label_coverage","metric":"replay_labels_covered","observed":8,"operator":"eq","pass":true,"rationale":"Replay must retain every declared label.","threshold":8},{"gate_id":"replay_action_coverage","metric":"replay_actions_covered","observed":4,"operator":"eq","pass":true,"rationale":"Replay must retain every declared action.","threshold":4},{"gate_id":"replay_state_coverage","metric":"replay_states_covered","observed":64,"operator":"ge","pass":true,"rationale":"Replay must cover at least 60 of 64 source states.","threshold":60},{"gate_id":"replay_expert_coverage","metric":"replay_experts_covered","observed":62,"operator":"ge","pass":true,"rationale":"Replay must retain broad assigned-expert coverage.","threshold":60},{"gate_id":"replay_transition_coverage","metric":"replay_transition_pairs_covered","observed":247,"operator":"ge","pass":true,"rationale":"Replay must preserve broad source-state/action transition support.","threshold":220},{"gate_id":"planning_path_found","metric":"path_found_rate","observed":0.984375,"operator":"ge","pass":true,"rationale":"At least three quarters of bounded planning cases must have a supported path.","threshold":0.75},{"gate_id":"expert_capacity","metric":"expert_count","observed":68,"operator":"le","pass":true,"rationale":"Adaptation cannot exceed the declared expert capacity.","threshold":80},{"gate_id":"retirement_budget","metric":"accepted_retirements","observed":0,"operator":"le","pass":true,"rationale":"Retirement remains optional and bounded.","threshold":4},{"gate_id":"topology_objective_non_degradation","metric":"topology_objective_gain_q20","observed":19208,"operator":"ge","pass":true,"rationale":"Accepted adaptation-training topology decisions cannot reduce their declared objective.","threshold":0},{"gate_id":"matched_compute_budget","metric":"matched_compute_training_evaluation_ratio","observed":0.8652368882823163,"operator":"le","pass":true,"rationale":"Candidate training work may exceed the matched fixed-topology budget by at most ten percent.","threshold":1.1},{"gate_id":"conditional_inference_efficiency","metric":"inference_evaluation_ratio_vs_flat64","observed":0.125,"operator":"le","pass":true,"rationale":"Routed inference must use at most one quarter of flat complete-scan expert evaluations.","threshold":0.25},{"gate_id":"observation_accuracy","metric":"adapted_drift_accuracy","observed":1.0,"operator":"ge","pass":true,"rationale":"Observation drift emphasizes routed classification.","threshold":0.9},{"gate_id":"observation_non_inferiority","metric":"drift_accuracy_delta","observed":0.06640625,"operator":"ge","pass":true,"rationale":"An already solved observation task uses non-inferiority.","threshold":-0.02},{"gate_id":"observation_reconstruction","metric":"reconstruction_improvement_ratio","observed":0.1764752366396183,"operator":"ge","pass":true,"rationale":"Observation adaptation cannot worsen reconstruction.","threshold":0},{"gate_id":"observation_prediction","metric":"prediction_improvement_ratio","observed":0.1784311661186835,"operator":"ge","pass":true,"rationale":"Observation adaptation cannot worsen next-observation prediction.","threshold":0},{"gate_id":"observation_reconstruction_retention","metric":"retention_reconstruction_degradation_ratio","observed":-0.3537202728905517,"operator":"le","pass":true,"rationale":"Original-task reconstruction may degrade by at most ten percent.","threshold":0.1},{"gate_id":"observation_exact_planning","metric":"exact_state_rate","observed":0.90625,"operator":"ge","pass":true,"rationale":"Observation drift remains fully observed and uses exact-state planning.","threshold":0.75},{"gate_id":"observation_bounded_births","metric":"accepted_births","observed":4,"operator":"le","pass":true,"rationale":"Limited headroom cannot justify the full birth budget.","threshold":12}],"metrics":{"accepted_births":4,"accepted_retirements":0,"adaptation_completed":true,"adaptation_training_accuracy":1.0,"adapted_drift_accuracy":1.0,"adapted_prediction_rmse":7.612135783251461,"adapted_reconstruction_rmse":7.068310192185542,"adapted_transition_accuracy":0.9703389830508474,"balanced_vs_periodic_drift_accuracy_delta":0.0,"balanced_vs_periodic_retention_delta":0.0,"base_accuracy":0.93359375,"base_prediction_rmse":6.816290406891743,"base_reconstruction_rmse":6.239307429339829,"belief_set_rate":0.90625,"belief_set_rate_delta":0.15625,"checkpoint_behavior":true,"checkpoint_identity":true,"checkpoint_mutations":true,"checkpoint_roundtrip":true,"checkpoint_size_bytes":45494,"drift_accuracy_delta":0.06640625,"exact_state_rate":0.90625,"exact_state_rate_delta":0.1875,"expert_count":68,"headroom_normalized_accuracy_improvement":1.0,"inference_evaluation_ratio_vs_flat64":0.125,"inference_expert_evaluations":2048,"lineage_invariants":true,"matched_compute_drift_accuracy_delta":0.06640625,"matched_compute_retention_delta":0.03125,"matched_compute_training_evaluation_ratio":0.8652368882823163,"no_birth_drift_accuracy_delta":0.06640625,"no_retirement_drift_accuracy_delta":0.0,"path_found_rate":0.984375,"prediction_improvement_ratio":0.1784311661186835,"reconstruction_improvement_ratio":0.1764752366396183,"replay_actions_covered":4,"replay_experts_covered":62,"replay_labels_covered":8,"replay_selected":256,"replay_states_covered":64,"replay_transition_pairs_covered":247,"replay_unique":256,"retention_accuracy":1.0,"retention_accuracy_delta_from_base":0.06640625,"retention_prediction_degradation":-2.3403675866551756,"retention_prediction_rmse":4.475922820236567,"retention_reconstruction_degradation_ratio":-0.3537202728905517,"retention_reconstruction_rmse":4.032337902785698,"retention_transition_accuracy_delta":0.05240174672489084,"routing_mismatches":0,"static_belief_set_rate":0.75,"static_drift_accuracy":0.93359375,"static_exact_state_rate":0.71875,"static_prediction_rmse":9.265365809082173,"static_reconstruction_rmse":8.582996537157422,"static_transition_accuracy":0.9449152542372882,"topology_objective_gain_q20":19208,"training_evaluations":1242584,"transition_accuracy_delta":0.025423728813559254,"transition_support_rate":0.921875,"unsupported_graph_edge_violations":0},"regime":"observation_drift","seed":"0xd16b29b526b37eba","trial_id":"validation-observation-01","trial_result":"PASS"},{"comparisons":{"fixed_8_expert":{"metrics":{"checkpoint_size_bytes":11294,"drift_accuracy":0.22265625,"expert_count":8,"expert_evaluations":2048,"planning_belief_set_rate":0.21875,"planning_exact_state_rate":0.03125,"prediction_rmse":31.483089990821213,"reconstruction_rmse":29.44830749664503,"retention_accuracy":0.234375,"training_evaluations":94208},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":35340,"drift_accuracy":0.77734375,"expert_count":62,"expert_evaluations":0,"planning_belief_set_rate":0.53125,"planning_exact_state_rate":0.71875,"prediction_rmse":-24.226581099340443,"reconstruction_rmse":-22.78515488994932,"retention_accuracy":0.765625,"training_evaluations":1398392},"pareto_relation":"mixed"},"fixed_topology_64_expert_routed":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":1.0,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":6.977268880778359,"reconstruction_rmse":6.53594805216097,"retention_accuracy":1.0,"training_evaluations":2588672},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":3420,"drift_accuracy":0.0,"expert_count":6,"expert_evaluations":0,"planning_belief_set_rate":-0.25,"planning_exact_state_rate":-0.25,"prediction_rmse":0.2792400107024111,"reconstruction_rmse":0.127204554534738,"retention_accuracy":0.0,"training_evaluations":-1096072},"pareto_relation":"mixed"},"flat_64_expert_complete_scan":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":1.0,"expert_count":64,"expert_evaluations":16384,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":6.977268880778359,"reconstruction_rmse":6.53594805216097,"retention_accuracy":1.0,"training_evaluations":2588672},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":3420,"drift_accuracy":0.0,"expert_count":6,"expert_evaluations":-14336,"planning_belief_set_rate":-0.25,"planning_exact_state_rate":-0.25,"prediction_rmse":0.2792400107024111,"reconstruction_rmse":0.127204554534738,"retention_accuracy":0.0,"training_evaluations":-1096072},"pareto_relation":"mixed"},"matched_compute_fixed_topology":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.9140625,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":0.671875,"planning_exact_state_rate":0.578125,"prediction_rmse":9.370201594980703,"reconstruction_rmse":8.892195543866784,"retention_accuracy":0.94140625,"training_evaluations":1663096},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":3420,"drift_accuracy":0.0859375,"expert_count":6,"expert_evaluations":0,"planning_belief_set_rate":0.078125,"planning_exact_state_rate":0.171875,"prediction_rmse":-2.1136927034999324,"reconstruction_rmse":-2.2290429371710756,"retention_accuracy":0.05859375,"training_evaluations":-170496},"pareto_relation":"mixed"},"matched_expert_count_capacity":{"metrics":{"checkpoint_size_bytes":46634,"drift_accuracy":1.0,"expert_count":70,"expert_evaluations":2048,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":7.015361448161429,"reconstruction_rmse":6.528529228349944,"retention_accuracy":1.0,"training_evaluations":3046400},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":-0.25,"planning_exact_state_rate":-0.25,"prediction_rmse":0.24114744331934101,"reconstruction_rmse":0.134623378345764,"retention_accuracy":0.0,"training_evaluations":-1553800},"pareto_relation":"mixed"},"nearest_centroid_16_no_recursive_births":{"metrics":{"checkpoint_size_bytes":15854,"drift_accuracy":0.1953125,"expert_count":16,"expert_evaluations":4096,"planning_belief_set_rate":0.484375,"planning_exact_state_rate":0.1875,"prediction_rmse":25.64876009076355,"reconstruction_rmse":23.704644814837568,"retention_accuracy":0.25390625,"training_evaluations":253952},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":30780,"drift_accuracy":0.8046875,"expert_count":54,"expert_evaluations":-2048,"planning_belief_set_rate":0.265625,"planning_exact_state_rate":0.5625,"prediction_rmse":-18.39225119928278,"reconstruction_rmse":-17.04149220814186,"retention_accuracy":0.74609375,"training_evaluations":1238648},"pareto_relation":"mixed"},"no_adaptation_static":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.9140625,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":0.671875,"planning_exact_state_rate":0.578125,"prediction_rmse":9.370201594980703,"reconstruction_rmse":8.892195543866784,"retention_accuracy":0.94140625,"training_evaluations":557176},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":3420,"drift_accuracy":0.0859375,"expert_count":6,"expert_evaluations":0,"planning_belief_set_rate":0.078125,"planning_exact_state_rate":0.171875,"prediction_rmse":-2.1136927034999324,"reconstruction_rmse":-2.2290429371710756,"retention_accuracy":0.05859375,"training_evaluations":935424},"pareto_relation":"mixed"},"periodic_replay_policy":{"metrics":{"checkpoint_size_bytes":46634,"drift_accuracy":1.0,"expert_count":70,"expert_evaluations":2048,"planning_belief_set_rate":0.75,"planning_exact_state_rate":0.75,"prediction_rmse":7.251259498564763,"reconstruction_rmse":6.637994783963524,"retention_accuracy":1.0,"training_evaluations":1492600},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.005249392916007345,"reconstruction_rmse":0.02515782273218381,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"variant_dominates"},"ravel_0_5_candidate":{"metrics":{"checkpoint_size_bytes":46634,"drift_accuracy":1.0,"expert_count":70,"expert_evaluations":2048,"planning_belief_set_rate":0.75,"planning_exact_state_rate":0.75,"prediction_rmse":7.25650889148077,"reconstruction_rmse":6.663152606695708,"retention_accuracy":1.0,"training_evaluations":1492600},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"equivalent"},"ravel_complete_scan_without_certification":{"metrics":{"checkpoint_size_bytes":46634,"drift_accuracy":1.0,"expert_count":70,"expert_evaluations":17920,"planning_belief_set_rate":0.75,"planning_exact_state_rate":0.75,"prediction_rmse":7.25650889148077,"reconstruction_rmse":6.663152606695708,"retention_accuracy":1.0,"training_evaluations":1683064},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":-15872,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":-190464},"pareto_relation":"candidate_dominates"},"ravel_no_birth_same_replay_iterations":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.9140625,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":0.671875,"planning_exact_state_rate":0.578125,"prediction_rmse":9.370201594980703,"reconstruction_rmse":8.892195543866784,"retention_accuracy":0.94140625,"training_evaluations":778360},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":3420,"drift_accuracy":0.0859375,"expert_count":6,"expert_evaluations":0,"planning_belief_set_rate":0.078125,"planning_exact_state_rate":0.171875,"prediction_rmse":-2.1136927034999324,"reconstruction_rmse":-2.2290429371710756,"retention_accuracy":0.05859375,"training_evaluations":714240},"pareto_relation":"mixed"},"ravel_random_births":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.9140625,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":0.671875,"planning_exact_state_rate":0.578125,"prediction_rmse":9.370201594980703,"reconstruction_rmse":8.892195543866784,"retention_accuracy":0.94140625,"training_evaluations":778360},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":3420,"drift_accuracy":0.0859375,"expert_count":6,"expert_evaluations":0,"planning_belief_set_rate":0.078125,"planning_exact_state_rate":0.171875,"prediction_rmse":-2.1136927034999324,"reconstruction_rmse":-2.2290429371710756,"retention_accuracy":0.05859375,"training_evaluations":714240},"pareto_relation":"mixed"},"ravel_without_replay":{"metrics":{"checkpoint_size_bytes":46634,"drift_accuracy":1.0,"expert_count":70,"expert_evaluations":2048,"planning_belief_set_rate":0.75,"planning_exact_state_rate":0.75,"prediction_rmse":7.265598948510612,"reconstruction_rmse":6.632688305504212,"retention_accuracy":1.0,"training_evaluations":1180792},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":-0.00909005702984178,"reconstruction_rmse":0.030464301191496013,"retention_accuracy":0.0,"training_evaluations":311808},"pareto_relation":"mixed"},"ravel_without_retirement_matched_work":{"metrics":{"checkpoint_size_bytes":46634,"drift_accuracy":1.0,"expert_count":70,"expert_evaluations":2048,"planning_belief_set_rate":0.75,"planning_exact_state_rate":0.75,"prediction_rmse":7.25650889148077,"reconstruction_rmse":6.663152606695708,"retention_accuracy":1.0,"training_evaluations":1492600},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"equivalent"}},"gates":[{"gate_id":"adaptation_completed","metric":"adaptation_completed","observed":true,"operator":"eq","pass":true,"rationale":"The bounded adaptation procedure must complete.","threshold":true},{"gate_id":"base_holdout_accuracy","metric":"base_accuracy","observed":0.93359375,"operator":"ge","pass":true,"rationale":"The base representation must establish the bounded task before drift.","threshold":0.85},{"gate_id":"base_holdout_retention","metric":"retention_accuracy","observed":1.0,"operator":"ge","pass":true,"rationale":"Anchored base behavior may lose at most ten percentage points in absolute retained accuracy.","threshold":0.9},{"gate_id":"routing_oracle_equivalence","metric":"routing_mismatches","observed":0,"operator":"eq","pass":true,"rationale":"Every routed classification must agree with complete scan.","threshold":0},{"gate_id":"checkpoint_roundtrip","metric":"checkpoint_roundtrip","observed":true,"operator":"eq","pass":true,"rationale":"Canonical in-memory restoration must succeed.","threshold":true},{"gate_id":"checkpoint_identity","metric":"checkpoint_identity","observed":true,"operator":"eq","pass":true,"rationale":"Restored complete model identity must match.","threshold":true},{"gate_id":"checkpoint_behavior","metric":"checkpoint_behavior","observed":true,"operator":"eq","pass":true,"rationale":"Restored evaluation and planning behavior must match.","threshold":true},{"gate_id":"checkpoint_mutation_rejection","metric":"checkpoint_mutations","observed":true,"operator":"eq","pass":true,"rationale":"Every declared behavioral and byte-level checkpoint mutation must be detected.","threshold":true},{"gate_id":"lineage_invariants","metric":"lineage_invariants","observed":true,"operator":"eq","pass":true,"rationale":"Generation, lineage uniqueness, descendant splitting, and deterministic topology invariants must hold.","threshold":true},{"gate_id":"unsupported_transitions_unknown","metric":"unsupported_graph_edge_violations","observed":0,"operator":"eq","pass":true,"rationale":"Unsupported actions cannot enter the planning graph.","threshold":0},{"gate_id":"replay_size","metric":"replay_selected","observed":256,"operator":"eq","pass":true,"rationale":"The declared replay budget must be filled on the non-sparse trial corpus.","threshold":256},{"gate_id":"replay_unique","metric":"replay_unique","observed":256,"operator":"eq","pass":true,"rationale":"Balanced replay cannot introduce accidental duplicates.","threshold":256},{"gate_id":"replay_label_coverage","metric":"replay_labels_covered","observed":8,"operator":"eq","pass":true,"rationale":"Replay must retain every declared label.","threshold":8},{"gate_id":"replay_action_coverage","metric":"replay_actions_covered","observed":4,"operator":"eq","pass":true,"rationale":"Replay must retain every declared action.","threshold":4},{"gate_id":"replay_state_coverage","metric":"replay_states_covered","observed":64,"operator":"ge","pass":true,"rationale":"Replay must cover at least 60 of 64 source states.","threshold":60},{"gate_id":"replay_expert_coverage","metric":"replay_experts_covered","observed":63,"operator":"ge","pass":true,"rationale":"Replay must retain broad assigned-expert coverage.","threshold":60},{"gate_id":"replay_transition_coverage","metric":"replay_transition_pairs_covered","observed":253,"operator":"ge","pass":true,"rationale":"Replay must preserve broad source-state/action transition support.","threshold":220},{"gate_id":"planning_path_found","metric":"path_found_rate","observed":0.984375,"operator":"ge","pass":true,"rationale":"At least three quarters of bounded planning cases must have a supported path.","threshold":0.75},{"gate_id":"expert_capacity","metric":"expert_count","observed":70,"operator":"le","pass":true,"rationale":"Adaptation cannot exceed the declared expert capacity.","threshold":80},{"gate_id":"retirement_budget","metric":"accepted_retirements","observed":0,"operator":"le","pass":true,"rationale":"Retirement remains optional and bounded.","threshold":4},{"gate_id":"topology_objective_non_degradation","metric":"topology_objective_gain_q20","observed":19553,"operator":"ge","pass":true,"rationale":"Accepted adaptation-training topology decisions cannot reduce their declared objective.","threshold":0},{"gate_id":"matched_compute_budget","metric":"matched_compute_training_evaluation_ratio","observed":0.8974827670801926,"operator":"le","pass":true,"rationale":"Candidate training work may exceed the matched fixed-topology budget by at most ten percent.","threshold":1.1},{"gate_id":"conditional_inference_efficiency","metric":"inference_evaluation_ratio_vs_flat64","observed":0.125,"operator":"le","pass":true,"rationale":"Routed inference must use at most one quarter of flat complete-scan expert evaluations.","threshold":0.25},{"gate_id":"observation_accuracy","metric":"adapted_drift_accuracy","observed":1.0,"operator":"ge","pass":true,"rationale":"Observation drift emphasizes routed classification.","threshold":0.9},{"gate_id":"observation_non_inferiority","metric":"drift_accuracy_delta","observed":0.0859375,"operator":"ge","pass":true,"rationale":"An already solved observation task uses non-inferiority.","threshold":-0.02},{"gate_id":"observation_reconstruction","metric":"reconstruction_improvement_ratio","observed":0.2506740800036178,"operator":"ge","pass":true,"rationale":"Observation adaptation cannot worsen reconstruction.","threshold":0},{"gate_id":"observation_prediction","metric":"prediction_improvement_ratio","observed":0.2255760115803875,"operator":"ge","pass":true,"rationale":"Observation adaptation cannot worsen next-observation prediction.","threshold":0},{"gate_id":"observation_reconstruction_retention","metric":"retention_reconstruction_degradation_ratio","observed":-0.3779119184270875,"operator":"le","pass":true,"rationale":"Original-task reconstruction may degrade by at most ten percent.","threshold":0.1},{"gate_id":"observation_exact_planning","metric":"exact_state_rate","observed":0.75,"operator":"ge","pass":true,"rationale":"Observation drift remains fully observed and uses exact-state planning.","threshold":0.75},{"gate_id":"observation_bounded_births","metric":"accepted_births","observed":6,"operator":"le","pass":true,"rationale":"Limited headroom cannot justify the full birth budget.","threshold":12}],"metrics":{"accepted_births":6,"accepted_retirements":0,"adaptation_completed":true,"adaptation_training_accuracy":1.0,"adapted_drift_accuracy":1.0,"adapted_prediction_rmse":7.25650889148077,"adapted_reconstruction_rmse":6.663152606695708,"adapted_transition_accuracy":0.9545454545454546,"balanced_vs_periodic_drift_accuracy_delta":0.0,"balanced_vs_periodic_retention_delta":0.0,"base_accuracy":0.93359375,"base_prediction_rmse":6.871479009966834,"base_reconstruction_rmse":6.306927108393625,"belief_set_rate":0.75,"belief_set_rate_delta":0.078125,"checkpoint_behavior":true,"checkpoint_identity":true,"checkpoint_mutations":true,"checkpoint_roundtrip":true,"checkpoint_size_bytes":46634,"drift_accuracy_delta":0.0859375,"exact_state_rate":0.75,"exact_state_rate_delta":0.171875,"expert_count":70,"headroom_normalized_accuracy_improvement":1.0,"inference_evaluation_ratio_vs_flat64":0.125,"inference_expert_evaluations":2048,"lineage_invariants":true,"matched_compute_drift_accuracy_delta":0.0859375,"matched_compute_retention_delta":0.05859375,"matched_compute_training_evaluation_ratio":0.8974827670801926,"no_birth_drift_accuracy_delta":0.0859375,"no_retirement_drift_accuracy_delta":0.0,"path_found_rate":0.984375,"prediction_improvement_ratio":0.2255760115803875,"reconstruction_improvement_ratio":0.2506740800036178,"replay_actions_covered":4,"replay_experts_covered":63,"replay_labels_covered":8,"replay_selected":256,"replay_states_covered":64,"replay_transition_pairs_covered":253,"replay_unique":256,"retention_accuracy":1.0,"retention_accuracy_delta_from_base":0.06640625,"retention_prediction_degradation":-2.6002040610799027,"retention_prediction_rmse":4.271274948886932,"retention_reconstruction_degradation_ratio":-0.3779119184270875,"retention_reconstruction_rmse":3.9234641854807863,"retention_transition_accuracy_delta":0.05748113500575547,"routing_mismatches":0,"static_belief_set_rate":0.671875,"static_drift_accuracy":0.9140625,"static_exact_state_rate":0.578125,"static_prediction_rmse":9.370201594980703,"static_reconstruction_rmse":8.892195543866784,"static_transition_accuracy":0.9346938775510204,"topology_objective_gain_q20":19553,"training_evaluations":1492600,"transition_accuracy_delta":0.019851576994434184,"transition_support_rate":0.9453125,"unsupported_graph_edge_violations":0},"regime":"observation_drift","seed":"0xb1c136bde36659bf","trial_id":"validation-observation-02","trial_result":"PASS"},{"comparisons":{"fixed_8_expert":{"metrics":{"checkpoint_size_bytes":11294,"drift_accuracy":0.21484375,"expert_count":8,"expert_evaluations":2048,"planning_belief_set_rate":0.140625,"planning_exact_state_rate":0.015625,"prediction_rmse":31.486710760306558,"reconstruction_rmse":29.69936909754196,"retention_accuracy":0.25390625,"training_evaluations":94208},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":33630,"drift_accuracy":0.78515625,"expert_count":59,"expert_evaluations":0,"planning_belief_set_rate":0.859375,"planning_exact_state_rate":0.984375,"prediction_rmse":-24.259380409192495,"reconstruction_rmse":-22.4154311981748,"retention_accuracy":0.74609375,"training_evaluations":1035262},"pareto_relation":"mixed"},"fixed_topology_64_expert_routed":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":1.0,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":6.6352252063516906,"reconstruction_rmse":6.74835152041876,"retention_accuracy":1.0,"training_evaluations":2588672},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":1710,"drift_accuracy":0.0,"expert_count":3,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.5921051447623702,"reconstruction_rmse":0.5355863789484019,"retention_accuracy":0.0,"training_evaluations":-1459202},"pareto_relation":"mixed"},"flat_64_expert_complete_scan":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":1.0,"expert_count":64,"expert_evaluations":16384,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":6.6352252063516906,"reconstruction_rmse":6.74835152041876,"retention_accuracy":1.0,"training_evaluations":2588672},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":1710,"drift_accuracy":0.0,"expert_count":3,"expert_evaluations":-14336,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.5921051447623702,"reconstruction_rmse":0.5355863789484019,"retention_accuracy":0.0,"training_evaluations":-1459202},"pareto_relation":"mixed"},"matched_compute_fixed_topology":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.95703125,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":0.65625,"planning_exact_state_rate":0.640625,"prediction_rmse":8.89073974857126,"reconstruction_rmse":8.253819091470287,"retention_accuracy":0.9375,"training_evaluations":1223304},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":1710,"drift_accuracy":0.04296875,"expert_count":3,"expert_evaluations":0,"planning_belief_set_rate":0.34375,"planning_exact_state_rate":0.359375,"prediction_rmse":-1.6634093974571993,"reconstruction_rmse":-0.9698811921031254,"retention_accuracy":0.0625,"training_evaluations":-93834},"pareto_relation":"mixed"},"matched_expert_count_capacity":{"metrics":{"checkpoint_size_bytes":44924,"drift_accuracy":1.0,"expert_count":67,"expert_evaluations":2048,"planning_belief_set_rate":0.984375,"planning_exact_state_rate":0.984375,"prediction_rmse":6.650499007467199,"reconstruction_rmse":6.738002290203464,"retention_accuracy":1.0,"training_evaluations":2812928},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.015625,"planning_exact_state_rate":0.015625,"prediction_rmse":0.5768313436468615,"reconstruction_rmse":0.5459356091636982,"retention_accuracy":0.0,"training_evaluations":-1683458},"pareto_relation":"mixed"},"nearest_centroid_16_no_recursive_births":{"metrics":{"checkpoint_size_bytes":15854,"drift_accuracy":0.24609375,"expert_count":16,"expert_evaluations":4096,"planning_belief_set_rate":0.484375,"planning_exact_state_rate":0.0625,"prediction_rmse":24.174236408581997,"reconstruction_rmse":23.91115412664408,"retention_accuracy":0.21484375,"training_evaluations":253952},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":29070,"drift_accuracy":0.75390625,"expert_count":51,"expert_evaluations":-2048,"planning_belief_set_rate":0.515625,"planning_exact_state_rate":0.9375,"prediction_rmse":-16.946906057467935,"reconstruction_rmse":-16.627216227276918,"retention_accuracy":0.78515625,"training_evaluations":875518},"pareto_relation":"mixed"},"no_adaptation_static":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.95703125,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":0.65625,"planning_exact_state_rate":0.640625,"prediction_rmse":8.89073974857126,"reconstruction_rmse":8.253819091470287,"retention_accuracy":0.9375,"training_evaluations":557736},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":1710,"drift_accuracy":0.04296875,"expert_count":3,"expert_evaluations":0,"planning_belief_set_rate":0.34375,"planning_exact_state_rate":0.359375,"prediction_rmse":-1.6634093974571993,"reconstruction_rmse":-0.9698811921031254,"retention_accuracy":0.0625,"training_evaluations":571734},"pareto_relation":"mixed"},"periodic_replay_policy":{"metrics":{"checkpoint_size_bytes":44924,"drift_accuracy":1.0,"expert_count":67,"expert_evaluations":2048,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":7.251286276126553,"reconstruction_rmse":7.280080316497144,"retention_accuracy":1.0,"training_evaluations":1129242},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":-0.02395592501249233,"reconstruction_rmse":0.003857582870018028,"retention_accuracy":0.0,"training_evaluations":228},"pareto_relation":"mixed"},"ravel_0_5_candidate":{"metrics":{"checkpoint_size_bytes":44924,"drift_accuracy":1.0,"expert_count":67,"expert_evaluations":2048,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":7.227330351114061,"reconstruction_rmse":7.283937899367162,"retention_accuracy":1.0,"training_evaluations":1129470},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"equivalent"},"ravel_complete_scan_without_certification":{"metrics":{"checkpoint_size_bytes":44924,"drift_accuracy":1.0,"expert_count":67,"expert_evaluations":17152,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":7.227330351114061,"reconstruction_rmse":7.283937899367162,"retention_accuracy":1.0,"training_evaluations":1310718},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":-15104,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":-181248},"pareto_relation":"candidate_dominates"},"ravel_no_birth_same_replay_iterations":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.95703125,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":0.65625,"planning_exact_state_rate":0.640625,"prediction_rmse":8.89073974857126,"reconstruction_rmse":8.253819091470287,"retention_accuracy":0.9375,"training_evaluations":779592},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":1710,"drift_accuracy":0.04296875,"expert_count":3,"expert_evaluations":0,"planning_belief_set_rate":0.34375,"planning_exact_state_rate":0.359375,"prediction_rmse":-1.6634093974571993,"reconstruction_rmse":-0.9698811921031254,"retention_accuracy":0.0625,"training_evaluations":349878},"pareto_relation":"mixed"},"ravel_random_births":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.95703125,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":0.65625,"planning_exact_state_rate":0.640625,"prediction_rmse":8.89073974857126,"reconstruction_rmse":8.253819091470287,"retention_accuracy":0.9375,"training_evaluations":779592},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":1710,"drift_accuracy":0.04296875,"expert_count":3,"expert_evaluations":0,"planning_belief_set_rate":0.34375,"planning_exact_state_rate":0.359375,"prediction_rmse":-1.6634093974571993,"reconstruction_rmse":-0.9698811921031254,"retention_accuracy":0.0625,"training_evaluations":349878},"pareto_relation":"mixed"},"ravel_without_replay":{"metrics":{"checkpoint_size_bytes":44924,"drift_accuracy":1.0,"expert_count":67,"expert_evaluations":2048,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":7.285026655624735,"reconstruction_rmse":7.279673920763514,"retention_accuracy":1.0,"training_evaluations":938778},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":-0.05769630451067442,"reconstruction_rmse":0.0042639786036478,"retention_accuracy":0.0,"training_evaluations":190692},"pareto_relation":"mixed"},"ravel_without_retirement_matched_work":{"metrics":{"checkpoint_size_bytes":44924,"drift_accuracy":1.0,"expert_count":67,"expert_evaluations":2048,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":7.227330351114061,"reconstruction_rmse":7.283937899367162,"retention_accuracy":1.0,"training_evaluations":1129470},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"equivalent"}},"gates":[{"gate_id":"adaptation_completed","metric":"adaptation_completed","observed":true,"operator":"eq","pass":true,"rationale":"The bounded adaptation procedure must complete.","threshold":true},{"gate_id":"base_holdout_accuracy","metric":"base_accuracy","observed":0.9609375,"operator":"ge","pass":true,"rationale":"The base representation must establish the bounded task before drift.","threshold":0.85},{"gate_id":"base_holdout_retention","metric":"retention_accuracy","observed":1.0,"operator":"ge","pass":true,"rationale":"Anchored base behavior may lose at most ten percentage points in absolute retained accuracy.","threshold":0.9},{"gate_id":"routing_oracle_equivalence","metric":"routing_mismatches","observed":0,"operator":"eq","pass":true,"rationale":"Every routed classification must agree with complete scan.","threshold":0},{"gate_id":"checkpoint_roundtrip","metric":"checkpoint_roundtrip","observed":true,"operator":"eq","pass":true,"rationale":"Canonical in-memory restoration must succeed.","threshold":true},{"gate_id":"checkpoint_identity","metric":"checkpoint_identity","observed":true,"operator":"eq","pass":true,"rationale":"Restored complete model identity must match.","threshold":true},{"gate_id":"checkpoint_behavior","metric":"checkpoint_behavior","observed":true,"operator":"eq","pass":true,"rationale":"Restored evaluation and planning behavior must match.","threshold":true},{"gate_id":"checkpoint_mutation_rejection","metric":"checkpoint_mutations","observed":true,"operator":"eq","pass":true,"rationale":"Every declared behavioral and byte-level checkpoint mutation must be detected.","threshold":true},{"gate_id":"lineage_invariants","metric":"lineage_invariants","observed":true,"operator":"eq","pass":true,"rationale":"Generation, lineage uniqueness, descendant splitting, and deterministic topology invariants must hold.","threshold":true},{"gate_id":"unsupported_transitions_unknown","metric":"unsupported_graph_edge_violations","observed":0,"operator":"eq","pass":true,"rationale":"Unsupported actions cannot enter the planning graph.","threshold":0},{"gate_id":"replay_size","metric":"replay_selected","observed":256,"operator":"eq","pass":true,"rationale":"The declared replay budget must be filled on the non-sparse trial corpus.","threshold":256},{"gate_id":"replay_unique","metric":"replay_unique","observed":256,"operator":"eq","pass":true,"rationale":"Balanced replay cannot introduce accidental duplicates.","threshold":256},{"gate_id":"replay_label_coverage","metric":"replay_labels_covered","observed":8,"operator":"eq","pass":true,"rationale":"Replay must retain every declared label.","threshold":8},{"gate_id":"replay_action_coverage","metric":"replay_actions_covered","observed":4,"operator":"eq","pass":true,"rationale":"Replay must retain every declared action.","threshold":4},{"gate_id":"replay_state_coverage","metric":"replay_states_covered","observed":64,"operator":"ge","pass":true,"rationale":"Replay must cover at least 60 of 64 source states.","threshold":60},{"gate_id":"replay_expert_coverage","metric":"replay_experts_covered","observed":63,"operator":"ge","pass":true,"rationale":"Replay must retain broad assigned-expert coverage.","threshold":60},{"gate_id":"replay_transition_coverage","metric":"replay_transition_pairs_covered","observed":251,"operator":"ge","pass":true,"rationale":"Replay must preserve broad source-state/action transition support.","threshold":220},{"gate_id":"planning_path_found","metric":"path_found_rate","observed":1.0,"operator":"ge","pass":true,"rationale":"At least three quarters of bounded planning cases must have a supported path.","threshold":0.75},{"gate_id":"expert_capacity","metric":"expert_count","observed":67,"operator":"le","pass":true,"rationale":"Adaptation cannot exceed the declared expert capacity.","threshold":80},{"gate_id":"retirement_budget","metric":"accepted_retirements","observed":0,"operator":"le","pass":true,"rationale":"Retirement remains optional and bounded.","threshold":4},{"gate_id":"topology_objective_non_degradation","metric":"topology_objective_gain_q20","observed":15579,"operator":"ge","pass":true,"rationale":"Accepted adaptation-training topology decisions cannot reduce their declared objective.","threshold":0},{"gate_id":"matched_compute_budget","metric":"matched_compute_training_evaluation_ratio","observed":0.9232946185085636,"operator":"le","pass":true,"rationale":"Candidate training work may exceed the matched fixed-topology budget by at most ten percent.","threshold":1.1},{"gate_id":"conditional_inference_efficiency","metric":"inference_evaluation_ratio_vs_flat64","observed":0.125,"operator":"le","pass":true,"rationale":"Routed inference must use at most one quarter of flat complete-scan expert evaluations.","threshold":0.25},{"gate_id":"observation_accuracy","metric":"adapted_drift_accuracy","observed":1.0,"operator":"ge","pass":true,"rationale":"Observation drift emphasizes routed classification.","threshold":0.9},{"gate_id":"observation_non_inferiority","metric":"drift_accuracy_delta","observed":0.04296875,"operator":"ge","pass":true,"rationale":"An already solved observation task uses non-inferiority.","threshold":-0.02},{"gate_id":"observation_reconstruction","metric":"reconstruction_improvement_ratio","observed":0.11750696027556819,"operator":"ge","pass":true,"rationale":"Observation adaptation cannot worsen reconstruction.","threshold":0},{"gate_id":"observation_prediction","metric":"prediction_improvement_ratio","observed":0.1870946000555813,"operator":"ge","pass":true,"rationale":"Observation adaptation cannot worsen next-observation prediction.","threshold":0},{"gate_id":"observation_reconstruction_retention","metric":"retention_reconstruction_degradation_ratio","observed":-0.26057222570911176,"operator":"le","pass":true,"rationale":"Original-task reconstruction may degrade by at most ten percent.","threshold":0.1},{"gate_id":"observation_exact_planning","metric":"exact_state_rate","observed":1.0,"operator":"ge","pass":true,"rationale":"Observation drift remains fully observed and uses exact-state planning.","threshold":0.75},{"gate_id":"observation_bounded_births","metric":"accepted_births","observed":3,"operator":"le","pass":true,"rationale":"Limited headroom cannot justify the full birth budget.","threshold":12}],"metrics":{"accepted_births":3,"accepted_retirements":0,"adaptation_completed":true,"adaptation_training_accuracy":1.0,"adapted_drift_accuracy":1.0,"adapted_prediction_rmse":7.227330351114061,"adapted_reconstruction_rmse":7.283937899367162,"adapted_transition_accuracy":0.9623430962343096,"balanced_vs_periodic_drift_accuracy_delta":0.0,"balanced_vs_periodic_retention_delta":0.0,"base_accuracy":0.9609375,"base_prediction_rmse":6.751369493196803,"base_reconstruction_rmse":5.79354233263011,"belief_set_rate":1.0,"belief_set_rate_delta":0.34375,"checkpoint_behavior":true,"checkpoint_identity":true,"checkpoint_mutations":true,"checkpoint_roundtrip":true,"checkpoint_size_bytes":44924,"drift_accuracy_delta":0.04296875,"exact_state_rate":1.0,"exact_state_rate_delta":0.359375,"expert_count":67,"headroom_normalized_accuracy_improvement":1.0,"inference_evaluation_ratio_vs_flat64":0.125,"inference_expert_evaluations":2048,"lineage_invariants":true,"matched_compute_drift_accuracy_delta":0.04296875,"matched_compute_retention_delta":0.0625,"matched_compute_training_evaluation_ratio":0.9232946185085636,"no_birth_drift_accuracy_delta":0.04296875,"no_retirement_drift_accuracy_delta":0.0,"path_found_rate":1.0,"prediction_improvement_ratio":0.1870946000555813,"reconstruction_improvement_ratio":0.11750696027556819,"replay_actions_covered":4,"replay_experts_covered":63,"replay_labels_covered":8,"replay_selected":256,"replay_states_covered":64,"replay_transition_pairs_covered":251,"replay_unique":256,"retention_accuracy":1.0,"retention_accuracy_delta_from_base":0.0390625,"retention_prediction_degradation":-1.8230057918471454,"retention_prediction_rmse":4.9283637013496575,"retention_reconstruction_degradation_ratio":-0.26057222570911176,"retention_reconstruction_rmse":4.283906112276723,"retention_transition_accuracy_delta":0.021059972105997193,"routing_mismatches":0,"static_belief_set_rate":0.65625,"static_drift_accuracy":0.95703125,"static_exact_state_rate":0.640625,"static_prediction_rmse":8.89073974857126,"static_reconstruction_rmse":8.253819091470287,"static_transition_accuracy":0.9372384937238494,"topology_objective_gain_q20":15579,"training_evaluations":1129470,"transition_accuracy_delta":0.025104602510460206,"transition_support_rate":0.93359375,"unsupported_graph_edge_violations":0},"regime":"observation_drift","seed":"0xcdfacd756a25c973","trial_id":"validation-observation-03","trial_result":"PASS"},{"comparisons":{"fixed_8_expert":{"metrics":{"checkpoint_size_bytes":11294,"drift_accuracy":0.234375,"expert_count":8,"expert_evaluations":2048,"planning_belief_set_rate":0.28125,"planning_exact_state_rate":0.0,"prediction_rmse":30.727284517034047,"reconstruction_rmse":28.873451309555865,"retention_accuracy":0.2578125,"training_evaluations":94208},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":35340,"drift_accuracy":0.765625,"expert_count":62,"expert_evaluations":0,"planning_belief_set_rate":0.53125,"planning_exact_state_rate":0.8125,"prediction_rmse":-23.978786344145657,"reconstruction_rmse":-22.69420769849977,"retention_accuracy":0.7421875,"training_evaluations":1397272},"pareto_relation":"mixed"},"fixed_topology_64_expert_routed":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":1.0,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":6.69467306437212,"reconstruction_rmse":6.401628965310812,"retention_accuracy":1.0,"training_evaluations":2588672},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":3420,"drift_accuracy":0.0,"expert_count":6,"expert_evaluations":0,"planning_belief_set_rate":-0.1875,"planning_exact_state_rate":-0.1875,"prediction_rmse":0.05382510851626865,"reconstruction_rmse":-0.22238535425471717,"retention_accuracy":0.0,"training_evaluations":-1097192},"pareto_relation":"mixed"},"flat_64_expert_complete_scan":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":1.0,"expert_count":64,"expert_evaluations":16384,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":6.69467306437212,"reconstruction_rmse":6.401628965310812,"retention_accuracy":1.0,"training_evaluations":2588672},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":3420,"drift_accuracy":0.0,"expert_count":6,"expert_evaluations":-14336,"planning_belief_set_rate":-0.1875,"planning_exact_state_rate":-0.1875,"prediction_rmse":0.05382510851626865,"reconstruction_rmse":-0.22238535425471717,"retention_accuracy":0.0,"training_evaluations":-1097192},"pareto_relation":"mixed"},"matched_compute_fixed_topology":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.95703125,"expert_count":64,"expert_evaluations":2104,"planning_belief_set_rate":0.640625,"planning_exact_state_rate":0.640625,"prediction_rmse":8.267732880182463,"reconstruction_rmse":7.932433287303836,"retention_accuracy":0.96875,"training_evaluations":1661976},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":3420,"drift_accuracy":0.04296875,"expert_count":6,"expert_evaluations":-56,"planning_belief_set_rate":0.171875,"planning_exact_state_rate":0.171875,"prediction_rmse":-1.519234707294074,"reconstruction_rmse":-1.7531896762477412,"retention_accuracy":0.03125,"training_evaluations":-170496},"pareto_relation":"mixed"},"matched_expert_count_capacity":{"metrics":{"checkpoint_size_bytes":46634,"drift_accuracy":1.0,"expert_count":70,"expert_evaluations":2048,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":6.707937035553674,"reconstruction_rmse":6.391907854369233,"retention_accuracy":1.0,"training_evaluations":3046400},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":-0.1875,"planning_exact_state_rate":-0.1875,"prediction_rmse":0.04056113733471456,"reconstruction_rmse":-0.21266424331313782,"retention_accuracy":0.0,"training_evaluations":-1554920},"pareto_relation":"mixed"},"nearest_centroid_16_no_recursive_births":{"metrics":{"checkpoint_size_bytes":15854,"drift_accuracy":0.28125,"expert_count":16,"expert_evaluations":4096,"planning_belief_set_rate":0.46875,"planning_exact_state_rate":0.09375,"prediction_rmse":25.851666736821343,"reconstruction_rmse":23.65019082643336,"retention_accuracy":0.2578125,"training_evaluations":253952},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":30780,"drift_accuracy":0.71875,"expert_count":54,"expert_evaluations":-2048,"planning_belief_set_rate":0.34375,"planning_exact_state_rate":0.71875,"prediction_rmse":-19.103168563932954,"reconstruction_rmse":-17.470947215377265,"retention_accuracy":0.7421875,"training_evaluations":1237528},"pareto_relation":"mixed"},"no_adaptation_static":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.95703125,"expert_count":64,"expert_evaluations":2104,"planning_belief_set_rate":0.640625,"planning_exact_state_rate":0.640625,"prediction_rmse":8.267732880182463,"reconstruction_rmse":7.932433287303836,"retention_accuracy":0.96875,"training_evaluations":556056},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":3420,"drift_accuracy":0.04296875,"expert_count":6,"expert_evaluations":-56,"planning_belief_set_rate":0.171875,"planning_exact_state_rate":0.171875,"prediction_rmse":-1.519234707294074,"reconstruction_rmse":-1.7531896762477412,"retention_accuracy":0.03125,"training_evaluations":935424},"pareto_relation":"mixed"},"periodic_replay_policy":{"metrics":{"checkpoint_size_bytes":46634,"drift_accuracy":1.0,"expert_count":70,"expert_evaluations":2048,"planning_belief_set_rate":0.8125,"planning_exact_state_rate":0.8125,"prediction_rmse":6.758947013792784,"reconstruction_rmse":6.181958206058101,"retention_accuracy":1.0,"training_evaluations":1491480},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":-0.01044884090439524,"reconstruction_rmse":-0.002714595002005993,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"candidate_dominates"},"ravel_0_5_candidate":{"metrics":{"checkpoint_size_bytes":46634,"drift_accuracy":1.0,"expert_count":70,"expert_evaluations":2048,"planning_belief_set_rate":0.8125,"planning_exact_state_rate":0.8125,"prediction_rmse":6.748498172888389,"reconstruction_rmse":6.179243611056095,"retention_accuracy":1.0,"training_evaluations":1491480},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"equivalent"},"ravel_complete_scan_without_certification":{"metrics":{"checkpoint_size_bytes":46634,"drift_accuracy":1.0,"expert_count":70,"expert_evaluations":17920,"planning_belief_set_rate":0.8125,"planning_exact_state_rate":0.8125,"prediction_rmse":6.748498172888389,"reconstruction_rmse":6.179243611056095,"retention_accuracy":1.0,"training_evaluations":1681944},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":-15872,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":-190464},"pareto_relation":"candidate_dominates"},"ravel_no_birth_same_replay_iterations":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.95703125,"expert_count":64,"expert_evaluations":2104,"planning_belief_set_rate":0.640625,"planning_exact_state_rate":0.640625,"prediction_rmse":8.267732880182463,"reconstruction_rmse":7.932433287303836,"retention_accuracy":0.96875,"training_evaluations":777240},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":3420,"drift_accuracy":0.04296875,"expert_count":6,"expert_evaluations":-56,"planning_belief_set_rate":0.171875,"planning_exact_state_rate":0.171875,"prediction_rmse":-1.519234707294074,"reconstruction_rmse":-1.7531896762477412,"retention_accuracy":0.03125,"training_evaluations":714240},"pareto_relation":"mixed"},"ravel_random_births":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.95703125,"expert_count":64,"expert_evaluations":2104,"planning_belief_set_rate":0.640625,"planning_exact_state_rate":0.640625,"prediction_rmse":8.267732880182463,"reconstruction_rmse":7.932433287303836,"retention_accuracy":0.96875,"training_evaluations":777240},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":3420,"drift_accuracy":0.04296875,"expert_count":6,"expert_evaluations":-56,"planning_belief_set_rate":0.171875,"planning_exact_state_rate":0.171875,"prediction_rmse":-1.519234707294074,"reconstruction_rmse":-1.7531896762477412,"retention_accuracy":0.03125,"training_evaluations":714240},"pareto_relation":"mixed"},"ravel_without_replay":{"metrics":{"checkpoint_size_bytes":46064,"drift_accuracy":1.0,"expert_count":69,"expert_evaluations":2048,"planning_belief_set_rate":0.8125,"planning_exact_state_rate":0.8125,"prediction_rmse":6.735403363639394,"reconstruction_rmse":6.180431711222197,"retention_accuracy":1.0,"training_evaluations":1097752},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":570,"drift_accuracy":0.0,"expert_count":1,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.013094809248994643,"reconstruction_rmse":-0.0011881001661020463,"retention_accuracy":0.0,"training_evaluations":393728},"pareto_relation":"mixed"},"ravel_without_retirement_matched_work":{"metrics":{"checkpoint_size_bytes":46634,"drift_accuracy":1.0,"expert_count":70,"expert_evaluations":2048,"planning_belief_set_rate":0.8125,"planning_exact_state_rate":0.8125,"prediction_rmse":6.748498172888389,"reconstruction_rmse":6.179243611056095,"retention_accuracy":1.0,"training_evaluations":1491480},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"equivalent"}},"gates":[{"gate_id":"adaptation_completed","metric":"adaptation_completed","observed":true,"operator":"eq","pass":true,"rationale":"The bounded adaptation procedure must complete.","threshold":true},{"gate_id":"base_holdout_accuracy","metric":"base_accuracy","observed":0.96484375,"operator":"ge","pass":true,"rationale":"The base representation must establish the bounded task before drift.","threshold":0.85},{"gate_id":"base_holdout_retention","metric":"retention_accuracy","observed":1.0,"operator":"ge","pass":true,"rationale":"Anchored base behavior may lose at most ten percentage points in absolute retained accuracy.","threshold":0.9},{"gate_id":"routing_oracle_equivalence","metric":"routing_mismatches","observed":0,"operator":"eq","pass":true,"rationale":"Every routed classification must agree with complete scan.","threshold":0},{"gate_id":"checkpoint_roundtrip","metric":"checkpoint_roundtrip","observed":true,"operator":"eq","pass":true,"rationale":"Canonical in-memory restoration must succeed.","threshold":true},{"gate_id":"checkpoint_identity","metric":"checkpoint_identity","observed":true,"operator":"eq","pass":true,"rationale":"Restored complete model identity must match.","threshold":true},{"gate_id":"checkpoint_behavior","metric":"checkpoint_behavior","observed":true,"operator":"eq","pass":true,"rationale":"Restored evaluation and planning behavior must match.","threshold":true},{"gate_id":"checkpoint_mutation_rejection","metric":"checkpoint_mutations","observed":true,"operator":"eq","pass":true,"rationale":"Every declared behavioral and byte-level checkpoint mutation must be detected.","threshold":true},{"gate_id":"lineage_invariants","metric":"lineage_invariants","observed":true,"operator":"eq","pass":true,"rationale":"Generation, lineage uniqueness, descendant splitting, and deterministic topology invariants must hold.","threshold":true},{"gate_id":"unsupported_transitions_unknown","metric":"unsupported_graph_edge_violations","observed":0,"operator":"eq","pass":true,"rationale":"Unsupported actions cannot enter the planning graph.","threshold":0},{"gate_id":"replay_size","metric":"replay_selected","observed":256,"operator":"eq","pass":true,"rationale":"The declared replay budget must be filled on the non-sparse trial corpus.","threshold":256},{"gate_id":"replay_unique","metric":"replay_unique","observed":256,"operator":"eq","pass":true,"rationale":"Balanced replay cannot introduce accidental duplicates.","threshold":256},{"gate_id":"replay_label_coverage","metric":"replay_labels_covered","observed":8,"operator":"eq","pass":true,"rationale":"Replay must retain every declared label.","threshold":8},{"gate_id":"replay_action_coverage","metric":"replay_actions_covered","observed":4,"operator":"eq","pass":true,"rationale":"Replay must retain every declared action.","threshold":4},{"gate_id":"replay_state_coverage","metric":"replay_states_covered","observed":64,"operator":"ge","pass":true,"rationale":"Replay must cover at least 60 of 64 source states.","threshold":60},{"gate_id":"replay_expert_coverage","metric":"replay_experts_covered","observed":62,"operator":"ge","pass":true,"rationale":"Replay must retain broad assigned-expert coverage.","threshold":60},{"gate_id":"replay_transition_coverage","metric":"replay_transition_pairs_covered","observed":251,"operator":"ge","pass":true,"rationale":"Replay must preserve broad source-state/action transition support.","threshold":220},{"gate_id":"planning_path_found","metric":"path_found_rate","observed":0.9375,"operator":"ge","pass":true,"rationale":"At least three quarters of bounded planning cases must have a supported path.","threshold":0.75},{"gate_id":"expert_capacity","metric":"expert_count","observed":70,"operator":"le","pass":true,"rationale":"Adaptation cannot exceed the declared expert capacity.","threshold":80},{"gate_id":"retirement_budget","metric":"accepted_retirements","observed":0,"operator":"le","pass":true,"rationale":"Retirement remains optional and bounded.","threshold":4},{"gate_id":"topology_objective_non_degradation","metric":"topology_objective_gain_q20","observed":10678,"operator":"ge","pass":true,"rationale":"Accepted adaptation-training topology decisions cannot reduce their declared objective.","threshold":0},{"gate_id":"matched_compute_budget","metric":"matched_compute_training_evaluation_ratio","observed":0.8974136810639864,"operator":"le","pass":true,"rationale":"Candidate training work may exceed the matched fixed-topology budget by at most ten percent.","threshold":1.1},{"gate_id":"conditional_inference_efficiency","metric":"inference_evaluation_ratio_vs_flat64","observed":0.125,"operator":"le","pass":true,"rationale":"Routed inference must use at most one quarter of flat complete-scan expert evaluations.","threshold":0.25},{"gate_id":"observation_accuracy","metric":"adapted_drift_accuracy","observed":1.0,"operator":"ge","pass":true,"rationale":"Observation drift emphasizes routed classification.","threshold":0.9},{"gate_id":"observation_non_inferiority","metric":"drift_accuracy_delta","observed":0.04296875,"operator":"ge","pass":true,"rationale":"An already solved observation task uses non-inferiority.","threshold":-0.02},{"gate_id":"observation_reconstruction","metric":"reconstruction_improvement_ratio","observed":0.2210153697798869,"operator":"ge","pass":true,"rationale":"Observation adaptation cannot worsen reconstruction.","threshold":0},{"gate_id":"observation_prediction","metric":"prediction_improvement_ratio","observed":0.18375469180138118,"operator":"ge","pass":true,"rationale":"Observation adaptation cannot worsen next-observation prediction.","threshold":0},{"gate_id":"observation_reconstruction_retention","metric":"retention_reconstruction_degradation_ratio","observed":-0.31742271016165985,"operator":"le","pass":true,"rationale":"Original-task reconstruction may degrade by at most ten percent.","threshold":0.1},{"gate_id":"observation_exact_planning","metric":"exact_state_rate","observed":0.8125,"operator":"ge","pass":true,"rationale":"Observation drift remains fully observed and uses exact-state planning.","threshold":0.75},{"gate_id":"observation_bounded_births","metric":"accepted_births","observed":6,"operator":"le","pass":true,"rationale":"Limited headroom cannot justify the full birth budget.","threshold":12}],"metrics":{"accepted_births":6,"accepted_retirements":0,"adaptation_completed":true,"adaptation_training_accuracy":1.0,"adapted_drift_accuracy":1.0,"adapted_prediction_rmse":6.748498172888389,"adapted_reconstruction_rmse":6.179243611056095,"adapted_transition_accuracy":0.9322033898305084,"balanced_vs_periodic_drift_accuracy_delta":0.0,"balanced_vs_periodic_retention_delta":0.0,"base_accuracy":0.96484375,"base_prediction_rmse":6.133351946701686,"base_reconstruction_rmse":5.376984225327644,"belief_set_rate":0.8125,"belief_set_rate_delta":0.171875,"checkpoint_behavior":true,"checkpoint_identity":true,"checkpoint_mutations":true,"checkpoint_roundtrip":true,"checkpoint_size_bytes":46634,"drift_accuracy_delta":0.04296875,"exact_state_rate":0.8125,"exact_state_rate_delta":0.171875,"expert_count":70,"headroom_normalized_accuracy_improvement":1.0,"inference_evaluation_ratio_vs_flat64":0.125,"inference_expert_evaluations":2048,"lineage_invariants":true,"matched_compute_drift_accuracy_delta":0.04296875,"matched_compute_retention_delta":0.03125,"matched_compute_training_evaluation_ratio":0.8974136810639864,"no_birth_drift_accuracy_delta":0.04296875,"no_retirement_drift_accuracy_delta":0.0,"path_found_rate":0.9375,"prediction_improvement_ratio":0.18375469180138118,"reconstruction_improvement_ratio":0.2210153697798869,"replay_actions_covered":4,"replay_experts_covered":62,"replay_labels_covered":8,"replay_selected":256,"replay_states_covered":64,"replay_transition_pairs_covered":251,"replay_unique":256,"retention_accuracy":1.0,"retention_accuracy_delta_from_base":0.03515625,"retention_prediction_degradation":-1.9011444222602663,"retention_prediction_rmse":4.23220752444142,"retention_reconstruction_degradation_ratio":-0.31742271016165985,"retention_reconstruction_rmse":3.67020732002765,"retention_transition_accuracy_delta":0.020854826823876182,"routing_mismatches":0,"static_belief_set_rate":0.640625,"static_drift_accuracy":0.95703125,"static_exact_state_rate":0.640625,"static_prediction_rmse":8.267732880182463,"static_reconstruction_rmse":7.932433287303836,"static_transition_accuracy":0.9621848739495799,"topology_objective_gain_q20":10678,"training_evaluations":1491480,"transition_accuracy_delta":-0.029981484119071422,"transition_support_rate":0.921875,"unsupported_graph_edge_violations":0},"regime":"observation_drift","seed":"0x76a01eddce0b3fc5","trial_id":"validation-observation-04","trial_result":"PASS"},{"comparisons":{"fixed_8_expert":{"metrics":{"checkpoint_size_bytes":11294,"drift_accuracy":0.19140625,"expert_count":8,"expert_evaluations":2048,"planning_belief_set_rate":0.171875,"planning_exact_state_rate":0.015625,"prediction_rmse":34.425634895728564,"reconstruction_rmse":29.128837419990386,"retention_accuracy":0.20703125,"training_evaluations":94208},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":34200,"drift_accuracy":0.80859375,"expert_count":60,"expert_evaluations":0,"planning_belief_set_rate":0.484375,"planning_exact_state_rate":0.640625,"prediction_rmse":-9.042354191951816,"reconstruction_rmse":-24.97953516373127,"retention_accuracy":0.79296875,"training_evaluations":1152856},"pareto_relation":"mixed"},"fixed_topology_64_expert_routed":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":1.0,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":0.703125,"planning_exact_state_rate":0.703125,"prediction_rmse":25.651694243091182,"reconstruction_rmse":3.2877616492983583,"retention_accuracy":1.0,"training_evaluations":2588672},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":2280,"drift_accuracy":0.0,"expert_count":4,"expert_evaluations":0,"planning_belief_set_rate":-0.046875,"planning_exact_state_rate":-0.046875,"prediction_rmse":-0.2684135393144338,"reconstruction_rmse":0.8615406069607592,"retention_accuracy":0.0,"training_evaluations":-1341608},"pareto_relation":"mixed"},"flat_64_expert_complete_scan":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":1.0,"expert_count":64,"expert_evaluations":16384,"planning_belief_set_rate":0.703125,"planning_exact_state_rate":0.703125,"prediction_rmse":25.651694243091182,"reconstruction_rmse":3.2877616492983583,"retention_accuracy":1.0,"training_evaluations":2588672},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":2280,"drift_accuracy":0.0,"expert_count":4,"expert_evaluations":-14336,"planning_belief_set_rate":-0.046875,"planning_exact_state_rate":-0.046875,"prediction_rmse":-0.2684135393144338,"reconstruction_rmse":0.8615406069607592,"retention_accuracy":0.0,"training_evaluations":-1341608},"pareto_relation":"mixed"},"matched_compute_fixed_topology":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.94921875,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":0.609375,"planning_exact_state_rate":0.59375,"prediction_rmse":26.219407227171814,"reconstruction_rmse":5.810690805912518,"retention_accuracy":0.953125,"training_evaluations":1440600},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":2280,"drift_accuracy":0.05078125,"expert_count":4,"expert_evaluations":0,"planning_belief_set_rate":0.046875,"planning_exact_state_rate":0.0625,"prediction_rmse":-0.8361265233950661,"reconstruction_rmse":-1.6613885496534007,"retention_accuracy":0.046875,"training_evaluations":-193536},"pareto_relation":"mixed"},"matched_expert_count_capacity":{"metrics":{"checkpoint_size_bytes":45494,"drift_accuracy":1.0,"expert_count":68,"expert_evaluations":2048,"planning_belief_set_rate":0.703125,"planning_exact_state_rate":0.703125,"prediction_rmse":25.5911601126143,"reconstruction_rmse":3.2873965458509584,"retention_accuracy":1.0,"training_evaluations":2889728},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":-0.046875,"planning_exact_state_rate":-0.046875,"prediction_rmse":-0.2078794088375524,"reconstruction_rmse":0.8619057104081591,"retention_accuracy":0.0,"training_evaluations":-1642664},"pareto_relation":"mixed"},"nearest_centroid_16_no_recursive_births":{"metrics":{"checkpoint_size_bytes":15854,"drift_accuracy":0.23046875,"expert_count":16,"expert_evaluations":4096,"planning_belief_set_rate":0.25,"planning_exact_state_rate":0.09375,"prediction_rmse":31.66620106756897,"reconstruction_rmse":23.43756222948118,"retention_accuracy":0.265625,"training_evaluations":253952},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":29640,"drift_accuracy":0.76953125,"expert_count":52,"expert_evaluations":-2048,"planning_belief_set_rate":0.40625,"planning_exact_state_rate":0.5625,"prediction_rmse":-6.282920363792222,"reconstruction_rmse":-19.28825997322206,"retention_accuracy":0.734375,"training_evaluations":993112},"pareto_relation":"mixed"},"no_adaptation_static":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.94921875,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":0.609375,"planning_exact_state_rate":0.59375,"prediction_rmse":26.219407227171814,"reconstruction_rmse":5.810690805912518,"retention_accuracy":0.953125,"training_evaluations":555864},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":2280,"drift_accuracy":0.05078125,"expert_count":4,"expert_evaluations":0,"planning_belief_set_rate":0.046875,"planning_exact_state_rate":0.0625,"prediction_rmse":-0.8361265233950661,"reconstruction_rmse":-1.6613885496534007,"retention_accuracy":0.046875,"training_evaluations":691200},"pareto_relation":"mixed"},"periodic_replay_policy":{"metrics":{"checkpoint_size_bytes":44924,"drift_accuracy":1.0,"expert_count":67,"expert_evaluations":2048,"planning_belief_set_rate":0.65625,"planning_exact_state_rate":0.65625,"prediction_rmse":25.36425832564463,"reconstruction_rmse":4.152465996485863,"retention_accuracy":1.0,"training_evaluations":1012056},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":570,"drift_accuracy":0.0,"expert_count":1,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.019022378132117268,"reconstruction_rmse":-0.0031637402267454817,"retention_accuracy":0.0,"training_evaluations":235008},"pareto_relation":"mixed"},"ravel_0_5_candidate":{"metrics":{"checkpoint_size_bytes":45494,"drift_accuracy":1.0,"expert_count":68,"expert_evaluations":2048,"planning_belief_set_rate":0.65625,"planning_exact_state_rate":0.65625,"prediction_rmse":25.383280703776748,"reconstruction_rmse":4.1493022562591175,"retention_accuracy":1.0,"training_evaluations":1247064},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"equivalent"},"ravel_complete_scan_without_certification":{"metrics":{"checkpoint_size_bytes":45494,"drift_accuracy":1.0,"expert_count":68,"expert_evaluations":17408,"planning_belief_set_rate":0.65625,"planning_exact_state_rate":0.65625,"prediction_rmse":25.383280703776748,"reconstruction_rmse":4.1493022562591175,"retention_accuracy":1.0,"training_evaluations":1431384},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":-15360,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":-184320},"pareto_relation":"candidate_dominates"},"ravel_no_birth_same_replay_iterations":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.94921875,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":0.609375,"planning_exact_state_rate":0.59375,"prediction_rmse":26.219407227171814,"reconstruction_rmse":5.810690805912518,"retention_accuracy":0.953125,"training_evaluations":777048},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":2280,"drift_accuracy":0.05078125,"expert_count":4,"expert_evaluations":0,"planning_belief_set_rate":0.046875,"planning_exact_state_rate":0.0625,"prediction_rmse":-0.8361265233950661,"reconstruction_rmse":-1.6613885496534007,"retention_accuracy":0.046875,"training_evaluations":470016},"pareto_relation":"mixed"},"ravel_random_births":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.94921875,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":0.609375,"planning_exact_state_rate":0.59375,"prediction_rmse":26.219407227171814,"reconstruction_rmse":5.810690805912518,"retention_accuracy":0.953125,"training_evaluations":777048},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":2280,"drift_accuracy":0.05078125,"expert_count":4,"expert_evaluations":0,"planning_belief_set_rate":0.046875,"planning_exact_state_rate":0.0625,"prediction_rmse":-0.8361265233950661,"reconstruction_rmse":-1.6613885496534007,"retention_accuracy":0.046875,"training_evaluations":470016},"pareto_relation":"mixed"},"ravel_without_replay":{"metrics":{"checkpoint_size_bytes":44924,"drift_accuracy":1.0,"expert_count":67,"expert_evaluations":2048,"planning_belief_set_rate":0.65625,"planning_exact_state_rate":0.65625,"prediction_rmse":25.41709019247764,"reconstruction_rmse":4.153053688175479,"retention_accuracy":1.0,"training_evaluations":859992},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":570,"drift_accuracy":0.0,"expert_count":1,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":-0.03380948870089284,"reconstruction_rmse":-0.003751431916361625,"retention_accuracy":0.0,"training_evaluations":387072},"pareto_relation":"mixed"},"ravel_without_retirement_matched_work":{"metrics":{"checkpoint_size_bytes":45494,"drift_accuracy":1.0,"expert_count":68,"expert_evaluations":2048,"planning_belief_set_rate":0.65625,"planning_exact_state_rate":0.65625,"prediction_rmse":25.383280703776748,"reconstruction_rmse":4.1493022562591175,"retention_accuracy":1.0,"training_evaluations":1247064},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"equivalent"}},"gates":[{"gate_id":"adaptation_completed","metric":"adaptation_completed","observed":true,"operator":"eq","pass":true,"rationale":"The bounded adaptation procedure must complete.","threshold":true},{"gate_id":"base_holdout_accuracy","metric":"base_accuracy","observed":0.953125,"operator":"ge","pass":true,"rationale":"The base representation must establish the bounded task before drift.","threshold":0.85},{"gate_id":"base_holdout_retention","metric":"retention_accuracy","observed":1.0,"operator":"ge","pass":true,"rationale":"Anchored base behavior may lose at most ten percentage points in absolute retained accuracy.","threshold":0.9},{"gate_id":"routing_oracle_equivalence","metric":"routing_mismatches","observed":0,"operator":"eq","pass":true,"rationale":"Every routed classification must agree with complete scan.","threshold":0},{"gate_id":"checkpoint_roundtrip","metric":"checkpoint_roundtrip","observed":true,"operator":"eq","pass":true,"rationale":"Canonical in-memory restoration must succeed.","threshold":true},{"gate_id":"checkpoint_identity","metric":"checkpoint_identity","observed":true,"operator":"eq","pass":true,"rationale":"Restored complete model identity must match.","threshold":true},{"gate_id":"checkpoint_behavior","metric":"checkpoint_behavior","observed":true,"operator":"eq","pass":true,"rationale":"Restored evaluation and planning behavior must match.","threshold":true},{"gate_id":"checkpoint_mutation_rejection","metric":"checkpoint_mutations","observed":true,"operator":"eq","pass":true,"rationale":"Every declared behavioral and byte-level checkpoint mutation must be detected.","threshold":true},{"gate_id":"lineage_invariants","metric":"lineage_invariants","observed":true,"operator":"eq","pass":true,"rationale":"Generation, lineage uniqueness, descendant splitting, and deterministic topology invariants must hold.","threshold":true},{"gate_id":"unsupported_transitions_unknown","metric":"unsupported_graph_edge_violations","observed":0,"operator":"eq","pass":true,"rationale":"Unsupported actions cannot enter the planning graph.","threshold":0},{"gate_id":"replay_size","metric":"replay_selected","observed":256,"operator":"eq","pass":true,"rationale":"The declared replay budget must be filled on the non-sparse trial corpus.","threshold":256},{"gate_id":"replay_unique","metric":"replay_unique","observed":256,"operator":"eq","pass":true,"rationale":"Balanced replay cannot introduce accidental duplicates.","threshold":256},{"gate_id":"replay_label_coverage","metric":"replay_labels_covered","observed":8,"operator":"eq","pass":true,"rationale":"Replay must retain every declared label.","threshold":8},{"gate_id":"replay_action_coverage","metric":"replay_actions_covered","observed":4,"operator":"eq","pass":true,"rationale":"Replay must retain every declared action.","threshold":4},{"gate_id":"replay_state_coverage","metric":"replay_states_covered","observed":64,"operator":"ge","pass":true,"rationale":"Replay must cover at least 60 of 64 source states.","threshold":60},{"gate_id":"replay_expert_coverage","metric":"replay_experts_covered","observed":63,"operator":"ge","pass":true,"rationale":"Replay must retain broad assigned-expert coverage.","threshold":60},{"gate_id":"replay_transition_coverage","metric":"replay_transition_pairs_covered","observed":252,"operator":"ge","pass":true,"rationale":"Replay must preserve broad source-state/action transition support.","threshold":220},{"gate_id":"planning_path_found","metric":"path_found_rate","observed":1.0,"operator":"ge","pass":true,"rationale":"At least three quarters of bounded planning cases must have a supported path.","threshold":0.75},{"gate_id":"expert_capacity","metric":"expert_count","observed":68,"operator":"le","pass":true,"rationale":"Adaptation cannot exceed the declared expert capacity.","threshold":80},{"gate_id":"retirement_budget","metric":"accepted_retirements","observed":0,"operator":"le","pass":true,"rationale":"Retirement remains optional and bounded.","threshold":4},{"gate_id":"topology_objective_non_degradation","metric":"topology_objective_gain_q20","observed":16109,"operator":"ge","pass":true,"rationale":"Accepted adaptation-training topology decisions cannot reduce their declared objective.","threshold":0},{"gate_id":"matched_compute_budget","metric":"matched_compute_training_evaluation_ratio","observed":0.8656559766763848,"operator":"le","pass":true,"rationale":"Candidate training work may exceed the matched fixed-topology budget by at most ten percent.","threshold":1.1},{"gate_id":"conditional_inference_efficiency","metric":"inference_evaluation_ratio_vs_flat64","observed":0.125,"operator":"le","pass":true,"rationale":"Routed inference must use at most one quarter of flat complete-scan expert evaluations.","threshold":0.25},{"gate_id":"transition_classification","metric":"adapted_drift_accuracy","observed":1.0,"operator":"ge","pass":true,"rationale":"Transition correction cannot sacrifice classification.","threshold":0.9},{"gate_id":"transition_prediction_improvement","metric":"prediction_improvement_ratio","observed":0.03188960437399087,"operator":"ge","pass":true,"rationale":"Changed transitions require at least one percent relative prediction improvement.","threshold":0.01},{"gate_id":"transition_accuracy_non_inferiority","metric":"transition_accuracy_delta","observed":0.018765133171912862,"operator":"ge","pass":true,"rationale":"Supported transition accuracy cannot lose more than five points.","threshold":-0.05},{"gate_id":"old_prediction_retention","metric":"retention_prediction_degradation","observed":-1.1019845341148278,"operator":"le","pass":true,"rationale":"Original-task prediction RMSE may rise by at most one observation unit.","threshold":1},{"gate_id":"old_transition_retention","metric":"retention_transition_accuracy_delta","observed":0.011613228982580215,"operator":"ge","pass":true,"rationale":"Original supported transition accuracy may fall by at most ten points.","threshold":-0.1},{"gate_id":"transition_exact_planning","metric":"exact_state_rate","observed":0.65625,"operator":"ge","pass":true,"rationale":"Transition drift retains a bounded exact-state planning floor.","threshold":0.25},{"gate_id":"transition_planning_non_inferiority","metric":"exact_state_rate_delta","observed":0.0625,"operator":"ge","pass":true,"rationale":"Adaptation cannot materially reduce exact planning relative to static.","threshold":-0.05}],"metrics":{"accepted_births":4,"accepted_retirements":0,"adaptation_completed":true,"adaptation_training_accuracy":1.0,"adapted_drift_accuracy":1.0,"adapted_prediction_rmse":25.383280703776748,"adapted_reconstruction_rmse":4.1493022562591175,"adapted_transition_accuracy":0.7330508474576272,"balanced_vs_periodic_drift_accuracy_delta":0.0,"balanced_vs_periodic_retention_delta":0.0,"base_accuracy":0.953125,"base_prediction_rmse":6.661313067056126,"base_reconstruction_rmse":6.031448248816213,"belief_set_rate":0.65625,"belief_set_rate_delta":0.046875,"checkpoint_behavior":true,"checkpoint_identity":true,"checkpoint_mutations":true,"checkpoint_roundtrip":true,"checkpoint_size_bytes":45494,"drift_accuracy_delta":0.05078125,"exact_state_rate":0.65625,"exact_state_rate_delta":0.0625,"expert_count":68,"headroom_normalized_accuracy_improvement":1.0,"inference_evaluation_ratio_vs_flat64":0.125,"inference_expert_evaluations":2048,"lineage_invariants":true,"matched_compute_drift_accuracy_delta":0.05078125,"matched_compute_retention_delta":0.046875,"matched_compute_training_evaluation_ratio":0.8656559766763848,"no_birth_drift_accuracy_delta":0.05078125,"no_retirement_drift_accuracy_delta":0.0,"path_found_rate":1.0,"prediction_improvement_ratio":0.03188960437399087,"reconstruction_improvement_ratio":0.28591928311912546,"replay_actions_covered":4,"replay_experts_covered":63,"replay_labels_covered":8,"replay_selected":256,"replay_states_covered":64,"replay_transition_pairs_covered":252,"replay_unique":256,"retention_accuracy":1.0,"retention_accuracy_delta_from_base":0.046875,"retention_prediction_degradation":-1.1019845341148278,"retention_prediction_rmse":5.559328532941298,"retention_reconstruction_degradation_ratio":-0.2614481628580416,"retention_reconstruction_rmse":4.454537184789862,"retention_transition_accuracy_delta":0.011613228982580215,"routing_mismatches":0,"static_belief_set_rate":0.609375,"static_drift_accuracy":0.94921875,"static_exact_state_rate":0.59375,"static_prediction_rmse":26.219407227171814,"static_reconstruction_rmse":5.810690805912518,"static_transition_accuracy":0.7142857142857143,"topology_objective_gain_q20":16109,"training_evaluations":1247064,"transition_accuracy_delta":0.018765133171912862,"transition_support_rate":0.921875,"unsupported_graph_edge_violations":0},"regime":"transition_drift","seed":"0xcd5ff324852e0944","trial_id":"validation-transition-01","trial_result":"PASS"},{"comparisons":{"fixed_8_expert":{"metrics":{"checkpoint_size_bytes":11294,"drift_accuracy":0.22265625,"expert_count":8,"expert_evaluations":2048,"planning_belief_set_rate":0.1875,"planning_exact_state_rate":0.03125,"prediction_rmse":32.23671097562035,"reconstruction_rmse":28.26926764712653,"retention_accuracy":0.171875,"training_evaluations":94208},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":34770,"drift_accuracy":0.77734375,"expert_count":61,"expert_evaluations":0,"planning_belief_set_rate":0.359375,"planning_exact_state_rate":0.515625,"prediction_rmse":-12.335184947662963,"reconstruction_rmse":-23.624589055729015,"retention_accuracy":0.828125,"training_evaluations":1278376},"pareto_relation":"mixed"},"fixed_topology_64_expert_routed":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":1.0,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":0.46875,"planning_exact_state_rate":0.46875,"prediction_rmse":20.271916516944064,"reconstruction_rmse":3.27134659590893,"retention_accuracy":1.0,"training_evaluations":2588672},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":2850,"drift_accuracy":0.0,"expert_count":5,"expert_evaluations":0,"planning_belief_set_rate":0.078125,"planning_exact_state_rate":0.078125,"prediction_rmse":-0.37039048898667915,"reconstruction_rmse":1.3733319954885839,"retention_accuracy":0.0,"training_evaluations":-1216088},"pareto_relation":"mixed"},"flat_64_expert_complete_scan":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":1.0,"expert_count":64,"expert_evaluations":16384,"planning_belief_set_rate":0.46875,"planning_exact_state_rate":0.46875,"prediction_rmse":20.271916516944064,"reconstruction_rmse":3.27134659590893,"retention_accuracy":1.0,"training_evaluations":2588672},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":2850,"drift_accuracy":0.0,"expert_count":5,"expert_evaluations":-14336,"planning_belief_set_rate":0.078125,"planning_exact_state_rate":0.078125,"prediction_rmse":-0.37039048898667915,"reconstruction_rmse":1.3733319954885839,"retention_accuracy":0.0,"training_evaluations":-1216088},"pareto_relation":"mixed"},"matched_compute_fixed_topology":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.9375,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":0.390625,"planning_exact_state_rate":0.359375,"prediction_rmse":20.951555562510872,"reconstruction_rmse":6.642669501008423,"retention_accuracy":0.9375,"training_evaluations":1444776},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":2850,"drift_accuracy":0.0625,"expert_count":5,"expert_evaluations":0,"planning_belief_set_rate":0.15625,"planning_exact_state_rate":0.1875,"prediction_rmse":-1.050029534553488,"reconstruction_rmse":-1.997990909610909,"retention_accuracy":0.0625,"training_evaluations":-72192},"pareto_relation":"mixed"},"matched_expert_count_capacity":{"metrics":{"checkpoint_size_bytes":46064,"drift_accuracy":1.0,"expert_count":69,"expert_evaluations":2048,"planning_belief_set_rate":0.46875,"planning_exact_state_rate":0.46875,"prediction_rmse":20.034398140185633,"reconstruction_rmse":3.2425755226232575,"retention_accuracy":1.0,"training_evaluations":2967552},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.078125,"planning_exact_state_rate":0.078125,"prediction_rmse":-0.1328721122282488,"reconstruction_rmse":1.4021030687742564,"retention_accuracy":0.0,"training_evaluations":-1594968},"pareto_relation":"mixed"},"nearest_centroid_16_no_recursive_births":{"metrics":{"checkpoint_size_bytes":15854,"drift_accuracy":0.28515625,"expert_count":16,"expert_evaluations":4096,"planning_belief_set_rate":0.515625,"planning_exact_state_rate":0.125,"prediction_rmse":28.951775409715815,"reconstruction_rmse":22.318921590965633,"retention_accuracy":0.2890625,"training_evaluations":253952},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":30210,"drift_accuracy":0.71484375,"expert_count":53,"expert_evaluations":-2048,"planning_belief_set_rate":0.03125,"planning_exact_state_rate":0.421875,"prediction_rmse":-9.05024938175843,"reconstruction_rmse":-17.67424299956812,"retention_accuracy":0.7109375,"training_evaluations":1118632},"pareto_relation":"mixed"},"no_adaptation_static":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.9375,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":0.390625,"planning_exact_state_rate":0.359375,"prediction_rmse":20.951555562510872,"reconstruction_rmse":6.642669501008423,"retention_accuracy":0.9375,"training_evaluations":560040},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":2850,"drift_accuracy":0.0625,"expert_count":5,"expert_evaluations":0,"planning_belief_set_rate":0.15625,"planning_exact_state_rate":0.1875,"prediction_rmse":-1.050029534553488,"reconstruction_rmse":-1.997990909610909,"retention_accuracy":0.0625,"training_evaluations":812544},"pareto_relation":"mixed"},"periodic_replay_policy":{"metrics":{"checkpoint_size_bytes":46064,"drift_accuracy":1.0,"expert_count":69,"expert_evaluations":2048,"planning_belief_set_rate":0.546875,"planning_exact_state_rate":0.546875,"prediction_rmse":19.936785648298603,"reconstruction_rmse":4.648184856643646,"retention_accuracy":1.0,"training_evaluations":1372584},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":-0.03525962034121832,"reconstruction_rmse":-0.0035062652461324006,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"candidate_dominates"},"ravel_0_5_candidate":{"metrics":{"checkpoint_size_bytes":46064,"drift_accuracy":1.0,"expert_count":69,"expert_evaluations":2048,"planning_belief_set_rate":0.546875,"planning_exact_state_rate":0.546875,"prediction_rmse":19.901526027957384,"reconstruction_rmse":4.644678591397514,"retention_accuracy":1.0,"training_evaluations":1372584},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"equivalent"},"ravel_complete_scan_without_certification":{"metrics":{"checkpoint_size_bytes":46064,"drift_accuracy":1.0,"expert_count":69,"expert_evaluations":17664,"planning_belief_set_rate":0.546875,"planning_exact_state_rate":0.546875,"prediction_rmse":19.901526027957384,"reconstruction_rmse":4.644678591397514,"retention_accuracy":1.0,"training_evaluations":1559976},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":-15616,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":-187392},"pareto_relation":"candidate_dominates"},"ravel_no_birth_same_replay_iterations":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.9375,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":0.390625,"planning_exact_state_rate":0.359375,"prediction_rmse":20.951555562510872,"reconstruction_rmse":6.642669501008423,"retention_accuracy":0.9375,"training_evaluations":781224},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":2850,"drift_accuracy":0.0625,"expert_count":5,"expert_evaluations":0,"planning_belief_set_rate":0.15625,"planning_exact_state_rate":0.1875,"prediction_rmse":-1.050029534553488,"reconstruction_rmse":-1.997990909610909,"retention_accuracy":0.0625,"training_evaluations":591360},"pareto_relation":"mixed"},"ravel_random_births":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.9375,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":0.390625,"planning_exact_state_rate":0.359375,"prediction_rmse":20.951555562510872,"reconstruction_rmse":6.642669501008423,"retention_accuracy":0.9375,"training_evaluations":781224},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":2850,"drift_accuracy":0.0625,"expert_count":5,"expert_evaluations":0,"planning_belief_set_rate":0.15625,"planning_exact_state_rate":0.1875,"prediction_rmse":-1.050029534553488,"reconstruction_rmse":-1.997990909610909,"retention_accuracy":0.0625,"training_evaluations":591360},"pareto_relation":"mixed"},"ravel_without_replay":{"metrics":{"checkpoint_size_bytes":45494,"drift_accuracy":1.0,"expert_count":68,"expert_evaluations":2048,"planning_belief_set_rate":0.546875,"planning_exact_state_rate":0.546875,"prediction_rmse":20.02274822567735,"reconstruction_rmse":4.647805415833448,"retention_accuracy":1.0,"training_evaluations":1020840},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":570,"drift_accuracy":0.0,"expert_count":1,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":-0.12122219771996612,"reconstruction_rmse":-0.003126824435933706,"retention_accuracy":0.0,"training_evaluations":351744},"pareto_relation":"mixed"},"ravel_without_retirement_matched_work":{"metrics":{"checkpoint_size_bytes":46064,"drift_accuracy":1.0,"expert_count":69,"expert_evaluations":2048,"planning_belief_set_rate":0.546875,"planning_exact_state_rate":0.546875,"prediction_rmse":19.901526027957384,"reconstruction_rmse":4.644678591397514,"retention_accuracy":1.0,"training_evaluations":1372584},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"equivalent"}},"gates":[{"gate_id":"adaptation_completed","metric":"adaptation_completed","observed":true,"operator":"eq","pass":true,"rationale":"The bounded adaptation procedure must complete.","threshold":true},{"gate_id":"base_holdout_accuracy","metric":"base_accuracy","observed":0.94921875,"operator":"ge","pass":true,"rationale":"The base representation must establish the bounded task before drift.","threshold":0.85},{"gate_id":"base_holdout_retention","metric":"retention_accuracy","observed":1.0,"operator":"ge","pass":true,"rationale":"Anchored base behavior may lose at most ten percentage points in absolute retained accuracy.","threshold":0.9},{"gate_id":"routing_oracle_equivalence","metric":"routing_mismatches","observed":0,"operator":"eq","pass":true,"rationale":"Every routed classification must agree with complete scan.","threshold":0},{"gate_id":"checkpoint_roundtrip","metric":"checkpoint_roundtrip","observed":true,"operator":"eq","pass":true,"rationale":"Canonical in-memory restoration must succeed.","threshold":true},{"gate_id":"checkpoint_identity","metric":"checkpoint_identity","observed":true,"operator":"eq","pass":true,"rationale":"Restored complete model identity must match.","threshold":true},{"gate_id":"checkpoint_behavior","metric":"checkpoint_behavior","observed":true,"operator":"eq","pass":true,"rationale":"Restored evaluation and planning behavior must match.","threshold":true},{"gate_id":"checkpoint_mutation_rejection","metric":"checkpoint_mutations","observed":true,"operator":"eq","pass":true,"rationale":"Every declared behavioral and byte-level checkpoint mutation must be detected.","threshold":true},{"gate_id":"lineage_invariants","metric":"lineage_invariants","observed":true,"operator":"eq","pass":true,"rationale":"Generation, lineage uniqueness, descendant splitting, and deterministic topology invariants must hold.","threshold":true},{"gate_id":"unsupported_transitions_unknown","metric":"unsupported_graph_edge_violations","observed":0,"operator":"eq","pass":true,"rationale":"Unsupported actions cannot enter the planning graph.","threshold":0},{"gate_id":"replay_size","metric":"replay_selected","observed":256,"operator":"eq","pass":true,"rationale":"The declared replay budget must be filled on the non-sparse trial corpus.","threshold":256},{"gate_id":"replay_unique","metric":"replay_unique","observed":256,"operator":"eq","pass":true,"rationale":"Balanced replay cannot introduce accidental duplicates.","threshold":256},{"gate_id":"replay_label_coverage","metric":"replay_labels_covered","observed":8,"operator":"eq","pass":true,"rationale":"Replay must retain every declared label.","threshold":8},{"gate_id":"replay_action_coverage","metric":"replay_actions_covered","observed":4,"operator":"eq","pass":true,"rationale":"Replay must retain every declared action.","threshold":4},{"gate_id":"replay_state_coverage","metric":"replay_states_covered","observed":64,"operator":"ge","pass":true,"rationale":"Replay must cover at least 60 of 64 source states.","threshold":60},{"gate_id":"replay_expert_coverage","metric":"replay_experts_covered","observed":63,"operator":"ge","pass":true,"rationale":"Replay must retain broad assigned-expert coverage.","threshold":60},{"gate_id":"replay_transition_coverage","metric":"replay_transition_pairs_covered","observed":250,"operator":"ge","pass":true,"rationale":"Replay must preserve broad source-state/action transition support.","threshold":220},{"gate_id":"planning_path_found","metric":"path_found_rate","observed":1.0,"operator":"ge","pass":true,"rationale":"At least three quarters of bounded planning cases must have a supported path.","threshold":0.75},{"gate_id":"expert_capacity","metric":"expert_count","observed":69,"operator":"le","pass":true,"rationale":"Adaptation cannot exceed the declared expert capacity.","threshold":80},{"gate_id":"retirement_budget","metric":"accepted_retirements","observed":0,"operator":"le","pass":true,"rationale":"Retirement remains optional and bounded.","threshold":4},{"gate_id":"topology_objective_non_degradation","metric":"topology_objective_gain_q20","observed":33124,"operator":"ge","pass":true,"rationale":"Accepted adaptation-training topology decisions cannot reduce their declared objective.","threshold":0},{"gate_id":"matched_compute_budget","metric":"matched_compute_training_evaluation_ratio","observed":0.9500323925646605,"operator":"le","pass":true,"rationale":"Candidate training work may exceed the matched fixed-topology budget by at most ten percent.","threshold":1.1},{"gate_id":"conditional_inference_efficiency","metric":"inference_evaluation_ratio_vs_flat64","observed":0.125,"operator":"le","pass":true,"rationale":"Routed inference must use at most one quarter of flat complete-scan expert evaluations.","threshold":0.25},{"gate_id":"transition_classification","metric":"adapted_drift_accuracy","observed":1.0,"operator":"ge","pass":true,"rationale":"Transition correction cannot sacrifice classification.","threshold":0.9},{"gate_id":"transition_prediction_improvement","metric":"prediction_improvement_ratio","observed":0.05011702025754743,"operator":"ge","pass":true,"rationale":"Changed transitions require at least one percent relative prediction improvement.","threshold":0.01},{"gate_id":"transition_accuracy_non_inferiority","metric":"transition_accuracy_delta","observed":0.060869565217391286,"operator":"ge","pass":true,"rationale":"Supported transition accuracy cannot lose more than five points.","threshold":-0.05},{"gate_id":"old_prediction_retention","metric":"retention_prediction_degradation","observed":0.39817427325097743,"operator":"le","pass":true,"rationale":"Original-task prediction RMSE may rise by at most one observation unit.","threshold":1},{"gate_id":"old_transition_retention","metric":"retention_transition_accuracy_delta","observed":0.016491754122938462,"operator":"ge","pass":true,"rationale":"Original supported transition accuracy may fall by at most ten points.","threshold":-0.1},{"gate_id":"transition_exact_planning","metric":"exact_state_rate","observed":0.546875,"operator":"ge","pass":true,"rationale":"Transition drift retains a bounded exact-state planning floor.","threshold":0.25},{"gate_id":"transition_planning_non_inferiority","metric":"exact_state_rate_delta","observed":0.1875,"operator":"ge","pass":true,"rationale":"Adaptation cannot materially reduce exact planning relative to static.","threshold":-0.05}],"metrics":{"accepted_births":5,"accepted_retirements":0,"adaptation_completed":true,"adaptation_training_accuracy":1.0,"adapted_drift_accuracy":1.0,"adapted_prediction_rmse":19.901526027957384,"adapted_reconstruction_rmse":4.644678591397514,"adapted_transition_accuracy":0.8130434782608695,"balanced_vs_periodic_drift_accuracy_delta":0.0,"balanced_vs_periodic_retention_delta":0.0,"base_accuracy":0.94921875,"base_prediction_rmse":6.550194401647629,"base_reconstruction_rmse":6.159062951977508,"belief_set_rate":0.546875,"belief_set_rate_delta":0.15625,"checkpoint_behavior":true,"checkpoint_identity":true,"checkpoint_mutations":true,"checkpoint_roundtrip":true,"checkpoint_size_bytes":46064,"drift_accuracy_delta":0.0625,"exact_state_rate":0.546875,"exact_state_rate_delta":0.1875,"expert_count":69,"headroom_normalized_accuracy_improvement":1.0,"inference_evaluation_ratio_vs_flat64":0.125,"inference_expert_evaluations":2048,"lineage_invariants":true,"matched_compute_drift_accuracy_delta":0.0625,"matched_compute_retention_delta":0.0625,"matched_compute_training_evaluation_ratio":0.9500323925646605,"no_birth_drift_accuracy_delta":0.0625,"no_retirement_drift_accuracy_delta":0.0,"path_found_rate":1.0,"prediction_improvement_ratio":0.05011702025754743,"reconstruction_improvement_ratio":0.3007813213208326,"replay_actions_covered":4,"replay_experts_covered":63,"replay_labels_covered":8,"replay_selected":256,"replay_states_covered":64,"replay_transition_pairs_covered":250,"replay_unique":256,"retention_accuracy":1.0,"retention_accuracy_delta_from_base":0.05078125,"retention_prediction_degradation":0.39817427325097743,"retention_prediction_rmse":6.948368674898607,"retention_reconstruction_degradation_ratio":-0.20946817783479857,"retention_reconstruction_rmse":4.868935258256964,"retention_transition_accuracy_delta":0.016491754122938462,"routing_mismatches":0,"static_belief_set_rate":0.390625,"static_drift_accuracy":0.9375,"static_exact_state_rate":0.359375,"static_prediction_rmse":20.951555562510872,"static_reconstruction_rmse":6.642669501008423,"static_transition_accuracy":0.7521739130434782,"topology_objective_gain_q20":33124,"training_evaluations":1372584,"transition_accuracy_delta":0.060869565217391286,"transition_support_rate":0.8984375,"unsupported_graph_edge_violations":0},"regime":"transition_drift","seed":"0x446029e572acbddb","trial_id":"validation-transition-02","trial_result":"PASS"},{"comparisons":{"fixed_8_expert":{"metrics":{"checkpoint_size_bytes":11294,"drift_accuracy":0.26171875,"expert_count":8,"expert_evaluations":2048,"planning_belief_set_rate":0.21875,"planning_exact_state_rate":0.015625,"prediction_rmse":32.955538020830296,"reconstruction_rmse":28.30586006312366,"retention_accuracy":0.17578125,"training_evaluations":94208},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":33630,"drift_accuracy":0.73828125,"expert_count":59,"expert_evaluations":0,"planning_belief_set_rate":0.40625,"planning_exact_state_rate":0.609375,"prediction_rmse":-12.841688453094708,"reconstruction_rmse":-25.005910532354036,"retention_accuracy":0.82421875,"training_evaluations":1029576},"pareto_relation":"mixed"},"fixed_topology_64_expert_routed":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":1.0,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":0.625,"planning_exact_state_rate":0.625,"prediction_rmse":20.10148721121242,"reconstruction_rmse":3.2691494910823837,"retention_accuracy":1.0,"training_evaluations":2588672},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":1710,"drift_accuracy":0.0,"expert_count":3,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.012362356523169638,"reconstruction_rmse":0.030800039687239433,"retention_accuracy":0.0,"training_evaluations":-1464888},"pareto_relation":"mixed"},"flat_64_expert_complete_scan":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":1.0,"expert_count":64,"expert_evaluations":16384,"planning_belief_set_rate":0.625,"planning_exact_state_rate":0.625,"prediction_rmse":20.10148721121242,"reconstruction_rmse":3.2691494910823837,"retention_accuracy":1.0,"training_evaluations":2588672},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":1710,"drift_accuracy":0.0,"expert_count":3,"expert_evaluations":-14336,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.012362356523169638,"reconstruction_rmse":0.030800039687239433,"retention_accuracy":0.0,"training_evaluations":-1464888},"pareto_relation":"mixed"},"matched_compute_fixed_topology":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.97265625,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":0.625,"planning_exact_state_rate":0.625,"prediction_rmse":21.049791116383755,"reconstruction_rmse":4.78365647148544,"retention_accuracy":0.98828125,"training_evaluations":1215944},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":1710,"drift_accuracy":0.02734375,"expert_count":3,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":-0.9359415486481666,"reconstruction_rmse":-1.4837069407158165,"retention_accuracy":0.01171875,"training_evaluations":-92160},"pareto_relation":"mixed"},"matched_expert_count_capacity":{"metrics":{"checkpoint_size_bytes":44924,"drift_accuracy":1.0,"expert_count":67,"expert_evaluations":2048,"planning_belief_set_rate":0.609375,"planning_exact_state_rate":0.609375,"prediction_rmse":20.188776850807933,"reconstruction_rmse":3.263946406513785,"retention_accuracy":1.0,"training_evaluations":2812928},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.015625,"planning_exact_state_rate":0.015625,"prediction_rmse":-0.07492728307234486,"reconstruction_rmse":0.03600312425583807,"retention_accuracy":0.0,"training_evaluations":-1689144},"pareto_relation":"mixed"},"nearest_centroid_16_no_recursive_births":{"metrics":{"checkpoint_size_bytes":15854,"drift_accuracy":0.30078125,"expert_count":16,"expert_evaluations":4096,"planning_belief_set_rate":0.34375,"planning_exact_state_rate":0.125,"prediction_rmse":29.984247939400667,"reconstruction_rmse":23.191035829062454,"retention_accuracy":0.24609375,"training_evaluations":253952},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":29070,"drift_accuracy":0.69921875,"expert_count":51,"expert_evaluations":-2048,"planning_belief_set_rate":0.28125,"planning_exact_state_rate":0.5,"prediction_rmse":-9.870398371665079,"reconstruction_rmse":-19.89108629829283,"retention_accuracy":0.75390625,"training_evaluations":869832},"pareto_relation":"mixed"},"no_adaptation_static":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.97265625,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":0.625,"planning_exact_state_rate":0.625,"prediction_rmse":21.049791116383755,"reconstruction_rmse":4.78365647148544,"retention_accuracy":0.98828125,"training_evaluations":552392},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":1710,"drift_accuracy":0.02734375,"expert_count":3,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":-0.9359415486481666,"reconstruction_rmse":-1.4837069407158165,"retention_accuracy":0.01171875,"training_evaluations":571392},"pareto_relation":"mixed"},"periodic_replay_policy":{"metrics":{"checkpoint_size_bytes":44354,"drift_accuracy":1.0,"expert_count":66,"expert_evaluations":2048,"planning_belief_set_rate":0.625,"planning_exact_state_rate":0.625,"prediction_rmse":20.108162337795477,"reconstruction_rmse":3.303874216011235,"retention_accuracy":1.0,"training_evaluations":1005512},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":570,"drift_accuracy":0.0,"expert_count":1,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0056872299401113935,"reconstruction_rmse":-0.003924685241611936,"retention_accuracy":0.0,"training_evaluations":118272},"pareto_relation":"mixed"},"ravel_0_5_candidate":{"metrics":{"checkpoint_size_bytes":44924,"drift_accuracy":1.0,"expert_count":67,"expert_evaluations":2048,"planning_belief_set_rate":0.625,"planning_exact_state_rate":0.625,"prediction_rmse":20.11384956773559,"reconstruction_rmse":3.299949530769623,"retention_accuracy":1.0,"training_evaluations":1123784},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"equivalent"},"ravel_complete_scan_without_certification":{"metrics":{"checkpoint_size_bytes":44924,"drift_accuracy":1.0,"expert_count":67,"expert_evaluations":17152,"planning_belief_set_rate":0.625,"planning_exact_state_rate":0.625,"prediction_rmse":20.11384956773559,"reconstruction_rmse":3.299949530769623,"retention_accuracy":1.0,"training_evaluations":1305032},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":-15104,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":-181248},"pareto_relation":"candidate_dominates"},"ravel_no_birth_same_replay_iterations":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.97265625,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":0.625,"planning_exact_state_rate":0.625,"prediction_rmse":21.049791116383755,"reconstruction_rmse":4.78365647148544,"retention_accuracy":0.98828125,"training_evaluations":773576},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":1710,"drift_accuracy":0.02734375,"expert_count":3,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":-0.9359415486481666,"reconstruction_rmse":-1.4837069407158165,"retention_accuracy":0.01171875,"training_evaluations":350208},"pareto_relation":"mixed"},"ravel_random_births":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.97265625,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":0.625,"planning_exact_state_rate":0.625,"prediction_rmse":21.049791116383755,"reconstruction_rmse":4.78365647148544,"retention_accuracy":0.98828125,"training_evaluations":773576},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":1710,"drift_accuracy":0.02734375,"expert_count":3,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":-0.9359415486481666,"reconstruction_rmse":-1.4837069407158165,"retention_accuracy":0.01171875,"training_evaluations":350208},"pareto_relation":"mixed"},"ravel_without_replay":{"metrics":{"checkpoint_size_bytes":44354,"drift_accuracy":1.0,"expert_count":66,"expert_evaluations":2048,"planning_belief_set_rate":0.625,"planning_exact_state_rate":0.625,"prediction_rmse":20.151993937601187,"reconstruction_rmse":3.305838291952226,"retention_accuracy":1.0,"training_evaluations":854472},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":570,"drift_accuracy":0.0,"expert_count":1,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":-0.03814436986559855,"reconstruction_rmse":-0.005888761182602842,"retention_accuracy":0.0,"training_evaluations":269312},"pareto_relation":"mixed"},"ravel_without_retirement_matched_work":{"metrics":{"checkpoint_size_bytes":44924,"drift_accuracy":1.0,"expert_count":67,"expert_evaluations":2048,"planning_belief_set_rate":0.625,"planning_exact_state_rate":0.625,"prediction_rmse":20.11384956773559,"reconstruction_rmse":3.299949530769623,"retention_accuracy":1.0,"training_evaluations":1123784},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"equivalent"}},"gates":[{"gate_id":"adaptation_completed","metric":"adaptation_completed","observed":true,"operator":"eq","pass":true,"rationale":"The bounded adaptation procedure must complete.","threshold":true},{"gate_id":"base_holdout_accuracy","metric":"base_accuracy","observed":0.99609375,"operator":"ge","pass":true,"rationale":"The base representation must establish the bounded task before drift.","threshold":0.85},{"gate_id":"base_holdout_retention","metric":"retention_accuracy","observed":1.0,"operator":"ge","pass":true,"rationale":"Anchored base behavior may lose at most ten percentage points in absolute retained accuracy.","threshold":0.9},{"gate_id":"routing_oracle_equivalence","metric":"routing_mismatches","observed":0,"operator":"eq","pass":true,"rationale":"Every routed classification must agree with complete scan.","threshold":0},{"gate_id":"checkpoint_roundtrip","metric":"checkpoint_roundtrip","observed":true,"operator":"eq","pass":true,"rationale":"Canonical in-memory restoration must succeed.","threshold":true},{"gate_id":"checkpoint_identity","metric":"checkpoint_identity","observed":true,"operator":"eq","pass":true,"rationale":"Restored complete model identity must match.","threshold":true},{"gate_id":"checkpoint_behavior","metric":"checkpoint_behavior","observed":true,"operator":"eq","pass":true,"rationale":"Restored evaluation and planning behavior must match.","threshold":true},{"gate_id":"checkpoint_mutation_rejection","metric":"checkpoint_mutations","observed":true,"operator":"eq","pass":true,"rationale":"Every declared behavioral and byte-level checkpoint mutation must be detected.","threshold":true},{"gate_id":"lineage_invariants","metric":"lineage_invariants","observed":true,"operator":"eq","pass":true,"rationale":"Generation, lineage uniqueness, descendant splitting, and deterministic topology invariants must hold.","threshold":true},{"gate_id":"unsupported_transitions_unknown","metric":"unsupported_graph_edge_violations","observed":0,"operator":"eq","pass":true,"rationale":"Unsupported actions cannot enter the planning graph.","threshold":0},{"gate_id":"replay_size","metric":"replay_selected","observed":256,"operator":"eq","pass":true,"rationale":"The declared replay budget must be filled on the non-sparse trial corpus.","threshold":256},{"gate_id":"replay_unique","metric":"replay_unique","observed":256,"operator":"eq","pass":true,"rationale":"Balanced replay cannot introduce accidental duplicates.","threshold":256},{"gate_id":"replay_label_coverage","metric":"replay_labels_covered","observed":8,"operator":"eq","pass":true,"rationale":"Replay must retain every declared label.","threshold":8},{"gate_id":"replay_action_coverage","metric":"replay_actions_covered","observed":4,"operator":"eq","pass":true,"rationale":"Replay must retain every declared action.","threshold":4},{"gate_id":"replay_state_coverage","metric":"replay_states_covered","observed":64,"operator":"ge","pass":true,"rationale":"Replay must cover at least 60 of 64 source states.","threshold":60},{"gate_id":"replay_expert_coverage","metric":"replay_experts_covered","observed":63,"operator":"ge","pass":true,"rationale":"Replay must retain broad assigned-expert coverage.","threshold":60},{"gate_id":"replay_transition_coverage","metric":"replay_transition_pairs_covered","observed":248,"operator":"ge","pass":true,"rationale":"Replay must preserve broad source-state/action transition support.","threshold":220},{"gate_id":"planning_path_found","metric":"path_found_rate","observed":1.0,"operator":"ge","pass":true,"rationale":"At least three quarters of bounded planning cases must have a supported path.","threshold":0.75},{"gate_id":"expert_capacity","metric":"expert_count","observed":67,"operator":"le","pass":true,"rationale":"Adaptation cannot exceed the declared expert capacity.","threshold":80},{"gate_id":"retirement_budget","metric":"accepted_retirements","observed":0,"operator":"le","pass":true,"rationale":"Retirement remains optional and bounded.","threshold":4},{"gate_id":"topology_objective_non_degradation","metric":"topology_objective_gain_q20","observed":5969,"operator":"ge","pass":true,"rationale":"Accepted adaptation-training topology decisions cannot reduce their declared objective.","threshold":0},{"gate_id":"matched_compute_budget","metric":"matched_compute_training_evaluation_ratio","observed":0.9242070358503353,"operator":"le","pass":true,"rationale":"Candidate training work may exceed the matched fixed-topology budget by at most ten percent.","threshold":1.1},{"gate_id":"conditional_inference_efficiency","metric":"inference_evaluation_ratio_vs_flat64","observed":0.125,"operator":"le","pass":true,"rationale":"Routed inference must use at most one quarter of flat complete-scan expert evaluations.","threshold":0.25},{"gate_id":"transition_classification","metric":"adapted_drift_accuracy","observed":1.0,"operator":"ge","pass":true,"rationale":"Transition correction cannot sacrifice classification.","threshold":0.9},{"gate_id":"transition_prediction_improvement","metric":"prediction_improvement_ratio","observed":0.044463222626455995,"operator":"ge","pass":true,"rationale":"Changed transitions require at least one percent relative prediction improvement.","threshold":0.01},{"gate_id":"transition_accuracy_non_inferiority","metric":"transition_accuracy_delta","observed":0.005119518162996384,"operator":"ge","pass":true,"rationale":"Supported transition accuracy cannot lose more than five points.","threshold":-0.05},{"gate_id":"old_prediction_retention","metric":"retention_prediction_degradation","observed":0.7564652393751299,"operator":"le","pass":true,"rationale":"Original-task prediction RMSE may rise by at most one observation unit.","threshold":1},{"gate_id":"old_transition_retention","metric":"retention_transition_accuracy_delta","observed":0.00344163798635011,"operator":"ge","pass":true,"rationale":"Original supported transition accuracy may fall by at most ten points.","threshold":-0.1},{"gate_id":"transition_exact_planning","metric":"exact_state_rate","observed":0.625,"operator":"ge","pass":true,"rationale":"Transition drift retains a bounded exact-state planning floor.","threshold":0.25},{"gate_id":"transition_planning_non_inferiority","metric":"exact_state_rate_delta","observed":0.0,"operator":"ge","pass":true,"rationale":"Adaptation cannot materially reduce exact planning relative to static.","threshold":-0.05}],"metrics":{"accepted_births":3,"accepted_retirements":0,"adaptation_completed":true,"adaptation_training_accuracy":1.0,"adapted_drift_accuracy":1.0,"adapted_prediction_rmse":20.11384956773559,"adapted_reconstruction_rmse":3.299949530769623,"adapted_transition_accuracy":0.8225108225108225,"balanced_vs_periodic_drift_accuracy_delta":0.0,"balanced_vs_periodic_retention_delta":0.0,"base_accuracy":0.99609375,"base_prediction_rmse":3.7190366652832587,"base_reconstruction_rmse":3.5196670025504093,"belief_set_rate":0.625,"belief_set_rate_delta":0.0,"checkpoint_behavior":true,"checkpoint_identity":true,"checkpoint_mutations":true,"checkpoint_roundtrip":true,"checkpoint_size_bytes":44924,"drift_accuracy_delta":0.02734375,"exact_state_rate":0.625,"exact_state_rate_delta":0.0,"expert_count":67,"headroom_normalized_accuracy_improvement":1.0,"inference_evaluation_ratio_vs_flat64":0.125,"inference_expert_evaluations":2048,"lineage_invariants":true,"matched_compute_drift_accuracy_delta":0.02734375,"matched_compute_retention_delta":0.01171875,"matched_compute_training_evaluation_ratio":0.9242070358503353,"no_birth_drift_accuracy_delta":0.02734375,"no_retirement_drift_accuracy_delta":0.0,"path_found_rate":1.0,"prediction_improvement_ratio":0.044463222626455995,"reconstruction_improvement_ratio":0.3101616827127827,"replay_actions_covered":4,"replay_experts_covered":63,"replay_labels_covered":8,"replay_selected":256,"replay_states_covered":64,"replay_transition_pairs_covered":248,"replay_unique":256,"retention_accuracy":1.0,"retention_accuracy_delta_from_base":0.00390625,"retention_prediction_degradation":0.7564652393751299,"retention_prediction_rmse":4.475501904658389,"retention_reconstruction_degradation_ratio":0.04951800854081289,"retention_reconstruction_rmse":3.693953903243518,"retention_transition_accuracy_delta":0.00344163798635011,"routing_mismatches":0,"static_belief_set_rate":0.625,"static_drift_accuracy":0.97265625,"static_exact_state_rate":0.625,"static_prediction_rmse":21.049791116383755,"static_reconstruction_rmse":4.78365647148544,"static_transition_accuracy":0.8173913043478261,"topology_objective_gain_q20":5969,"training_evaluations":1123784,"transition_accuracy_delta":0.005119518162996384,"transition_support_rate":0.90234375,"unsupported_graph_edge_violations":0},"regime":"transition_drift","seed":"0x60919d13af913fb7","trial_id":"validation-transition-03","trial_result":"PASS"},{"comparisons":{"fixed_8_expert":{"metrics":{"checkpoint_size_bytes":11294,"drift_accuracy":0.2265625,"expert_count":8,"expert_evaluations":2048,"planning_belief_set_rate":0.265625,"planning_exact_state_rate":0.0,"prediction_rmse":33.86366840108345,"reconstruction_rmse":28.637776042900867,"retention_accuracy":0.2109375,"training_evaluations":94208},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":36480,"drift_accuracy":0.7734375,"expert_count":64,"expert_evaluations":0,"planning_belief_set_rate":0.15625,"planning_exact_state_rate":0.421875,"prediction_rmse":-11.574791952247683,"reconstruction_rmse":-24.05771830675077,"retention_accuracy":0.7890625,"training_evaluations":1648696},"pareto_relation":"mixed"},"fixed_topology_64_expert_routed":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":1.0,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":0.59375,"planning_exact_state_rate":0.59375,"prediction_rmse":24.11767572010949,"reconstruction_rmse":3.3489175829362807,"retention_accuracy":1.0,"training_evaluations":2588672},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":4560,"drift_accuracy":0.0,"expert_count":8,"expert_evaluations":0,"planning_belief_set_rate":-0.171875,"planning_exact_state_rate":-0.171875,"prediction_rmse":-1.82879927127372,"reconstruction_rmse":1.2311401532138184,"retention_accuracy":0.0,"training_evaluations":-845768},"pareto_relation":"mixed"},"flat_64_expert_complete_scan":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":1.0,"expert_count":64,"expert_evaluations":16384,"planning_belief_set_rate":0.59375,"planning_exact_state_rate":0.59375,"prediction_rmse":24.11767572010949,"reconstruction_rmse":3.3489175829362807,"retention_accuracy":1.0,"training_evaluations":2588672},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":4560,"drift_accuracy":0.0,"expert_count":8,"expert_evaluations":-14336,"planning_belief_set_rate":-0.171875,"planning_exact_state_rate":-0.171875,"prediction_rmse":-1.82879927127372,"reconstruction_rmse":1.2311401532138184,"retention_accuracy":0.0,"training_evaluations":-845768},"pareto_relation":"mixed"},"matched_compute_fixed_topology":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.921875,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":0.375,"planning_exact_state_rate":0.359375,"prediction_rmse":24.864691129143065,"reconstruction_rmse":6.956280175437978,"retention_accuracy":0.91796875,"training_evaluations":1884216},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":4560,"drift_accuracy":0.078125,"expert_count":8,"expert_evaluations":0,"planning_belief_set_rate":0.046875,"planning_exact_state_rate":0.0625,"prediction_rmse":-2.575814680307296,"reconstruction_rmse":-2.3762224392878792,"retention_accuracy":0.08203125,"training_evaluations":-141312},"pareto_relation":"mixed"},"matched_expert_count_capacity":{"metrics":{"checkpoint_size_bytes":47774,"drift_accuracy":1.0,"expert_count":72,"expert_evaluations":2048,"planning_belief_set_rate":0.578125,"planning_exact_state_rate":0.578125,"prediction_rmse":24.373520052050637,"reconstruction_rmse":3.3474175549336884,"retention_accuracy":1.0,"training_evaluations":3207168},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":-0.15625,"planning_exact_state_rate":-0.15625,"prediction_rmse":-2.084643603214868,"reconstruction_rmse":1.2326401812164107,"retention_accuracy":0.0,"training_evaluations":-1464264},"pareto_relation":"mixed"},"nearest_centroid_16_no_recursive_births":{"metrics":{"checkpoint_size_bytes":15854,"drift_accuracy":0.25390625,"expert_count":16,"expert_evaluations":4096,"planning_belief_set_rate":0.578125,"planning_exact_state_rate":0.0625,"prediction_rmse":31.444357145861723,"reconstruction_rmse":22.508802719373563,"retention_accuracy":0.22265625,"training_evaluations":253952},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":31920,"drift_accuracy":0.74609375,"expert_count":56,"expert_evaluations":-2048,"planning_belief_set_rate":-0.15625,"planning_exact_state_rate":0.359375,"prediction_rmse":-9.155480697025954,"reconstruction_rmse":-17.928744983223464,"retention_accuracy":0.77734375,"training_evaluations":1488952},"pareto_relation":"mixed"},"no_adaptation_static":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.921875,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":0.375,"planning_exact_state_rate":0.359375,"prediction_rmse":24.864691129143065,"reconstruction_rmse":6.956280175437978,"retention_accuracy":0.91796875,"training_evaluations":557112},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":4560,"drift_accuracy":0.078125,"expert_count":8,"expert_evaluations":0,"planning_belief_set_rate":0.046875,"planning_exact_state_rate":0.0625,"prediction_rmse":-2.575814680307296,"reconstruction_rmse":-2.3762224392878792,"retention_accuracy":0.08203125,"training_evaluations":1185792},"pareto_relation":"mixed"},"periodic_replay_policy":{"metrics":{"checkpoint_size_bytes":47774,"drift_accuracy":1.0,"expert_count":72,"expert_evaluations":2048,"planning_belief_set_rate":0.4375,"planning_exact_state_rate":0.4375,"prediction_rmse":22.469736072428006,"reconstruction_rmse":4.579615596290478,"retention_accuracy":1.0,"training_evaluations":1742904},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":-0.015625,"planning_exact_state_rate":-0.015625,"prediction_rmse":-0.18085962359223728,"reconstruction_rmse":0.0004421398596212711,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"mixed"},"ravel_0_5_candidate":{"metrics":{"checkpoint_size_bytes":47774,"drift_accuracy":1.0,"expert_count":72,"expert_evaluations":2048,"planning_belief_set_rate":0.421875,"planning_exact_state_rate":0.421875,"prediction_rmse":22.28887644883577,"reconstruction_rmse":4.580057736150099,"retention_accuracy":1.0,"training_evaluations":1742904},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"equivalent"},"ravel_complete_scan_without_certification":{"metrics":{"checkpoint_size_bytes":47774,"drift_accuracy":1.0,"expert_count":72,"expert_evaluations":18432,"planning_belief_set_rate":0.421875,"planning_exact_state_rate":0.421875,"prediction_rmse":22.28887644883577,"reconstruction_rmse":4.580057736150099,"retention_accuracy":1.0,"training_evaluations":1939512},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":-16384,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":-196608},"pareto_relation":"candidate_dominates"},"ravel_no_birth_same_replay_iterations":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.921875,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":0.375,"planning_exact_state_rate":0.359375,"prediction_rmse":24.864691129143065,"reconstruction_rmse":6.956280175437978,"retention_accuracy":0.91796875,"training_evaluations":778296},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":4560,"drift_accuracy":0.078125,"expert_count":8,"expert_evaluations":0,"planning_belief_set_rate":0.046875,"planning_exact_state_rate":0.0625,"prediction_rmse":-2.575814680307296,"reconstruction_rmse":-2.3762224392878792,"retention_accuracy":0.08203125,"training_evaluations":964608},"pareto_relation":"mixed"},"ravel_random_births":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.921875,"expert_count":64,"expert_evaluations":2048,"planning_belief_set_rate":0.375,"planning_exact_state_rate":0.359375,"prediction_rmse":24.864691129143065,"reconstruction_rmse":6.956280175437978,"retention_accuracy":0.91796875,"training_evaluations":778296},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":4560,"drift_accuracy":0.078125,"expert_count":8,"expert_evaluations":0,"planning_belief_set_rate":0.046875,"planning_exact_state_rate":0.0625,"prediction_rmse":-2.575814680307296,"reconstruction_rmse":-2.3762224392878792,"retention_accuracy":0.08203125,"training_evaluations":964608},"pareto_relation":"mixed"},"ravel_without_replay":{"metrics":{"checkpoint_size_bytes":47774,"drift_accuracy":1.0,"expert_count":72,"expert_evaluations":2048,"planning_belief_set_rate":0.421875,"planning_exact_state_rate":0.421875,"prediction_rmse":22.272876015795212,"reconstruction_rmse":4.579986509380832,"retention_accuracy":1.0,"training_evaluations":1347640},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.016000433040556317,"reconstruction_rmse":7.122676926751836e-05,"retention_accuracy":0.0,"training_evaluations":395264},"pareto_relation":"variant_dominates"},"ravel_without_retirement_matched_work":{"metrics":{"checkpoint_size_bytes":47774,"drift_accuracy":1.0,"expert_count":72,"expert_evaluations":2048,"planning_belief_set_rate":0.421875,"planning_exact_state_rate":0.421875,"prediction_rmse":22.28887644883577,"reconstruction_rmse":4.580057736150099,"retention_accuracy":1.0,"training_evaluations":1742904},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"equivalent"}},"gates":[{"gate_id":"adaptation_completed","metric":"adaptation_completed","observed":true,"operator":"eq","pass":true,"rationale":"The bounded adaptation procedure must complete.","threshold":true},{"gate_id":"base_holdout_accuracy","metric":"base_accuracy","observed":0.92578125,"operator":"ge","pass":true,"rationale":"The base representation must establish the bounded task before drift.","threshold":0.85},{"gate_id":"base_holdout_retention","metric":"retention_accuracy","observed":1.0,"operator":"ge","pass":true,"rationale":"Anchored base behavior may lose at most ten percentage points in absolute retained accuracy.","threshold":0.9},{"gate_id":"routing_oracle_equivalence","metric":"routing_mismatches","observed":0,"operator":"eq","pass":true,"rationale":"Every routed classification must agree with complete scan.","threshold":0},{"gate_id":"checkpoint_roundtrip","metric":"checkpoint_roundtrip","observed":true,"operator":"eq","pass":true,"rationale":"Canonical in-memory restoration must succeed.","threshold":true},{"gate_id":"checkpoint_identity","metric":"checkpoint_identity","observed":true,"operator":"eq","pass":true,"rationale":"Restored complete model identity must match.","threshold":true},{"gate_id":"checkpoint_behavior","metric":"checkpoint_behavior","observed":true,"operator":"eq","pass":true,"rationale":"Restored evaluation and planning behavior must match.","threshold":true},{"gate_id":"checkpoint_mutation_rejection","metric":"checkpoint_mutations","observed":true,"operator":"eq","pass":true,"rationale":"Every declared behavioral and byte-level checkpoint mutation must be detected.","threshold":true},{"gate_id":"lineage_invariants","metric":"lineage_invariants","observed":true,"operator":"eq","pass":true,"rationale":"Generation, lineage uniqueness, descendant splitting, and deterministic topology invariants must hold.","threshold":true},{"gate_id":"unsupported_transitions_unknown","metric":"unsupported_graph_edge_violations","observed":0,"operator":"eq","pass":true,"rationale":"Unsupported actions cannot enter the planning graph.","threshold":0},{"gate_id":"replay_size","metric":"replay_selected","observed":256,"operator":"eq","pass":true,"rationale":"The declared replay budget must be filled on the non-sparse trial corpus.","threshold":256},{"gate_id":"replay_unique","metric":"replay_unique","observed":256,"operator":"eq","pass":true,"rationale":"Balanced replay cannot introduce accidental duplicates.","threshold":256},{"gate_id":"replay_label_coverage","metric":"replay_labels_covered","observed":8,"operator":"eq","pass":true,"rationale":"Replay must retain every declared label.","threshold":8},{"gate_id":"replay_action_coverage","metric":"replay_actions_covered","observed":4,"operator":"eq","pass":true,"rationale":"Replay must retain every declared action.","threshold":4},{"gate_id":"replay_state_coverage","metric":"replay_states_covered","observed":64,"operator":"ge","pass":true,"rationale":"Replay must cover at least 60 of 64 source states.","threshold":60},{"gate_id":"replay_expert_coverage","metric":"replay_experts_covered","observed":63,"operator":"ge","pass":true,"rationale":"Replay must retain broad assigned-expert coverage.","threshold":60},{"gate_id":"replay_transition_coverage","metric":"replay_transition_pairs_covered","observed":250,"operator":"ge","pass":true,"rationale":"Replay must preserve broad source-state/action transition support.","threshold":220},{"gate_id":"planning_path_found","metric":"path_found_rate","observed":1.0,"operator":"ge","pass":true,"rationale":"At least three quarters of bounded planning cases must have a supported path.","threshold":0.75},{"gate_id":"expert_capacity","metric":"expert_count","observed":72,"operator":"le","pass":true,"rationale":"Adaptation cannot exceed the declared expert capacity.","threshold":80},{"gate_id":"retirement_budget","metric":"accepted_retirements","observed":0,"operator":"le","pass":true,"rationale":"Retirement remains optional and bounded.","threshold":4},{"gate_id":"topology_objective_non_degradation","metric":"topology_objective_gain_q20","observed":39045,"operator":"ge","pass":true,"rationale":"Accepted adaptation-training topology decisions cannot reduce their declared objective.","threshold":0},{"gate_id":"matched_compute_budget","metric":"matched_compute_training_evaluation_ratio","observed":0.9250022290438039,"operator":"le","pass":true,"rationale":"Candidate training work may exceed the matched fixed-topology budget by at most ten percent.","threshold":1.1},{"gate_id":"conditional_inference_efficiency","metric":"inference_evaluation_ratio_vs_flat64","observed":0.125,"operator":"le","pass":true,"rationale":"Routed inference must use at most one quarter of flat complete-scan expert evaluations.","threshold":0.25},{"gate_id":"transition_classification","metric":"adapted_drift_accuracy","observed":1.0,"operator":"ge","pass":true,"rationale":"Transition correction cannot sacrifice classification.","threshold":0.9},{"gate_id":"transition_prediction_improvement","metric":"prediction_improvement_ratio","observed":0.10359327075204529,"operator":"ge","pass":true,"rationale":"Changed transitions require at least one percent relative prediction improvement.","threshold":0.01},{"gate_id":"transition_accuracy_non_inferiority","metric":"transition_accuracy_delta","observed":0.04768928220255653,"operator":"ge","pass":true,"rationale":"Supported transition accuracy cannot lose more than five points.","threshold":-0.05},{"gate_id":"old_prediction_retention","metric":"retention_prediction_degradation","observed":1.2630735338642944,"operator":"le","pass":false,"rationale":"Original-task prediction RMSE may rise by at most one observation unit.","threshold":1},{"gate_id":"old_transition_retention","metric":"retention_transition_accuracy_delta","observed":-0.011959883775424118,"operator":"ge","pass":true,"rationale":"Original supported transition accuracy may fall by at most ten points.","threshold":-0.1},{"gate_id":"transition_exact_planning","metric":"exact_state_rate","observed":0.421875,"operator":"ge","pass":true,"rationale":"Transition drift retains a bounded exact-state planning floor.","threshold":0.25},{"gate_id":"transition_planning_non_inferiority","metric":"exact_state_rate_delta","observed":0.0625,"operator":"ge","pass":true,"rationale":"Adaptation cannot materially reduce exact planning relative to static.","threshold":-0.05}],"metrics":{"accepted_births":8,"accepted_retirements":0,"adaptation_completed":true,"adaptation_training_accuracy":1.0,"adapted_drift_accuracy":1.0,"adapted_prediction_rmse":22.28887644883577,"adapted_reconstruction_rmse":4.580057736150099,"adapted_transition_accuracy":0.7699115044247787,"balanced_vs_periodic_drift_accuracy_delta":0.0,"balanced_vs_periodic_retention_delta":0.0,"base_accuracy":0.92578125,"base_prediction_rmse":7.498560640318154,"base_reconstruction_rmse":6.656422567796004,"belief_set_rate":0.421875,"belief_set_rate_delta":0.046875,"checkpoint_behavior":true,"checkpoint_identity":true,"checkpoint_mutations":true,"checkpoint_roundtrip":true,"checkpoint_size_bytes":47774,"drift_accuracy_delta":0.078125,"exact_state_rate":0.421875,"exact_state_rate_delta":0.0625,"expert_count":72,"headroom_normalized_accuracy_improvement":1.0,"inference_evaluation_ratio_vs_flat64":0.125,"inference_expert_evaluations":2048,"lineage_invariants":true,"matched_compute_drift_accuracy_delta":0.078125,"matched_compute_retention_delta":0.08203125,"matched_compute_training_evaluation_ratio":0.9250022290438039,"no_birth_drift_accuracy_delta":0.078125,"no_retirement_drift_accuracy_delta":0.0,"path_found_rate":1.0,"prediction_improvement_ratio":0.10359327075204529,"reconstruction_improvement_ratio":0.34159383741875643,"replay_actions_covered":4,"replay_experts_covered":63,"replay_labels_covered":8,"replay_selected":256,"replay_states_covered":64,"replay_transition_pairs_covered":250,"replay_unique":256,"retention_accuracy":1.0,"retention_accuracy_delta_from_base":0.07421875,"retention_prediction_degradation":1.2630735338642944,"retention_prediction_rmse":8.761634174182449,"retention_reconstruction_degradation_ratio":-0.35896322615963316,"retention_reconstruction_rmse":4.267011648178161,"retention_transition_accuracy_delta":-0.011959883775424118,"routing_mismatches":0,"static_belief_set_rate":0.375,"static_drift_accuracy":0.921875,"static_exact_state_rate":0.359375,"static_prediction_rmse":24.864691129143065,"static_reconstruction_rmse":6.956280175437978,"static_transition_accuracy":0.7222222222222222,"topology_objective_gain_q20":39045,"training_evaluations":1742904,"transition_accuracy_delta":0.04768928220255653,"transition_support_rate":0.8828125,"unsupported_graph_edge_violations":0},"regime":"transition_drift","seed":"0xe8f0f59872923c4c","trial_id":"validation-transition-04","trial_result":"FAIL"},{"comparisons":{"fixed_8_expert":{"metrics":{"checkpoint_size_bytes":11294,"drift_accuracy":0.15234375,"expert_count":8,"expert_evaluations":2048,"planning_belief_set_rate":0.4375,"planning_exact_state_rate":0.0625,"prediction_rmse":26.570096989393203,"reconstruction_rmse":24.725618483549734,"retention_accuracy":0.14453125,"training_evaluations":94208},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":41040,"drift_accuracy":0.625,"expert_count":72,"expert_evaluations":864,"planning_belief_set_rate":0.296875,"planning_exact_state_rate":0.671875,"prediction_rmse":-17.926906087787316,"reconstruction_rmse":-16.873950624239743,"retention_accuracy":0.82421875,"training_evaluations":2699692},"pareto_relation":"mixed"},"fixed_topology_64_expert_routed":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.66015625,"expert_count":64,"expert_evaluations":2552,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":8.570844935854353,"reconstruction_rmse":8.172889535919182,"retention_accuracy":1.0,"training_evaluations":2588672},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":9120,"drift_accuracy":0.1171875,"expert_count":16,"expert_evaluations":360,"planning_belief_set_rate":-0.265625,"planning_exact_state_rate":-0.265625,"prediction_rmse":0.0723459657515324,"reconstruction_rmse":-0.3212216766091913,"retention_accuracy":-0.03125,"training_evaluations":205228},"pareto_relation":"mixed"},"flat_64_expert_complete_scan":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.66015625,"expert_count":64,"expert_evaluations":16384,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":8.570844935854353,"reconstruction_rmse":8.172889535919182,"retention_accuracy":1.0,"training_evaluations":2588672},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":9120,"drift_accuracy":0.1171875,"expert_count":16,"expert_evaluations":-13472,"planning_belief_set_rate":-0.265625,"planning_exact_state_rate":-0.265625,"prediction_rmse":0.0723459657515324,"reconstruction_rmse":-0.3212216766091913,"retention_accuracy":-0.03125,"training_evaluations":205228},"pareto_relation":"mixed"},"matched_compute_fixed_topology":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.61328125,"expert_count":64,"expert_evaluations":3112,"planning_belief_set_rate":0.609375,"planning_exact_state_rate":0.5625,"prediction_rmse":9.981291800979045,"reconstruction_rmse":8.99535353167555,"retention_accuracy":0.953125,"training_evaluations":2685304},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":9120,"drift_accuracy":0.1640625,"expert_count":16,"expert_evaluations":-200,"planning_belief_set_rate":0.125,"planning_exact_state_rate":0.171875,"prediction_rmse":-1.3381008993731598,"reconstruction_rmse":-1.1436856723655584,"retention_accuracy":0.015625,"training_evaluations":108596},"pareto_relation":"mixed"},"matched_expert_count_capacity":{"metrics":{"checkpoint_size_bytes":52334,"drift_accuracy":0.66015625,"expert_count":80,"expert_evaluations":3344,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":8.587198905301523,"reconstruction_rmse":8.10682594346399,"retention_accuracy":1.0,"training_evaluations":3891200},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.1171875,"expert_count":0,"expert_evaluations":-432,"planning_belief_set_rate":-0.265625,"planning_exact_state_rate":-0.265625,"prediction_rmse":0.055991996304362246,"reconstruction_rmse":-0.2551580841539991,"retention_accuracy":-0.03125,"training_evaluations":-1097300},"pareto_relation":"mixed"},"nearest_centroid_16_no_recursive_births":{"metrics":{"checkpoint_size_bytes":15854,"drift_accuracy":0.1796875,"expert_count":16,"expert_evaluations":4096,"planning_belief_set_rate":0.71875,"planning_exact_state_rate":0.15625,"prediction_rmse":20.629138907196598,"reconstruction_rmse":19.931143212174394,"retention_accuracy":0.21484375,"training_evaluations":253952},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":36480,"drift_accuracy":0.59765625,"expert_count":64,"expert_evaluations":-1184,"planning_belief_set_rate":0.015625,"planning_exact_state_rate":0.578125,"prediction_rmse":-11.985948005590712,"reconstruction_rmse":-12.079475352864403,"retention_accuracy":0.75390625,"training_evaluations":2539948},"pareto_relation":"mixed"},"no_adaptation_static":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.61328125,"expert_count":64,"expert_evaluations":3112,"planning_belief_set_rate":0.609375,"planning_exact_state_rate":0.5625,"prediction_rmse":9.981291800979045,"reconstruction_rmse":8.99535353167555,"retention_accuracy":0.953125,"training_evaluations":577720},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":9120,"drift_accuracy":0.1640625,"expert_count":16,"expert_evaluations":-200,"planning_belief_set_rate":0.125,"planning_exact_state_rate":0.171875,"prediction_rmse":-1.3381008993731598,"reconstruction_rmse":-1.1436856723655584,"retention_accuracy":0.015625,"training_evaluations":2216180},"pareto_relation":"mixed"},"periodic_replay_policy":{"metrics":{"checkpoint_size_bytes":52334,"drift_accuracy":0.77734375,"expert_count":80,"expert_evaluations":2912,"planning_belief_set_rate":0.734375,"planning_exact_state_rate":0.734375,"prediction_rmse":8.66571385998563,"reconstruction_rmse":7.857543614269616,"retention_accuracy":0.96875,"training_evaluations":2522178},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":-0.02252295837974394,"reconstruction_rmse":-0.005875754959625112,"retention_accuracy":0.0,"training_evaluations":271722},"pareto_relation":"mixed"},"ravel_0_5_candidate":{"metrics":{"checkpoint_size_bytes":52334,"drift_accuracy":0.77734375,"expert_count":80,"expert_evaluations":2912,"planning_belief_set_rate":0.734375,"planning_exact_state_rate":0.734375,"prediction_rmse":8.643190901605886,"reconstruction_rmse":7.851667859309991,"retention_accuracy":0.96875,"training_evaluations":2793900},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"equivalent"},"ravel_complete_scan_without_certification":{"metrics":{"checkpoint_size_bytes":52334,"drift_accuracy":0.77734375,"expert_count":80,"expert_evaluations":20480,"planning_belief_set_rate":0.734375,"planning_exact_state_rate":0.734375,"prediction_rmse":8.643190901605886,"reconstruction_rmse":7.851667859309991,"retention_accuracy":0.96875,"training_evaluations":3007596},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":-17568,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":-213696},"pareto_relation":"candidate_dominates"},"ravel_no_birth_same_replay_iterations":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.61328125,"expert_count":64,"expert_evaluations":3112,"planning_belief_set_rate":0.609375,"planning_exact_state_rate":0.5625,"prediction_rmse":9.981291800979045,"reconstruction_rmse":8.99535353167555,"retention_accuracy":0.953125,"training_evaluations":811896},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":9120,"drift_accuracy":0.1640625,"expert_count":16,"expert_evaluations":-200,"planning_belief_set_rate":0.125,"planning_exact_state_rate":0.171875,"prediction_rmse":-1.3381008993731598,"reconstruction_rmse":-1.1436856723655584,"retention_accuracy":0.015625,"training_evaluations":1982004},"pareto_relation":"mixed"},"ravel_random_births":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.61328125,"expert_count":64,"expert_evaluations":3112,"planning_belief_set_rate":0.609375,"planning_exact_state_rate":0.5625,"prediction_rmse":9.981291800979045,"reconstruction_rmse":8.99535353167555,"retention_accuracy":0.953125,"training_evaluations":811896},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":9120,"drift_accuracy":0.1640625,"expert_count":16,"expert_evaluations":-200,"planning_belief_set_rate":0.125,"planning_exact_state_rate":0.171875,"prediction_rmse":-1.3381008993731598,"reconstruction_rmse":-1.1436856723655584,"retention_accuracy":0.015625,"training_evaluations":1982004},"pareto_relation":"mixed"},"ravel_without_replay":{"metrics":{"checkpoint_size_bytes":52334,"drift_accuracy":0.77734375,"expert_count":80,"expert_evaluations":2912,"planning_belief_set_rate":0.734375,"planning_exact_state_rate":0.734375,"prediction_rmse":8.671406604722014,"reconstruction_rmse":7.866164230732507,"retention_accuracy":0.97265625,"training_evaluations":1987400},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":-0.02821570311612831,"reconstruction_rmse":-0.014496371422516141,"retention_accuracy":-0.00390625,"training_evaluations":806500},"pareto_relation":"mixed"},"ravel_without_retirement_matched_work":{"metrics":{"checkpoint_size_bytes":52334,"drift_accuracy":0.77734375,"expert_count":80,"expert_evaluations":2912,"planning_belief_set_rate":0.734375,"planning_exact_state_rate":0.734375,"prediction_rmse":8.643190901605886,"reconstruction_rmse":7.851667859309991,"retention_accuracy":0.96875,"training_evaluations":2793900},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"equivalent"}},"gates":[{"gate_id":"adaptation_completed","metric":"adaptation_completed","observed":true,"operator":"eq","pass":true,"rationale":"The bounded adaptation procedure must complete.","threshold":true},{"gate_id":"base_holdout_accuracy","metric":"base_accuracy","observed":0.94921875,"operator":"ge","pass":true,"rationale":"The base representation must establish the bounded task before drift.","threshold":0.85},{"gate_id":"base_holdout_retention","metric":"retention_accuracy","observed":0.96875,"operator":"ge","pass":true,"rationale":"Anchored base behavior may lose at most ten percentage points in absolute retained accuracy.","threshold":0.9},{"gate_id":"routing_oracle_equivalence","metric":"routing_mismatches","observed":0,"operator":"eq","pass":true,"rationale":"Every routed classification must agree with complete scan.","threshold":0},{"gate_id":"checkpoint_roundtrip","metric":"checkpoint_roundtrip","observed":true,"operator":"eq","pass":true,"rationale":"Canonical in-memory restoration must succeed.","threshold":true},{"gate_id":"checkpoint_identity","metric":"checkpoint_identity","observed":true,"operator":"eq","pass":true,"rationale":"Restored complete model identity must match.","threshold":true},{"gate_id":"checkpoint_behavior","metric":"checkpoint_behavior","observed":true,"operator":"eq","pass":true,"rationale":"Restored evaluation and planning behavior must match.","threshold":true},{"gate_id":"checkpoint_mutation_rejection","metric":"checkpoint_mutations","observed":true,"operator":"eq","pass":true,"rationale":"Every declared behavioral and byte-level checkpoint mutation must be detected.","threshold":true},{"gate_id":"lineage_invariants","metric":"lineage_invariants","observed":true,"operator":"eq","pass":true,"rationale":"Generation, lineage uniqueness, descendant splitting, and deterministic topology invariants must hold.","threshold":true},{"gate_id":"unsupported_transitions_unknown","metric":"unsupported_graph_edge_violations","observed":0,"operator":"eq","pass":true,"rationale":"Unsupported actions cannot enter the planning graph.","threshold":0},{"gate_id":"replay_size","metric":"replay_selected","observed":256,"operator":"eq","pass":true,"rationale":"The declared replay budget must be filled on the non-sparse trial corpus.","threshold":256},{"gate_id":"replay_unique","metric":"replay_unique","observed":256,"operator":"eq","pass":true,"rationale":"Balanced replay cannot introduce accidental duplicates.","threshold":256},{"gate_id":"replay_label_coverage","metric":"replay_labels_covered","observed":8,"operator":"eq","pass":true,"rationale":"Replay must retain every declared label.","threshold":8},{"gate_id":"replay_action_coverage","metric":"replay_actions_covered","observed":4,"operator":"eq","pass":true,"rationale":"Replay must retain every declared action.","threshold":4},{"gate_id":"replay_state_coverage","metric":"replay_states_covered","observed":64,"operator":"ge","pass":true,"rationale":"Replay must cover at least 60 of 64 source states.","threshold":60},{"gate_id":"replay_expert_coverage","metric":"replay_experts_covered","observed":62,"operator":"ge","pass":true,"rationale":"Replay must retain broad assigned-expert coverage.","threshold":60},{"gate_id":"replay_transition_coverage","metric":"replay_transition_pairs_covered","observed":255,"operator":"ge","pass":true,"rationale":"Replay must preserve broad source-state/action transition support.","threshold":220},{"gate_id":"planning_path_found","metric":"path_found_rate","observed":0.9375,"operator":"ge","pass":true,"rationale":"At least three quarters of bounded planning cases must have a supported path.","threshold":0.75},{"gate_id":"expert_capacity","metric":"expert_count","observed":80,"operator":"le","pass":true,"rationale":"Adaptation cannot exceed the declared expert capacity.","threshold":80},{"gate_id":"retirement_budget","metric":"accepted_retirements","observed":0,"operator":"le","pass":true,"rationale":"Retirement remains optional and bounded.","threshold":4},{"gate_id":"topology_objective_non_degradation","metric":"topology_objective_gain_q20","observed":49288,"operator":"ge","pass":true,"rationale":"Accepted adaptation-training topology decisions cannot reduce their declared objective.","threshold":0},{"gate_id":"matched_compute_budget","metric":"matched_compute_training_evaluation_ratio","observed":1.0404408588375842,"operator":"le","pass":true,"rationale":"Candidate training work may exceed the matched fixed-topology budget by at most ten percent.","threshold":1.1},{"gate_id":"conditional_inference_efficiency","metric":"inference_evaluation_ratio_vs_flat64","observed":0.177734375,"operator":"le","pass":true,"rationale":"Routed inference must use at most one quarter of flat complete-scan expert evaluations.","threshold":0.25},{"gate_id":"combined_adaptation","metric":"adapted_drift_accuracy","observed":0.77734375,"operator":"ge","pass":true,"rationale":"Combined drift requires useful untouched-holdout classification.","threshold":0.65},{"gate_id":"combined_gain","metric":"drift_accuracy_delta","observed":0.1640625,"operator":"ge","pass":true,"rationale":"Combined drift requires a meaningful absolute adaptation gain.","threshold":0.05},{"gate_id":"combined_reconstruction","metric":"reconstruction_improvement_ratio","observed":0.12714182587024192,"operator":"ge","pass":true,"rationale":"Observation correction cannot be averaged away by label gain.","threshold":0},{"gate_id":"combined_prediction","metric":"prediction_improvement_ratio","observed":0.13406089372539015,"operator":"ge","pass":true,"rationale":"Prediction correction cannot be averaged away by classification gain.","threshold":0},{"gate_id":"combined_transition_non_inferiority","metric":"transition_accuracy_delta","observed":-0.0753603088629421,"operator":"ge","pass":true,"rationale":"Combined behavior permits bounded transition variance but not collapse.","threshold":-0.15},{"gate_id":"combined_reconstruction_retention","metric":"retention_reconstruction_degradation_ratio","observed":-0.13168337973832175,"operator":"le","pass":true,"rationale":"Original-task reconstruction cannot materially degrade.","threshold":0.1},{"gate_id":"combined_prediction_retention","metric":"retention_prediction_degradation","observed":-1.2125183142490412,"operator":"le","pass":true,"rationale":"Original-task prediction cannot materially degrade.","threshold":1},{"gate_id":"combined_exact_planning","metric":"exact_state_rate","observed":0.734375,"operator":"ge","pass":true,"rationale":"The combined regime remains fully observed and gates exact planning.","threshold":0.5}],"metrics":{"accepted_births":16,"accepted_retirements":0,"adaptation_completed":true,"adaptation_training_accuracy":0.79296875,"adapted_drift_accuracy":0.77734375,"adapted_prediction_rmse":8.643190901605886,"adapted_reconstruction_rmse":7.851667859309991,"adapted_transition_accuracy":0.8602620087336245,"balanced_vs_periodic_drift_accuracy_delta":0.0,"balanced_vs_periodic_retention_delta":0.0,"base_accuracy":0.94921875,"base_prediction_rmse":6.887331862989348,"base_reconstruction_rmse":5.916615736276692,"belief_set_rate":0.734375,"belief_set_rate_delta":0.125,"checkpoint_behavior":true,"checkpoint_identity":true,"checkpoint_mutations":true,"checkpoint_roundtrip":true,"checkpoint_size_bytes":52334,"drift_accuracy_delta":0.1640625,"exact_state_rate":0.734375,"exact_state_rate_delta":0.171875,"expert_count":80,"headroom_normalized_accuracy_improvement":0.42424242424242425,"inference_evaluation_ratio_vs_flat64":0.177734375,"inference_expert_evaluations":2912,"lineage_invariants":true,"matched_compute_drift_accuracy_delta":0.1640625,"matched_compute_retention_delta":0.015625,"matched_compute_training_evaluation_ratio":1.0404408588375842,"no_birth_drift_accuracy_delta":0.1640625,"no_retirement_drift_accuracy_delta":0.0,"path_found_rate":0.9375,"prediction_improvement_ratio":0.13406089372539015,"reconstruction_improvement_ratio":0.12714182587024192,"replay_actions_covered":4,"replay_experts_covered":62,"replay_labels_covered":8,"replay_selected":256,"replay_states_covered":64,"replay_transition_pairs_covered":255,"replay_unique":256,"retention_accuracy":0.96875,"retention_accuracy_delta_from_base":0.01953125,"retention_prediction_degradation":-1.2125183142490412,"retention_prediction_rmse":5.674813548740307,"retention_reconstruction_degradation_ratio":-0.13168337973832175,"retention_reconstruction_rmse":5.1374957795108385,"retention_transition_accuracy_delta":0.007400555041628065,"routing_mismatches":0,"static_belief_set_rate":0.609375,"static_drift_accuracy":0.61328125,"static_exact_state_rate":0.5625,"static_prediction_rmse":9.981291800979045,"static_reconstruction_rmse":8.99535353167555,"static_transition_accuracy":0.9356223175965666,"topology_objective_gain_q20":49288,"training_evaluations":2793900,"transition_accuracy_delta":-0.0753603088629421,"transition_support_rate":0.89453125,"unsupported_graph_edge_violations":0},"regime":"combined_observation_and_label_drift","seed":"0x979e1c635f578971","trial_id":"validation-combined-01","trial_result":"PASS"},{"comparisons":{"fixed_8_expert":{"metrics":{"checkpoint_size_bytes":11294,"drift_accuracy":0.1484375,"expert_count":8,"expert_evaluations":2048,"planning_belief_set_rate":0.390625,"planning_exact_state_rate":0.0625,"prediction_rmse":25.149699631798196,"reconstruction_rmse":24.00984107120247,"retention_accuracy":0.23828125,"training_evaluations":94208},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":41040,"drift_accuracy":0.6015625,"expert_count":72,"expert_evaluations":1728,"planning_belief_set_rate":0.078125,"planning_exact_state_rate":0.40625,"prediction_rmse":-15.528029068562505,"reconstruction_rmse":-15.54843420504621,"retention_accuracy":0.69140625,"training_evaluations":2516674},"pareto_relation":"mixed"},"fixed_topology_64_expert_routed":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.65625,"expert_count":64,"expert_evaluations":2888,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":8.430426163382759,"reconstruction_rmse":8.184493429358577,"retention_accuracy":1.0,"training_evaluations":2588672},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":9120,"drift_accuracy":0.09375,"expert_count":16,"expert_evaluations":888,"planning_belief_set_rate":-0.53125,"planning_exact_state_rate":-0.53125,"prediction_rmse":1.1912443998529323,"reconstruction_rmse":0.2769134367976829,"retention_accuracy":-0.0703125,"training_evaluations":22210},"pareto_relation":"mixed"},"flat_64_expert_complete_scan":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.65625,"expert_count":64,"expert_evaluations":16384,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":8.430426163382759,"reconstruction_rmse":8.184493429358577,"retention_accuracy":1.0,"training_evaluations":2588672},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":9120,"drift_accuracy":0.09375,"expert_count":16,"expert_evaluations":-12608,"planning_belief_set_rate":-0.53125,"planning_exact_state_rate":-0.53125,"prediction_rmse":1.1912443998529323,"reconstruction_rmse":0.2769134367976829,"retention_accuracy":-0.0703125,"training_evaluations":22210},"pareto_relation":"mixed"},"matched_compute_fixed_topology":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.5625,"expert_count":64,"expert_evaluations":4400,"planning_belief_set_rate":0.515625,"planning_exact_state_rate":0.4375,"prediction_rmse":11.422767564447971,"reconstruction_rmse":10.132355988059158,"retention_accuracy":0.8828125,"training_evaluations":2786744},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":9120,"drift_accuracy":0.1875,"expert_count":16,"expert_evaluations":-624,"planning_belief_set_rate":-0.046875,"planning_exact_state_rate":0.03125,"prediction_rmse":-1.8010970012122804,"reconstruction_rmse":-1.6709491219028987,"retention_accuracy":0.046875,"training_evaluations":-175862},"pareto_relation":"mixed"},"matched_expert_count_capacity":{"metrics":{"checkpoint_size_bytes":52334,"drift_accuracy":0.65625,"expert_count":80,"expert_evaluations":3416,"planning_belief_set_rate":0.953125,"planning_exact_state_rate":0.953125,"prediction_rmse":8.427423179541892,"reconstruction_rmse":8.129483832544114,"retention_accuracy":1.0,"training_evaluations":3891200},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.09375,"expert_count":0,"expert_evaluations":360,"planning_belief_set_rate":-0.484375,"planning_exact_state_rate":-0.484375,"prediction_rmse":1.1942473836937992,"reconstruction_rmse":0.3319230336121457,"retention_accuracy":-0.0703125,"training_evaluations":-1280318},"pareto_relation":"mixed"},"nearest_centroid_16_no_recursive_births":{"metrics":{"checkpoint_size_bytes":15854,"drift_accuracy":0.1484375,"expert_count":16,"expert_evaluations":4096,"planning_belief_set_rate":0.546875,"planning_exact_state_rate":0.09375,"prediction_rmse":22.460378609472926,"reconstruction_rmse":20.238824326010928,"retention_accuracy":0.3671875,"training_evaluations":253952},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":36480,"drift_accuracy":0.6015625,"expert_count":64,"expert_evaluations":-320,"planning_belief_set_rate":-0.078125,"planning_exact_state_rate":0.375,"prediction_rmse":-12.838708046237235,"reconstruction_rmse":-11.777417459854668,"retention_accuracy":0.5625,"training_evaluations":2356930},"pareto_relation":"mixed"},"no_adaptation_static":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.5625,"expert_count":64,"expert_evaluations":4400,"planning_belief_set_rate":0.515625,"planning_exact_state_rate":0.4375,"prediction_rmse":11.422767564447971,"reconstruction_rmse":10.132355988059158,"retention_accuracy":0.8828125,"training_evaluations":578360},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":9120,"drift_accuracy":0.1875,"expert_count":16,"expert_evaluations":-624,"planning_belief_set_rate":-0.046875,"planning_exact_state_rate":0.03125,"prediction_rmse":-1.8010970012122804,"reconstruction_rmse":-1.6709491219028987,"retention_accuracy":0.046875,"training_evaluations":2032522},"pareto_relation":"mixed"},"periodic_replay_policy":{"metrics":{"checkpoint_size_bytes":52334,"drift_accuracy":0.75,"expert_count":80,"expert_evaluations":3776,"planning_belief_set_rate":0.484375,"planning_exact_state_rate":0.484375,"prediction_rmse":9.661461206170733,"reconstruction_rmse":8.464455586989176,"retention_accuracy":0.9296875,"training_evaluations":2590469},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":-0.015625,"planning_exact_state_rate":-0.015625,"prediction_rmse":-0.039790642935042086,"reconstruction_rmse":-0.0030487208329166293,"retention_accuracy":0.0,"training_evaluations":20413},"pareto_relation":"mixed"},"ravel_0_5_candidate":{"metrics":{"checkpoint_size_bytes":52334,"drift_accuracy":0.75,"expert_count":80,"expert_evaluations":3776,"planning_belief_set_rate":0.46875,"planning_exact_state_rate":0.46875,"prediction_rmse":9.621670563235691,"reconstruction_rmse":8.46140686615626,"retention_accuracy":0.9296875,"training_evaluations":2610882},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"equivalent"},"ravel_complete_scan_without_certification":{"metrics":{"checkpoint_size_bytes":52334,"drift_accuracy":0.75,"expert_count":80,"expert_evaluations":20480,"planning_belief_set_rate":0.46875,"planning_exact_state_rate":0.46875,"prediction_rmse":9.621670563235691,"reconstruction_rmse":8.46140686615626,"retention_accuracy":0.9296875,"training_evaluations":2816514},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":-16704,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":-205632},"pareto_relation":"candidate_dominates"},"ravel_no_birth_same_replay_iterations":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.5625,"expert_count":64,"expert_evaluations":4400,"planning_belief_set_rate":0.515625,"planning_exact_state_rate":0.4375,"prediction_rmse":11.422767564447971,"reconstruction_rmse":10.132355988059158,"retention_accuracy":0.8828125,"training_evaluations":823736},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":9120,"drift_accuracy":0.1875,"expert_count":16,"expert_evaluations":-624,"planning_belief_set_rate":-0.046875,"planning_exact_state_rate":0.03125,"prediction_rmse":-1.8010970012122804,"reconstruction_rmse":-1.6709491219028987,"retention_accuracy":0.046875,"training_evaluations":1787146},"pareto_relation":"mixed"},"ravel_random_births":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.5625,"expert_count":64,"expert_evaluations":4400,"planning_belief_set_rate":0.515625,"planning_exact_state_rate":0.4375,"prediction_rmse":11.422767564447971,"reconstruction_rmse":10.132355988059158,"retention_accuracy":0.8828125,"training_evaluations":823736},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":9120,"drift_accuracy":0.1875,"expert_count":16,"expert_evaluations":-624,"planning_belief_set_rate":-0.046875,"planning_exact_state_rate":0.03125,"prediction_rmse":-1.8010970012122804,"reconstruction_rmse":-1.6709491219028987,"retention_accuracy":0.046875,"training_evaluations":1787146},"pareto_relation":"mixed"},"ravel_without_replay":{"metrics":{"checkpoint_size_bytes":52334,"drift_accuracy":0.75,"expert_count":80,"expert_evaluations":3776,"planning_belief_set_rate":0.453125,"planning_exact_state_rate":0.453125,"prediction_rmse":9.734304491932804,"reconstruction_rmse":8.461677717654716,"retention_accuracy":0.9375,"training_evaluations":2232377},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.015625,"planning_exact_state_rate":0.015625,"prediction_rmse":-0.11263392869711275,"reconstruction_rmse":-0.0002708514984561816,"retention_accuracy":-0.0078125,"training_evaluations":378505},"pareto_relation":"mixed"},"ravel_without_retirement_matched_work":{"metrics":{"checkpoint_size_bytes":52334,"drift_accuracy":0.75,"expert_count":80,"expert_evaluations":3776,"planning_belief_set_rate":0.46875,"planning_exact_state_rate":0.46875,"prediction_rmse":9.621670563235691,"reconstruction_rmse":8.46140686615626,"retention_accuracy":0.9296875,"training_evaluations":2610882},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"equivalent"}},"gates":[{"gate_id":"adaptation_completed","metric":"adaptation_completed","observed":true,"operator":"eq","pass":true,"rationale":"The bounded adaptation procedure must complete.","threshold":true},{"gate_id":"base_holdout_accuracy","metric":"base_accuracy","observed":0.859375,"operator":"ge","pass":true,"rationale":"The base representation must establish the bounded task before drift.","threshold":0.85},{"gate_id":"base_holdout_retention","metric":"retention_accuracy","observed":0.9296875,"operator":"ge","pass":true,"rationale":"Anchored base behavior may lose at most ten percentage points in absolute retained accuracy.","threshold":0.9},{"gate_id":"routing_oracle_equivalence","metric":"routing_mismatches","observed":0,"operator":"eq","pass":true,"rationale":"Every routed classification must agree with complete scan.","threshold":0},{"gate_id":"checkpoint_roundtrip","metric":"checkpoint_roundtrip","observed":true,"operator":"eq","pass":true,"rationale":"Canonical in-memory restoration must succeed.","threshold":true},{"gate_id":"checkpoint_identity","metric":"checkpoint_identity","observed":true,"operator":"eq","pass":true,"rationale":"Restored complete model identity must match.","threshold":true},{"gate_id":"checkpoint_behavior","metric":"checkpoint_behavior","observed":true,"operator":"eq","pass":true,"rationale":"Restored evaluation and planning behavior must match.","threshold":true},{"gate_id":"checkpoint_mutation_rejection","metric":"checkpoint_mutations","observed":true,"operator":"eq","pass":true,"rationale":"Every declared behavioral and byte-level checkpoint mutation must be detected.","threshold":true},{"gate_id":"lineage_invariants","metric":"lineage_invariants","observed":true,"operator":"eq","pass":true,"rationale":"Generation, lineage uniqueness, descendant splitting, and deterministic topology invariants must hold.","threshold":true},{"gate_id":"unsupported_transitions_unknown","metric":"unsupported_graph_edge_violations","observed":0,"operator":"eq","pass":true,"rationale":"Unsupported actions cannot enter the planning graph.","threshold":0},{"gate_id":"replay_size","metric":"replay_selected","observed":256,"operator":"eq","pass":true,"rationale":"The declared replay budget must be filled on the non-sparse trial corpus.","threshold":256},{"gate_id":"replay_unique","metric":"replay_unique","observed":256,"operator":"eq","pass":true,"rationale":"Balanced replay cannot introduce accidental duplicates.","threshold":256},{"gate_id":"replay_label_coverage","metric":"replay_labels_covered","observed":8,"operator":"eq","pass":true,"rationale":"Replay must retain every declared label.","threshold":8},{"gate_id":"replay_action_coverage","metric":"replay_actions_covered","observed":4,"operator":"eq","pass":true,"rationale":"Replay must retain every declared action.","threshold":4},{"gate_id":"replay_state_coverage","metric":"replay_states_covered","observed":64,"operator":"ge","pass":true,"rationale":"Replay must cover at least 60 of 64 source states.","threshold":60},{"gate_id":"replay_expert_coverage","metric":"replay_experts_covered","observed":62,"operator":"ge","pass":true,"rationale":"Replay must retain broad assigned-expert coverage.","threshold":60},{"gate_id":"replay_transition_coverage","metric":"replay_transition_pairs_covered","observed":250,"operator":"ge","pass":true,"rationale":"Replay must preserve broad source-state/action transition support.","threshold":220},{"gate_id":"planning_path_found","metric":"path_found_rate","observed":0.84375,"operator":"ge","pass":true,"rationale":"At least three quarters of bounded planning cases must have a supported path.","threshold":0.75},{"gate_id":"expert_capacity","metric":"expert_count","observed":80,"operator":"le","pass":true,"rationale":"Adaptation cannot exceed the declared expert capacity.","threshold":80},{"gate_id":"retirement_budget","metric":"accepted_retirements","observed":0,"operator":"le","pass":true,"rationale":"Retirement remains optional and bounded.","threshold":4},{"gate_id":"topology_objective_non_degradation","metric":"topology_objective_gain_q20","observed":56718,"operator":"ge","pass":true,"rationale":"Accepted adaptation-training topology decisions cannot reduce their declared objective.","threshold":0},{"gate_id":"matched_compute_budget","metric":"matched_compute_training_evaluation_ratio","observed":0.936893378078503,"operator":"le","pass":true,"rationale":"Candidate training work may exceed the matched fixed-topology budget by at most ten percent.","threshold":1.1},{"gate_id":"conditional_inference_efficiency","metric":"inference_evaluation_ratio_vs_flat64","observed":0.23046875,"operator":"le","pass":true,"rationale":"Routed inference must use at most one quarter of flat complete-scan expert evaluations.","threshold":0.25},{"gate_id":"combined_adaptation","metric":"adapted_drift_accuracy","observed":0.75,"operator":"ge","pass":true,"rationale":"Combined drift requires useful untouched-holdout classification.","threshold":0.65},{"gate_id":"combined_gain","metric":"drift_accuracy_delta","observed":0.1875,"operator":"ge","pass":true,"rationale":"Combined drift requires a meaningful absolute adaptation gain.","threshold":0.05},{"gate_id":"combined_reconstruction","metric":"reconstruction_improvement_ratio","observed":0.1649122004667117,"operator":"ge","pass":true,"rationale":"Observation correction cannot be averaged away by label gain.","threshold":0},{"gate_id":"combined_prediction","metric":"prediction_improvement_ratio","observed":0.15767606151927527,"operator":"ge","pass":true,"rationale":"Prediction correction cannot be averaged away by classification gain.","threshold":0},{"gate_id":"combined_transition_non_inferiority","metric":"transition_accuracy_delta","observed":0.013984018264840192,"operator":"ge","pass":true,"rationale":"Combined behavior permits bounded transition variance but not collapse.","threshold":-0.15},{"gate_id":"combined_reconstruction_retention","metric":"retention_reconstruction_degradation_ratio","observed":-0.21081025960831043,"operator":"le","pass":true,"rationale":"Original-task reconstruction cannot materially degrade.","threshold":0.1},{"gate_id":"combined_prediction_retention","metric":"retention_prediction_degradation","observed":-1.832572941719743,"operator":"le","pass":true,"rationale":"Original-task prediction cannot materially degrade.","threshold":1},{"gate_id":"combined_exact_planning","metric":"exact_state_rate","observed":0.46875,"operator":"ge","pass":false,"rationale":"The combined regime remains fully observed and gates exact planning.","threshold":0.5}],"metrics":{"accepted_births":16,"accepted_retirements":0,"adaptation_completed":true,"adaptation_training_accuracy":0.744140625,"adapted_drift_accuracy":0.75,"adapted_prediction_rmse":9.621670563235691,"adapted_reconstruction_rmse":8.46140686615626,"adapted_transition_accuracy":0.8264840182648402,"balanced_vs_periodic_drift_accuracy_delta":0.0,"balanced_vs_periodic_retention_delta":0.0,"base_accuracy":0.859375,"base_prediction_rmse":8.918845631271548,"base_reconstruction_rmse":7.781283084457221,"belief_set_rate":0.46875,"belief_set_rate_delta":-0.046875,"checkpoint_behavior":true,"checkpoint_identity":true,"checkpoint_mutations":true,"checkpoint_roundtrip":true,"checkpoint_size_bytes":52334,"drift_accuracy_delta":0.1875,"exact_state_rate":0.46875,"exact_state_rate_delta":0.03125,"expert_count":80,"headroom_normalized_accuracy_improvement":0.42857142857142855,"inference_evaluation_ratio_vs_flat64":0.23046875,"inference_expert_evaluations":3776,"lineage_invariants":true,"matched_compute_drift_accuracy_delta":0.1875,"matched_compute_retention_delta":0.046875,"matched_compute_training_evaluation_ratio":0.936893378078503,"no_birth_drift_accuracy_delta":0.1875,"no_retirement_drift_accuracy_delta":0.0,"path_found_rate":0.84375,"prediction_improvement_ratio":0.15767606151927527,"reconstruction_improvement_ratio":0.1649122004667117,"replay_actions_covered":4,"replay_experts_covered":62,"replay_labels_covered":8,"replay_selected":256,"replay_states_covered":64,"replay_transition_pairs_covered":250,"replay_unique":256,"retention_accuracy":0.9296875,"retention_accuracy_delta_from_base":0.0703125,"retention_prediction_degradation":-1.832572941719743,"retention_prediction_rmse":7.086272689551805,"retention_reconstruction_degradation_ratio":-0.21081025960831043,"retention_reconstruction_rmse":6.14090877733704,"retention_transition_accuracy_delta":0.05378564405113073,"routing_mismatches":0,"static_belief_set_rate":0.515625,"static_drift_accuracy":0.5625,"static_exact_state_rate":0.4375,"static_prediction_rmse":11.422767564447971,"static_reconstruction_rmse":10.132355988059158,"static_transition_accuracy":0.8125,"topology_objective_gain_q20":56718,"training_evaluations":2610882,"transition_accuracy_delta":0.013984018264840192,"transition_support_rate":0.85546875,"unsupported_graph_edge_violations":0},"regime":"combined_observation_and_label_drift","seed":"0xae29c26efd3217a6","trial_id":"validation-combined-02","trial_result":"FAIL"},{"comparisons":{"fixed_8_expert":{"metrics":{"checkpoint_size_bytes":11294,"drift_accuracy":0.19921875,"expert_count":8,"expert_evaluations":2048,"planning_belief_set_rate":0.15625,"planning_exact_state_rate":0.03125,"prediction_rmse":26.83174717831276,"reconstruction_rmse":24.854130631970982,"retention_accuracy":0.23828125,"training_evaluations":94208},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":41040,"drift_accuracy":0.62109375,"expert_count":72,"expert_evaluations":432,"planning_belief_set_rate":0.515625,"planning_exact_state_rate":0.640625,"prediction_rmse":-17.630398513034244,"reconstruction_rmse":-17.112118921356362,"retention_accuracy":0.71484375,"training_evaluations":2293949},"pareto_relation":"mixed"},"fixed_topology_64_expert_routed":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.6484375,"expert_count":64,"expert_evaluations":2384,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":8.804907985284595,"reconstruction_rmse":8.096601085737962,"retention_accuracy":1.0,"training_evaluations":2588672},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":9120,"drift_accuracy":0.171875,"expert_count":16,"expert_evaluations":96,"planning_belief_set_rate":-0.328125,"planning_exact_state_rate":-0.328125,"prediction_rmse":0.39644067999392085,"reconstruction_rmse":-0.35458937512334465,"retention_accuracy":-0.046875,"training_evaluations":-200515},"pareto_relation":"mixed"},"flat_64_expert_complete_scan":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.6484375,"expert_count":64,"expert_evaluations":16384,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":8.804907985284595,"reconstruction_rmse":8.096601085737962,"retention_accuracy":1.0,"training_evaluations":2588672},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":9120,"drift_accuracy":0.171875,"expert_count":16,"expert_evaluations":-13904,"planning_belief_set_rate":-0.328125,"planning_exact_state_rate":-0.328125,"prediction_rmse":0.39644067999392085,"reconstruction_rmse":-0.35458937512334465,"retention_accuracy":-0.046875,"training_evaluations":-200515},"pareto_relation":"mixed"},"matched_compute_fixed_topology":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.58984375,"expert_count":64,"expert_evaluations":3280,"planning_belief_set_rate":0.609375,"planning_exact_state_rate":0.59375,"prediction_rmse":11.109368350285648,"reconstruction_rmse":9.681980191095334,"retention_accuracy":0.9375,"training_evaluations":2429968},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":9120,"drift_accuracy":0.23046875,"expert_count":16,"expert_evaluations":-800,"planning_belief_set_rate":0.0625,"planning_exact_state_rate":0.078125,"prediction_rmse":-1.9080196850071314,"reconstruction_rmse":-1.939968480480717,"retention_accuracy":0.015625,"training_evaluations":-41811},"pareto_relation":"mixed"},"matched_expert_count_capacity":{"metrics":{"checkpoint_size_bytes":52334,"drift_accuracy":0.6484375,"expert_count":80,"expert_evaluations":2696,"planning_belief_set_rate":0.890625,"planning_exact_state_rate":0.890625,"prediction_rmse":8.799876242408317,"reconstruction_rmse":8.061159924814683,"retention_accuracy":1.0,"training_evaluations":3891200},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.171875,"expert_count":0,"expert_evaluations":-216,"planning_belief_set_rate":-0.21875,"planning_exact_state_rate":-0.21875,"prediction_rmse":0.40147242287019935,"reconstruction_rmse":-0.3191482142000659,"retention_accuracy":-0.046875,"training_evaluations":-1503043},"pareto_relation":"mixed"},"nearest_centroid_16_no_recursive_births":{"metrics":{"checkpoint_size_bytes":15854,"drift_accuracy":0.20703125,"expert_count":16,"expert_evaluations":4096,"planning_belief_set_rate":0.59375,"planning_exact_state_rate":0.203125,"prediction_rmse":22.17767292631078,"reconstruction_rmse":20.172547247090762,"retention_accuracy":0.28125,"training_evaluations":253952},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":36480,"drift_accuracy":0.61328125,"expert_count":64,"expert_evaluations":-1616,"planning_belief_set_rate":0.078125,"planning_exact_state_rate":0.46875,"prediction_rmse":-12.976324261032264,"reconstruction_rmse":-12.430535536476144,"retention_accuracy":0.671875,"training_evaluations":2134205},"pareto_relation":"mixed"},"no_adaptation_static":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.58984375,"expert_count":64,"expert_evaluations":3280,"planning_belief_set_rate":0.609375,"planning_exact_state_rate":0.59375,"prediction_rmse":11.109368350285648,"reconstruction_rmse":9.681980191095334,"retention_accuracy":0.9375,"training_evaluations":570896},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":9120,"drift_accuracy":0.23046875,"expert_count":16,"expert_evaluations":-800,"planning_belief_set_rate":0.0625,"planning_exact_state_rate":0.078125,"prediction_rmse":-1.9080196850071314,"reconstruction_rmse":-1.939968480480717,"retention_accuracy":0.015625,"training_evaluations":1817261},"pareto_relation":"mixed"},"periodic_replay_policy":{"metrics":{"checkpoint_size_bytes":52334,"drift_accuracy":0.8203125,"expert_count":80,"expert_evaluations":2480,"planning_belief_set_rate":0.65625,"planning_exact_state_rate":0.65625,"prediction_rmse":9.202440489916333,"reconstruction_rmse":7.7438385917168615,"retention_accuracy":0.95703125,"training_evaluations":2515180},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.015625,"planning_exact_state_rate":0.015625,"prediction_rmse":-0.0010918246378164298,"reconstruction_rmse":-0.001826881102243938,"retention_accuracy":-0.00390625,"training_evaluations":-127023},"pareto_relation":"mixed"},"ravel_0_5_candidate":{"metrics":{"checkpoint_size_bytes":52334,"drift_accuracy":0.8203125,"expert_count":80,"expert_evaluations":2480,"planning_belief_set_rate":0.671875,"planning_exact_state_rate":0.671875,"prediction_rmse":9.201348665278516,"reconstruction_rmse":7.742011710614618,"retention_accuracy":0.953125,"training_evaluations":2388157},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"equivalent"},"ravel_complete_scan_without_certification":{"metrics":{"checkpoint_size_bytes":52334,"drift_accuracy":0.8203125,"expert_count":80,"expert_evaluations":20480,"planning_belief_set_rate":0.671875,"planning_exact_state_rate":0.671875,"prediction_rmse":9.201348665278516,"reconstruction_rmse":7.742011710614618,"retention_accuracy":0.953125,"training_evaluations":2602141},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":-18000,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":-213984},"pareto_relation":"candidate_dominates"},"ravel_no_birth_same_replay_iterations":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.58984375,"expert_count":64,"expert_evaluations":3280,"planning_belief_set_rate":0.609375,"planning_exact_state_rate":0.59375,"prediction_rmse":11.109368350285648,"reconstruction_rmse":9.681980191095334,"retention_accuracy":0.9375,"training_evaluations":803280},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":9120,"drift_accuracy":0.23046875,"expert_count":16,"expert_evaluations":-800,"planning_belief_set_rate":0.0625,"planning_exact_state_rate":0.078125,"prediction_rmse":-1.9080196850071314,"reconstruction_rmse":-1.939968480480717,"retention_accuracy":0.015625,"training_evaluations":1584877},"pareto_relation":"mixed"},"ravel_random_births":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.58984375,"expert_count":64,"expert_evaluations":3280,"planning_belief_set_rate":0.609375,"planning_exact_state_rate":0.59375,"prediction_rmse":11.109368350285648,"reconstruction_rmse":9.681980191095334,"retention_accuracy":0.9375,"training_evaluations":803280},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":9120,"drift_accuracy":0.23046875,"expert_count":16,"expert_evaluations":-800,"planning_belief_set_rate":0.0625,"planning_exact_state_rate":0.078125,"prediction_rmse":-1.9080196850071314,"reconstruction_rmse":-1.939968480480717,"retention_accuracy":0.015625,"training_evaluations":1584877},"pareto_relation":"mixed"},"ravel_without_replay":{"metrics":{"checkpoint_size_bytes":52334,"drift_accuracy":0.8203125,"expert_count":80,"expert_evaluations":2480,"planning_belief_set_rate":0.65625,"planning_exact_state_rate":0.65625,"prediction_rmse":9.25016606700948,"reconstruction_rmse":7.756221954742779,"retention_accuracy":0.95703125,"training_evaluations":1882459},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.015625,"planning_exact_state_rate":0.015625,"prediction_rmse":-0.048817401730964605,"reconstruction_rmse":-0.01421024412816152,"retention_accuracy":-0.00390625,"training_evaluations":505698},"pareto_relation":"mixed"},"ravel_without_retirement_matched_work":{"metrics":{"checkpoint_size_bytes":52334,"drift_accuracy":0.8203125,"expert_count":80,"expert_evaluations":2480,"planning_belief_set_rate":0.671875,"planning_exact_state_rate":0.671875,"prediction_rmse":9.201348665278516,"reconstruction_rmse":7.742011710614618,"retention_accuracy":0.953125,"training_evaluations":2388157},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"equivalent"}},"gates":[{"gate_id":"adaptation_completed","metric":"adaptation_completed","observed":true,"operator":"eq","pass":true,"rationale":"The bounded adaptation procedure must complete.","threshold":true},{"gate_id":"base_holdout_accuracy","metric":"base_accuracy","observed":0.91015625,"operator":"ge","pass":true,"rationale":"The base representation must establish the bounded task before drift.","threshold":0.85},{"gate_id":"base_holdout_retention","metric":"retention_accuracy","observed":0.953125,"operator":"ge","pass":true,"rationale":"Anchored base behavior may lose at most ten percentage points in absolute retained accuracy.","threshold":0.9},{"gate_id":"routing_oracle_equivalence","metric":"routing_mismatches","observed":0,"operator":"eq","pass":true,"rationale":"Every routed classification must agree with complete scan.","threshold":0},{"gate_id":"checkpoint_roundtrip","metric":"checkpoint_roundtrip","observed":true,"operator":"eq","pass":true,"rationale":"Canonical in-memory restoration must succeed.","threshold":true},{"gate_id":"checkpoint_identity","metric":"checkpoint_identity","observed":true,"operator":"eq","pass":true,"rationale":"Restored complete model identity must match.","threshold":true},{"gate_id":"checkpoint_behavior","metric":"checkpoint_behavior","observed":true,"operator":"eq","pass":true,"rationale":"Restored evaluation and planning behavior must match.","threshold":true},{"gate_id":"checkpoint_mutation_rejection","metric":"checkpoint_mutations","observed":true,"operator":"eq","pass":true,"rationale":"Every declared behavioral and byte-level checkpoint mutation must be detected.","threshold":true},{"gate_id":"lineage_invariants","metric":"lineage_invariants","observed":true,"operator":"eq","pass":true,"rationale":"Generation, lineage uniqueness, descendant splitting, and deterministic topology invariants must hold.","threshold":true},{"gate_id":"unsupported_transitions_unknown","metric":"unsupported_graph_edge_violations","observed":0,"operator":"eq","pass":true,"rationale":"Unsupported actions cannot enter the planning graph.","threshold":0},{"gate_id":"replay_size","metric":"replay_selected","observed":256,"operator":"eq","pass":true,"rationale":"The declared replay budget must be filled on the non-sparse trial corpus.","threshold":256},{"gate_id":"replay_unique","metric":"replay_unique","observed":256,"operator":"eq","pass":true,"rationale":"Balanced replay cannot introduce accidental duplicates.","threshold":256},{"gate_id":"replay_label_coverage","metric":"replay_labels_covered","observed":8,"operator":"eq","pass":true,"rationale":"Replay must retain every declared label.","threshold":8},{"gate_id":"replay_action_coverage","metric":"replay_actions_covered","observed":4,"operator":"eq","pass":true,"rationale":"Replay must retain every declared action.","threshold":4},{"gate_id":"replay_state_coverage","metric":"replay_states_covered","observed":64,"operator":"ge","pass":true,"rationale":"Replay must cover at least 60 of 64 source states.","threshold":60},{"gate_id":"replay_expert_coverage","metric":"replay_experts_covered","observed":64,"operator":"ge","pass":true,"rationale":"Replay must retain broad assigned-expert coverage.","threshold":60},{"gate_id":"replay_transition_coverage","metric":"replay_transition_pairs_covered","observed":253,"operator":"ge","pass":true,"rationale":"Replay must preserve broad source-state/action transition support.","threshold":220},{"gate_id":"planning_path_found","metric":"path_found_rate","observed":0.859375,"operator":"ge","pass":true,"rationale":"At least three quarters of bounded planning cases must have a supported path.","threshold":0.75},{"gate_id":"expert_capacity","metric":"expert_count","observed":80,"operator":"le","pass":true,"rationale":"Adaptation cannot exceed the declared expert capacity.","threshold":80},{"gate_id":"retirement_budget","metric":"accepted_retirements","observed":0,"operator":"le","pass":true,"rationale":"Retirement remains optional and bounded.","threshold":4},{"gate_id":"topology_objective_non_degradation","metric":"topology_objective_gain_q20","observed":51067,"operator":"ge","pass":true,"rationale":"Accepted adaptation-training topology decisions cannot reduce their declared objective.","threshold":0},{"gate_id":"matched_compute_budget","metric":"matched_compute_training_evaluation_ratio","observed":0.982793600574164,"operator":"le","pass":true,"rationale":"Candidate training work may exceed the matched fixed-topology budget by at most ten percent.","threshold":1.1},{"gate_id":"conditional_inference_efficiency","metric":"inference_evaluation_ratio_vs_flat64","observed":0.1513671875,"operator":"le","pass":true,"rationale":"Routed inference must use at most one quarter of flat complete-scan expert evaluations.","threshold":0.25},{"gate_id":"combined_adaptation","metric":"adapted_drift_accuracy","observed":0.8203125,"operator":"ge","pass":true,"rationale":"Combined drift requires useful untouched-holdout classification.","threshold":0.65},{"gate_id":"combined_gain","metric":"drift_accuracy_delta","observed":0.23046875,"operator":"ge","pass":true,"rationale":"Combined drift requires a meaningful absolute adaptation gain.","threshold":0.05},{"gate_id":"combined_reconstruction","metric":"reconstruction_improvement_ratio","observed":0.20036897847249632,"operator":"ge","pass":true,"rationale":"Observation correction cannot be averaged away by label gain.","threshold":0},{"gate_id":"combined_prediction","metric":"prediction_improvement_ratio","observed":0.17174871017379414,"operator":"ge","pass":true,"rationale":"Prediction correction cannot be averaged away by classification gain.","threshold":0},{"gate_id":"combined_transition_non_inferiority","metric":"transition_accuracy_delta","observed":-0.07753493904252151,"operator":"ge","pass":true,"rationale":"Combined behavior permits bounded transition variance but not collapse.","threshold":-0.15},{"gate_id":"combined_reconstruction_retention","metric":"retention_reconstruction_degradation_ratio","observed":-0.2295232157146421,"operator":"le","pass":true,"rationale":"Original-task reconstruction cannot materially degrade.","threshold":0.1},{"gate_id":"combined_prediction_retention","metric":"retention_prediction_degradation","observed":-1.9296757552540669,"operator":"le","pass":true,"rationale":"Original-task prediction cannot materially degrade.","threshold":1},{"gate_id":"combined_exact_planning","metric":"exact_state_rate","observed":0.671875,"operator":"ge","pass":true,"rationale":"The combined regime remains fully observed and gates exact planning.","threshold":0.5}],"metrics":{"accepted_births":16,"accepted_retirements":0,"adaptation_completed":true,"adaptation_training_accuracy":0.833984375,"adapted_drift_accuracy":0.8203125,"adapted_prediction_rmse":9.201348665278516,"adapted_reconstruction_rmse":7.742011710614618,"adapted_transition_accuracy":0.8377192982456141,"balanced_vs_periodic_drift_accuracy_delta":0.0,"balanced_vs_periodic_retention_delta":-0.00390625,"base_accuracy":0.91015625,"base_prediction_rmse":7.314527537333241,"base_reconstruction_rmse":6.661635369735226,"belief_set_rate":0.671875,"belief_set_rate_delta":0.0625,"checkpoint_behavior":true,"checkpoint_identity":true,"checkpoint_mutations":true,"checkpoint_roundtrip":true,"checkpoint_size_bytes":52334,"drift_accuracy_delta":0.23046875,"exact_state_rate":0.671875,"exact_state_rate_delta":0.078125,"expert_count":80,"headroom_normalized_accuracy_improvement":0.5619047619047619,"inference_evaluation_ratio_vs_flat64":0.1513671875,"inference_expert_evaluations":2480,"lineage_invariants":true,"matched_compute_drift_accuracy_delta":0.23046875,"matched_compute_retention_delta":0.015625,"matched_compute_training_evaluation_ratio":0.982793600574164,"no_birth_drift_accuracy_delta":0.23046875,"no_retirement_drift_accuracy_delta":0.0,"path_found_rate":0.859375,"prediction_improvement_ratio":0.17174871017379414,"reconstruction_improvement_ratio":0.20036897847249632,"replay_actions_covered":4,"replay_experts_covered":64,"replay_labels_covered":8,"replay_selected":256,"replay_states_covered":64,"replay_transition_pairs_covered":253,"replay_unique":256,"retention_accuracy":0.953125,"retention_accuracy_delta_from_base":0.04296875,"retention_prediction_degradation":-1.9296757552540669,"retention_prediction_rmse":5.384851782079174,"retention_reconstruction_degradation_ratio":-0.2295232157146421,"retention_reconstruction_rmse":5.132635397755198,"retention_transition_accuracy_delta":0.03834136425237167,"routing_mismatches":0,"static_belief_set_rate":0.609375,"static_drift_accuracy":0.58984375,"static_exact_state_rate":0.59375,"static_prediction_rmse":11.109368350285648,"static_reconstruction_rmse":9.681980191095334,"static_transition_accuracy":0.9152542372881356,"topology_objective_gain_q20":51067,"training_evaluations":2388157,"transition_accuracy_delta":-0.07753493904252151,"transition_support_rate":0.890625,"unsupported_graph_edge_violations":0},"regime":"combined_observation_and_label_drift","seed":"0xbb7d6905881932af","trial_id":"validation-combined-03","trial_result":"PASS"},{"comparisons":{"fixed_8_expert":{"metrics":{"checkpoint_size_bytes":11294,"drift_accuracy":0.16796875,"expert_count":8,"expert_evaluations":2048,"planning_belief_set_rate":0.484375,"planning_exact_state_rate":0.109375,"prediction_rmse":25.635421439664775,"reconstruction_rmse":24.37105819341984,"retention_accuracy":0.23046875,"training_evaluations":94208},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":41040,"drift_accuracy":0.6015625,"expert_count":72,"expert_evaluations":792,"planning_belief_set_rate":0.171875,"planning_exact_state_rate":0.546875,"prediction_rmse":-16.99605374302314,"reconstruction_rmse":-16.206005776980962,"retention_accuracy":0.73046875,"training_evaluations":2289613},"pareto_relation":"mixed"},"fixed_topology_64_expert_routed":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.65625,"expert_count":64,"expert_evaluations":2552,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":8.434518160855397,"reconstruction_rmse":8.165043866372038,"retention_accuracy":1.0,"training_evaluations":2588672},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":9120,"drift_accuracy":0.11328125,"expert_count":16,"expert_evaluations":288,"planning_belief_set_rate":-0.34375,"planning_exact_state_rate":-0.34375,"prediction_rmse":0.2048495357862361,"reconstruction_rmse":8.550066841195303e-06,"retention_accuracy":-0.0390625,"training_evaluations":-204851},"pareto_relation":"mixed"},"flat_64_expert_complete_scan":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.65625,"expert_count":64,"expert_evaluations":16384,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":8.434518160855397,"reconstruction_rmse":8.165043866372038,"retention_accuracy":1.0,"training_evaluations":2588672},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":9120,"drift_accuracy":0.11328125,"expert_count":16,"expert_evaluations":-13544,"planning_belief_set_rate":-0.34375,"planning_exact_state_rate":-0.34375,"prediction_rmse":0.2048495357862361,"reconstruction_rmse":8.550066841195303e-06,"retention_accuracy":-0.0390625,"training_evaluations":-204851},"pareto_relation":"mixed"},"matched_compute_fixed_topology":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.55078125,"expert_count":64,"expert_evaluations":3896,"planning_belief_set_rate":0.703125,"planning_exact_state_rate":0.59375,"prediction_rmse":10.45206052655869,"reconstruction_rmse":9.906443164854199,"retention_accuracy":0.93359375,"training_evaluations":2434744},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":9120,"drift_accuracy":0.21875,"expert_count":16,"expert_evaluations":-1056,"planning_belief_set_rate":-0.046875,"planning_exact_state_rate":0.0625,"prediction_rmse":-1.8126928299170562,"reconstruction_rmse":-1.74139074841532,"retention_accuracy":0.02734375,"training_evaluations":-50923},"pareto_relation":"mixed"},"matched_expert_count_capacity":{"metrics":{"checkpoint_size_bytes":52334,"drift_accuracy":0.65625,"expert_count":80,"expert_evaluations":2768,"planning_belief_set_rate":1.0,"planning_exact_state_rate":1.0,"prediction_rmse":8.527662386418982,"reconstruction_rmse":8.059795827263144,"retention_accuracy":1.0,"training_evaluations":3891200},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.11328125,"expert_count":0,"expert_evaluations":72,"planning_belief_set_rate":-0.34375,"planning_exact_state_rate":-0.34375,"prediction_rmse":0.11170531022265173,"reconstruction_rmse":0.10525658917573466,"retention_accuracy":-0.0390625,"training_evaluations":-1507379},"pareto_relation":"mixed"},"nearest_centroid_16_no_recursive_births":{"metrics":{"checkpoint_size_bytes":15854,"drift_accuracy":0.20703125,"expert_count":16,"expert_evaluations":4096,"planning_belief_set_rate":0.484375,"planning_exact_state_rate":0.125,"prediction_rmse":21.050245540360887,"reconstruction_rmse":20.20220719302089,"retention_accuracy":0.3125,"training_evaluations":253952},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":36480,"drift_accuracy":0.5625,"expert_count":64,"expert_evaluations":-1256,"planning_belief_set_rate":0.171875,"planning_exact_state_rate":0.53125,"prediction_rmse":-12.410877843719254,"reconstruction_rmse":-12.03715477658201,"retention_accuracy":0.6484375,"training_evaluations":2129869},"pareto_relation":"mixed"},"no_adaptation_static":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.55078125,"expert_count":64,"expert_evaluations":3896,"planning_belief_set_rate":0.703125,"planning_exact_state_rate":0.59375,"prediction_rmse":10.45206052655869,"reconstruction_rmse":9.906443164854199,"retention_accuracy":0.93359375,"training_evaluations":573880},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":9120,"drift_accuracy":0.21875,"expert_count":16,"expert_evaluations":-1056,"planning_belief_set_rate":-0.046875,"planning_exact_state_rate":0.0625,"prediction_rmse":-1.8126928299170562,"reconstruction_rmse":-1.74139074841532,"retention_accuracy":0.02734375,"training_evaluations":1809941},"pareto_relation":"mixed"},"periodic_replay_policy":{"metrics":{"checkpoint_size_bytes":52334,"drift_accuracy":0.76953125,"expert_count":80,"expert_evaluations":2840,"planning_belief_set_rate":0.671875,"planning_exact_state_rate":0.671875,"prediction_rmse":8.620265523270948,"reconstruction_rmse":8.15107321220518,"retention_accuracy":0.96484375,"training_evaluations":2648479},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":-0.015625,"planning_exact_state_rate":-0.015625,"prediction_rmse":0.019102173370685094,"reconstruction_rmse":0.01397920423369925,"retention_accuracy":-0.00390625,"training_evaluations":-264658},"pareto_relation":"mixed"},"ravel_0_5_candidate":{"metrics":{"checkpoint_size_bytes":52334,"drift_accuracy":0.76953125,"expert_count":80,"expert_evaluations":2840,"planning_belief_set_rate":0.65625,"planning_exact_state_rate":0.65625,"prediction_rmse":8.639367696641633,"reconstruction_rmse":8.16505241643888,"retention_accuracy":0.9609375,"training_evaluations":2383821},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"equivalent"},"ravel_complete_scan_without_certification":{"metrics":{"checkpoint_size_bytes":52334,"drift_accuracy":0.76953125,"expert_count":80,"expert_evaluations":20480,"planning_belief_set_rate":0.65625,"planning_exact_state_rate":0.65625,"prediction_rmse":8.639367696641633,"reconstruction_rmse":8.16505241643888,"retention_accuracy":0.9609375,"training_evaluations":2597157},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":-17640,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":-213336},"pareto_relation":"candidate_dominates"},"ravel_no_birth_same_replay_iterations":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.55078125,"expert_count":64,"expert_evaluations":3896,"planning_belief_set_rate":0.703125,"planning_exact_state_rate":0.59375,"prediction_rmse":10.45206052655869,"reconstruction_rmse":9.906443164854199,"retention_accuracy":0.93359375,"training_evaluations":806488},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":9120,"drift_accuracy":0.21875,"expert_count":16,"expert_evaluations":-1056,"planning_belief_set_rate":-0.046875,"planning_exact_state_rate":0.0625,"prediction_rmse":-1.8126928299170562,"reconstruction_rmse":-1.74139074841532,"retention_accuracy":0.02734375,"training_evaluations":1577333},"pareto_relation":"mixed"},"ravel_random_births":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.55078125,"expert_count":64,"expert_evaluations":3896,"planning_belief_set_rate":0.703125,"planning_exact_state_rate":0.59375,"prediction_rmse":10.45206052655869,"reconstruction_rmse":9.906443164854199,"retention_accuracy":0.93359375,"training_evaluations":806488},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":9120,"drift_accuracy":0.21875,"expert_count":16,"expert_evaluations":-1056,"planning_belief_set_rate":-0.046875,"planning_exact_state_rate":0.0625,"prediction_rmse":-1.8126928299170562,"reconstruction_rmse":-1.74139074841532,"retention_accuracy":0.02734375,"training_evaluations":1577333},"pareto_relation":"mixed"},"ravel_without_replay":{"metrics":{"checkpoint_size_bytes":52334,"drift_accuracy":0.76953125,"expert_count":80,"expert_evaluations":2840,"planning_belief_set_rate":0.671875,"planning_exact_state_rate":0.671875,"prediction_rmse":8.681062729991835,"reconstruction_rmse":8.216961893172847,"retention_accuracy":0.96484375,"training_evaluations":1879660},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":-0.015625,"planning_exact_state_rate":-0.015625,"prediction_rmse":-0.04169503335020153,"reconstruction_rmse":-0.05190947673396806,"retention_accuracy":-0.00390625,"training_evaluations":504161},"pareto_relation":"mixed"},"ravel_without_retirement_matched_work":{"metrics":{"checkpoint_size_bytes":52334,"drift_accuracy":0.76953125,"expert_count":80,"expert_evaluations":2840,"planning_belief_set_rate":0.65625,"planning_exact_state_rate":0.65625,"prediction_rmse":8.639367696641633,"reconstruction_rmse":8.16505241643888,"retention_accuracy":0.9609375,"training_evaluations":2383821},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"equivalent"}},"gates":[{"gate_id":"adaptation_completed","metric":"adaptation_completed","observed":true,"operator":"eq","pass":true,"rationale":"The bounded adaptation procedure must complete.","threshold":true},{"gate_id":"base_holdout_accuracy","metric":"base_accuracy","observed":0.9140625,"operator":"ge","pass":true,"rationale":"The base representation must establish the bounded task before drift.","threshold":0.85},{"gate_id":"base_holdout_retention","metric":"retention_accuracy","observed":0.9609375,"operator":"ge","pass":true,"rationale":"Anchored base behavior may lose at most ten percentage points in absolute retained accuracy.","threshold":0.9},{"gate_id":"routing_oracle_equivalence","metric":"routing_mismatches","observed":0,"operator":"eq","pass":true,"rationale":"Every routed classification must agree with complete scan.","threshold":0},{"gate_id":"checkpoint_roundtrip","metric":"checkpoint_roundtrip","observed":true,"operator":"eq","pass":true,"rationale":"Canonical in-memory restoration must succeed.","threshold":true},{"gate_id":"checkpoint_identity","metric":"checkpoint_identity","observed":true,"operator":"eq","pass":true,"rationale":"Restored complete model identity must match.","threshold":true},{"gate_id":"checkpoint_behavior","metric":"checkpoint_behavior","observed":true,"operator":"eq","pass":true,"rationale":"Restored evaluation and planning behavior must match.","threshold":true},{"gate_id":"checkpoint_mutation_rejection","metric":"checkpoint_mutations","observed":true,"operator":"eq","pass":true,"rationale":"Every declared behavioral and byte-level checkpoint mutation must be detected.","threshold":true},{"gate_id":"lineage_invariants","metric":"lineage_invariants","observed":true,"operator":"eq","pass":true,"rationale":"Generation, lineage uniqueness, descendant splitting, and deterministic topology invariants must hold.","threshold":true},{"gate_id":"unsupported_transitions_unknown","metric":"unsupported_graph_edge_violations","observed":0,"operator":"eq","pass":true,"rationale":"Unsupported actions cannot enter the planning graph.","threshold":0},{"gate_id":"replay_size","metric":"replay_selected","observed":256,"operator":"eq","pass":true,"rationale":"The declared replay budget must be filled on the non-sparse trial corpus.","threshold":256},{"gate_id":"replay_unique","metric":"replay_unique","observed":256,"operator":"eq","pass":true,"rationale":"Balanced replay cannot introduce accidental duplicates.","threshold":256},{"gate_id":"replay_label_coverage","metric":"replay_labels_covered","observed":8,"operator":"eq","pass":true,"rationale":"Replay must retain every declared label.","threshold":8},{"gate_id":"replay_action_coverage","metric":"replay_actions_covered","observed":4,"operator":"eq","pass":true,"rationale":"Replay must retain every declared action.","threshold":4},{"gate_id":"replay_state_coverage","metric":"replay_states_covered","observed":64,"operator":"ge","pass":true,"rationale":"Replay must cover at least 60 of 64 source states.","threshold":60},{"gate_id":"replay_expert_coverage","metric":"replay_experts_covered","observed":62,"operator":"ge","pass":true,"rationale":"Replay must retain broad assigned-expert coverage.","threshold":60},{"gate_id":"replay_transition_coverage","metric":"replay_transition_pairs_covered","observed":252,"operator":"ge","pass":true,"rationale":"Replay must preserve broad source-state/action transition support.","threshold":220},{"gate_id":"planning_path_found","metric":"path_found_rate","observed":0.875,"operator":"ge","pass":true,"rationale":"At least three quarters of bounded planning cases must have a supported path.","threshold":0.75},{"gate_id":"expert_capacity","metric":"expert_count","observed":80,"operator":"le","pass":true,"rationale":"Adaptation cannot exceed the declared expert capacity.","threshold":80},{"gate_id":"retirement_budget","metric":"accepted_retirements","observed":0,"operator":"le","pass":true,"rationale":"Retirement remains optional and bounded.","threshold":4},{"gate_id":"topology_objective_non_degradation","metric":"topology_objective_gain_q20","observed":40870,"operator":"ge","pass":true,"rationale":"Accepted adaptation-training topology decisions cannot reduce their declared objective.","threshold":0},{"gate_id":"matched_compute_budget","metric":"matched_compute_training_evaluation_ratio","observed":0.9790848647742842,"operator":"le","pass":true,"rationale":"Candidate training work may exceed the matched fixed-topology budget by at most ten percent.","threshold":1.1},{"gate_id":"conditional_inference_efficiency","metric":"inference_evaluation_ratio_vs_flat64","observed":0.17333984375,"operator":"le","pass":true,"rationale":"Routed inference must use at most one quarter of flat complete-scan expert evaluations.","threshold":0.25},{"gate_id":"combined_adaptation","metric":"adapted_drift_accuracy","observed":0.76953125,"operator":"ge","pass":true,"rationale":"Combined drift requires useful untouched-holdout classification.","threshold":0.65},{"gate_id":"combined_gain","metric":"drift_accuracy_delta","observed":0.21875,"operator":"ge","pass":true,"rationale":"Combined drift requires a meaningful absolute adaptation gain.","threshold":0.05},{"gate_id":"combined_reconstruction","metric":"reconstruction_improvement_ratio","observed":0.17578365104777233,"operator":"ge","pass":true,"rationale":"Observation correction cannot be averaged away by label gain.","threshold":0},{"gate_id":"combined_prediction","metric":"prediction_improvement_ratio","observed":0.17342923199793983,"operator":"ge","pass":true,"rationale":"Prediction correction cannot be averaged away by classification gain.","threshold":0},{"gate_id":"combined_transition_non_inferiority","metric":"transition_accuracy_delta","observed":-0.01537163401570174,"operator":"ge","pass":true,"rationale":"Combined behavior permits bounded transition variance but not collapse.","threshold":-0.15},{"gate_id":"combined_reconstruction_retention","metric":"retention_reconstruction_degradation_ratio","observed":-0.2181259687741264,"operator":"le","pass":true,"rationale":"Original-task reconstruction cannot materially degrade.","threshold":0.1},{"gate_id":"combined_prediction_retention","metric":"retention_prediction_degradation","observed":-1.6535494086941824,"operator":"le","pass":true,"rationale":"Original-task prediction cannot materially degrade.","threshold":1},{"gate_id":"combined_exact_planning","metric":"exact_state_rate","observed":0.65625,"operator":"ge","pass":true,"rationale":"The combined regime remains fully observed and gates exact planning.","threshold":0.5}],"metrics":{"accepted_births":16,"accepted_retirements":0,"adaptation_completed":true,"adaptation_training_accuracy":0.720703125,"adapted_drift_accuracy":0.76953125,"adapted_prediction_rmse":8.639367696641633,"adapted_reconstruction_rmse":8.16505241643888,"adapted_transition_accuracy":0.8744588744588745,"balanced_vs_periodic_drift_accuracy_delta":0.0,"balanced_vs_periodic_retention_delta":-0.00390625,"base_accuracy":0.9140625,"base_prediction_rmse":7.522202599994798,"base_reconstruction_rmse":6.605531341912079,"belief_set_rate":0.65625,"belief_set_rate_delta":-0.046875,"checkpoint_behavior":true,"checkpoint_identity":true,"checkpoint_mutations":true,"checkpoint_roundtrip":true,"checkpoint_size_bytes":52334,"drift_accuracy_delta":0.21875,"exact_state_rate":0.65625,"exact_state_rate_delta":0.0625,"expert_count":80,"headroom_normalized_accuracy_improvement":0.48695652173913045,"inference_evaluation_ratio_vs_flat64":0.17333984375,"inference_expert_evaluations":2840,"lineage_invariants":true,"matched_compute_drift_accuracy_delta":0.21875,"matched_compute_retention_delta":0.02734375,"matched_compute_training_evaluation_ratio":0.9790848647742842,"no_birth_drift_accuracy_delta":0.21875,"no_retirement_drift_accuracy_delta":0.0,"path_found_rate":0.875,"prediction_improvement_ratio":0.17342923199793983,"reconstruction_improvement_ratio":0.17578365104777233,"replay_actions_covered":4,"replay_experts_covered":62,"replay_labels_covered":8,"replay_selected":256,"replay_states_covered":64,"replay_transition_pairs_covered":252,"replay_unique":256,"retention_accuracy":0.9609375,"retention_accuracy_delta_from_base":0.046875,"retention_prediction_degradation":-1.6535494086941824,"retention_prediction_rmse":5.8686531913006155,"retention_reconstruction_degradation_ratio":-0.2181259687741264,"retention_reconstruction_rmse":5.164693418689652,"retention_transition_accuracy_delta":0.020936250294048442,"routing_mismatches":0,"static_belief_set_rate":0.703125,"static_drift_accuracy":0.55078125,"static_exact_state_rate":0.59375,"static_prediction_rmse":10.45206052655869,"static_reconstruction_rmse":9.906443164854199,"static_transition_accuracy":0.8898305084745762,"topology_objective_gain_q20":40870,"training_evaluations":2383821,"transition_accuracy_delta":-0.01537163401570174,"transition_support_rate":0.90234375,"unsupported_graph_edge_violations":0},"regime":"combined_observation_and_label_drift","seed":"0x5a6a789f3e8a6718","trial_id":"validation-combined-04","trial_result":"PASS"},{"comparisons":{"fixed_8_expert":{"metrics":{"checkpoint_size_bytes":11294,"drift_accuracy":0.19921875,"expert_count":8,"expert_evaluations":2048,"planning_belief_set_rate":0.34375,"planning_exact_state_rate":0.046875,"prediction_rmse":24.414767792985533,"reconstruction_rmse":19.093242272556687,"retention_accuracy":0.28515625,"training_evaluations":94208},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":39330,"drift_accuracy":0.69140625,"expert_count":69,"expert_evaluations":345,"planning_belief_set_rate":0.0625,"planning_exact_state_rate":0.09375,"prediction_rmse":-7.75189530019172,"reconstruction_rmse":-12.106333443586722,"retention_accuracy":0.71484375,"training_evaluations":2354938},"pareto_relation":"mixed"},"fixed_topology_64_expert_routed":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.578125,"expert_count":64,"expert_evaluations":3728,"planning_belief_set_rate":0.28125,"planning_exact_state_rate":0.125,"prediction_rmse":21.60151570994203,"reconstruction_rmse":8.220852286330775,"retention_accuracy":1.0,"training_evaluations":2588672},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":7410,"drift_accuracy":0.3125,"expert_count":13,"expert_evaluations":-1335,"planning_belief_set_rate":0.125,"planning_exact_state_rate":0.015625,"prediction_rmse":-4.938643217148218,"reconstruction_rmse":-1.2339434573608106,"retention_accuracy":0.0,"training_evaluations":-139526},"pareto_relation":"mixed"},"flat_64_expert_complete_scan":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.578125,"expert_count":64,"expert_evaluations":16384,"planning_belief_set_rate":0.28125,"planning_exact_state_rate":0.125,"prediction_rmse":21.60151570994203,"reconstruction_rmse":8.220852286330775,"retention_accuracy":1.0,"training_evaluations":2588672},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":7410,"drift_accuracy":0.3125,"expert_count":13,"expert_evaluations":-13991,"planning_belief_set_rate":0.125,"planning_exact_state_rate":0.015625,"prediction_rmse":-4.938643217148218,"reconstruction_rmse":-1.2339434573608106,"retention_accuracy":0.0,"training_evaluations":-139526},"pareto_relation":"mixed"},"matched_compute_fixed_topology":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.578125,"expert_count":64,"expert_evaluations":3784,"planning_belief_set_rate":0.28125,"planning_exact_state_rate":0.125,"prediction_rmse":20.915572669807723,"reconstruction_rmse":8.173725385287966,"retention_accuracy":1.0,"training_evaluations":2644968},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":7410,"drift_accuracy":0.3125,"expert_count":13,"expert_evaluations":-1391,"planning_belief_set_rate":0.125,"planning_exact_state_rate":0.015625,"prediction_rmse":-4.25270017701391,"reconstruction_rmse":-1.1868165563180018,"retention_accuracy":0.0,"training_evaluations":-195822},"pareto_relation":"mixed"},"matched_expert_count_capacity":{"metrics":{"checkpoint_size_bytes":50624,"drift_accuracy":0.578125,"expert_count":77,"expert_evaluations":4325,"planning_belief_set_rate":0.203125,"planning_exact_state_rate":0.109375,"prediction_rmse":21.6156207822845,"reconstruction_rmse":8.076492135462466,"retention_accuracy":1.0,"training_evaluations":3627008},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.3125,"expert_count":0,"expert_evaluations":-1932,"planning_belief_set_rate":0.203125,"planning_exact_state_rate":0.03125,"prediction_rmse":-4.952748289490685,"reconstruction_rmse":-1.0895833064925018,"retention_accuracy":0.0,"training_evaluations":-1177862},"pareto_relation":"candidate_dominates"},"nearest_centroid_16_no_recursive_births":{"metrics":{"checkpoint_size_bytes":15854,"drift_accuracy":0.25,"expert_count":16,"expert_evaluations":4096,"planning_belief_set_rate":0.328125,"planning_exact_state_rate":0.0625,"prediction_rmse":22.70838308812732,"reconstruction_rmse":13.532733804736617,"retention_accuracy":0.44140625,"training_evaluations":253952},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":34770,"drift_accuracy":0.640625,"expert_count":61,"expert_evaluations":-1703,"planning_belief_set_rate":0.078125,"planning_exact_state_rate":0.078125,"prediction_rmse":-6.045510595333507,"reconstruction_rmse":-6.545824975766653,"retention_accuracy":0.55859375,"training_evaluations":2195194},"pareto_relation":"mixed"},"no_adaptation_static":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.578125,"expert_count":64,"expert_evaluations":3784,"planning_belief_set_rate":0.28125,"planning_exact_state_rate":0.125,"prediction_rmse":20.915572669807723,"reconstruction_rmse":8.173725385287966,"retention_accuracy":1.0,"training_evaluations":549480},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":7410,"drift_accuracy":0.3125,"expert_count":13,"expert_evaluations":-1391,"planning_belief_set_rate":0.125,"planning_exact_state_rate":0.015625,"prediction_rmse":-4.25270017701391,"reconstruction_rmse":-1.1868165563180018,"retention_accuracy":0.0,"training_evaluations":1899666},"pareto_relation":"mixed"},"periodic_replay_policy":{"metrics":{"checkpoint_size_bytes":51764,"drift_accuracy":0.89453125,"expert_count":79,"expert_evaluations":2403,"planning_belief_set_rate":0.359375,"planning_exact_state_rate":0.140625,"prediction_rmse":16.506373945804896,"reconstruction_rmse":6.983790911462941,"retention_accuracy":1.0,"training_evaluations":2588440},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":-1140,"drift_accuracy":-0.00390625,"expert_count":-2,"expert_evaluations":-10,"planning_belief_set_rate":0.046875,"planning_exact_state_rate":0.0,"prediction_rmse":0.1564985469889173,"reconstruction_rmse":0.0031179175070237264,"retention_accuracy":0.0,"training_evaluations":-139294},"pareto_relation":"mixed"},"ravel_0_5_candidate":{"metrics":{"checkpoint_size_bytes":50624,"drift_accuracy":0.890625,"expert_count":77,"expert_evaluations":2393,"planning_belief_set_rate":0.40625,"planning_exact_state_rate":0.140625,"prediction_rmse":16.662872492793813,"reconstruction_rmse":6.986908828969964,"retention_accuracy":1.0,"training_evaluations":2449146},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"equivalent"},"ravel_complete_scan_without_certification":{"metrics":{"checkpoint_size_bytes":50624,"drift_accuracy":0.890625,"expert_count":77,"expert_evaluations":19712,"planning_belief_set_rate":0.40625,"planning_exact_state_rate":0.140625,"prediction_rmse":16.662872492793813,"reconstruction_rmse":6.986908828969964,"retention_accuracy":1.0,"training_evaluations":2660546},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":-17319,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":-211400},"pareto_relation":"candidate_dominates"},"ravel_no_birth_same_replay_iterations":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.578125,"expert_count":64,"expert_evaluations":3784,"planning_belief_set_rate":0.28125,"planning_exact_state_rate":0.125,"prediction_rmse":20.915572669807723,"reconstruction_rmse":8.173725385287966,"retention_accuracy":1.0,"training_evaluations":782312},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":7410,"drift_accuracy":0.3125,"expert_count":13,"expert_evaluations":-1391,"planning_belief_set_rate":0.125,"planning_exact_state_rate":0.015625,"prediction_rmse":-4.25270017701391,"reconstruction_rmse":-1.1868165563180018,"retention_accuracy":0.0,"training_evaluations":1666834},"pareto_relation":"mixed"},"ravel_random_births":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.578125,"expert_count":64,"expert_evaluations":3784,"planning_belief_set_rate":0.28125,"planning_exact_state_rate":0.125,"prediction_rmse":20.915572669807723,"reconstruction_rmse":8.173725385287966,"retention_accuracy":1.0,"training_evaluations":782312},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":7410,"drift_accuracy":0.3125,"expert_count":13,"expert_evaluations":-1391,"planning_belief_set_rate":0.125,"planning_exact_state_rate":0.015625,"prediction_rmse":-4.25270017701391,"reconstruction_rmse":-1.1868165563180018,"retention_accuracy":0.0,"training_evaluations":1666834},"pareto_relation":"mixed"},"ravel_without_replay":{"metrics":{"checkpoint_size_bytes":52334,"drift_accuracy":0.89453125,"expert_count":80,"expert_evaluations":2480,"planning_belief_set_rate":0.40625,"planning_exact_state_rate":0.140625,"prediction_rmse":16.55663428164124,"reconstruction_rmse":6.980758543035017,"retention_accuracy":1.0,"training_evaluations":1932024},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":-1710,"drift_accuracy":-0.00390625,"expert_count":-3,"expert_evaluations":-87,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.10623821115257215,"reconstruction_rmse":0.006150285934947597,"retention_accuracy":0.0,"training_evaluations":517122},"pareto_relation":"mixed"},"ravel_without_retirement_matched_work":{"metrics":{"checkpoint_size_bytes":51194,"drift_accuracy":0.890625,"expert_count":78,"expert_evaluations":2398,"planning_belief_set_rate":0.40625,"planning_exact_state_rate":0.140625,"prediction_rmse":16.662872492793813,"reconstruction_rmse":6.986908828969964,"retention_accuracy":1.0,"training_evaluations":2449146},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":-570,"drift_accuracy":0.0,"expert_count":-1,"expert_evaluations":-5,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"candidate_dominates"}},"gates":[{"gate_id":"adaptation_completed","metric":"adaptation_completed","observed":true,"operator":"eq","pass":true,"rationale":"The bounded adaptation procedure must complete.","threshold":true},{"gate_id":"base_holdout_accuracy","metric":"base_accuracy","observed":1.0,"operator":"ge","pass":true,"rationale":"The base representation must establish the bounded task before drift.","threshold":0.85},{"gate_id":"base_holdout_retention","metric":"retention_accuracy","observed":1.0,"operator":"ge","pass":true,"rationale":"Anchored base behavior may lose at most ten percentage points in absolute retained accuracy.","threshold":0.9},{"gate_id":"routing_oracle_equivalence","metric":"routing_mismatches","observed":0,"operator":"eq","pass":true,"rationale":"Every routed classification must agree with complete scan.","threshold":0},{"gate_id":"checkpoint_roundtrip","metric":"checkpoint_roundtrip","observed":true,"operator":"eq","pass":true,"rationale":"Canonical in-memory restoration must succeed.","threshold":true},{"gate_id":"checkpoint_identity","metric":"checkpoint_identity","observed":true,"operator":"eq","pass":true,"rationale":"Restored complete model identity must match.","threshold":true},{"gate_id":"checkpoint_behavior","metric":"checkpoint_behavior","observed":true,"operator":"eq","pass":true,"rationale":"Restored evaluation and planning behavior must match.","threshold":true},{"gate_id":"checkpoint_mutation_rejection","metric":"checkpoint_mutations","observed":true,"operator":"eq","pass":true,"rationale":"Every declared behavioral and byte-level checkpoint mutation must be detected.","threshold":true},{"gate_id":"lineage_invariants","metric":"lineage_invariants","observed":true,"operator":"eq","pass":true,"rationale":"Generation, lineage uniqueness, descendant splitting, and deterministic topology invariants must hold.","threshold":true},{"gate_id":"unsupported_transitions_unknown","metric":"unsupported_graph_edge_violations","observed":0,"operator":"eq","pass":true,"rationale":"Unsupported actions cannot enter the planning graph.","threshold":0},{"gate_id":"replay_size","metric":"replay_selected","observed":256,"operator":"eq","pass":true,"rationale":"The declared replay budget must be filled on the non-sparse trial corpus.","threshold":256},{"gate_id":"replay_unique","metric":"replay_unique","observed":256,"operator":"eq","pass":true,"rationale":"Balanced replay cannot introduce accidental duplicates.","threshold":256},{"gate_id":"replay_label_coverage","metric":"replay_labels_covered","observed":8,"operator":"eq","pass":true,"rationale":"Replay must retain every declared label.","threshold":8},{"gate_id":"replay_action_coverage","metric":"replay_actions_covered","observed":4,"operator":"eq","pass":true,"rationale":"Replay must retain every declared action.","threshold":4},{"gate_id":"replay_state_coverage","metric":"replay_states_covered","observed":64,"operator":"ge","pass":true,"rationale":"Replay must cover at least 60 of 64 source states.","threshold":60},{"gate_id":"replay_expert_coverage","metric":"replay_experts_covered","observed":60,"operator":"ge","pass":true,"rationale":"Replay must retain broad assigned-expert coverage.","threshold":60},{"gate_id":"replay_transition_coverage","metric":"replay_transition_pairs_covered","observed":254,"operator":"ge","pass":true,"rationale":"Replay must preserve broad source-state/action transition support.","threshold":220},{"gate_id":"planning_path_found","metric":"path_found_rate","observed":0.8125,"operator":"ge","pass":true,"rationale":"At least three quarters of bounded planning cases must have a supported path.","threshold":0.75},{"gate_id":"expert_capacity","metric":"expert_count","observed":77,"operator":"le","pass":true,"rationale":"Adaptation cannot exceed the declared expert capacity.","threshold":80},{"gate_id":"retirement_budget","metric":"accepted_retirements","observed":1,"operator":"le","pass":true,"rationale":"Retirement remains optional and bounded.","threshold":4},{"gate_id":"topology_objective_non_degradation","metric":"topology_objective_gain_q20","observed":50755,"operator":"ge","pass":true,"rationale":"Accepted adaptation-training topology decisions cannot reduce their declared objective.","threshold":0},{"gate_id":"matched_compute_budget","metric":"matched_compute_training_evaluation_ratio","observed":0.9259643216855553,"operator":"le","pass":true,"rationale":"Candidate training work may exceed the matched fixed-topology budget by at most ten percent.","threshold":1.1},{"gate_id":"conditional_inference_efficiency","metric":"inference_evaluation_ratio_vs_flat64","observed":0.14605712890625,"operator":"le","pass":true,"rationale":"Routed inference must use at most one quarter of flat complete-scan expert evaluations.","threshold":0.25},{"gate_id":"ambiguous_adaptation","metric":"adapted_drift_accuracy","observed":0.890625,"operator":"ge","pass":true,"rationale":"Visible evidence must support useful classification despite hidden-state aliasing.","threshold":0.7},{"gate_id":"ambiguous_gain","metric":"drift_accuracy_delta","observed":0.3125,"operator":"ge","pass":true,"rationale":"The aliased regime has adaptation headroom and requires improvement.","threshold":0.05},{"gate_id":"ambiguous_belief_success","metric":"belief_set_rate","observed":0.40625,"operator":"ge","pass":true,"rationale":"Belief-set target success is the capability gate under declared aliasing.","threshold":0.2},{"gate_id":"ambiguous_belief_gain","metric":"belief_set_rate_delta","observed":0.125,"operator":"ge","pass":true,"rationale":"Adaptation must improve alias-aware planning over the static model.","threshold":0.05},{"gate_id":"ambiguous_reconstruction_retention","metric":"retention_reconstruction_degradation_ratio","observed":0.012769303739751551,"operator":"le","pass":true,"rationale":"Original visible-state reconstruction cannot materially degrade.","threshold":0.1},{"gate_id":"ambiguous_prediction_retention","metric":"retention_prediction_degradation","observed":-0.15825869434720907,"operator":"le","pass":true,"rationale":"Original visible-state prediction cannot materially degrade.","threshold":1}],"metrics":{"accepted_births":14,"accepted_retirements":1,"adaptation_completed":true,"adaptation_training_accuracy":0.892578125,"adapted_drift_accuracy":0.890625,"adapted_prediction_rmse":16.662872492793813,"adapted_reconstruction_rmse":6.986908828969964,"adapted_transition_accuracy":0.43043478260869567,"balanced_vs_periodic_drift_accuracy_delta":-0.00390625,"balanced_vs_periodic_retention_delta":0.0,"base_accuracy":1.0,"base_prediction_rmse":15.171959831129499,"base_reconstruction_rmse":5.40598595871411,"belief_set_rate":0.40625,"belief_set_rate_delta":0.125,"checkpoint_behavior":true,"checkpoint_identity":true,"checkpoint_mutations":true,"checkpoint_roundtrip":true,"checkpoint_size_bytes":50624,"drift_accuracy_delta":0.3125,"exact_state_rate":0.140625,"exact_state_rate_delta":0.015625,"expert_count":77,"headroom_normalized_accuracy_improvement":0.7407407407407407,"inference_evaluation_ratio_vs_flat64":0.14605712890625,"inference_expert_evaluations":2393,"lineage_invariants":true,"matched_compute_drift_accuracy_delta":0.3125,"matched_compute_retention_delta":0.0,"matched_compute_training_evaluation_ratio":0.9259643216855553,"no_birth_drift_accuracy_delta":0.3125,"no_retirement_drift_accuracy_delta":0.0,"path_found_rate":0.8125,"prediction_improvement_ratio":0.20332697766161642,"reconstruction_improvement_ratio":0.14519897603290832,"replay_actions_covered":4,"replay_experts_covered":60,"replay_labels_covered":8,"replay_selected":256,"replay_states_covered":64,"replay_transition_pairs_covered":254,"replay_unique":256,"retention_accuracy":1.0,"retention_accuracy_delta_from_base":0.0,"retention_prediction_degradation":-0.15825869434720907,"retention_prediction_rmse":15.01370113678229,"retention_reconstruction_degradation_ratio":0.012769303739751551,"retention_reconstruction_rmse":5.475016635433763,"retention_transition_accuracy_delta":-0.05485232067510548,"routing_mismatches":0,"static_belief_set_rate":0.28125,"static_drift_accuracy":0.578125,"static_exact_state_rate":0.125,"static_prediction_rmse":20.915572669807723,"static_reconstruction_rmse":8.173725385287966,"static_transition_accuracy":0.3393665158371041,"topology_objective_gain_q20":50755,"training_evaluations":2449146,"transition_accuracy_delta":0.09106826677159158,"transition_support_rate":0.8984375,"unsupported_graph_edge_violations":0},"regime":"partially_observed_ambiguous","seed":"0xf2128c2769bbcb97","trial_id":"validation-ambiguous-01","trial_result":"PASS"},{"comparisons":{"fixed_8_expert":{"metrics":{"checkpoint_size_bytes":11294,"drift_accuracy":0.21875,"expert_count":8,"expert_evaluations":2048,"planning_belief_set_rate":0.28125,"planning_exact_state_rate":0.046875,"prediction_rmse":24.887910342096795,"reconstruction_rmse":19.442361796230397,"retention_accuracy":0.31640625,"training_evaluations":94208},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":38760,"drift_accuracy":0.69140625,"expert_count":68,"expert_evaluations":340,"planning_belief_set_rate":-0.15625,"planning_exact_state_rate":0.015625,"prediction_rmse":-8.329165353342042,"reconstruction_rmse":-12.614687451405029,"retention_accuracy":0.671875,"training_evaluations":2121716},"pareto_relation":"mixed"},"fixed_topology_64_expert_routed":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.6171875,"expert_count":64,"expert_evaluations":3392,"planning_belief_set_rate":0.171875,"planning_exact_state_rate":0.0625,"prediction_rmse":21.79867936474416,"reconstruction_rmse":8.0113360914223,"retention_accuracy":1.0,"training_evaluations":2588672},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":6840,"drift_accuracy":0.29296875,"expert_count":12,"expert_evaluations":-1004,"planning_belief_set_rate":-0.046875,"planning_exact_state_rate":0.0,"prediction_rmse":-5.239934375989407,"reconstruction_rmse":-1.1836617465969326,"retention_accuracy":-0.01171875,"training_evaluations":-372748},"pareto_relation":"mixed"},"flat_64_expert_complete_scan":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.6171875,"expert_count":64,"expert_evaluations":16384,"planning_belief_set_rate":0.171875,"planning_exact_state_rate":0.0625,"prediction_rmse":21.79867936474416,"reconstruction_rmse":8.0113360914223,"retention_accuracy":1.0,"training_evaluations":2588672},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":6840,"drift_accuracy":0.29296875,"expert_count":12,"expert_evaluations":-13996,"planning_belief_set_rate":-0.046875,"planning_exact_state_rate":0.0,"prediction_rmse":-5.239934375989407,"reconstruction_rmse":-1.1836617465969326,"retention_accuracy":-0.01171875,"training_evaluations":-372748},"pareto_relation":"mixed"},"matched_compute_fixed_topology":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.6171875,"expert_count":64,"expert_evaluations":3224,"planning_belief_set_rate":0.125,"planning_exact_state_rate":0.0625,"prediction_rmse":21.686039761393904,"reconstruction_rmse":7.9831911026573925,"retention_accuracy":1.0,"training_evaluations":2407336},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":6840,"drift_accuracy":0.29296875,"expert_count":12,"expert_evaluations":-836,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":-5.12729477263915,"reconstruction_rmse":-1.1555167578320242,"retention_accuracy":-0.01171875,"training_evaluations":-191412},"pareto_relation":"mixed"},"matched_expert_count_capacity":{"metrics":{"checkpoint_size_bytes":50054,"drift_accuracy":0.6171875,"expert_count":76,"expert_evaluations":4224,"planning_belief_set_rate":0.171875,"planning_exact_state_rate":0.078125,"prediction_rmse":22.306174206951567,"reconstruction_rmse":7.928134854410766,"retention_accuracy":1.0,"training_evaluations":3540992},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.29296875,"expert_count":0,"expert_evaluations":-1836,"planning_belief_set_rate":-0.046875,"planning_exact_state_rate":-0.015625,"prediction_rmse":-5.747429218196814,"reconstruction_rmse":-1.1004605095853979,"retention_accuracy":-0.01171875,"training_evaluations":-1325068},"pareto_relation":"mixed"},"nearest_centroid_16_no_recursive_births":{"metrics":{"checkpoint_size_bytes":15854,"drift_accuracy":0.3046875,"expert_count":16,"expert_evaluations":4096,"planning_belief_set_rate":0.15625,"planning_exact_state_rate":0.046875,"prediction_rmse":22.857974133634123,"reconstruction_rmse":13.558652089135496,"retention_accuracy":0.50390625,"training_evaluations":253952},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":34200,"drift_accuracy":0.60546875,"expert_count":60,"expert_evaluations":-1708,"planning_belief_set_rate":-0.03125,"planning_exact_state_rate":0.015625,"prediction_rmse":-6.299229144879369,"reconstruction_rmse":-6.7309777443101275,"retention_accuracy":0.484375,"training_evaluations":1961972},"pareto_relation":"mixed"},"no_adaptation_static":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.6171875,"expert_count":64,"expert_evaluations":3224,"planning_belief_set_rate":0.125,"planning_exact_state_rate":0.0625,"prediction_rmse":21.686039761393904,"reconstruction_rmse":7.9831911026573925,"retention_accuracy":1.0,"training_evaluations":546472},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":6840,"drift_accuracy":0.29296875,"expert_count":12,"expert_evaluations":-836,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":-5.12729477263915,"reconstruction_rmse":-1.1555167578320242,"retention_accuracy":-0.01171875,"training_evaluations":1669452},"pareto_relation":"mixed"},"periodic_replay_policy":{"metrics":{"checkpoint_size_bytes":50054,"drift_accuracy":0.91015625,"expert_count":76,"expert_evaluations":2388,"planning_belief_set_rate":0.125,"planning_exact_state_rate":0.0625,"prediction_rmse":16.55930231570829,"reconstruction_rmse":6.828434312525723,"retention_accuracy":0.98828125,"training_evaluations":2216788},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":-0.0005573269535368297,"reconstruction_rmse":-0.0007599677003549132,"retention_accuracy":0.0,"training_evaluations":-864},"pareto_relation":"candidate_dominates"},"ravel_0_5_candidate":{"metrics":{"checkpoint_size_bytes":50054,"drift_accuracy":0.91015625,"expert_count":76,"expert_evaluations":2388,"planning_belief_set_rate":0.125,"planning_exact_state_rate":0.0625,"prediction_rmse":16.558744988754754,"reconstruction_rmse":6.827674344825368,"retention_accuracy":0.98828125,"training_evaluations":2215924},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"equivalent"},"ravel_complete_scan_without_certification":{"metrics":{"checkpoint_size_bytes":50054,"drift_accuracy":0.91015625,"expert_count":76,"expert_evaluations":19456,"planning_belief_set_rate":0.125,"planning_exact_state_rate":0.0625,"prediction_rmse":16.558744988754754,"reconstruction_rmse":6.827674344825368,"retention_accuracy":0.98828125,"training_evaluations":2422708},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":-17068,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":-206784},"pareto_relation":"candidate_dominates"},"ravel_no_birth_same_replay_iterations":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.6171875,"expert_count":64,"expert_evaluations":3224,"planning_belief_set_rate":0.125,"planning_exact_state_rate":0.0625,"prediction_rmse":21.686039761393904,"reconstruction_rmse":7.9831911026573925,"retention_accuracy":1.0,"training_evaluations":779080},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":6840,"drift_accuracy":0.29296875,"expert_count":12,"expert_evaluations":-836,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":-5.12729477263915,"reconstruction_rmse":-1.1555167578320242,"retention_accuracy":-0.01171875,"training_evaluations":1436844},"pareto_relation":"mixed"},"ravel_random_births":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.6171875,"expert_count":64,"expert_evaluations":3224,"planning_belief_set_rate":0.125,"planning_exact_state_rate":0.0625,"prediction_rmse":21.686039761393904,"reconstruction_rmse":7.9831911026573925,"retention_accuracy":1.0,"training_evaluations":779080},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":6840,"drift_accuracy":0.29296875,"expert_count":12,"expert_evaluations":-836,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":-5.12729477263915,"reconstruction_rmse":-1.1555167578320242,"retention_accuracy":-0.01171875,"training_evaluations":1436844},"pareto_relation":"mixed"},"ravel_without_replay":{"metrics":{"checkpoint_size_bytes":52334,"drift_accuracy":0.9140625,"expert_count":80,"expert_evaluations":3272,"planning_belief_set_rate":0.125,"planning_exact_state_rate":0.0625,"prediction_rmse":16.526058453960577,"reconstruction_rmse":6.817904978848722,"retention_accuracy":0.98046875,"training_evaluations":1675508},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":-2280,"drift_accuracy":-0.00390625,"expert_count":-4,"expert_evaluations":-884,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.032686534794176936,"reconstruction_rmse":0.009769365976646682,"retention_accuracy":0.0078125,"training_evaluations":540416},"pareto_relation":"mixed"},"ravel_without_retirement_matched_work":{"metrics":{"checkpoint_size_bytes":52334,"drift_accuracy":0.9140625,"expert_count":80,"expert_evaluations":3272,"planning_belief_set_rate":0.125,"planning_exact_state_rate":0.0625,"prediction_rmse":16.526058453960577,"reconstruction_rmse":6.817904978848722,"retention_accuracy":0.98046875,"training_evaluations":2215924},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":-2280,"drift_accuracy":-0.00390625,"expert_count":-4,"expert_evaluations":-884,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.032686534794176936,"reconstruction_rmse":0.009769365976646682,"retention_accuracy":0.0078125,"training_evaluations":0},"pareto_relation":"mixed"}},"gates":[{"gate_id":"adaptation_completed","metric":"adaptation_completed","observed":true,"operator":"eq","pass":true,"rationale":"The bounded adaptation procedure must complete.","threshold":true},{"gate_id":"base_holdout_accuracy","metric":"base_accuracy","observed":1.0,"operator":"ge","pass":true,"rationale":"The base representation must establish the bounded task before drift.","threshold":0.85},{"gate_id":"base_holdout_retention","metric":"retention_accuracy","observed":0.98828125,"operator":"ge","pass":true,"rationale":"Anchored base behavior may lose at most ten percentage points in absolute retained accuracy.","threshold":0.9},{"gate_id":"routing_oracle_equivalence","metric":"routing_mismatches","observed":0,"operator":"eq","pass":true,"rationale":"Every routed classification must agree with complete scan.","threshold":0},{"gate_id":"checkpoint_roundtrip","metric":"checkpoint_roundtrip","observed":true,"operator":"eq","pass":true,"rationale":"Canonical in-memory restoration must succeed.","threshold":true},{"gate_id":"checkpoint_identity","metric":"checkpoint_identity","observed":true,"operator":"eq","pass":true,"rationale":"Restored complete model identity must match.","threshold":true},{"gate_id":"checkpoint_behavior","metric":"checkpoint_behavior","observed":true,"operator":"eq","pass":true,"rationale":"Restored evaluation and planning behavior must match.","threshold":true},{"gate_id":"checkpoint_mutation_rejection","metric":"checkpoint_mutations","observed":true,"operator":"eq","pass":true,"rationale":"Every declared behavioral and byte-level checkpoint mutation must be detected.","threshold":true},{"gate_id":"lineage_invariants","metric":"lineage_invariants","observed":true,"operator":"eq","pass":true,"rationale":"Generation, lineage uniqueness, descendant splitting, and deterministic topology invariants must hold.","threshold":true},{"gate_id":"unsupported_transitions_unknown","metric":"unsupported_graph_edge_violations","observed":0,"operator":"eq","pass":true,"rationale":"Unsupported actions cannot enter the planning graph.","threshold":0},{"gate_id":"replay_size","metric":"replay_selected","observed":256,"operator":"eq","pass":true,"rationale":"The declared replay budget must be filled on the non-sparse trial corpus.","threshold":256},{"gate_id":"replay_unique","metric":"replay_unique","observed":256,"operator":"eq","pass":true,"rationale":"Balanced replay cannot introduce accidental duplicates.","threshold":256},{"gate_id":"replay_label_coverage","metric":"replay_labels_covered","observed":8,"operator":"eq","pass":true,"rationale":"Replay must retain every declared label.","threshold":8},{"gate_id":"replay_action_coverage","metric":"replay_actions_covered","observed":4,"operator":"eq","pass":true,"rationale":"Replay must retain every declared action.","threshold":4},{"gate_id":"replay_state_coverage","metric":"replay_states_covered","observed":64,"operator":"ge","pass":true,"rationale":"Replay must cover at least 60 of 64 source states.","threshold":60},{"gate_id":"replay_expert_coverage","metric":"replay_experts_covered","observed":61,"operator":"ge","pass":true,"rationale":"Replay must retain broad assigned-expert coverage.","threshold":60},{"gate_id":"replay_transition_coverage","metric":"replay_transition_pairs_covered","observed":252,"operator":"ge","pass":true,"rationale":"Replay must preserve broad source-state/action transition support.","threshold":220},{"gate_id":"planning_path_found","metric":"path_found_rate","observed":0.734375,"operator":"ge","pass":false,"rationale":"At least three quarters of bounded planning cases must have a supported path.","threshold":0.75},{"gate_id":"expert_capacity","metric":"expert_count","observed":76,"operator":"le","pass":true,"rationale":"Adaptation cannot exceed the declared expert capacity.","threshold":80},{"gate_id":"retirement_budget","metric":"accepted_retirements","observed":4,"operator":"le","pass":true,"rationale":"Retirement remains optional and bounded.","threshold":4},{"gate_id":"topology_objective_non_degradation","metric":"topology_objective_gain_q20","observed":41884,"operator":"ge","pass":true,"rationale":"Accepted adaptation-training topology decisions cannot reduce their declared objective.","threshold":0},{"gate_id":"matched_compute_budget","metric":"matched_compute_training_evaluation_ratio","observed":0.9204880415529864,"operator":"le","pass":true,"rationale":"Candidate training work may exceed the matched fixed-topology budget by at most ten percent.","threshold":1.1},{"gate_id":"conditional_inference_efficiency","metric":"inference_evaluation_ratio_vs_flat64","observed":0.145751953125,"operator":"le","pass":true,"rationale":"Routed inference must use at most one quarter of flat complete-scan expert evaluations.","threshold":0.25},{"gate_id":"ambiguous_adaptation","metric":"adapted_drift_accuracy","observed":0.91015625,"operator":"ge","pass":true,"rationale":"Visible evidence must support useful classification despite hidden-state aliasing.","threshold":0.7},{"gate_id":"ambiguous_gain","metric":"drift_accuracy_delta","observed":0.29296875,"operator":"ge","pass":true,"rationale":"The aliased regime has adaptation headroom and requires improvement.","threshold":0.05},{"gate_id":"ambiguous_belief_success","metric":"belief_set_rate","observed":0.125,"operator":"ge","pass":false,"rationale":"Belief-set target success is the capability gate under declared aliasing.","threshold":0.2},{"gate_id":"ambiguous_belief_gain","metric":"belief_set_rate_delta","observed":0.0,"operator":"ge","pass":false,"rationale":"Adaptation must improve alias-aware planning over the static model.","threshold":0.05},{"gate_id":"ambiguous_reconstruction_retention","metric":"retention_reconstruction_degradation_ratio","observed":-0.013331722112376081,"operator":"le","pass":true,"rationale":"Original visible-state reconstruction cannot materially degrade.","threshold":0.1},{"gate_id":"ambiguous_prediction_retention","metric":"retention_prediction_degradation","observed":-1.4819624299238061,"operator":"le","pass":true,"rationale":"Original visible-state prediction cannot materially degrade.","threshold":1}],"metrics":{"accepted_births":16,"accepted_retirements":4,"adaptation_completed":true,"adaptation_training_accuracy":0.908203125,"adapted_drift_accuracy":0.91015625,"adapted_prediction_rmse":16.558744988754754,"adapted_reconstruction_rmse":6.827674344825368,"adapted_transition_accuracy":0.4449760765550239,"balanced_vs_periodic_drift_accuracy_delta":0.0,"balanced_vs_periodic_retention_delta":0.0,"base_accuracy":1.0,"base_prediction_rmse":15.707376087994545,"base_reconstruction_rmse":5.409828730853543,"belief_set_rate":0.125,"belief_set_rate_delta":0.0,"checkpoint_behavior":true,"checkpoint_identity":true,"checkpoint_mutations":true,"checkpoint_roundtrip":true,"checkpoint_size_bytes":50054,"drift_accuracy_delta":0.29296875,"exact_state_rate":0.0625,"exact_state_rate_delta":0.0,"expert_count":76,"headroom_normalized_accuracy_improvement":0.7653061224489796,"inference_evaluation_ratio_vs_flat64":0.145751953125,"inference_expert_evaluations":2388,"lineage_invariants":true,"matched_compute_drift_accuracy_delta":0.29296875,"matched_compute_retention_delta":-0.01171875,"matched_compute_training_evaluation_ratio":0.9204880415529864,"no_birth_drift_accuracy_delta":0.29296875,"no_retirement_drift_accuracy_delta":-0.00390625,"path_found_rate":0.734375,"prediction_improvement_ratio":0.2364329692767097,"reconstruction_improvement_ratio":0.14474371751509035,"replay_actions_covered":4,"replay_experts_covered":61,"replay_labels_covered":8,"replay_selected":256,"replay_states_covered":64,"replay_transition_pairs_covered":252,"replay_unique":256,"retention_accuracy":0.98828125,"retention_accuracy_delta_from_base":-0.01171875,"retention_prediction_degradation":-1.4819624299238061,"retention_prediction_rmse":14.225413658070739,"retention_reconstruction_degradation_ratio":-0.013331722112376081,"retention_reconstruction_rmse":5.3377063975382555,"retention_transition_accuracy_delta":-0.049369747899159655,"routing_mismatches":0,"static_belief_set_rate":0.125,"static_drift_accuracy":0.6171875,"static_exact_state_rate":0.0625,"static_prediction_rmse":21.686039761393904,"static_reconstruction_rmse":7.9831911026573925,"static_transition_accuracy":0.3826086956521739,"topology_objective_gain_q20":41884,"training_evaluations":2215924,"transition_accuracy_delta":0.06236738090284999,"transition_support_rate":0.81640625,"unsupported_graph_edge_violations":0},"regime":"partially_observed_ambiguous","seed":"0xdad034619fabf595","trial_id":"validation-ambiguous-02","trial_result":"FAIL"},{"comparisons":{"fixed_8_expert":{"metrics":{"checkpoint_size_bytes":11294,"drift_accuracy":0.2109375,"expert_count":8,"expert_evaluations":2048,"planning_belief_set_rate":0.34375,"planning_exact_state_rate":0.046875,"prediction_rmse":23.57130819219268,"reconstruction_rmse":18.969008168777826,"retention_accuracy":0.3359375,"training_evaluations":94208},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":40470,"drift_accuracy":0.65625,"expert_count":71,"expert_evaluations":497,"planning_belief_set_rate":-0.078125,"planning_exact_state_rate":0.109375,"prediction_rmse":-6.563227704635221,"reconstruction_rmse":-12.0021350249474,"retention_accuracy":0.6640625,"training_evaluations":2101837},"pareto_relation":"mixed"},"fixed_topology_64_expert_routed":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.640625,"expert_count":64,"expert_evaluations":3560,"planning_belief_set_rate":0.234375,"planning_exact_state_rate":0.0625,"prediction_rmse":20.018130305650583,"reconstruction_rmse":7.868998980336184,"retention_accuracy":1.0,"training_evaluations":2588672},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":8550,"drift_accuracy":0.2265625,"expert_count":15,"expert_evaluations":-1015,"planning_belief_set_rate":0.03125,"planning_exact_state_rate":0.09375,"prediction_rmse":-3.0100498180931226,"reconstruction_rmse":-0.9021258365057578,"retention_accuracy":0.0,"training_evaluations":-392627},"pareto_relation":"mixed"},"flat_64_expert_complete_scan":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.640625,"expert_count":64,"expert_evaluations":16384,"planning_belief_set_rate":0.234375,"planning_exact_state_rate":0.0625,"prediction_rmse":20.018130305650583,"reconstruction_rmse":7.868998980336184,"retention_accuracy":1.0,"training_evaluations":2588672},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":8550,"drift_accuracy":0.2265625,"expert_count":15,"expert_evaluations":-13839,"planning_belief_set_rate":0.03125,"planning_exact_state_rate":0.09375,"prediction_rmse":-3.0100498180931226,"reconstruction_rmse":-0.9021258365057578,"retention_accuracy":0.0,"training_evaluations":-392627},"pareto_relation":"mixed"},"matched_compute_fixed_topology":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.640625,"expert_count":64,"expert_evaluations":3504,"planning_belief_set_rate":0.21875,"planning_exact_state_rate":0.09375,"prediction_rmse":20.482769965843165,"reconstruction_rmse":7.904838930362171,"retention_accuracy":1.0,"training_evaluations":2407328},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":8550,"drift_accuracy":0.2265625,"expert_count":15,"expert_evaluations":-959,"planning_belief_set_rate":0.046875,"planning_exact_state_rate":0.0625,"prediction_rmse":-3.474689478285704,"reconstruction_rmse":-0.9379657865317448,"retention_accuracy":0.0,"training_evaluations":-211283},"pareto_relation":"mixed"},"matched_expert_count_capacity":{"metrics":{"checkpoint_size_bytes":51764,"drift_accuracy":0.640625,"expert_count":79,"expert_evaluations":4462,"planning_belief_set_rate":0.1875,"planning_exact_state_rate":0.046875,"prediction_rmse":20.633697405993978,"reconstruction_rmse":7.756156656226764,"retention_accuracy":1.0,"training_evaluations":3802112},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.2265625,"expert_count":0,"expert_evaluations":-1917,"planning_belief_set_rate":0.078125,"planning_exact_state_rate":0.109375,"prediction_rmse":-3.625616918436517,"reconstruction_rmse":-0.789283512396338,"retention_accuracy":0.0,"training_evaluations":-1606067},"pareto_relation":"candidate_dominates"},"nearest_centroid_16_no_recursive_births":{"metrics":{"checkpoint_size_bytes":15854,"drift_accuracy":0.25,"expert_count":16,"expert_evaluations":4096,"planning_belief_set_rate":0.21875,"planning_exact_state_rate":0.03125,"prediction_rmse":22.068047073823998,"reconstruction_rmse":13.420762236426642,"retention_accuracy":0.51171875,"training_evaluations":253952},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":35910,"drift_accuracy":0.6171875,"expert_count":63,"expert_evaluations":-1551,"planning_belief_set_rate":0.046875,"planning_exact_state_rate":0.125,"prediction_rmse":-5.059966586266537,"reconstruction_rmse":-6.453889092596215,"retention_accuracy":0.48828125,"training_evaluations":1942093},"pareto_relation":"mixed"},"no_adaptation_static":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.640625,"expert_count":64,"expert_evaluations":3504,"planning_belief_set_rate":0.21875,"planning_exact_state_rate":0.09375,"prediction_rmse":20.482769965843165,"reconstruction_rmse":7.904838930362171,"retention_accuracy":1.0,"training_evaluations":544672},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":8550,"drift_accuracy":0.2265625,"expert_count":15,"expert_evaluations":-959,"planning_belief_set_rate":0.046875,"planning_exact_state_rate":0.0625,"prediction_rmse":-3.474689478285704,"reconstruction_rmse":-0.9379657865317448,"retention_accuracy":0.0,"training_evaluations":1651373},"pareto_relation":"mixed"},"periodic_replay_policy":{"metrics":{"checkpoint_size_bytes":51764,"drift_accuracy":0.8671875,"expert_count":79,"expert_evaluations":2545,"planning_belief_set_rate":0.265625,"planning_exact_state_rate":0.15625,"prediction_rmse":17.00808048755746,"reconstruction_rmse":6.965477316818984,"retention_accuracy":1.0,"training_evaluations":2196045},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0013958270114420301,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"variant_dominates"},"ravel_0_5_candidate":{"metrics":{"checkpoint_size_bytes":51764,"drift_accuracy":0.8671875,"expert_count":79,"expert_evaluations":2545,"planning_belief_set_rate":0.265625,"planning_exact_state_rate":0.15625,"prediction_rmse":17.00808048755746,"reconstruction_rmse":6.966873143830426,"retention_accuracy":1.0,"training_evaluations":2196045},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"equivalent"},"ravel_complete_scan_without_certification":{"metrics":{"checkpoint_size_bytes":51764,"drift_accuracy":0.8671875,"expert_count":79,"expert_evaluations":20224,"planning_belief_set_rate":0.265625,"planning_exact_state_rate":0.15625,"prediction_rmse":17.00808048755746,"reconstruction_rmse":6.966873143830426,"retention_accuracy":1.0,"training_evaluations":2410394},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":-17679,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":-214349},"pareto_relation":"candidate_dominates"},"ravel_no_birth_same_replay_iterations":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.640625,"expert_count":64,"expert_evaluations":3504,"planning_belief_set_rate":0.21875,"planning_exact_state_rate":0.09375,"prediction_rmse":20.482769965843165,"reconstruction_rmse":7.904838930362171,"retention_accuracy":1.0,"training_evaluations":777504},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":8550,"drift_accuracy":0.2265625,"expert_count":15,"expert_evaluations":-959,"planning_belief_set_rate":0.046875,"planning_exact_state_rate":0.0625,"prediction_rmse":-3.474689478285704,"reconstruction_rmse":-0.9379657865317448,"retention_accuracy":0.0,"training_evaluations":1418541},"pareto_relation":"mixed"},"ravel_random_births":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.640625,"expert_count":64,"expert_evaluations":3504,"planning_belief_set_rate":0.21875,"planning_exact_state_rate":0.09375,"prediction_rmse":20.482769965843165,"reconstruction_rmse":7.904838930362171,"retention_accuracy":1.0,"training_evaluations":777504},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":8550,"drift_accuracy":0.2265625,"expert_count":15,"expert_evaluations":-959,"planning_belief_set_rate":0.046875,"planning_exact_state_rate":0.0625,"prediction_rmse":-3.474689478285704,"reconstruction_rmse":-0.9379657865317448,"retention_accuracy":0.0,"training_evaluations":1418541},"pareto_relation":"mixed"},"ravel_without_replay":{"metrics":{"checkpoint_size_bytes":51764,"drift_accuracy":0.8671875,"expert_count":79,"expert_evaluations":2545,"planning_belief_set_rate":0.265625,"planning_exact_state_rate":0.15625,"prediction_rmse":17.00808048755746,"reconstruction_rmse":6.965477316818984,"retention_accuracy":1.0,"training_evaluations":1663565},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0013958270114420301,"retention_accuracy":0.0,"training_evaluations":532480},"pareto_relation":"variant_dominates"},"ravel_without_retirement_matched_work":{"metrics":{"checkpoint_size_bytes":51764,"drift_accuracy":0.8671875,"expert_count":79,"expert_evaluations":2545,"planning_belief_set_rate":0.265625,"planning_exact_state_rate":0.15625,"prediction_rmse":17.00808048755746,"reconstruction_rmse":6.966873143830426,"retention_accuracy":1.0,"training_evaluations":2196045},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"equivalent"}},"gates":[{"gate_id":"adaptation_completed","metric":"adaptation_completed","observed":true,"operator":"eq","pass":true,"rationale":"The bounded adaptation procedure must complete.","threshold":true},{"gate_id":"base_holdout_accuracy","metric":"base_accuracy","observed":1.0,"operator":"ge","pass":true,"rationale":"The base representation must establish the bounded task before drift.","threshold":0.85},{"gate_id":"base_holdout_retention","metric":"retention_accuracy","observed":1.0,"operator":"ge","pass":true,"rationale":"Anchored base behavior may lose at most ten percentage points in absolute retained accuracy.","threshold":0.9},{"gate_id":"routing_oracle_equivalence","metric":"routing_mismatches","observed":0,"operator":"eq","pass":true,"rationale":"Every routed classification must agree with complete scan.","threshold":0},{"gate_id":"checkpoint_roundtrip","metric":"checkpoint_roundtrip","observed":true,"operator":"eq","pass":true,"rationale":"Canonical in-memory restoration must succeed.","threshold":true},{"gate_id":"checkpoint_identity","metric":"checkpoint_identity","observed":true,"operator":"eq","pass":true,"rationale":"Restored complete model identity must match.","threshold":true},{"gate_id":"checkpoint_behavior","metric":"checkpoint_behavior","observed":true,"operator":"eq","pass":true,"rationale":"Restored evaluation and planning behavior must match.","threshold":true},{"gate_id":"checkpoint_mutation_rejection","metric":"checkpoint_mutations","observed":true,"operator":"eq","pass":true,"rationale":"Every declared behavioral and byte-level checkpoint mutation must be detected.","threshold":true},{"gate_id":"lineage_invariants","metric":"lineage_invariants","observed":true,"operator":"eq","pass":true,"rationale":"Generation, lineage uniqueness, descendant splitting, and deterministic topology invariants must hold.","threshold":true},{"gate_id":"unsupported_transitions_unknown","metric":"unsupported_graph_edge_violations","observed":0,"operator":"eq","pass":true,"rationale":"Unsupported actions cannot enter the planning graph.","threshold":0},{"gate_id":"replay_size","metric":"replay_selected","observed":256,"operator":"eq","pass":true,"rationale":"The declared replay budget must be filled on the non-sparse trial corpus.","threshold":256},{"gate_id":"replay_unique","metric":"replay_unique","observed":256,"operator":"eq","pass":true,"rationale":"Balanced replay cannot introduce accidental duplicates.","threshold":256},{"gate_id":"replay_label_coverage","metric":"replay_labels_covered","observed":8,"operator":"eq","pass":true,"rationale":"Replay must retain every declared label.","threshold":8},{"gate_id":"replay_action_coverage","metric":"replay_actions_covered","observed":4,"operator":"eq","pass":true,"rationale":"Replay must retain every declared action.","threshold":4},{"gate_id":"replay_state_coverage","metric":"replay_states_covered","observed":64,"operator":"ge","pass":true,"rationale":"Replay must cover at least 60 of 64 source states.","threshold":60},{"gate_id":"replay_expert_coverage","metric":"replay_experts_covered","observed":60,"operator":"ge","pass":true,"rationale":"Replay must retain broad assigned-expert coverage.","threshold":60},{"gate_id":"replay_transition_coverage","metric":"replay_transition_pairs_covered","observed":254,"operator":"ge","pass":true,"rationale":"Replay must preserve broad source-state/action transition support.","threshold":220},{"gate_id":"planning_path_found","metric":"path_found_rate","observed":1.0,"operator":"ge","pass":true,"rationale":"At least three quarters of bounded planning cases must have a supported path.","threshold":0.75},{"gate_id":"expert_capacity","metric":"expert_count","observed":79,"operator":"le","pass":true,"rationale":"Adaptation cannot exceed the declared expert capacity.","threshold":80},{"gate_id":"retirement_budget","metric":"accepted_retirements","observed":0,"operator":"le","pass":true,"rationale":"Retirement remains optional and bounded.","threshold":4},{"gate_id":"topology_objective_non_degradation","metric":"topology_objective_gain_q20","observed":58045,"operator":"ge","pass":true,"rationale":"Accepted adaptation-training topology decisions cannot reduce their declared objective.","threshold":0},{"gate_id":"matched_compute_budget","metric":"matched_compute_training_evaluation_ratio","observed":0.9122333973600606,"operator":"le","pass":true,"rationale":"Candidate training work may exceed the matched fixed-topology budget by at most ten percent.","threshold":1.1},{"gate_id":"conditional_inference_efficiency","metric":"inference_evaluation_ratio_vs_flat64","observed":0.15533447265625,"operator":"le","pass":true,"rationale":"Routed inference must use at most one quarter of flat complete-scan expert evaluations.","threshold":0.25},{"gate_id":"ambiguous_adaptation","metric":"adapted_drift_accuracy","observed":0.8671875,"operator":"ge","pass":true,"rationale":"Visible evidence must support useful classification despite hidden-state aliasing.","threshold":0.7},{"gate_id":"ambiguous_gain","metric":"drift_accuracy_delta","observed":0.2265625,"operator":"ge","pass":true,"rationale":"The aliased regime has adaptation headroom and requires improvement.","threshold":0.05},{"gate_id":"ambiguous_belief_success","metric":"belief_set_rate","observed":0.265625,"operator":"ge","pass":true,"rationale":"Belief-set target success is the capability gate under declared aliasing.","threshold":0.2},{"gate_id":"ambiguous_belief_gain","metric":"belief_set_rate_delta","observed":0.046875,"operator":"ge","pass":false,"rationale":"Adaptation must improve alias-aware planning over the static model.","threshold":0.05},{"gate_id":"ambiguous_reconstruction_retention","metric":"retention_reconstruction_degradation_ratio","observed":-0.0002652089122856194,"operator":"le","pass":true,"rationale":"Original visible-state reconstruction cannot materially degrade.","threshold":0.1},{"gate_id":"ambiguous_prediction_retention","metric":"retention_prediction_degradation","observed":-1.1480344632545112,"operator":"le","pass":true,"rationale":"Original visible-state prediction cannot materially degrade.","threshold":1}],"metrics":{"accepted_births":15,"accepted_retirements":0,"adaptation_completed":true,"adaptation_training_accuracy":0.912109375,"adapted_drift_accuracy":0.8671875,"adapted_prediction_rmse":17.00808048755746,"adapted_reconstruction_rmse":6.966873143830426,"adapted_transition_accuracy":0.4824561403508772,"balanced_vs_periodic_drift_accuracy_delta":0.0,"balanced_vs_periodic_retention_delta":0.0,"base_accuracy":1.0,"base_prediction_rmse":15.393334437577716,"base_reconstruction_rmse":5.370450311006731,"belief_set_rate":0.265625,"belief_set_rate_delta":0.046875,"checkpoint_behavior":true,"checkpoint_identity":true,"checkpoint_mutations":true,"checkpoint_roundtrip":true,"checkpoint_size_bytes":51764,"drift_accuracy_delta":0.2265625,"exact_state_rate":0.15625,"exact_state_rate_delta":0.0625,"expert_count":79,"headroom_normalized_accuracy_improvement":0.6304347826086957,"inference_evaluation_ratio_vs_flat64":0.15533447265625,"inference_expert_evaluations":2545,"lineage_invariants":true,"matched_compute_drift_accuracy_delta":0.2265625,"matched_compute_retention_delta":0.0,"matched_compute_training_evaluation_ratio":0.9122333973600606,"no_birth_drift_accuracy_delta":0.2265625,"no_retirement_drift_accuracy_delta":0.0,"path_found_rate":1.0,"prediction_improvement_ratio":0.169639628042499,"reconstruction_improvement_ratio":0.11865716617312158,"replay_actions_covered":4,"replay_experts_covered":60,"replay_labels_covered":8,"replay_selected":256,"replay_states_covered":64,"replay_transition_pairs_covered":254,"replay_unique":256,"retention_accuracy":1.0,"retention_accuracy_delta_from_base":0.0,"retention_prediction_degradation":-1.1480344632545112,"retention_prediction_rmse":14.245299974323204,"retention_reconstruction_degradation_ratio":-0.0002652089122856194,"retention_reconstruction_rmse":5.369026019721265,"retention_transition_accuracy_delta":0.015462979807167487,"routing_mismatches":0,"static_belief_set_rate":0.21875,"static_drift_accuracy":0.640625,"static_exact_state_rate":0.09375,"static_prediction_rmse":20.482769965843165,"static_reconstruction_rmse":7.904838930362171,"static_transition_accuracy":0.40789473684210525,"topology_objective_gain_q20":58045,"training_evaluations":2196045,"transition_accuracy_delta":0.07456140350877194,"transition_support_rate":0.890625,"unsupported_graph_edge_violations":0},"regime":"partially_observed_ambiguous","seed":"0x81024ac97a8edb6c","trial_id":"validation-ambiguous-03","trial_result":"FAIL"},{"comparisons":{"fixed_8_expert":{"metrics":{"checkpoint_size_bytes":11294,"drift_accuracy":0.2421875,"expert_count":8,"expert_evaluations":2048,"planning_belief_set_rate":0.140625,"planning_exact_state_rate":0.03125,"prediction_rmse":24.71333894647622,"reconstruction_rmse":19.784526328460085,"retention_accuracy":0.234375,"training_evaluations":94208},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":39900,"drift_accuracy":0.61328125,"expert_count":70,"expert_evaluations":2100,"planning_belief_set_rate":0.109375,"planning_exact_state_rate":0.109375,"prediction_rmse":-7.047461107050722,"reconstruction_rmse":-12.721040044962605,"retention_accuracy":0.765625,"training_evaluations":2120592},"pareto_relation":"mixed"},"fixed_topology_64_expert_routed":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.640625,"expert_count":64,"expert_evaluations":2888,"planning_belief_set_rate":0.1875,"planning_exact_state_rate":0.109375,"prediction_rmse":20.778247466148272,"reconstruction_rmse":7.676291377585656,"retention_accuracy":1.0,"training_evaluations":2588672},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":7980,"drift_accuracy":0.21484375,"expert_count":14,"expert_evaluations":1260,"planning_belief_set_rate":0.0625,"planning_exact_state_rate":0.03125,"prediction_rmse":-3.1123696267227743,"reconstruction_rmse":-0.6128050940881753,"retention_accuracy":0.0,"training_evaluations":-373872},"pareto_relation":"mixed"},"flat_64_expert_complete_scan":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.640625,"expert_count":64,"expert_evaluations":16384,"planning_belief_set_rate":0.1875,"planning_exact_state_rate":0.109375,"prediction_rmse":20.778247466148272,"reconstruction_rmse":7.676291377585656,"retention_accuracy":1.0,"training_evaluations":2588672},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":7980,"drift_accuracy":0.21484375,"expert_count":14,"expert_evaluations":-12236,"planning_belief_set_rate":0.0625,"planning_exact_state_rate":0.03125,"prediction_rmse":-3.1123696267227743,"reconstruction_rmse":-0.6128050940881753,"retention_accuracy":0.0,"training_evaluations":-373872},"pareto_relation":"mixed"},"matched_compute_fixed_topology":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.640625,"expert_count":64,"expert_evaluations":3280,"planning_belief_set_rate":0.140625,"planning_exact_state_rate":0.078125,"prediction_rmse":20.812407962202325,"reconstruction_rmse":7.88438637271158,"retention_accuracy":1.0,"training_evaluations":2430216},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":7980,"drift_accuracy":0.21484375,"expert_count":14,"expert_evaluations":868,"planning_belief_set_rate":0.109375,"planning_exact_state_rate":0.0625,"prediction_rmse":-3.146530122776827,"reconstruction_rmse":-0.8209000892140992,"retention_accuracy":0.0,"training_evaluations":-215416},"pareto_relation":"mixed"},"matched_expert_count_capacity":{"metrics":{"checkpoint_size_bytes":51194,"drift_accuracy":0.640625,"expert_count":78,"expert_evaluations":3448,"planning_belief_set_rate":0.171875,"planning_exact_state_rate":0.09375,"prediction_rmse":20.671215562907,"reconstruction_rmse":7.543621157962548,"retention_accuracy":1.0,"training_evaluations":3714048},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.21484375,"expert_count":0,"expert_evaluations":700,"planning_belief_set_rate":0.078125,"planning_exact_state_rate":0.046875,"prediction_rmse":-3.005337723481503,"reconstruction_rmse":-0.4801348744650671,"retention_accuracy":0.0,"training_evaluations":-1499248},"pareto_relation":"mixed"},"nearest_centroid_16_no_recursive_births":{"metrics":{"checkpoint_size_bytes":15854,"drift_accuracy":0.375,"expert_count":16,"expert_evaluations":4096,"planning_belief_set_rate":0.203125,"planning_exact_state_rate":0.09375,"prediction_rmse":22.682904715661223,"reconstruction_rmse":13.910693199335427,"retention_accuracy":0.52734375,"training_evaluations":253952},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":35340,"drift_accuracy":0.48046875,"expert_count":62,"expert_evaluations":52,"planning_belief_set_rate":0.046875,"planning_exact_state_rate":0.046875,"prediction_rmse":-5.017026876235725,"reconstruction_rmse":-6.847206915837946,"retention_accuracy":0.47265625,"training_evaluations":1960848},"pareto_relation":"mixed"},"no_adaptation_static":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.640625,"expert_count":64,"expert_evaluations":3280,"planning_belief_set_rate":0.140625,"planning_exact_state_rate":0.078125,"prediction_rmse":20.812407962202325,"reconstruction_rmse":7.88438637271158,"retention_accuracy":1.0,"training_evaluations":546056},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":7980,"drift_accuracy":0.21484375,"expert_count":14,"expert_evaluations":868,"planning_belief_set_rate":0.109375,"planning_exact_state_rate":0.0625,"prediction_rmse":-3.146530122776827,"reconstruction_rmse":-0.8209000892140992,"retention_accuracy":0.0,"training_evaluations":1668744},"pareto_relation":"mixed"},"periodic_replay_policy":{"metrics":{"checkpoint_size_bytes":51194,"drift_accuracy":0.85546875,"expert_count":78,"expert_evaluations":4148,"planning_belief_set_rate":0.25,"planning_exact_state_rate":0.140625,"prediction_rmse":17.665877839425498,"reconstruction_rmse":7.064735769152491,"retention_accuracy":1.0,"training_evaluations":2214870},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":-0.0012494856550100408,"retention_accuracy":0.0,"training_evaluations":-70},"pareto_relation":"candidate_dominates"},"ravel_0_5_candidate":{"metrics":{"checkpoint_size_bytes":51194,"drift_accuracy":0.85546875,"expert_count":78,"expert_evaluations":4148,"planning_belief_set_rate":0.25,"planning_exact_state_rate":0.140625,"prediction_rmse":17.665877839425498,"reconstruction_rmse":7.063486283497481,"retention_accuracy":1.0,"training_evaluations":2214800},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"equivalent"},"ravel_complete_scan_without_certification":{"metrics":{"checkpoint_size_bytes":51194,"drift_accuracy":0.85546875,"expert_count":78,"expert_evaluations":19968,"planning_belief_set_rate":0.25,"planning_exact_state_rate":0.140625,"prediction_rmse":17.665877839425498,"reconstruction_rmse":7.063486283497481,"retention_accuracy":1.0,"training_evaluations":2410940},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":-15820,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":-196140},"pareto_relation":"candidate_dominates"},"ravel_no_birth_same_replay_iterations":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.640625,"expert_count":64,"expert_evaluations":3280,"planning_belief_set_rate":0.140625,"planning_exact_state_rate":0.078125,"prediction_rmse":20.812407962202325,"reconstruction_rmse":7.88438637271158,"retention_accuracy":1.0,"training_evaluations":781576},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":7980,"drift_accuracy":0.21484375,"expert_count":14,"expert_evaluations":868,"planning_belief_set_rate":0.109375,"planning_exact_state_rate":0.0625,"prediction_rmse":-3.146530122776827,"reconstruction_rmse":-0.8209000892140992,"retention_accuracy":0.0,"training_evaluations":1433224},"pareto_relation":"mixed"},"ravel_random_births":{"metrics":{"checkpoint_size_bytes":43214,"drift_accuracy":0.640625,"expert_count":64,"expert_evaluations":3280,"planning_belief_set_rate":0.140625,"planning_exact_state_rate":0.078125,"prediction_rmse":20.812407962202325,"reconstruction_rmse":7.88438637271158,"retention_accuracy":1.0,"training_evaluations":781576},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":7980,"drift_accuracy":0.21484375,"expert_count":14,"expert_evaluations":868,"planning_belief_set_rate":0.109375,"planning_exact_state_rate":0.0625,"prediction_rmse":-3.146530122776827,"reconstruction_rmse":-0.8209000892140992,"retention_accuracy":0.0,"training_evaluations":1433224},"pareto_relation":"mixed"},"ravel_without_replay":{"metrics":{"checkpoint_size_bytes":51194,"drift_accuracy":0.85546875,"expert_count":78,"expert_evaluations":4148,"planning_belief_set_rate":0.25,"planning_exact_state_rate":0.140625,"prediction_rmse":17.665877839425498,"reconstruction_rmse":7.064735769152491,"retention_accuracy":1.0,"training_evaluations":1681030},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":-0.0012494856550100408,"retention_accuracy":0.0,"training_evaluations":533770},"pareto_relation":"mixed"},"ravel_without_retirement_matched_work":{"metrics":{"checkpoint_size_bytes":51194,"drift_accuracy":0.85546875,"expert_count":78,"expert_evaluations":4148,"planning_belief_set_rate":0.25,"planning_exact_state_rate":0.140625,"prediction_rmse":17.665877839425498,"reconstruction_rmse":7.063486283497481,"retention_accuracy":1.0,"training_evaluations":2214800},"paired_delta_candidate_minus_variant":{"checkpoint_size_bytes":0,"drift_accuracy":0.0,"expert_count":0,"expert_evaluations":0,"planning_belief_set_rate":0.0,"planning_exact_state_rate":0.0,"prediction_rmse":0.0,"reconstruction_rmse":0.0,"retention_accuracy":0.0,"training_evaluations":0},"pareto_relation":"equivalent"}},"gates":[{"gate_id":"adaptation_completed","metric":"adaptation_completed","observed":true,"operator":"eq","pass":true,"rationale":"The bounded adaptation procedure must complete.","threshold":true},{"gate_id":"base_holdout_accuracy","metric":"base_accuracy","observed":1.0,"operator":"ge","pass":true,"rationale":"The base representation must establish the bounded task before drift.","threshold":0.85},{"gate_id":"base_holdout_retention","metric":"retention_accuracy","observed":1.0,"operator":"ge","pass":true,"rationale":"Anchored base behavior may lose at most ten percentage points in absolute retained accuracy.","threshold":0.9},{"gate_id":"routing_oracle_equivalence","metric":"routing_mismatches","observed":0,"operator":"eq","pass":true,"rationale":"Every routed classification must agree with complete scan.","threshold":0},{"gate_id":"checkpoint_roundtrip","metric":"checkpoint_roundtrip","observed":true,"operator":"eq","pass":true,"rationale":"Canonical in-memory restoration must succeed.","threshold":true},{"gate_id":"checkpoint_identity","metric":"checkpoint_identity","observed":true,"operator":"eq","pass":true,"rationale":"Restored complete model identity must match.","threshold":true},{"gate_id":"checkpoint_behavior","metric":"checkpoint_behavior","observed":true,"operator":"eq","pass":true,"rationale":"Restored evaluation and planning behavior must match.","threshold":true},{"gate_id":"checkpoint_mutation_rejection","metric":"checkpoint_mutations","observed":true,"operator":"eq","pass":true,"rationale":"Every declared behavioral and byte-level checkpoint mutation must be detected.","threshold":true},{"gate_id":"lineage_invariants","metric":"lineage_invariants","observed":true,"operator":"eq","pass":true,"rationale":"Generation, lineage uniqueness, descendant splitting, and deterministic topology invariants must hold.","threshold":true},{"gate_id":"unsupported_transitions_unknown","metric":"unsupported_graph_edge_violations","observed":0,"operator":"eq","pass":true,"rationale":"Unsupported actions cannot enter the planning graph.","threshold":0},{"gate_id":"replay_size","metric":"replay_selected","observed":256,"operator":"eq","pass":true,"rationale":"The declared replay budget must be filled on the non-sparse trial corpus.","threshold":256},{"gate_id":"replay_unique","metric":"replay_unique","observed":256,"operator":"eq","pass":true,"rationale":"Balanced replay cannot introduce accidental duplicates.","threshold":256},{"gate_id":"replay_label_coverage","metric":"replay_labels_covered","observed":8,"operator":"eq","pass":true,"rationale":"Replay must retain every declared label.","threshold":8},{"gate_id":"replay_action_coverage","metric":"replay_actions_covered","observed":4,"operator":"eq","pass":true,"rationale":"Replay must retain every declared action.","threshold":4},{"gate_id":"replay_state_coverage","metric":"replay_states_covered","observed":64,"operator":"ge","pass":true,"rationale":"Replay must cover at least 60 of 64 source states.","threshold":60},{"gate_id":"replay_expert_coverage","metric":"replay_experts_covered","observed":61,"operator":"ge","pass":true,"rationale":"Replay must retain broad assigned-expert coverage.","threshold":60},{"gate_id":"replay_transition_coverage","metric":"replay_transition_pairs_covered","observed":250,"operator":"ge","pass":true,"rationale":"Replay must preserve broad source-state/action transition support.","threshold":220},{"gate_id":"planning_path_found","metric":"path_found_rate","observed":0.75,"operator":"ge","pass":true,"rationale":"At least three quarters of bounded planning cases must have a supported path.","threshold":0.75},{"gate_id":"expert_capacity","metric":"expert_count","observed":78,"operator":"le","pass":true,"rationale":"Adaptation cannot exceed the declared expert capacity.","threshold":80},{"gate_id":"retirement_budget","metric":"accepted_retirements","observed":0,"operator":"le","pass":true,"rationale":"Retirement remains optional and bounded.","threshold":4},{"gate_id":"topology_objective_non_degradation","metric":"topology_objective_gain_q20","observed":50745,"operator":"ge","pass":true,"rationale":"Accepted adaptation-training topology decisions cannot reduce their declared objective.","threshold":0},{"gate_id":"matched_compute_budget","metric":"matched_compute_training_evaluation_ratio","observed":0.911359319500818,"operator":"le","pass":true,"rationale":"Candidate training work may exceed the matched fixed-topology budget by at most ten percent.","threshold":1.1},{"gate_id":"conditional_inference_efficiency","metric":"inference_evaluation_ratio_vs_flat64","observed":0.253173828125,"operator":"le","pass":false,"rationale":"Routed inference must use at most one quarter of flat complete-scan expert evaluations.","threshold":0.25},{"gate_id":"ambiguous_adaptation","metric":"adapted_drift_accuracy","observed":0.85546875,"operator":"ge","pass":true,"rationale":"Visible evidence must support useful classification despite hidden-state aliasing.","threshold":0.7},{"gate_id":"ambiguous_gain","metric":"drift_accuracy_delta","observed":0.21484375,"operator":"ge","pass":true,"rationale":"The aliased regime has adaptation headroom and requires improvement.","threshold":0.05},{"gate_id":"ambiguous_belief_success","metric":"belief_set_rate","observed":0.25,"operator":"ge","pass":true,"rationale":"Belief-set target success is the capability gate under declared aliasing.","threshold":0.2},{"gate_id":"ambiguous_belief_gain","metric":"belief_set_rate_delta","observed":0.109375,"operator":"ge","pass":true,"rationale":"Adaptation must improve alias-aware planning over the static model.","threshold":0.05},{"gate_id":"ambiguous_reconstruction_retention","metric":"retention_reconstruction_degradation_ratio","observed":0.015344544131075426,"operator":"le","pass":true,"rationale":"Original visible-state reconstruction cannot materially degrade.","threshold":0.1},{"gate_id":"ambiguous_prediction_retention","metric":"retention_prediction_degradation","observed":-0.6106164936894167,"operator":"le","pass":true,"rationale":"Original visible-state prediction cannot materially degrade.","threshold":1}],"metrics":{"accepted_births":14,"accepted_retirements":0,"adaptation_completed":true,"adaptation_training_accuracy":0.912109375,"adapted_drift_accuracy":0.85546875,"adapted_prediction_rmse":17.665877839425498,"adapted_reconstruction_rmse":7.063486283497481,"adapted_transition_accuracy":0.4104803493449782,"balanced_vs_periodic_drift_accuracy_delta":0.0,"balanced_vs_periodic_retention_delta":0.0,"base_accuracy":1.0,"base_prediction_rmse":15.135102215962204,"base_reconstruction_rmse":5.354584974615211,"belief_set_rate":0.25,"belief_set_rate_delta":0.109375,"checkpoint_behavior":true,"checkpoint_identity":true,"checkpoint_mutations":true,"checkpoint_roundtrip":true,"checkpoint_size_bytes":51194,"drift_accuracy_delta":0.21484375,"exact_state_rate":0.140625,"exact_state_rate_delta":0.0625,"expert_count":78,"headroom_normalized_accuracy_improvement":0.5978260869565217,"inference_evaluation_ratio_vs_flat64":0.253173828125,"inference_expert_evaluations":4148,"lineage_invariants":true,"matched_compute_drift_accuracy_delta":0.21484375,"matched_compute_retention_delta":0.0,"matched_compute_training_evaluation_ratio":0.911359319500818,"no_birth_drift_accuracy_delta":0.21484375,"no_retirement_drift_accuracy_delta":0.0,"path_found_rate":0.75,"prediction_improvement_ratio":0.15118529910096323,"reconstruction_improvement_ratio":0.10411718178288326,"replay_actions_covered":4,"replay_experts_covered":61,"replay_labels_covered":8,"replay_selected":256,"replay_states_covered":64,"replay_transition_pairs_covered":250,"replay_unique":256,"retention_accuracy":1.0,"retention_accuracy_delta_from_base":0.0,"retention_prediction_degradation":-0.6106164936894167,"retention_prediction_rmse":14.524485722272788,"retention_reconstruction_degradation_ratio":0.015344544131075426,"retention_reconstruction_rmse":5.436748640061787,"retention_transition_accuracy_delta":-0.006177932505584294,"routing_mismatches":0,"static_belief_set_rate":0.140625,"static_drift_accuracy":0.640625,"static_exact_state_rate":0.078125,"static_prediction_rmse":20.812407962202325,"static_reconstruction_rmse":7.88438637271158,"static_transition_accuracy":0.35807860262008734,"topology_objective_gain_q20":50745,"training_evaluations":2214800,"transition_accuracy_delta":0.05240174672489084,"transition_support_rate":0.89453125,"unsupported_graph_edge_violations":0},"regime":"partially_observed_ambiguous","seed":"0x6a4bbee6ac7a2a32","trial_id":"validation-ambiguous-04","trial_result":"FAIL"}]} diff --git a/tools/ravel_0_5_evidence.py b/tools/ravel_0_5_evidence.py index 1274875..e81d865 100644 --- a/tools/ravel_0_5_evidence.py +++ b/tools/ravel_0_5_evidence.py @@ -164,7 +164,12 @@ def evaluator_mutation_observations( observations["seed_mutation"] = _expect_rejection(lambda: evaluate(seed, prereg)) regime = copy.deepcopy(raw) - regime["trials"][0]["regime"] = prereg["trials"][1]["regime"] + original_regime = regime["trials"][0]["regime"] + regime["trials"][0]["regime"] = next( + trial["regime"] + for trial in prereg["trials"] + if trial["regime"] != original_regime + ) observations["regime_mutation"] = _expect_rejection( lambda: evaluate(regime, prereg) ) @@ -384,6 +389,40 @@ def results_markdown(trial: dict[str, Any]) -> bytes: f"{record['trial_result']} | {', '.join(failed) if failed else 'none'} |" ) summary = trial["trial_summary"] + lines.extend( + [ + "", + "## Paired baseline and ablation summary", + "", + "All deltas are arithmetic means of per-seed candidate-minus-variant " + "differences. A positive accuracy delta favors the candidate; a " + "negative work or size delta uses fewer resources. Pareto counts use " + "drift, retention, reconstruction, prediction, exact and belief-set " + "planning, inference and training evaluations, expert count, and " + "checkpoint size.", + "", + "| Variant | Drift accuracy delta | Retention delta | " + "Training-evaluation delta | Inference-evaluation delta | " + "Candidate dominates | Variant dominates | Mixed | Equivalent |", + "|---|---:|---:|---:|---:|---:|---:|---:|---:|", + ] + ) + comparison_names = sorted(trial["trials"][0]["comparisons"]) + for name in comparison_names: + records = [item["comparisons"][name] for item in trial["trials"]] + deltas = [record["paired_delta_candidate_minus_variant"] for record in records] + relations = [record["pareto_relation"] for record in records] + lines.append( + f"| {name} | " + f"{statistics.fmean(item['drift_accuracy'] for item in deltas):.6f} | " + f"{statistics.fmean(item['retention_accuracy'] for item in deltas):.6f} | " + f"{statistics.fmean(item['training_evaluations'] for item in deltas):.2f} | " + f"{statistics.fmean(item['expert_evaluations'] for item in deltas):.2f} | " + f"{relations.count('candidate_dominates')} | " + f"{relations.count('variant_dominates')} | " + f"{relations.count('mixed')} | " + f"{relations.count('equivalent')} |" + ) lines.extend( [ "", From 9566717e1fa8d571c4a86b1be046ba83dfcb4730 Mon Sep 17 00:00:00 2001 From: epi13 Date: Fri, 31 Jul 2026 22:50:42 -0800 Subject: [PATCH 06/13] Separate RAVEL development failure from CI integrity --- ravel-0.5-assurance-case.json | 2 +- ravel-0.5-source-and-execution-manifest.json | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/ravel-0.5-assurance-case.json b/ravel-0.5-assurance-case.json index 39e4505..ee7ec51 100644 --- a/ravel-0.5-assurance-case.json +++ b/ravel-0.5-assurance-case.json @@ -1 +1 @@ -{"assurance_case_id":"ravel.adaptive-mechanism-correction.epoch-1","claim_boundaries":["development evidence is not independent protected evidence","synthetic results do not establish real-data generalization","deterministic reproduction is not cross-organizational reproduction","routing equivalence is not overall model correctness","checkpoint reproducibility is not production rollback authorization","formal MNCS and MNCDS status remain UNKNOWN","promotion remains unauthorized"],"development_result":"FAIL","disposition":"NON_PROMOTION_RESEARCH_EVIDENCE","evaluator_authority":{"all_gates_independently_derived":true,"path":"case-studies/ravel/tools/ravel_0_5_evaluator.py","preregistration":"ravel-0.5-preregistration.json","raw_executable_verdicts_trusted":false},"evidence":{"deterministic_reproduction":true,"holdouts_used_for_adaptation_or_selection":false,"independent_custody":false,"negative_and_mutation_tests":true,"protected_custody":false,"records":[{"bytes":859770,"path":"ravel-0.5-raw-observations.json","sha256":"bb34d0292a9286ea321d50d31919dc43793a58b90b4c7a7892f91552b841f354"},{"bytes":607011,"path":"ravel-0.5-trial-evidence.json","sha256":"9ffefe97e5331b65e5b998f9c2d3aac91cdf9cca246a377ca421a3bef0ba0e80"},{"bytes":10150,"path":"ravel-0.5-negative-evidence.json","sha256":"3c18eb94e0a76019a7fa3f4d2a85972332705867174f5d694d278464fc07cdb9"}]},"execution_integrity":"PASS","formal_mncds_status":"UNKNOWN","formal_mncs_status":"UNKNOWN","implementation":{"build_configuration":{"canonical_compiler":"cc","canonical_flags":["-std=c11","-O3","-Wall","-Wextra","-Werror","-pedantic"],"language":"C","link_libraries":["m"],"standard":"C11"},"entrypoint":"case-studies/ravel/ravel_0_5.c","source_digest":"a182be923d77fb841905eb501e387440bcb64a3dee85ad4b60e65a1f881b816e","source_manifest":"ravel-0.5-source-and-execution-manifest.json","source_manifest_sha256":"82b372e43cc012b8b8d3aabe46eba57b8d6116f55cbeae21e98ce9525d1e22ee","source_provenance":{"classification":"maintained_source","generator":null,"statement":"RAVEL 0.5 is directly maintained C11 source. No higher-level generator or generated execution shard exists."}},"promotion_authorized":false,"schema":"ravel-assurance-case/0.5","trial_summary":{"declared":32,"failing":8,"minimum_passing_trials":32,"minimum_passing_trials_per_regime":4,"passing":24,"passing_by_regime":{"combined_observation_and_label_drift":3,"increased_observation_noise":4,"label_drift":1,"observation_drift":4,"partially_observed_ambiguous":1,"partially_overlapping_observations":4,"separated_state":4,"transition_drift":3}}} +{"assurance_case_id":"ravel.adaptive-mechanism-correction.epoch-1","claim_boundaries":["development evidence is not independent protected evidence","synthetic results do not establish real-data generalization","deterministic reproduction is not cross-organizational reproduction","routing equivalence is not overall model correctness","checkpoint reproducibility is not production rollback authorization","formal MNCS and MNCDS status remain UNKNOWN","promotion remains unauthorized"],"development_result":"FAIL","disposition":"NON_PROMOTION_RESEARCH_EVIDENCE","evaluator_authority":{"all_gates_independently_derived":true,"path":"case-studies/ravel/tools/ravel_0_5_evaluator.py","preregistration":"ravel-0.5-preregistration.json","raw_executable_verdicts_trusted":false},"evidence":{"deterministic_reproduction":true,"holdouts_used_for_adaptation_or_selection":false,"independent_custody":false,"negative_and_mutation_tests":true,"protected_custody":false,"records":[{"bytes":859770,"path":"ravel-0.5-raw-observations.json","sha256":"bb34d0292a9286ea321d50d31919dc43793a58b90b4c7a7892f91552b841f354"},{"bytes":607011,"path":"ravel-0.5-trial-evidence.json","sha256":"9ffefe97e5331b65e5b998f9c2d3aac91cdf9cca246a377ca421a3bef0ba0e80"},{"bytes":10150,"path":"ravel-0.5-negative-evidence.json","sha256":"3c18eb94e0a76019a7fa3f4d2a85972332705867174f5d694d278464fc07cdb9"}]},"execution_integrity":"PASS","formal_mncds_status":"UNKNOWN","formal_mncs_status":"UNKNOWN","implementation":{"build_configuration":{"canonical_compiler":"cc","canonical_flags":["-std=c11","-O3","-Wall","-Wextra","-Werror","-pedantic"],"language":"C","link_libraries":["m"],"standard":"C11"},"entrypoint":"case-studies/ravel/ravel_0_5.c","source_digest":"8452595512bc33f077ae83c4db0fb84668574f583cbd51788c9292ac55f2f8f9","source_manifest":"ravel-0.5-source-and-execution-manifest.json","source_manifest_sha256":"40619c74f09883cc352379193b21c01ea5dc34553d9a56ba02a609556b498782","source_provenance":{"classification":"maintained_source","generator":null,"statement":"RAVEL 0.5 is directly maintained C11 source. No higher-level generator or generated execution shard exists."}},"promotion_authorized":false,"schema":"ravel-assurance-case/0.5","trial_summary":{"declared":32,"failing":8,"minimum_passing_trials":32,"minimum_passing_trials_per_regime":4,"passing":24,"passing_by_regime":{"combined_observation_and_label_drift":3,"increased_observation_noise":4,"label_drift":1,"observation_drift":4,"partially_observed_ambiguous":1,"partially_overlapping_observations":4,"separated_state":4,"transition_drift":3}}} diff --git a/ravel-0.5-source-and-execution-manifest.json b/ravel-0.5-source-and-execution-manifest.json index 81150d7..900dbe9 100644 --- a/ravel-0.5-source-and-execution-manifest.json +++ b/ravel-0.5-source-and-execution-manifest.json @@ -1 +1 @@ -{"build_configuration":{"canonical_compiler":"cc","canonical_flags":["-std=c11","-O3","-Wall","-Wextra","-Werror","-pedantic"],"language":"C","link_libraries":["m"],"standard":"C11"},"checkpoint_schema":{"byte_order":"big_endian","magic_hex":"524156454c303500","payload_digest":"sha256","real_encoding":"signed_q20_int64","version":5},"digest_algorithm":"sha256","digest_procedure":"For each ordered entry, hash uint32_be(path_utf8_length), path_utf8, uint64_be(content_length), and exact content bytes; concatenate frames into one SHA-256 stream.","entrypoint":"case-studies/ravel/ravel_0_5.c","evidence_schema_versions":["ravel-preregistration/0.5","ravel-raw-trial/0.5","ravel-raw-observations/0.5","ravel-self-test-observations/0.5","ravel-trial-evidence/0.5","ravel-negative-evidence/0.5","ravel-source-and-execution-manifest/0.5","ravel-assurance-case/0.5"],"generated_execution_shards":[],"generator_source":null,"maintained_execution_sources":["case-studies/ravel/ravel_0_5.c"],"ordered_files":[{"bytes":129796,"order":0,"path":"case-studies/ravel/ravel_0_5.c","role":"entrypoint","sha256":"1a8466ea1805811873c461fb891aaeaec18f6c9e7491b5ea7bd09bf698be102d"},{"bytes":4566,"order":1,"path":"case-studies/ravel/RAVEL_0_5_CONTRACT.md","role":"contract","sha256":"84fd9e1ebdfaadd813926415364ca0b71cf54d33419116cd6719a947de2c8751"},{"bytes":2153,"order":2,"path":"case-studies/ravel/RAVEL_0_5_SCOPE.md","role":"scope","sha256":"014dcce959d2163ad099567d16cbcd7ce80fc73c9ae8b4fd284a2c7e9f52eece"},{"bytes":3938,"order":3,"path":"case-studies/ravel/RAVEL_0_5_POSTMORTEM.md","role":"postmortem","sha256":"310e3b04282cea7a1771f7634c1abb0fd91188afa151242271988a4319a8c72d"},{"bytes":2017,"order":4,"path":"case-studies/ravel/ravel-0.5-development-corpus.json","role":"development_corpus","sha256":"b8505dd8cc56ac6291d2d973998394470cc1ee3c92bec9e3210485397383b95a"},{"bytes":29843,"order":5,"path":"case-studies/ravel/ravel-0.5-preregistration.json","role":"preregistration","sha256":"f240c391b92823471132ffce1eeed154b3f03dc2af1e3e1f789690a99eb4cfaa"},{"bytes":2873,"order":6,"path":"case-studies/ravel/ravel-0.5-threat-model.json","role":"threat_model","sha256":"6bad8dd77684da4d7024fa35adcc28e5c750b1bdf81d7fdb01ad301dd667bee1"},{"bytes":1441,"order":7,"path":"case-studies/ravel/ravel-0.5-limitations.md","role":"limitations","sha256":"7a0791c040ce78a1c2300cac4ccd69b7561395a4ae46e8c75b8e82c7b2459556"},{"bytes":47892,"order":8,"path":"case-studies/ravel/tools/ravel_0_5_evaluator.py","role":"independent_evaluator","sha256":"6d1c716b77c4b7615cd93cd52e67ba8073825cd68026b72d126c4faf561fd19f"},{"bytes":22461,"order":9,"path":"case-studies/ravel/tools/ravel_0_5_evidence.py","role":"evidence_generator","sha256":"9733b53bebe722bba6dc3d1df993ab8c20a03ee5b0486b8452b83586ffafccbe"},{"bytes":10132,"order":10,"path":"case-studies/ravel/tools/ravel_0_5_source_digest.py","role":"source_digest_utility","sha256":"5b79cb95c4da5c58ad68328f1a39d6d390d8796db7ea39c1297d798d191b5b7a"},{"bytes":3152,"order":11,"path":"case-studies/ravel/ravel-0.5-source-manifest-spec.json","role":"manifest_specification","sha256":"4e756fff03b2addb64544c1bd609df3ef9ae8c9de26bb2e296e3d3b49700f338"},{"bytes":8533,"order":12,"path":"case-studies/ravel/Makefile","role":"case_build_specification","sha256":"bcbac380293d3761ed9170ef9d35397827d121725deaaf4fbcfdd073f066bc4d"},{"bytes":6424,"order":13,"path":"Makefile","role":"root_build_specification","sha256":"ac20c500b4e136c0fb2e54aa9c72afde9a27cbf5693e390aab184bbef218f974"},{"bytes":3758,"order":14,"path":".github/workflows/ravel-0.5.yml","role":"ci_workflow","sha256":"a68a1fc5fcf72b9000f14c7235132dc57ac384a240eb56bf2d50f9e7ec80eaae"}],"schema":"ravel-source-and-execution-manifest/0.5","source_digest":"a182be923d77fb841905eb501e387440bcb64a3dee85ad4b60e65a1f881b816e","source_provenance":{"classification":"maintained_source","generator":null,"statement":"RAVEL 0.5 is directly maintained C11 source. No higher-level generator or generated execution shard exists."},"unexpected_execution_shards":[]} +{"build_configuration":{"canonical_compiler":"cc","canonical_flags":["-std=c11","-O3","-Wall","-Wextra","-Werror","-pedantic"],"language":"C","link_libraries":["m"],"standard":"C11"},"checkpoint_schema":{"byte_order":"big_endian","magic_hex":"524156454c303500","payload_digest":"sha256","real_encoding":"signed_q20_int64","version":5},"digest_algorithm":"sha256","digest_procedure":"For each ordered entry, hash uint32_be(path_utf8_length), path_utf8, uint64_be(content_length), and exact content bytes; concatenate frames into one SHA-256 stream.","entrypoint":"case-studies/ravel/ravel_0_5.c","evidence_schema_versions":["ravel-preregistration/0.5","ravel-raw-trial/0.5","ravel-raw-observations/0.5","ravel-self-test-observations/0.5","ravel-trial-evidence/0.5","ravel-negative-evidence/0.5","ravel-source-and-execution-manifest/0.5","ravel-assurance-case/0.5"],"generated_execution_shards":[],"generator_source":null,"maintained_execution_sources":["case-studies/ravel/ravel_0_5.c"],"ordered_files":[{"bytes":129796,"order":0,"path":"case-studies/ravel/ravel_0_5.c","role":"entrypoint","sha256":"1a8466ea1805811873c461fb891aaeaec18f6c9e7491b5ea7bd09bf698be102d"},{"bytes":4566,"order":1,"path":"case-studies/ravel/RAVEL_0_5_CONTRACT.md","role":"contract","sha256":"84fd9e1ebdfaadd813926415364ca0b71cf54d33419116cd6719a947de2c8751"},{"bytes":2153,"order":2,"path":"case-studies/ravel/RAVEL_0_5_SCOPE.md","role":"scope","sha256":"014dcce959d2163ad099567d16cbcd7ce80fc73c9ae8b4fd284a2c7e9f52eece"},{"bytes":3938,"order":3,"path":"case-studies/ravel/RAVEL_0_5_POSTMORTEM.md","role":"postmortem","sha256":"310e3b04282cea7a1771f7634c1abb0fd91188afa151242271988a4319a8c72d"},{"bytes":2017,"order":4,"path":"case-studies/ravel/ravel-0.5-development-corpus.json","role":"development_corpus","sha256":"b8505dd8cc56ac6291d2d973998394470cc1ee3c92bec9e3210485397383b95a"},{"bytes":29843,"order":5,"path":"case-studies/ravel/ravel-0.5-preregistration.json","role":"preregistration","sha256":"f240c391b92823471132ffce1eeed154b3f03dc2af1e3e1f789690a99eb4cfaa"},{"bytes":2873,"order":6,"path":"case-studies/ravel/ravel-0.5-threat-model.json","role":"threat_model","sha256":"6bad8dd77684da4d7024fa35adcc28e5c750b1bdf81d7fdb01ad301dd667bee1"},{"bytes":1441,"order":7,"path":"case-studies/ravel/ravel-0.5-limitations.md","role":"limitations","sha256":"7a0791c040ce78a1c2300cac4ccd69b7561395a4ae46e8c75b8e82c7b2459556"},{"bytes":47892,"order":8,"path":"case-studies/ravel/tools/ravel_0_5_evaluator.py","role":"independent_evaluator","sha256":"6d1c716b77c4b7615cd93cd52e67ba8073825cd68026b72d126c4faf561fd19f"},{"bytes":22461,"order":9,"path":"case-studies/ravel/tools/ravel_0_5_evidence.py","role":"evidence_generator","sha256":"9733b53bebe722bba6dc3d1df993ab8c20a03ee5b0486b8452b83586ffafccbe"},{"bytes":10132,"order":10,"path":"case-studies/ravel/tools/ravel_0_5_source_digest.py","role":"source_digest_utility","sha256":"5b79cb95c4da5c58ad68328f1a39d6d390d8796db7ea39c1297d798d191b5b7a"},{"bytes":3152,"order":11,"path":"case-studies/ravel/ravel-0.5-source-manifest-spec.json","role":"manifest_specification","sha256":"4e756fff03b2addb64544c1bd609df3ef9ae8c9de26bb2e296e3d3b49700f338"},{"bytes":8533,"order":12,"path":"case-studies/ravel/Makefile","role":"case_build_specification","sha256":"bcbac380293d3761ed9170ef9d35397827d121725deaaf4fbcfdd073f066bc4d"},{"bytes":6424,"order":13,"path":"Makefile","role":"root_build_specification","sha256":"ac20c500b4e136c0fb2e54aa9c72afde9a27cbf5693e390aab184bbef218f974"},{"bytes":3790,"order":14,"path":".github/workflows/ravel-0.5.yml","role":"ci_workflow","sha256":"8bd041cea72cdbaba61649b44af4de4c23393c1e7d0f873668fd2bb3479ffcf1"}],"schema":"ravel-source-and-execution-manifest/0.5","source_digest":"8452595512bc33f077ae83c4db0fb84668574f583cbd51788c9292ac55f2f8f9","source_provenance":{"classification":"maintained_source","generator":null,"statement":"RAVEL 0.5 is directly maintained C11 source. No higher-level generator or generated execution shard exists."},"unexpected_execution_shards":[]} From a7bab13c5e889adcd42590c863f14a5fe38c0de7 Mon Sep 17 00:00:00 2001 From: epi13 Date: Fri, 31 Jul 2026 23:02:11 -0800 Subject: [PATCH 07/13] Record non-normative RAVEL 0.5 runtime --- README.md | 4 +++- ravel-0.5-runtime-observations.json | 1 + 2 files changed, 4 insertions(+), 1 deletion(-) create mode 100644 ravel-0.5-runtime-observations.json diff --git a/README.md b/README.md index 26112c0..2e1390b 100644 --- a/README.md +++ b/README.md @@ -171,7 +171,9 @@ Requirements: a C11 compiler, the C math library, and Make. records; and - `ravel-0.5-source-and-execution-manifest.json` and `ravel-0.5-assurance-case.json` — bound build/source identity and current - bounded non-promotion record. + bounded non-promotion record; and +- `ravel-0.5-runtime-observations.json` — host-specific, non-normative timing + observations; canonical comparisons use deterministic operation counts. ## MNCS boundary diff --git a/ravel-0.5-runtime-observations.json b/ravel-0.5-runtime-observations.json new file mode 100644 index 0000000..9d98d6d --- /dev/null +++ b/ravel-0.5-runtime-observations.json @@ -0,0 +1 @@ +{"arithmetic_mean_nanoseconds":448882874.6666667,"elapsed_nanoseconds":[455640204,447793757,443214663],"limitations":["wall-clock observations are host-specific and non-normative","deterministic expert-evaluation counts are the canonical work measure"],"maximum_nanoseconds":455640204,"median_nanoseconds":447793757,"minimum_nanoseconds":443214663,"normative":false,"output_sha256":"5ecfcd4f73bb151bb0bb0c350d6b86790bd2cd1716dc31a4d7ccfd8e1b1f5569","platform":"Linux-7.1.3-200.fc44.x86_64-x86_64-with-glibc2.43","python":"3.14.6","runs":3,"schema":"ravel-runtime-observations/0.5","scope":"one_complete_trial_with_all_variants"} From 49891c4a4848c828d7748acdc777ac35829620b9 Mon Sep 17 00:00:00 2001 From: epi13 Date: Fri, 31 Jul 2026 23:06:57 -0800 Subject: [PATCH 08/13] Exercise real RAVEL provenance mutations --- ravel-0.5-assurance-case.json | 2 +- ravel-0.5-source-and-execution-manifest.json | 2 +- tools/ravel_0_5_evidence.py | 109 +++++++++++++++---- tools/ravel_0_5_source_digest.py | 57 +++++++--- 4 files changed, 126 insertions(+), 44 deletions(-) diff --git a/ravel-0.5-assurance-case.json b/ravel-0.5-assurance-case.json index ee7ec51..b2b2a6a 100644 --- a/ravel-0.5-assurance-case.json +++ b/ravel-0.5-assurance-case.json @@ -1 +1 @@ -{"assurance_case_id":"ravel.adaptive-mechanism-correction.epoch-1","claim_boundaries":["development evidence is not independent protected evidence","synthetic results do not establish real-data generalization","deterministic reproduction is not cross-organizational reproduction","routing equivalence is not overall model correctness","checkpoint reproducibility is not production rollback authorization","formal MNCS and MNCDS status remain UNKNOWN","promotion remains unauthorized"],"development_result":"FAIL","disposition":"NON_PROMOTION_RESEARCH_EVIDENCE","evaluator_authority":{"all_gates_independently_derived":true,"path":"case-studies/ravel/tools/ravel_0_5_evaluator.py","preregistration":"ravel-0.5-preregistration.json","raw_executable_verdicts_trusted":false},"evidence":{"deterministic_reproduction":true,"holdouts_used_for_adaptation_or_selection":false,"independent_custody":false,"negative_and_mutation_tests":true,"protected_custody":false,"records":[{"bytes":859770,"path":"ravel-0.5-raw-observations.json","sha256":"bb34d0292a9286ea321d50d31919dc43793a58b90b4c7a7892f91552b841f354"},{"bytes":607011,"path":"ravel-0.5-trial-evidence.json","sha256":"9ffefe97e5331b65e5b998f9c2d3aac91cdf9cca246a377ca421a3bef0ba0e80"},{"bytes":10150,"path":"ravel-0.5-negative-evidence.json","sha256":"3c18eb94e0a76019a7fa3f4d2a85972332705867174f5d694d278464fc07cdb9"}]},"execution_integrity":"PASS","formal_mncds_status":"UNKNOWN","formal_mncs_status":"UNKNOWN","implementation":{"build_configuration":{"canonical_compiler":"cc","canonical_flags":["-std=c11","-O3","-Wall","-Wextra","-Werror","-pedantic"],"language":"C","link_libraries":["m"],"standard":"C11"},"entrypoint":"case-studies/ravel/ravel_0_5.c","source_digest":"8452595512bc33f077ae83c4db0fb84668574f583cbd51788c9292ac55f2f8f9","source_manifest":"ravel-0.5-source-and-execution-manifest.json","source_manifest_sha256":"40619c74f09883cc352379193b21c01ea5dc34553d9a56ba02a609556b498782","source_provenance":{"classification":"maintained_source","generator":null,"statement":"RAVEL 0.5 is directly maintained C11 source. No higher-level generator or generated execution shard exists."}},"promotion_authorized":false,"schema":"ravel-assurance-case/0.5","trial_summary":{"declared":32,"failing":8,"minimum_passing_trials":32,"minimum_passing_trials_per_regime":4,"passing":24,"passing_by_regime":{"combined_observation_and_label_drift":3,"increased_observation_noise":4,"label_drift":1,"observation_drift":4,"partially_observed_ambiguous":1,"partially_overlapping_observations":4,"separated_state":4,"transition_drift":3}}} +{"assurance_case_id":"ravel.adaptive-mechanism-correction.epoch-1","claim_boundaries":["development evidence is not independent protected evidence","synthetic results do not establish real-data generalization","deterministic reproduction is not cross-organizational reproduction","routing equivalence is not overall model correctness","checkpoint reproducibility is not production rollback authorization","formal MNCS and MNCDS status remain UNKNOWN","promotion remains unauthorized"],"development_result":"FAIL","disposition":"NON_PROMOTION_RESEARCH_EVIDENCE","evaluator_authority":{"all_gates_independently_derived":true,"path":"case-studies/ravel/tools/ravel_0_5_evaluator.py","preregistration":"ravel-0.5-preregistration.json","raw_executable_verdicts_trusted":false},"evidence":{"deterministic_reproduction":true,"holdouts_used_for_adaptation_or_selection":false,"independent_custody":false,"negative_and_mutation_tests":true,"protected_custody":false,"records":[{"bytes":859770,"path":"ravel-0.5-raw-observations.json","sha256":"bb34d0292a9286ea321d50d31919dc43793a58b90b4c7a7892f91552b841f354"},{"bytes":607011,"path":"ravel-0.5-trial-evidence.json","sha256":"9ffefe97e5331b65e5b998f9c2d3aac91cdf9cca246a377ca421a3bef0ba0e80"},{"bytes":10150,"path":"ravel-0.5-negative-evidence.json","sha256":"3c18eb94e0a76019a7fa3f4d2a85972332705867174f5d694d278464fc07cdb9"}]},"execution_integrity":"PASS","formal_mncds_status":"UNKNOWN","formal_mncs_status":"UNKNOWN","implementation":{"build_configuration":{"canonical_compiler":"cc","canonical_flags":["-std=c11","-O3","-Wall","-Wextra","-Werror","-pedantic"],"language":"C","link_libraries":["m"],"standard":"C11"},"entrypoint":"case-studies/ravel/ravel_0_5.c","source_digest":"201e0373cc8d8f2fb26f284f44b0f87a5751a047d91556213b7aa7bf07e26fa4","source_manifest":"ravel-0.5-source-and-execution-manifest.json","source_manifest_sha256":"18006006db509269ee374a39133bb25d8452edc0fe0103a43fa92c5660fd89d0","source_provenance":{"classification":"maintained_source","generator":null,"statement":"RAVEL 0.5 is directly maintained C11 source. No higher-level generator or generated execution shard exists."}},"promotion_authorized":false,"schema":"ravel-assurance-case/0.5","trial_summary":{"declared":32,"failing":8,"minimum_passing_trials":32,"minimum_passing_trials_per_regime":4,"passing":24,"passing_by_regime":{"combined_observation_and_label_drift":3,"increased_observation_noise":4,"label_drift":1,"observation_drift":4,"partially_observed_ambiguous":1,"partially_overlapping_observations":4,"separated_state":4,"transition_drift":3}}} diff --git a/ravel-0.5-source-and-execution-manifest.json b/ravel-0.5-source-and-execution-manifest.json index 900dbe9..92f21e3 100644 --- a/ravel-0.5-source-and-execution-manifest.json +++ b/ravel-0.5-source-and-execution-manifest.json @@ -1 +1 @@ -{"build_configuration":{"canonical_compiler":"cc","canonical_flags":["-std=c11","-O3","-Wall","-Wextra","-Werror","-pedantic"],"language":"C","link_libraries":["m"],"standard":"C11"},"checkpoint_schema":{"byte_order":"big_endian","magic_hex":"524156454c303500","payload_digest":"sha256","real_encoding":"signed_q20_int64","version":5},"digest_algorithm":"sha256","digest_procedure":"For each ordered entry, hash uint32_be(path_utf8_length), path_utf8, uint64_be(content_length), and exact content bytes; concatenate frames into one SHA-256 stream.","entrypoint":"case-studies/ravel/ravel_0_5.c","evidence_schema_versions":["ravel-preregistration/0.5","ravel-raw-trial/0.5","ravel-raw-observations/0.5","ravel-self-test-observations/0.5","ravel-trial-evidence/0.5","ravel-negative-evidence/0.5","ravel-source-and-execution-manifest/0.5","ravel-assurance-case/0.5"],"generated_execution_shards":[],"generator_source":null,"maintained_execution_sources":["case-studies/ravel/ravel_0_5.c"],"ordered_files":[{"bytes":129796,"order":0,"path":"case-studies/ravel/ravel_0_5.c","role":"entrypoint","sha256":"1a8466ea1805811873c461fb891aaeaec18f6c9e7491b5ea7bd09bf698be102d"},{"bytes":4566,"order":1,"path":"case-studies/ravel/RAVEL_0_5_CONTRACT.md","role":"contract","sha256":"84fd9e1ebdfaadd813926415364ca0b71cf54d33419116cd6719a947de2c8751"},{"bytes":2153,"order":2,"path":"case-studies/ravel/RAVEL_0_5_SCOPE.md","role":"scope","sha256":"014dcce959d2163ad099567d16cbcd7ce80fc73c9ae8b4fd284a2c7e9f52eece"},{"bytes":3938,"order":3,"path":"case-studies/ravel/RAVEL_0_5_POSTMORTEM.md","role":"postmortem","sha256":"310e3b04282cea7a1771f7634c1abb0fd91188afa151242271988a4319a8c72d"},{"bytes":2017,"order":4,"path":"case-studies/ravel/ravel-0.5-development-corpus.json","role":"development_corpus","sha256":"b8505dd8cc56ac6291d2d973998394470cc1ee3c92bec9e3210485397383b95a"},{"bytes":29843,"order":5,"path":"case-studies/ravel/ravel-0.5-preregistration.json","role":"preregistration","sha256":"f240c391b92823471132ffce1eeed154b3f03dc2af1e3e1f789690a99eb4cfaa"},{"bytes":2873,"order":6,"path":"case-studies/ravel/ravel-0.5-threat-model.json","role":"threat_model","sha256":"6bad8dd77684da4d7024fa35adcc28e5c750b1bdf81d7fdb01ad301dd667bee1"},{"bytes":1441,"order":7,"path":"case-studies/ravel/ravel-0.5-limitations.md","role":"limitations","sha256":"7a0791c040ce78a1c2300cac4ccd69b7561395a4ae46e8c75b8e82c7b2459556"},{"bytes":47892,"order":8,"path":"case-studies/ravel/tools/ravel_0_5_evaluator.py","role":"independent_evaluator","sha256":"6d1c716b77c4b7615cd93cd52e67ba8073825cd68026b72d126c4faf561fd19f"},{"bytes":22461,"order":9,"path":"case-studies/ravel/tools/ravel_0_5_evidence.py","role":"evidence_generator","sha256":"9733b53bebe722bba6dc3d1df993ab8c20a03ee5b0486b8452b83586ffafccbe"},{"bytes":10132,"order":10,"path":"case-studies/ravel/tools/ravel_0_5_source_digest.py","role":"source_digest_utility","sha256":"5b79cb95c4da5c58ad68328f1a39d6d390d8796db7ea39c1297d798d191b5b7a"},{"bytes":3152,"order":11,"path":"case-studies/ravel/ravel-0.5-source-manifest-spec.json","role":"manifest_specification","sha256":"4e756fff03b2addb64544c1bd609df3ef9ae8c9de26bb2e296e3d3b49700f338"},{"bytes":8533,"order":12,"path":"case-studies/ravel/Makefile","role":"case_build_specification","sha256":"bcbac380293d3761ed9170ef9d35397827d121725deaaf4fbcfdd073f066bc4d"},{"bytes":6424,"order":13,"path":"Makefile","role":"root_build_specification","sha256":"ac20c500b4e136c0fb2e54aa9c72afde9a27cbf5693e390aab184bbef218f974"},{"bytes":3790,"order":14,"path":".github/workflows/ravel-0.5.yml","role":"ci_workflow","sha256":"8bd041cea72cdbaba61649b44af4de4c23393c1e7d0f873668fd2bb3479ffcf1"}],"schema":"ravel-source-and-execution-manifest/0.5","source_digest":"8452595512bc33f077ae83c4db0fb84668574f583cbd51788c9292ac55f2f8f9","source_provenance":{"classification":"maintained_source","generator":null,"statement":"RAVEL 0.5 is directly maintained C11 source. No higher-level generator or generated execution shard exists."},"unexpected_execution_shards":[]} +{"build_configuration":{"canonical_compiler":"cc","canonical_flags":["-std=c11","-O3","-Wall","-Wextra","-Werror","-pedantic"],"language":"C","link_libraries":["m"],"standard":"C11"},"checkpoint_schema":{"byte_order":"big_endian","magic_hex":"524156454c303500","payload_digest":"sha256","real_encoding":"signed_q20_int64","version":5},"digest_algorithm":"sha256","digest_procedure":"For each ordered entry, hash uint32_be(path_utf8_length), path_utf8, uint64_be(content_length), and exact content bytes; concatenate frames into one SHA-256 stream.","entrypoint":"case-studies/ravel/ravel_0_5.c","evidence_schema_versions":["ravel-preregistration/0.5","ravel-raw-trial/0.5","ravel-raw-observations/0.5","ravel-self-test-observations/0.5","ravel-trial-evidence/0.5","ravel-negative-evidence/0.5","ravel-source-and-execution-manifest/0.5","ravel-assurance-case/0.5"],"generated_execution_shards":[],"generator_source":null,"maintained_execution_sources":["case-studies/ravel/ravel_0_5.c"],"ordered_files":[{"bytes":129796,"order":0,"path":"case-studies/ravel/ravel_0_5.c","role":"entrypoint","sha256":"1a8466ea1805811873c461fb891aaeaec18f6c9e7491b5ea7bd09bf698be102d"},{"bytes":4566,"order":1,"path":"case-studies/ravel/RAVEL_0_5_CONTRACT.md","role":"contract","sha256":"84fd9e1ebdfaadd813926415364ca0b71cf54d33419116cd6719a947de2c8751"},{"bytes":2153,"order":2,"path":"case-studies/ravel/RAVEL_0_5_SCOPE.md","role":"scope","sha256":"014dcce959d2163ad099567d16cbcd7ce80fc73c9ae8b4fd284a2c7e9f52eece"},{"bytes":3938,"order":3,"path":"case-studies/ravel/RAVEL_0_5_POSTMORTEM.md","role":"postmortem","sha256":"310e3b04282cea7a1771f7634c1abb0fd91188afa151242271988a4319a8c72d"},{"bytes":2017,"order":4,"path":"case-studies/ravel/ravel-0.5-development-corpus.json","role":"development_corpus","sha256":"b8505dd8cc56ac6291d2d973998394470cc1ee3c92bec9e3210485397383b95a"},{"bytes":29843,"order":5,"path":"case-studies/ravel/ravel-0.5-preregistration.json","role":"preregistration","sha256":"f240c391b92823471132ffce1eeed154b3f03dc2af1e3e1f789690a99eb4cfaa"},{"bytes":2873,"order":6,"path":"case-studies/ravel/ravel-0.5-threat-model.json","role":"threat_model","sha256":"6bad8dd77684da4d7024fa35adcc28e5c750b1bdf81d7fdb01ad301dd667bee1"},{"bytes":1441,"order":7,"path":"case-studies/ravel/ravel-0.5-limitations.md","role":"limitations","sha256":"7a0791c040ce78a1c2300cac4ccd69b7561395a4ae46e8c75b8e82c7b2459556"},{"bytes":47892,"order":8,"path":"case-studies/ravel/tools/ravel_0_5_evaluator.py","role":"independent_evaluator","sha256":"6d1c716b77c4b7615cd93cd52e67ba8073825cd68026b72d126c4faf561fd19f"},{"bytes":24539,"order":9,"path":"case-studies/ravel/tools/ravel_0_5_evidence.py","role":"evidence_generator","sha256":"7d6fc4f2728b10e42b93ada594347006f9b10c92c8a0a2b1adc0ec1e129adfb9"},{"bytes":10644,"order":10,"path":"case-studies/ravel/tools/ravel_0_5_source_digest.py","role":"source_digest_utility","sha256":"6c6b3dff1b135b12b1a961b0d265f002c92811bf7dafe75db8ad57d5dd47ee9d"},{"bytes":3152,"order":11,"path":"case-studies/ravel/ravel-0.5-source-manifest-spec.json","role":"manifest_specification","sha256":"4e756fff03b2addb64544c1bd609df3ef9ae8c9de26bb2e296e3d3b49700f338"},{"bytes":8533,"order":12,"path":"case-studies/ravel/Makefile","role":"case_build_specification","sha256":"bcbac380293d3761ed9170ef9d35397827d121725deaaf4fbcfdd073f066bc4d"},{"bytes":6424,"order":13,"path":"Makefile","role":"root_build_specification","sha256":"ac20c500b4e136c0fb2e54aa9c72afde9a27cbf5693e390aab184bbef218f974"},{"bytes":3790,"order":14,"path":".github/workflows/ravel-0.5.yml","role":"ci_workflow","sha256":"8bd041cea72cdbaba61649b44af4de4c23393c1e7d0f873668fd2bb3479ffcf1"}],"schema":"ravel-source-and-execution-manifest/0.5","source_digest":"201e0373cc8d8f2fb26f284f44b0f87a5751a047d91556213b7aa7bf07e26fa4","source_provenance":{"classification":"maintained_source","generator":null,"statement":"RAVEL 0.5 is directly maintained C11 source. No higher-level generator or generated execution shard exists."},"unexpected_execution_shards":[]} diff --git a/tools/ravel_0_5_evidence.py b/tools/ravel_0_5_evidence.py index e81d865..31f9ebc 100644 --- a/tools/ravel_0_5_evidence.py +++ b/tools/ravel_0_5_evidence.py @@ -12,6 +12,7 @@ import statistics import subprocess import sys +import tempfile import time from collections.abc import Callable from pathlib import Path @@ -31,6 +32,7 @@ from ravel_0_5_source_digest import ( # noqa: E402 ManifestError, build_manifest, + verify_assurance_record, verify_manifest_record, ) @@ -198,43 +200,98 @@ def manifest_mutation_observations( ) -> dict[str, bool]: observations: dict[str, bool] = {} - stale = copy.deepcopy(manifest) - stale["source_digest"] = "0" * 64 + def copied_recalculation( + mutate: Callable[[Path, Path], None], + ) -> dict[str, Any]: + spec = load_json(MANIFEST_SPEC) + with tempfile.TemporaryDirectory(prefix="ravel-0.5-manifest-") as directory: + root = Path(directory) + for entry in spec["ordered_files"]: + source = Path(__file__).resolve().parents[3] / entry["path"] + destination = root / entry["path"] + destination.parent.mkdir(parents=True, exist_ok=True) + destination.write_bytes(source.read_bytes()) + spec_path = root / "case-studies/ravel" / MANIFEST_SPEC.name + mutate(root, spec_path) + return build_manifest(spec_path, root) + + def append_to(relative: str, payload: bytes) -> Callable[[Path, Path], None]: + def mutate(root: Path, _spec_path: Path) -> None: + path = root / relative + path.write_bytes(path.read_bytes() + payload) + + return mutate + observations["stale_manifest"] = _expect_rejection( - lambda: verify_manifest_record(manifest, stale) + lambda: verify_manifest_record( + copied_recalculation( + append_to( + "case-studies/ravel/RAVEL_0_5_CONTRACT.md", + b"\nstale manifest fixture\n", + ) + ), + manifest, + ) ) - substituted = copy.deepcopy(manifest) - substituted["ordered_files"][0]["sha256"] = "f" * 64 observations["substituted_source"] = _expect_rejection( - lambda: verify_manifest_record(manifest, substituted) + lambda: verify_manifest_record( + copied_recalculation( + append_to( + "case-studies/ravel/ravel_0_5.c", + b"\n/* substituted source fixture */\n", + ) + ), + manifest, + ) ) - reordered = copy.deepcopy(manifest) - reordered["ordered_files"][0], reordered["ordered_files"][1] = ( - reordered["ordered_files"][1], - reordered["ordered_files"][0], - ) + def reorder(_root: Path, spec_path: Path) -> None: + spec = load_json(spec_path) + spec["ordered_files"][0], spec["ordered_files"][1] = ( + spec["ordered_files"][1], + spec["ordered_files"][0], + ) + spec_path.write_bytes(canonical_bytes(spec)) + observations["reordered_file"] = _expect_rejection( - lambda: verify_manifest_record(manifest, reordered) + lambda: verify_manifest_record(copied_recalculation(reorder), manifest) ) - omitted = copy.deepcopy(manifest) - omitted["ordered_files"].pop() + def omit(_root: Path, spec_path: Path) -> None: + spec = load_json(spec_path) + spec["ordered_files"] = [ + entry + for entry in spec["ordered_files"] + if entry["role"] != "contract" + ] + spec_path.write_bytes(canonical_bytes(spec)) + observations["omitted_file"] = _expect_rejection( - lambda: verify_manifest_record(manifest, omitted) + lambda: copied_recalculation(omit) ) - build = copy.deepcopy(manifest) - build["build_configuration"]["canonical_flags"][0] = "-std=c99" + def mutate_build(_root: Path, spec_path: Path) -> None: + spec = load_json(spec_path) + spec["build_configuration"]["canonical_flags"][0] = "-std=c99" + spec_path.write_bytes(canonical_bytes(spec)) + observations["build_configuration_mutation"] = _expect_rejection( - lambda: verify_manifest_record(manifest, build) + lambda: verify_manifest_record( + copied_recalculation(mutate_build), manifest + ) ) - artifact = copy.deepcopy(manifest) - artifact["ordered_files"][0]["bytes"] += 1 observations["artifact_mutation"] = _expect_rejection( - lambda: verify_manifest_record(manifest, artifact) + lambda: verify_manifest_record( + copied_recalculation( + append_to( + "case-studies/ravel/tools/ravel_0_5_evaluator.py", + b"\n# artifact mutation fixture\n", + ) + ), + manifest, + ) ) if assurance is None: @@ -242,9 +299,13 @@ def manifest_mutation_observations( else: stale_assurance = copy.deepcopy(assurance) stale_assurance["implementation"]["source_digest"] = "0" * 64 - observations["stale_assurance"] = ( - stale_assurance["implementation"]["source_digest"] - != manifest["source_digest"] + observations["stale_assurance"] = _expect_rejection( + lambda: verify_assurance_record( + stale_assurance, + manifest, + MANIFEST.name, + hashlib.sha256(canonical_bytes(manifest)).hexdigest(), + ) ) return observations diff --git a/tools/ravel_0_5_source_digest.py b/tools/ravel_0_5_source_digest.py index d1dfa5c..83042eb 100755 --- a/tools/ravel_0_5_source_digest.py +++ b/tools/ravel_0_5_source_digest.py @@ -52,11 +52,13 @@ def file_sha256(path: Path) -> str: return hashlib.sha256(path.read_bytes()).hexdigest() -def framed_source_digest(entries: list[dict[str, Any]]) -> str: +def framed_source_digest( + entries: list[dict[str, Any]], repository_root: Path = REPOSITORY_ROOT +) -> str: digest = hashlib.sha256() for entry in entries: relative = entry["path"].encode("utf-8") - content = (REPOSITORY_ROOT / entry["path"]).read_bytes() + content = (repository_root / entry["path"]).read_bytes() digest.update(struct.pack(">I", len(relative))) digest.update(relative) digest.update(struct.pack(">Q", len(content))) @@ -110,7 +112,9 @@ def validate_spec(spec: dict[str, Any]) -> None: raise ManifestError("canonical_flags must be a non-empty array") -def discover_execution_shards(spec: dict[str, Any]) -> set[str]: +def discover_execution_shards( + spec: dict[str, Any], repository_root: Path = REPOSITORY_ROOT +) -> set[str]: discovered: set[str] = set() globs = spec.get("execution_source_discovery_globs", []) if not isinstance(globs, list): @@ -118,19 +122,21 @@ def discover_execution_shards(spec: dict[str, Any]) -> set[str]: for pattern in globs: if not isinstance(pattern, str): raise ManifestError("execution shard glob must be a string") - for path in REPOSITORY_ROOT.glob(pattern): + for path in repository_root.glob(pattern): if path.is_file(): - discovered.add(path.relative_to(REPOSITORY_ROOT).as_posix()) + discovered.add(path.relative_to(repository_root).as_posix()) return discovered -def build_manifest(spec_path: Path) -> dict[str, Any]: +def build_manifest( + spec_path: Path, repository_root: Path = REPOSITORY_ROOT +) -> dict[str, Any]: spec = load_json(spec_path) validate_spec(spec) declared_shards = set(spec["generated_execution_shards"]) | set( spec["maintained_execution_sources"] ) - discovered_shards = discover_execution_shards(spec) + discovered_shards = discover_execution_shards(spec, repository_root) unexpected = sorted(discovered_shards - declared_shards) omitted = sorted(declared_shards - discovered_shards) if unexpected: @@ -141,7 +147,7 @@ def build_manifest(spec_path: Path) -> dict[str, Any]: entries: list[dict[str, Any]] = [] for item in spec["ordered_files"]: relative = item["path"] - absolute = REPOSITORY_ROOT / relative + absolute = repository_root / relative if not absolute.is_file(): raise ManifestError(f"listed source file is missing: {relative}") content = absolute.read_bytes() @@ -167,7 +173,7 @@ def build_manifest(spec_path: Path) -> dict[str, Any]: "digest_algorithm": spec["digest_algorithm"], "digest_procedure": spec["digest_procedure"], "ordered_files": entries, - "source_digest": framed_source_digest(entries), + "source_digest": framed_source_digest(entries, repository_root), "unexpected_execution_shards": [], } @@ -187,15 +193,12 @@ def verify_manifest( } if assurance_path is not None: assurance = load_json(assurance_path) - implementation = assurance.get("implementation") - if not isinstance(implementation, dict): - raise ManifestError("assurance record lacks implementation object") - if implementation.get("source_digest") != expected["source_digest"]: - raise ManifestError("assurance record contains a stale source digest") - if implementation.get("source_manifest_sha256") != result["manifest_sha256"]: - raise ManifestError("assurance record contains a stale manifest digest") - if implementation.get("source_manifest") != manifest_path.name: - raise ManifestError("assurance record names the wrong source manifest") + verify_assurance_record( + assurance, + expected, + manifest_path.name, + result["manifest_sha256"], + ) result["assurance_match"] = True return result @@ -208,6 +211,24 @@ def verify_manifest_record(expected: dict[str, Any], actual: dict[str, Any]) -> ) +def verify_assurance_record( + assurance: dict[str, Any], + manifest: dict[str, Any], + manifest_name: str, + manifest_sha256: str, +) -> None: + """Reject an assurance record that does not bind the exact manifest.""" + implementation = assurance.get("implementation") + if not isinstance(implementation, dict): + raise ManifestError("assurance record lacks implementation object") + if implementation.get("source_digest") != manifest["source_digest"]: + raise ManifestError("assurance record contains a stale source digest") + if implementation.get("source_manifest_sha256") != manifest_sha256: + raise ManifestError("assurance record contains a stale manifest digest") + if implementation.get("source_manifest") != manifest_name: + raise ManifestError("assurance record names the wrong source manifest") + + def parse_args() -> argparse.Namespace: parser = argparse.ArgumentParser() subparsers = parser.add_subparsers(dest="command", required=True) From ec43895344fafaca9c1b6a9a8d020653468d0e17 Mon Sep 17 00:00:00 2001 From: epi13 Date: Sat, 1 Aug 2026 06:31:01 -0800 Subject: [PATCH 09/13] style: format RAVEL 0.5 tooling --- tools/ravel_0_5_evaluator.py | 136 +++++++++---------------------- tools/ravel_0_5_evidence.py | 46 +++-------- tools/ravel_0_5_source_digest.py | 4 +- 3 files changed, 52 insertions(+), 134 deletions(-) diff --git a/tools/ravel_0_5_evaluator.py b/tools/ravel_0_5_evaluator.py index 4c34ae0..7075de2 100644 --- a/tools/ravel_0_5_evaluator.py +++ b/tools/ravel_0_5_evaluator.py @@ -81,8 +81,7 @@ def load_json(path: Path) -> Any: def canonical_bytes(value: Any) -> bytes: return ( - json.dumps(value, sort_keys=True, separators=(",", ":"), allow_nan=False) - + "\n" + json.dumps(value, sort_keys=True, separators=(",", ":"), allow_nan=False) + "\n" ).encode() @@ -96,21 +95,15 @@ def require_object(value: Any, context: str) -> dict[str, Any]: return value -def require_exact_keys( - value: dict[str, Any], keys: set[str], context: str -) -> None: +def require_exact_keys(value: dict[str, Any], keys: set[str], context: str) -> None: actual = set(value) if actual != keys: missing = sorted(keys - actual) unknown = sorted(actual - keys) - raise EvaluationError( - f"{context}: key mismatch missing={missing} unknown={unknown}" - ) + raise EvaluationError(f"{context}: key mismatch missing={missing} unknown={unknown}") -def require_int( - value: Any, context: str, minimum: int = 0, maximum: int | None = None -) -> int: +def require_int(value: Any, context: str, minimum: int = 0, maximum: int | None = None) -> int: if isinstance(value, bool) or not isinstance(value, int): raise EvaluationError(f"{context}: expected integer") if value < minimum or (maximum is not None and value > maximum): @@ -249,9 +242,12 @@ def validate_plan(value: Any, context: str) -> dict[str, Any]: ): if record[key] > cases: raise EvaluationError(f"{context}.{key}: exceeds cases") - if record["path_found"] + record["graph_disconnection_failures"] + record[ - "no_supported_edge_failures" - ] != cases: + if ( + record["path_found"] + + record["graph_disconnection_failures"] + + record["no_supported_edge_failures"] + != cases + ): raise EvaluationError(f"{context}: planning disposition contradiction") _validate_hex(record["checksum"], f"{context}.checksum", 16) return record @@ -266,27 +262,19 @@ def derive_eval(record: dict[str, Any]) -> dict[str, float | int]: result: dict[str, float | int] = { "accuracy": record["correct"] / samples, "reconstruction_rmse": math.sqrt( - (record["reconstruction_sse_q20"] / Q20_SCALE) - / (samples * DIMENSIONS) + (record["reconstruction_sse_q20"] / Q20_SCALE) / (samples * DIMENSIONS) ), "prediction_rmse": math.sqrt( - (record["prediction_sse_q20"] / Q20_SCALE) - / (prediction_samples * DIMENSIONS) + (record["prediction_sse_q20"] / Q20_SCALE) / (prediction_samples * DIMENSIONS) ) if prediction_samples else math.inf, - "transition_accuracy": record["transition_correct"] / supported - if supported - else 0.0, + "transition_accuracy": record["transition_correct"] / supported if supported else 0.0, "transition_support_rate": supported / samples, "routing_mismatches": record["routed_complete_mismatches"], "expert_evaluations": record["expert_evaluations"], } - if not all( - math.isfinite(value) - for value in result.values() - if isinstance(value, float) - ): + if not all(math.isfinite(value) for value in result.values() if isinstance(value, float)): raise EvaluationError("derived evaluation contains non-finite metric") return result @@ -466,9 +454,7 @@ def validate_preregistration(value: Any) -> dict[str, Any]: raise EvaluationError("final validation must be declared one-shot") require_string(freeze["development_corpus"], "preregistration.freeze.development") - derivation = require_object( - prereg["seed_derivation"], "preregistration.seed_derivation" - ) + derivation = require_object(prereg["seed_derivation"], "preregistration.seed_derivation") require_exact_keys( derivation, { @@ -495,9 +481,7 @@ def validate_preregistration(value: Any) -> dict[str, Any]: 1, ) - datasets = require_object( - prereg["datasets_per_trial"], "preregistration.datasets_per_trial" - ) + datasets = require_object(prereg["datasets_per_trial"], "preregistration.datasets_per_trial") require_exact_keys(datasets, DATASET_KEYS, "preregistration.datasets_per_trial") for name, count in datasets.items(): require_int(count, f"preregistration.datasets_per_trial.{name}", 1) @@ -507,9 +491,7 @@ def validate_preregistration(value: Any) -> dict[str, Any]: for index, prohibition in enumerate(prohibitions): require_string(prohibition, f"dataset_prohibitions[{index}]") - constants = require_object( - prereg["mechanism_constants"], "preregistration.mechanism_constants" - ) + constants = require_object(prereg["mechanism_constants"], "preregistration.mechanism_constants") require_exact_keys( constants, { @@ -556,9 +538,7 @@ def validate_preregistration(value: Any) -> dict[str, Any]: regime_index = regimes.get(regime, 0) derived_seed = _derive_validation_seed(root_seed, regime, regime_index) if seed_value != derived_seed: - raise EvaluationError( - f"trials[{index}].seed disagrees with frozen derivation" - ) + raise EvaluationError(f"trials[{index}].seed disagrees with frozen derivation") if trial_id in identities or seed in seeds: raise EvaluationError("duplicate trial id or seed") identities.add(trial_id) @@ -570,11 +550,7 @@ def validate_preregistration(value: Any) -> dict[str, Any]: if any(count != expected_per_regime for count in regimes.values()): raise EvaluationError("unexpected validation seed count per regime") variants = prereg["comparison_variants"] - if ( - not isinstance(variants, list) - or not variants - or len(variants) != len(set(variants)) - ): + if not isinstance(variants, list) or not variants or len(variants) != len(set(variants)): raise EvaluationError("comparison_variants must be a unique non-empty list") for index, variant in enumerate(variants): require_string(variant, f"comparison_variants[{index}]") @@ -582,9 +558,7 @@ def validate_preregistration(value: Any) -> dict[str, Any]: _validate_gate_list(prereg[collection_name], collection_name) for regime, gates in prereg["regime_gates"].items(): _validate_gate_list(gates, f"regime_gates.{regime}") - global_rule = require_object( - prereg["global_pass_rule"], "preregistration.global_pass_rule" - ) + global_rule = require_object(prereg["global_pass_rule"], "preregistration.global_pass_rule") require_exact_keys( global_rule, { @@ -681,9 +655,7 @@ def _validate_gate_list(value: Any, context: str) -> None: raise EvaluationError(f"{context}[{index}]: non-finite threshold") -def validate_trial( - trial: Any, expected: dict[str, Any], prereg: dict[str, Any] -) -> dict[str, Any]: +def validate_trial(trial: Any, expected: dict[str, Any], prereg: dict[str, Any]) -> dict[str, Any]: context = f"trial[{expected['trial_id']}]" record = require_object(trial, context) require_exact_keys( @@ -721,8 +693,7 @@ def validate_trial( if len(set(parsed_dataset_seeds.values())) != len(parsed_dataset_seeds): raise EvaluationError(f"{context}: dataset seed collision") expected_dataset_seeds = { - name: _mix64(trial_seed ^ xor_value) - for name, xor_value in DATASET_SEED_XORS.items() + name: _mix64(trial_seed ^ xor_value) for name, xor_value in DATASET_SEED_XORS.items() } if parsed_dataset_seeds != expected_dataset_seeds: raise EvaluationError(f"{context}: dataset seed derivation mismatch") @@ -845,12 +816,9 @@ def validate_trial( candidate_comparison = comparisons["ravel_0_5_candidate"] if ( candidate_comparison["expert_count"] != candidate["expert_count"] - or candidate_comparison["checkpoint_size_bytes"] - != candidate["checkpoint_size_bytes"] - or candidate_comparison["drift_holdout"] - != candidate["adapted_model_drift_holdout"] - or candidate_comparison["retention_holdout"] - != candidate["base_holdout_retention"] + or candidate_comparison["checkpoint_size_bytes"] != candidate["checkpoint_size_bytes"] + or candidate_comparison["drift_holdout"] != candidate["adapted_model_drift_holdout"] + or candidate_comparison["retention_holdout"] != candidate["base_holdout_retention"] or candidate_comparison["planning"] != candidate["planning"] ): raise EvaluationError(f"{context}: candidate comparison contradicts raw candidate") @@ -876,8 +844,7 @@ def derive_trial_metrics(record: dict[str, Any]) -> dict[str, Any]: replay = candidate["replay"] topology = candidate["topology"] routing_mismatches = sum( - int(view["routing_mismatches"]) - for view in (base, adaptation, static, adapted, retention) + int(view["routing_mismatches"]) for view in (base, adaptation, static, adapted, retention) ) metrics: dict[str, Any] = { "adaptation_completed": candidate["adaptation_completed"], @@ -897,13 +864,11 @@ def derive_trial_metrics(record: dict[str, Any]) -> dict[str, Any]: "adapted_reconstruction_rmse": adapted["reconstruction_rmse"], "retention_reconstruction_rmse": retention["reconstruction_rmse"], "retention_reconstruction_degradation_ratio": ( - float(retention["reconstruction_rmse"]) - - float(base["reconstruction_rmse"]) + float(retention["reconstruction_rmse"]) - float(base["reconstruction_rmse"]) ) / max(float(base["reconstruction_rmse"]), 1e-12), "reconstruction_improvement_ratio": ( - float(static["reconstruction_rmse"]) - - float(adapted["reconstruction_rmse"]) + float(static["reconstruction_rmse"]) - float(adapted["reconstruction_rmse"]) ) / max(float(static["reconstruction_rmse"]), 1e-12), "base_prediction_rmse": base["prediction_rmse"], @@ -920,9 +885,7 @@ def derive_trial_metrics(record: dict[str, Any]) -> dict[str, Any]: "adapted_transition_accuracy": adapted["transition_accuracy"], "transition_accuracy_delta": float(adapted["transition_accuracy"]) - float(static["transition_accuracy"]), - "retention_transition_accuracy_delta": float( - retention["transition_accuracy"] - ) + "retention_transition_accuracy_delta": float(retention["transition_accuracy"]) - float(base["transition_accuracy"]), "transition_support_rate": adapted["transition_support_rate"], "path_found_rate": planning["path_found_rate"], @@ -948,9 +911,7 @@ def derive_trial_metrics(record: dict[str, Any]) -> dict[str, Any]: "checkpoint_behavior": integrity["checkpoint_behavior_match"], "checkpoint_mutations": all(integrity["checkpoint_mutations"].values()), "lineage_invariants": all(integrity["lineage_invariants"].values()), - "unsupported_graph_edge_violations": integrity[ - "unsupported_graph_edge_violations" - ], + "unsupported_graph_edge_violations": integrity["unsupported_graph_edge_violations"], } comparison_metrics: dict[str, dict[str, float | int]] = {} for name, variant in record["comparisons"].items(): @@ -989,9 +950,7 @@ def derive_trial_metrics(record: dict[str, Any]) -> dict[str, Any]: - float(matched_compute["drift_accuracy"]), "matched_compute_retention_delta": float(retention["accuracy"]) - float(matched_compute["retention_accuracy"]), - "matched_compute_training_evaluation_ratio": float( - metrics["training_evaluations"] - ) + "matched_compute_training_evaluation_ratio": float(metrics["training_evaluations"]) / max(float(matched_compute["training_evaluations"]), 1.0), "no_birth_drift_accuracy_delta": float(adapted["accuracy"]) - float(no_birth["drift_accuracy"]), @@ -1001,19 +960,13 @@ def derive_trial_metrics(record: dict[str, Any]) -> dict[str, Any]: - float(periodic_replay["drift_accuracy"]), "balanced_vs_periodic_retention_delta": float(retention["accuracy"]) - float(periodic_replay["retention_accuracy"]), - "inference_evaluation_ratio_vs_flat64": float( - metrics["inference_expert_evaluations"] - ) + "inference_evaluation_ratio_vs_flat64": float(metrics["inference_expert_evaluations"]) / max(float(flat_complete["expert_evaluations"]), 1.0), "topology_objective_gain_q20": topology["objective_after_q20"] - topology["objective_before_q20"], } ) - if not all( - math.isfinite(value) - for value in metrics.values() - if isinstance(value, float) - ): + if not all(math.isfinite(value) for value in metrics.values() if isinstance(value, float)): raise EvaluationError("trial derived non-finite metric") return metrics @@ -1053,9 +1006,7 @@ def _aggregate(values: list[float | int]) -> dict[str, float]: } -def _pareto_relation( - candidate: dict[str, float | int], variant: dict[str, float | int] -) -> str: +def _pareto_relation(candidate: dict[str, float | int], variant: dict[str, float | int]) -> str: maximize = { "drift_accuracy", "retention_accuracy", @@ -1114,16 +1065,13 @@ def evaluate(raw: Any, preregistration: Any) -> dict[str, Any]: evaluated_trials: list[dict[str, Any]] = [] metric_series: dict[str, list[float | int]] = {} passing = 0 - passing_by_regime: dict[str, int] = { - regime: 0 for regime in prereg["regime_gates"] - } + passing_by_regime: dict[str, int] = {regime: 0 for regime in prereg["regime_gates"]} for index, expected in enumerate(prereg["trials"]): record = validate_trial(trials[index], expected, prereg) metrics = derive_trial_metrics(record) gates = [ _apply_gate(gate, metrics) - for gate in prereg["common_gates"] - + prereg["regime_gates"][record["regime"]] + for gate in prereg["common_gates"] + prereg["regime_gates"][record["regime"]] ] trial_pass = all(gate["pass"] for gate in gates) passing += int(trial_pass) @@ -1167,9 +1115,7 @@ def evaluate(raw: Any, preregistration: Any) -> dict[str, Any]: metric: candidate_quality[metric] - value for metric, value in variant_metrics.items() }, - "pareto_relation": _pareto_relation( - candidate_quality, variant_metrics - ), + "pareto_relation": _pareto_relation(candidate_quality, variant_metrics), } evaluated_trials.append( { @@ -1184,9 +1130,7 @@ def evaluate(raw: Any, preregistration: Any) -> dict[str, Any]: ) failing = len(evaluated_trials) - passing required = prereg["global_pass_rule"]["minimum_passing_trials"] - required_per_regime = prereg["global_pass_rule"][ - "minimum_passing_trials_per_regime" - ] + required_per_regime = prereg["global_pass_rule"]["minimum_passing_trials_per_regime"] global_pass = passing >= required and all( count >= required_per_regime for count in passing_by_regime.values() ) @@ -1204,9 +1148,7 @@ def evaluate(raw: Any, preregistration: Any) -> dict[str, Any]: "minimum_passing_trials_per_regime": required_per_regime, }, "trials": evaluated_trials, - "aggregates": { - name: _aggregate(values) for name, values in metric_series.items() - }, + "aggregates": {name: _aggregate(values) for name, values in metric_series.items()}, "development_result": development_result, "evidence_reproduction": "PASS", "formal_mncs_status": "UNKNOWN", diff --git a/tools/ravel_0_5_evidence.py b/tools/ravel_0_5_evidence.py index 31f9ebc..d6e4890 100644 --- a/tools/ravel_0_5_evidence.py +++ b/tools/ravel_0_5_evidence.py @@ -63,8 +63,7 @@ def _run(binary: Path, arguments: list[str]) -> bytes: ) if completed.stderr: raise EvidenceError( - "RAVEL executable wrote unexpected stderr: " - + completed.stderr.decode(errors="replace") + "RAVEL executable wrote unexpected stderr: " + completed.stderr.decode(errors="replace") ) return completed.stdout @@ -145,9 +144,7 @@ def evaluator_mutation_observations( threshold = copy.deepcopy(prereg) threshold["common_gates"][0]["value"] = not threshold["common_gates"][0]["value"] - observations["threshold_mutation"] = _expect_rejection( - lambda: evaluate(raw, threshold) - ) + observations["threshold_mutation"] = _expect_rejection(lambda: evaluate(raw, threshold)) trial_result = copy.deepcopy(raw) trial_result["trials"][0]["trial_result"] = "PASS" @@ -168,19 +165,13 @@ def evaluator_mutation_observations( regime = copy.deepcopy(raw) original_regime = regime["trials"][0]["regime"] regime["trials"][0]["regime"] = next( - trial["regime"] - for trial in prereg["trials"] - if trial["regime"] != original_regime - ) - observations["regime_mutation"] = _expect_rejection( - lambda: evaluate(regime, prereg) + trial["regime"] for trial in prereg["trials"] if trial["regime"] != original_regime ) + observations["regime_mutation"] = _expect_rejection(lambda: evaluate(regime, prereg)) aggregate = copy.deepcopy(raw) aggregate["development_result"] = "PASS" - observations["aggregate_mutation"] = _expect_rejection( - lambda: evaluate(aggregate, prereg) - ) + observations["aggregate_mutation"] = _expect_rejection(lambda: evaluate(aggregate, prereg)) return observations @@ -261,15 +252,11 @@ def reorder(_root: Path, spec_path: Path) -> None: def omit(_root: Path, spec_path: Path) -> None: spec = load_json(spec_path) spec["ordered_files"] = [ - entry - for entry in spec["ordered_files"] - if entry["role"] != "contract" + entry for entry in spec["ordered_files"] if entry["role"] != "contract" ] spec_path.write_bytes(canonical_bytes(spec)) - observations["omitted_file"] = _expect_rejection( - lambda: copied_recalculation(omit) - ) + observations["omitted_file"] = _expect_rejection(lambda: copied_recalculation(omit)) def mutate_build(_root: Path, spec_path: Path) -> None: spec = load_json(spec_path) @@ -277,9 +264,7 @@ def mutate_build(_root: Path, spec_path: Path) -> None: spec_path.write_bytes(canonical_bytes(spec)) observations["build_configuration_mutation"] = _expect_rejection( - lambda: verify_manifest_record( - copied_recalculation(mutate_build), manifest - ) + lambda: verify_manifest_record(copied_recalculation(mutate_build), manifest) ) observations["artifact_mutation"] = _expect_rejection( @@ -387,9 +372,7 @@ def build_assurance( return { "schema": "ravel-assurance-case/0.5", "assurance_case_id": "ravel.adaptive-mechanism-correction.epoch-1", - "execution_integrity": ( - "PASS" if negative["all_negative_tests_pass"] else "FAIL" - ), + "execution_integrity": ("PASS" if negative["all_negative_tests_pass"] else "FAIL"), "development_result": trial["development_result"], "disposition": "NON_PROMOTION_RESEARCH_EVIDENCE", "formal_mncs_status": "UNKNOWN", @@ -398,9 +381,7 @@ def build_assurance( "implementation": { "entrypoint": manifest["entrypoint"], "source_manifest": MANIFEST.name, - "source_manifest_sha256": hashlib.sha256( - canonical_bytes(manifest) - ).hexdigest(), + "source_manifest_sha256": hashlib.sha256(canonical_bytes(manifest)).hexdigest(), "source_digest": manifest["source_digest"], "build_configuration": manifest["build_configuration"], "source_provenance": manifest["source_provenance"], @@ -518,9 +499,7 @@ def expected_package(binary: Path) -> dict[Path, bytes]: }, manifest, ) - manifest_observations = manifest_mutation_observations( - manifest, preliminary_assurance - ) + manifest_observations = manifest_mutation_observations(manifest, preliminary_assurance) negative = derive_negative( self_tests, prereg, @@ -584,8 +563,7 @@ def development_gates() -> None: trial = load_json(TRIAL) if trial.get("development_result") != "PASS": raise EvidenceError( - "independent evaluator development result is " - f"{trial.get('development_result')}" + f"independent evaluator development result is {trial.get('development_result')}" ) diff --git a/tools/ravel_0_5_source_digest.py b/tools/ravel_0_5_source_digest.py index 83042eb..20261cf 100755 --- a/tools/ravel_0_5_source_digest.py +++ b/tools/ravel_0_5_source_digest.py @@ -128,9 +128,7 @@ def discover_execution_shards( return discovered -def build_manifest( - spec_path: Path, repository_root: Path = REPOSITORY_ROOT -) -> dict[str, Any]: +def build_manifest(spec_path: Path, repository_root: Path = REPOSITORY_ROOT) -> dict[str, Any]: spec = load_json(spec_path) validate_spec(spec) declared_shards = set(spec["generated_execution_shards"]) | set( From 251a44c8c6614f830273097f38042e185ae51856 Mon Sep 17 00:00:00 2001 From: epi13 Date: Sat, 1 Aug 2026 08:02:21 -0800 Subject: [PATCH 10/13] Preregister the RAVEL 0.6 development epoch --- RAVEL_0_6_PREREGISTRATION.md | 100 +++++ RAVEL_0_6_SCOPE.md | 47 ++ README.md | 39 +- ravel-0.6-development-record.json | 49 +++ ravel-0.6-limitations.md | 23 + ravel-0.6-preregistration.json | 599 ++++++++++++++++++++++++++ ravel-0.6-preregistration.schema.json | 415 ++++++++++++++++++ ravel-0.6-threat-model.json | 79 ++++ 8 files changed, 1346 insertions(+), 5 deletions(-) create mode 100644 RAVEL_0_6_PREREGISTRATION.md create mode 100644 RAVEL_0_6_SCOPE.md create mode 100644 ravel-0.6-development-record.json create mode 100644 ravel-0.6-limitations.md create mode 100644 ravel-0.6-preregistration.json create mode 100644 ravel-0.6-preregistration.schema.json create mode 100644 ravel-0.6-threat-model.json diff --git a/RAVEL_0_6_PREREGISTRATION.md b/RAVEL_0_6_PREREGISTRATION.md new file mode 100644 index 0000000..56e7919 --- /dev/null +++ b/RAVEL_0_6_PREREGISTRATION.md @@ -0,0 +1,100 @@ +# RAVEL 0.6 preregistration + +This document is the readable companion to +`ravel-0.6-preregistration.json`. The JSON record is the structured +development authority for epoch `ravel.retention-constrained-adaptation.epoch-1`. +It is preregistration, not evidence that the mechanism exists or works. + +## Frozen baseline and permitted recursion + +RAVEL 0.5 candidate `ravel-0.5-candidate-1` is the immutable baseline. Its +source digest is +`201e0373cc8d8f2fb26f284f44b0f87a5751a047d91556213b7aa7bf07e26fa4` +and its source/execution manifest SHA-256 is +`18006006db509269ee374a39133bb25d8452edc0fe0103a43fa92c5660fd89d0`. +Its development result remains `FAIL`, formal MNCS and MNCDS status remain +`UNKNOWN`, and promotion remains unauthorized. + +The following final 0.5 findings may inform a new epoch: + +- three label-drift trials failed the frozen label-gain gate; +- one transition-drift trial failed original-task prediction retention; +- one combined-drift trial failed exact-state planning; +- ambiguous trials failed belief/path planning or conditional-inference + efficiency gates; +- paired Pareto comparisons were mixed; and +- the complete 0.5 assurance and provenance limitations remain applicable. + +These are recursive design inputs only. They are not 0.6 final evidence and +must not be relabeled as such. + +## Authority and identities + +The intended first implementation identity is +`ravel-0.6-candidate-001`; every material implementation change after any +material evaluation increments the candidate identity. The generator is a +repository-controlled development actor. The evaluator must be a separately +maintained program that consumes raw observations and derives gates without +trusting executable verdicts. This separation does not create organizational +independence. + +Development and selection seeds are distinct and deterministically derived. +Retention, transition-retention, and planning inputs use separate domain tags +within each trial. Future final seed material is deliberately absent. It must +be obtained after candidate freeze, preferably by an external custodian, and +must never be disclosed to the development generator. Until that happens, +protected custody and independent evaluation are `UNKNOWN`. + +## Mechanism and budget + +The candidate may add retention constraints around the existing 0.5 +adaptation surface. Replay remains stratified and bounded to 256 records. +Each proposed update is measured on adaptation objectives plus development-only +retention and transition-support probes. An update is accepted only if it +improves the declared adaptation objective, preserves the retention floors, +and does not remove uniquely supported transitions. Rejection leaves the prior +state unchanged. + +The epoch permits at most 16 births, four retirements, two objective-tested +update passes, 80 experts, eight candidate implementations before a new +preregistration revision, and 1.10 times matched fixed-topology training +evaluations. Thresholds may not be changed in response to selection or final +observations. + +## Primary gates + +Every selected label-drift and combined-drift trial must satisfy: + +- base holdout accuracy at least `0.85`; +- retained original-task accuracy at least `0.90`; +- retained accuracy loss from base no worse than `-0.10`; +- original-task prediction RMSE degradation at most `1.0`; +- no routed-versus-complete mismatch; +- capacity, compute, replay, checkpoint, lineage, and transition-support + integrity gates. + +Label drift additionally requires adapted drift accuracy at least `0.60` and +gain over static of at least `0.04`. Combined drift requires adapted accuracy +at least `0.65`, gain at least `0.05`, non-worsening reconstruction and +prediction, transition-accuracy loss no worse than `-0.15`, and exact-state +planning at least `0.50`. These retain the relevant 0.5 meanings rather than +weakening gates to fit known failures. + +Selection requires every selection trial to pass all primary gates. If none +does, the epoch stops with no selected candidate. Ties are resolved by the +frozen lexicographic policy in the JSON record, never by future final results. + +## Final boundary and stopping + +After selection, source, evaluator, manifest, compiler profiles, thresholds, +partitions, and the candidate are frozen before a final seed request. Final +evaluation is one-shot. Its observations cannot repair the same candidate +epoch. A material change starts a new candidate identity and, when it changes +the hypothesis, thresholds, evaluator, or partitions, a new epoch or explicit +preregistration revision. + +Any malformed, missing, unsupported, timed-out, crashed, identity-drifted, or +unavailable required material yields `UNKNOWN`, never `PASS`. `FAIL` dominates +`UNKNOWN`, which dominates `PASS`. Regardless of future development results, +formal MNCS and MNCDS status remain separate and require their own complete +evidence and governance. Promotion defaults to `false`. diff --git a/RAVEL_0_6_SCOPE.md b/RAVEL_0_6_SCOPE.md new file mode 100644 index 0000000..7eb115b --- /dev/null +++ b/RAVEL_0_6_SCOPE.md @@ -0,0 +1,47 @@ +# RAVEL 0.6 retention-constrained adaptation scope + +RAVEL 0.6 is a new, preregistered development epoch. It may use the frozen +RAVEL 0.5 final observations as cross-epoch design information, but it may not +alter 0.5 or reuse its final material as 0.6 final evaluation. + +## Primary hypothesis + +A retention-constrained adaptation policy using stratified replay protection, +objective-tested updates, and transition-support preservation can improve +label-drift and combined-drift holdout performance while preserving base-task +retention and original-task next-observation prediction within frozen bounds. + +The hypothesis is narrow. It is not “make all trials pass.” Ambiguous +belief-planning and broad efficiency superiority are secondary diagnostics and +non-promotion observations, not primary selection objectives. + +## In scope + +- label drift and combined observation/label drift; +- distinct development, selection, retention, transition-retention, planning, + and future final-evaluation partitions; +- deterministic development and selection seed derivation; +- retention-protected replay strata and transition-support constraints; +- objective-tested, bounded updates with an explicit reject/no-change outcome; +- matched-compute RAVEL 0.5 and fixed-topology comparisons; +- no-retention-constraint, no-transition-protection, periodic-replay, and + unconditional-update ablations; +- canonical checkpoints, source identities, mutation tests, and independently + derived evaluator dispositions; and +- a future one-shot final evaluation whose seed material is obtained only after + the selected candidate is frozen. + +## Out of scope + +- modifying or relabeling RAVEL 0.4 or 0.5; +- reusing 0.5 final seeds or evidence as 0.6 final evaluation; +- optimizing against future final material; +- broad ambiguous-belief planning claims or universal efficiency superiority; +- real-world, language, multimodal, distributed, accelerator, deployment, or + production-safety claims; and +- claims of protected custody, independent evaluation, formal conformance, + certification, governance approval, or promotion. + +No 0.6 implementation or evaluation exists at preregistration time. All +implementation, development, final, MNCS, and MNCDS results therefore remain +`UNKNOWN`, and promotion is unauthorized. diff --git a/README.md b/README.md index 2e1390b..2936950 100644 --- a/README.md +++ b/README.md @@ -121,6 +121,29 @@ complete paired Pareto results are mixed. No superiority claim is made. See `RAVEL_0_5_RESULTS.md`, `RAVEL_0_5_POSTMORTEM.md`, and `ravel-0.5-assurance-case.json`. +## RAVEL 0.6 — preregistered future development + +RAVEL 0.6 is a clean new epoch preregistered before implementation. It binds +the immutable 0.5 candidate and evidence as a failed development baseline and +uses the published label-gain, prediction-retention, combined-planning, +ambiguous-planning/efficiency, mixed-Pareto, and assurance findings only as +permitted cross-epoch design input. + +The narrow hypothesis concerns retention-constrained adaptation for label and +combined observation/label drift. The planned policy combines stratified +replay protection, objective-tested updates, and transition-support +preservation. Development, selection, retention, transition-retention, +planning, and future final partitions have distinct identities. Development +and selection seeds are distinct from every 0.5 final seed. Future final seed +material is intentionally absent and may be obtained only after candidate +freeze, preferably from an external custodian. + +No 0.6 mechanism has been implemented, selected, frozen, or evaluated. +Development and final results, protected custody, independent evaluation, and +formal MNCS/MNCDS status are all `UNKNOWN`; promotion is unauthorized. See +`RAVEL_0_6_SCOPE.md`, `RAVEL_0_6_PREREGISTRATION.md`, and +`ravel-0.6-preregistration.json`. + ## Run ```bash @@ -129,6 +152,7 @@ make training-check make unified-check make 0.4-check make 0.5-check +make ravel-0.6-preregistration-check ``` To rewrite repository-visible development evidence: @@ -173,7 +197,11 @@ Requirements: a C11 compiler, the C math library, and Make. `ravel-0.5-assurance-case.json` — bound build/source identity and current bounded non-promotion record; and - `ravel-0.5-runtime-observations.json` — host-specific, non-normative timing - observations; canonical comparisons use deterministic operation counts. + observations; canonical comparisons use deterministic operation counts; and +- `RAVEL_0_6_SCOPE.md`, `RAVEL_0_6_PREREGISTRATION.md`, + `ravel-0.6-preregistration.json`, `ravel-0.6-threat-model.json`, + `ravel-0.6-development-record.json`, and `ravel-0.6-limitations.md` — a new + preregistered epoch with no implementation or evaluation claim. ## MNCS boundary @@ -186,10 +214,11 @@ Requirements: a C11 compiler, the C math library, and Make. Historical RAVEL 0.1–0.3 studies recorded favorable development observations. RAVEL 0.4 records development `FAIL` with zero of eight trials passing. RAVEL 0.5 records development `FAIL` with 24 of 32 trials passing. Formal MNCS and -MNCDS status remain `UNKNOWN`; promotion is unauthorized pending independent -protected real-data evaluation, adversarial continual-learning studies, learned -modality adapters, cross-host reproduction, accelerator and distributed -evidence, and operational release controls. +MNCDS status remain `UNKNOWN`. RAVEL 0.6 is preregistered future work whose +implementation and evaluation remain `UNKNOWN`. Promotion is unauthorized +pending independent protected real-data evaluation, adversarial +continual-learning studies, learned modality adapters, cross-host reproduction, +accelerator and distributed evidence, and operational release controls. ## Claim boundary diff --git a/ravel-0.6-development-record.json b/ravel-0.6-development-record.json new file mode 100644 index 0000000..5163120 --- /dev/null +++ b/ravel-0.6-development-record.json @@ -0,0 +1,49 @@ +{ + "schema": "ravel-development-record/0.6-preregistration", + "record_id": "ravel-0.6-development-record-initial", + "study_id": "ravel.retention-constrained-adaptation.epoch-1", + "preregistration_id": "ravel-0.6-preregistration-revision-1", + "recorded_at": "2026-08-01T00:00:00Z", + "record_class": "operator_controlled_preregistration_state", + "candidate": { + "implementation_status": "NOT_IMPLEMENTED", + "selected_candidate_id": null, + "frozen": false, + "manifest_identity": null + }, + "development_evaluation": { + "status": "UNKNOWN", + "executed": false, + "evidence": [] + }, + "final_evaluation": { + "status": "UNKNOWN", + "executed": false, + "seed_material_present": false, + "evidence": [] + }, + "authority": { + "protected_custody": "UNKNOWN", + "independent_evaluation": "UNKNOWN", + "external_custodian_assigned": false, + "external_evaluator_assigned": false + }, + "formal_status": { + "mncs": "UNKNOWN", + "mncds": "UNKNOWN", + "promotion_authorized": false + }, + "baseline": { + "candidate_id": "ravel-0.5-candidate-1", + "development_result": "FAIL", + "formal_mncs_status": "UNKNOWN", + "formal_mncds_status": "UNKNOWN", + "promotion_authorized": false, + "immutable": true + }, + "limitations": [ + "Preregistration is not implementation or evaluation evidence.", + "No local record can create independence, protected custody, governance approval, certification, or promotion.", + "RAVEL 0.5 final observations are cross-epoch design inputs only and are not RAVEL 0.6 final evidence." + ] +} diff --git a/ravel-0.6-limitations.md b/ravel-0.6-limitations.md new file mode 100644 index 0000000..46a9311 --- /dev/null +++ b/ravel-0.6-limitations.md @@ -0,0 +1,23 @@ +# RAVEL 0.6 preregistration limitations + +- No RAVEL 0.6 candidate has been implemented, frozen, selected, or evaluated. +- Development and selection seeds are repository-visible operator-controlled + material, not protected evidence. +- Future final seed material does not yet exist in this checkout. +- An external custodian and operationally independent evaluator have not been + appointed; both statuses remain `UNKNOWN`. +- The proposed evaluator/generator code separation would not establish + organizational independence. +- The primary hypothesis covers synthetic label and combined drift only. +- Retention floors and transition-support constraints are bounded experimental + proxies, not a general continual-learning guarantee. +- RAVEL 0.5 final observations are permitted cross-epoch design inputs but are + not RAVEL 0.6 final evidence. +- Ambiguous belief planning, broad efficiency superiority, real-data + generalization, language/multimodal behavior, accelerators, distributed + execution, production rollback, and deployment authorization are non-goals. +- Reproduction on one operator-controlled host is not cross-organizational + reproduction or protected custody. +- Formal MNCS status is `UNKNOWN`. +- Formal MNCDS status is `UNKNOWN`. +- Promotion is unauthorized. diff --git a/ravel-0.6-preregistration.json b/ravel-0.6-preregistration.json new file mode 100644 index 0000000..1b643c3 --- /dev/null +++ b/ravel-0.6-preregistration.json @@ -0,0 +1,599 @@ +{ + "schema": "ravel-preregistration/0.6", + "preregistration_id": "ravel-0.6-preregistration-revision-1", + "study_id": "ravel.retention-constrained-adaptation.epoch-1", + "normative_for_epoch": true, + "created_at": "2026-08-01T00:00:00Z", + "status": "PREREGISTERED_BEFORE_IMPLEMENTATION", + "status_precedence": "FAIL > UNKNOWN > PASS", + "baseline": { + "study_id": "ravel.adaptive-mechanism-correction.epoch-1", + "candidate_id": "ravel-0.5-candidate-1", + "immutable": true, + "source_path": "case-studies/ravel/ravel_0_5.c", + "source_sha256": "1a8466ea1805811873c461fb891aaeaec18f6c9e7491b5ea7bd09bf698be102d", + "source_digest": "201e0373cc8d8f2fb26f284f44b0f87a5751a047d91556213b7aa7bf07e26fa4", + "preregistration_path": "case-studies/ravel/ravel-0.5-preregistration.json", + "preregistration_sha256": "f240c391b92823471132ffce1eeed154b3f03dc2af1e3e1f789690a99eb4cfaa", + "manifest_path": "case-studies/ravel/ravel-0.5-source-and-execution-manifest.json", + "manifest_sha256": "18006006db509269ee374a39133bb25d8452edc0fe0103a43fa92c5660fd89d0", + "raw_observations_sha256": "bb34d0292a9286ea321d50d31919dc43793a58b90b4c7a7892f91552b841f354", + "trial_evidence_sha256": "9ffefe97e5331b65e5b998f9c2d3aac91cdf9cca246a377ca421a3bef0ba0e80", + "assurance_case_sha256": "4bcce0a8dbcc6ff2ce085b809736be33511fffdc648f0c1545daeac7e695f429", + "execution_integrity": "PASS", + "development_result": "FAIL", + "formal_mncs_status": "UNKNOWN", + "formal_mncds_status": "UNKNOWN", + "promotion_authorized": false + }, + "permitted_recursive_feedback": [ + { + "finding_id": "ravel-0.5-label-gain-retention", + "observation": "Three label-drift trials failed the frozen label-gain gate while retention constraints remained material.", + "permitted_use": "design new retention-constrained development mechanisms", + "prohibited_use": "relabel as RAVEL 0.6 final evaluation" + }, + { + "finding_id": "ravel-0.5-transition-prediction-retention", + "observation": "One transition-drift trial failed original-task next-observation prediction retention.", + "permitted_use": "design transition-support preservation and retention probes", + "prohibited_use": "repair RAVEL 0.5 or reuse its final seed" + }, + { + "finding_id": "ravel-0.5-combined-planning", + "observation": "One combined-drift trial failed the exact-state planning gate.", + "permitted_use": "retain planning as a bounded diagnostic and hard combined gate", + "prohibited_use": "tune against the 0.5 final trial" + }, + { + "finding_id": "ravel-0.5-ambiguous-belief-efficiency", + "observation": "Ambiguous trials failed belief/path planning or conditional-inference efficiency gates.", + "permitted_use": "record secondary diagnostics and explicit non-goals", + "prohibited_use": "broaden the primary 0.6 hypothesis" + }, + { + "finding_id": "ravel-0.5-mixed-paired-pareto", + "observation": "Paired Pareto comparisons were mixed.", + "permitted_use": "require paired reporting without a superiority claim", + "prohibited_use": "claim broad efficiency superiority" + }, + { + "finding_id": "ravel-0.5-assurance-provenance", + "observation": "All published 0.5 assurance, custody, provenance, and external-evidence limitations remain applicable.", + "permitted_use": "strengthen 0.6 preregistration and identity controls", + "prohibited_use": "claim local code can manufacture independence or custody" + } + ], + "hypothesis": { + "primary": "A retention-constrained adaptation policy using stratified replay protection, objective-tested updates, and transition-support preservation can improve label-drift and combined-drift holdout performance while preserving base-task retention and original-task next-observation prediction within frozen bounds.", + "primary_regimes": [ + "label_drift", + "combined_observation_and_label_drift" + ], + "secondary_diagnostics": [ + "exact-state planning", + "belief-set planning", + "conditional-inference efficiency", + "paired Pareto outcomes" + ], + "non_goals": [ + "make all trials pass", + "broad ambiguous-belief planning superiority", + "universal efficiency superiority", + "real-data or production generalization", + "formal conformance or promotion" + ] + }, + "candidate_policy": { + "implementation_status": "NOT_IMPLEMENTED", + "selected_candidate": null, + "first_candidate_id": "ravel-0.6-candidate-001", + "naming_rule": "^ravel-0\\.6-candidate-[0-9]{3}$", + "material_change_rule": "Every implementation change after material evaluation creates the next candidate identity.", + "maximum_candidate_identities": 8, + "post_limit_action": "Start a new preregistration revision or epoch; do not weaken gates." + }, + "authorities": { + "generator": { + "authority_id": "ravel-0.6-development-generator", + "custody": "repository_operator_controlled", + "may_access": [ + "development partitions", + "development retention probes", + "development planning diagnostics" + ], + "must_not_access": [ + "selection observations before candidate evaluation", + "future final seed material", + "future final observations" + ] + }, + "selector": { + "authority_id": "ravel-0.6-selection-evaluator", + "custody": "repository_operator_controlled", + "may_access_after_candidate_freeze": [ + "selection partitions", + "frozen candidate identities" + ], + "must_not_repair": "A candidate from its selection observations." + }, + "final_evaluator": { + "authority_id": "UNASSIGNED", + "preferred_actor": "external evaluator distinct from generator and selector", + "status": "UNKNOWN" + }, + "final_seed_custodian": { + "authority_id": "UNASSIGNED", + "preferred_actor": "external custodian distinct from generator", + "protected_custody": "UNKNOWN" + }, + "evaluator_rule": "The implementation emits raw observations only; a separately maintained evaluator derives all gates and dispositions.", + "independence_boundary": "Repository-local generator/evaluator separation does not establish operational or organizational independence." + }, + "partitions": [ + { + "partition_id": "ravel-0.6-development-adaptation-v1", + "purpose": "mechanism implementation and development repair", + "seed_domain": "ravel-0.6/development", + "visible_to_generator": true, + "protected": false + }, + { + "partition_id": "ravel-0.6-selection-v1", + "purpose": "frozen candidate selection only", + "seed_domain": "ravel-0.6/selection", + "visible_to_generator": false, + "protected": false + }, + { + "partition_id": "ravel-0.6-future-final-reservation-v1", + "purpose": "future one-shot final evaluation", + "seed_domain": "ravel-0.6/final/post-freeze-custodian-material", + "visible_to_generator": false, + "protected": "UNKNOWN" + }, + { + "partition_id": "ravel-0.6-retention-holdout-v1", + "purpose": "original-task classification and representation retention", + "seed_domain": "ravel-0.6/retention", + "visible_to_generator": false, + "protected": false + }, + { + "partition_id": "ravel-0.6-transition-retention-v1", + "purpose": "original-task next-observation and transition-support retention", + "seed_domain": "ravel-0.6/transition-retention", + "visible_to_generator": false, + "protected": false + }, + { + "partition_id": "ravel-0.6-planning-diagnostics-v1", + "purpose": "exact-state and belief-planning diagnostics", + "seed_domain": "ravel-0.6/planning", + "visible_to_generator": false, + "protected": false + } + ], + "seed_derivation": { + "root_seed": "0x524156454c303644", + "algorithm": "sha256-first-u64-big-endian", + "framing": "root_seed_u64_be || utf8('ravel-0.6\\0') || utf8(phase) || zero_byte || utf8(regime) || zero_byte || index_u32_be", + "development_seeds": [ + { + "trial_id": "development-label-01", + "regime": "label_drift", + "seed": "0x0a31e8cc9b0027a0" + }, + { + "trial_id": "development-label-02", + "regime": "label_drift", + "seed": "0x03f56834ccd0d3d3" + }, + { + "trial_id": "development-label-03", + "regime": "label_drift", + "seed": "0x5a8d9a6c4bbdd0b4" + }, + { + "trial_id": "development-label-04", + "regime": "label_drift", + "seed": "0x10f8dcc5d4749795" + }, + { + "trial_id": "development-combined-01", + "regime": "combined_observation_and_label_drift", + "seed": "0xccb7555695e5d7a5" + }, + { + "trial_id": "development-combined-02", + "regime": "combined_observation_and_label_drift", + "seed": "0xb272eac5c943235e" + }, + { + "trial_id": "development-combined-03", + "regime": "combined_observation_and_label_drift", + "seed": "0xcf103ff18fbae499" + }, + { + "trial_id": "development-combined-04", + "regime": "combined_observation_and_label_drift", + "seed": "0x9079fcf25f25f034" + } + ], + "selection_seeds": [ + { + "trial_id": "selection-label-01", + "regime": "label_drift", + "seed": "0xf9872feaeed11760" + }, + { + "trial_id": "selection-label-02", + "regime": "label_drift", + "seed": "0xcf0fa6f591fc4094" + }, + { + "trial_id": "selection-combined-01", + "regime": "combined_observation_and_label_drift", + "seed": "0xad8469dc02bb0f39" + }, + { + "trial_id": "selection-combined-02", + "regime": "combined_observation_and_label_drift", + "seed": "0x0d33c2594a3b3ee4" + } + ], + "future_final_seeds": [], + "future_final_seed_state": "NOT_OBTAINED", + "prohibition": "No RAVEL 0.5 final seed or future RAVEL 0.6 final seed may be used for development, selection, repair, or threshold changes." + }, + "datasets_per_trial": { + "base_training": 1024, + "base_holdout": 256, + "drift_adaptation_training": 512, + "drift_holdout": 256, + "original_task_retention_holdout": 256, + "transition_retention_holdout": 256, + "planning_diagnostics": 64 + }, + "mechanism": { + "name": "retention-constrained adaptation", + "required_features": [ + "deterministic stratified replay protection", + "objective-tested updates with an explicit rejected/no-change outcome", + "base-task retention constraints", + "original-task transition-support preservation", + "unique-support retirement protection", + "deterministic tie-breaking and recorded decision provenance" + ], + "update_acceptance": [ + "adaptation objective improves by at least the declared development epsilon", + "retention accuracy and representation floors remain satisfied", + "original-task prediction degradation remains within its floor", + "no uniquely supported transition becomes unsupported", + "capacity and compute budgets remain satisfied" + ], + "no_acceptance_behavior": "Retain the preceding candidate state unchanged.", + "budget": { + "maximum_experts": 80, + "maximum_births_per_trial": 16, + "maximum_retirements_per_trial": 4, + "replay_records": 256, + "maximum_objective_tested_update_passes": 2, + "maximum_training_evaluation_ratio_vs_matched_fixed_topology": 1.1, + "maximum_candidate_identities": 8 + } + }, + "environment": { + "language": "C", + "standard": "C11", + "canonical_compiler_command": [ + "cc", + "-std=c11", + "-O3", + "-Wall", + "-Wextra", + "-Werror", + "-pedantic" + ], + "link_libraries": [ + "m" + ], + "required_recorded_identities": [ + "compiler executable SHA-256", + "compiler version output digest", + "source manifest SHA-256", + "evaluator SHA-256", + "preregistration SHA-256", + "environment-key names", + "command argv", + "exit status", + "stdout and stderr digests" + ], + "optional_profiles": [ + "clang C11 warnings-as-errors", + "GCC C11 warnings-as-errors", + "address and undefined behavior sanitizers" + ], + "missing_optional_profile": "UNKNOWN informational evidence, never PASS" + }, + "metrics": { + "primary": [ + "adapted_drift_accuracy", + "drift_accuracy_delta", + "retention_accuracy", + "retention_accuracy_delta_from_base", + "retention_prediction_degradation", + "reconstruction_improvement_ratio", + "prediction_improvement_ratio", + "transition_accuracy_delta", + "exact_state_rate" + ], + "secondary": [ + "belief_success_rate", + "path_found_rate", + "inference_evaluation_ratio_vs_flat64", + "training_evaluation_ratio_vs_matched_fixed_topology", + "accepted_births", + "accepted_retirements", + "paired_pareto_outcomes" + ] + }, + "hard_gates": { + "common": [ + { + "gate_id": "base_holdout_accuracy", + "metric": "base_accuracy", + "operator": "ge", + "value": 0.85 + }, + { + "gate_id": "base_holdout_retention", + "metric": "retention_accuracy", + "operator": "ge", + "value": 0.9 + }, + { + "gate_id": "retention_loss_floor", + "metric": "retention_accuracy_delta_from_base", + "operator": "ge", + "value": -0.1 + }, + { + "gate_id": "old_prediction_retention", + "metric": "retention_prediction_degradation", + "operator": "le", + "value": 1.0 + }, + { + "gate_id": "routing_oracle_equivalence", + "metric": "routing_mismatches", + "operator": "eq", + "value": 0 + }, + { + "gate_id": "replay_size", + "metric": "replay_selected", + "operator": "eq", + "value": 256 + }, + { + "gate_id": "transition_unique_support", + "metric": "unique_transition_support_losses", + "operator": "eq", + "value": 0 + }, + { + "gate_id": "checkpoint_identity_and_behavior", + "metric": "checkpoint_roundtrip_complete", + "operator": "eq", + "value": true + }, + { + "gate_id": "lineage_invariants", + "metric": "lineage_invariants", + "operator": "eq", + "value": true + }, + { + "gate_id": "expert_capacity", + "metric": "expert_count", + "operator": "le", + "value": 80 + }, + { + "gate_id": "matched_compute_budget", + "metric": "matched_compute_training_evaluation_ratio", + "operator": "le", + "value": 1.1 + } + ], + "label_drift": [ + { + "gate_id": "label_adaptation", + "metric": "adapted_drift_accuracy", + "operator": "ge", + "value": 0.6 + }, + { + "gate_id": "label_gain", + "metric": "drift_accuracy_delta", + "operator": "ge", + "value": 0.04 + }, + { + "gate_id": "label_planning_non_inferiority", + "metric": "exact_state_rate_delta", + "operator": "ge", + "value": -0.05 + } + ], + "combined_observation_and_label_drift": [ + { + "gate_id": "combined_adaptation", + "metric": "adapted_drift_accuracy", + "operator": "ge", + "value": 0.65 + }, + { + "gate_id": "combined_gain", + "metric": "drift_accuracy_delta", + "operator": "ge", + "value": 0.05 + }, + { + "gate_id": "combined_reconstruction", + "metric": "reconstruction_improvement_ratio", + "operator": "ge", + "value": 0.0 + }, + { + "gate_id": "combined_prediction", + "metric": "prediction_improvement_ratio", + "operator": "ge", + "value": 0.0 + }, + { + "gate_id": "combined_transition_non_inferiority", + "metric": "transition_accuracy_delta", + "operator": "ge", + "value": -0.15 + }, + { + "gate_id": "combined_exact_planning", + "metric": "exact_state_rate", + "operator": "ge", + "value": 0.5 + } + ] + }, + "comparisons": [ + "frozen RAVEL 0.5 candidate under matched 0.6 development partitions", + "fixed-topology 64-expert routed matched-compute baseline", + "no-adaptation static baseline", + "flat 64-expert complete-scan reference" + ], + "ablations": [ + "no retention constraint", + "no transition-support preservation", + "periodic replay instead of stratified replay", + "unconditional updates instead of objective-tested updates", + "no births", + "no retirements" + ], + "checkpoint_rules": { + "format": "versioned canonical big-endian fixed-point record with SHA-256 payload identity", + "required_roundtrip_scope": [ + "classification", + "reconstruction", + "next-observation prediction", + "transition support", + "routing", + "planning", + "topology", + "lineage", + "replay provenance", + "retention constraints", + "reported raw metrics" + ], + "mutation_rejection_required": true, + "substitution_rejection_required": true + }, + "mutation_campaign": [ + "raw metric mutation", + "threshold mutation", + "development seed mutation", + "selection seed mutation", + "partition identity substitution", + "candidate identity substitution", + "executable verdict injection", + "evaluator substitution", + "source omission or reordering", + "compiler profile mutation", + "checkpoint field, payload, truncation, append, schema, and substitution mutations", + "retention constraint removal", + "transition unique-support removal", + "nondeterministic output" + ], + "selection_policy": { + "eligibility": "Every selection trial must PASS every common and regime-specific hard gate.", + "no_eligible_candidate": "Stop the epoch with no selected candidate and development evaluation FAIL or UNKNOWN according to available evidence.", + "ordering": [ + "descending minimum per-trial drift_accuracy_delta", + "descending minimum per-trial retention_accuracy_delta_from_base", + "ascending maximum retention_prediction_degradation", + "ascending total training evaluations", + "ascending numeric candidate suffix" + ], + "future_final_use": "Forbidden for selection or tie-breaking." + }, + "future_final_protocol": { + "state": "NOT_STARTED", + "seed_material_present": false, + "prerequisites": [ + "one selected candidate identity", + "frozen source and execution manifest", + "frozen evaluator identity", + "frozen compiler profiles", + "frozen thresholds and partitions", + "recorded request to a final seed custodian" + ], + "seed_request": "After freeze, request fresh unpredictable seed material from an external custodian when available.", + "derivation": "sha256-first-u64-big-endian over custodian material, frozen candidate identity, regime, and trial index", + "minimum_trials": { + "label_drift": 4, + "combined_observation_and_label_drift": 4 + }, + "custody_if_no_external_actor": "UNKNOWN", + "independent_evaluation_if_no_external_actor": "UNKNOWN", + "one_shot": true, + "same_epoch_repair_feedback": false, + "development_generator_access": "FORBIDDEN" + }, + "source_and_manifest_rules": { + "implementation_entrypoint_rule": "case-studies/ravel/ravel_0_6_candidate_NNN.c", + "evaluator_rule": "case-studies/ravel/tools/ravel_0_6_evaluator.py", + "generator_rule": "case-studies/ravel/tools/ravel_0_6_development.py", + "ordered_manifest_required": true, + "manifest_must_bind": [ + "implementation", + "scope and preregistration", + "evaluator and development tooling", + "compiler profiles", + "schemas", + "build files", + "raw and derived evidence", + "checkpoint identities" + ], + "digest": "sha256", + "unexpected_execution_shards": "FAIL" + }, + "unknown_policy": { + "missing_required_evidence": "UNKNOWN", + "unsupported_required_construct": "UNKNOWN", + "timeout": "UNKNOWN", + "crash": "UNKNOWN", + "missing_executable": "UNKNOWN", + "malformed_response": "UNKNOWN", + "output_limit": "UNKNOWN", + "identity_drift": "UNKNOWN", + "aggregation": "FAIL > UNKNOWN > PASS", + "workflow_success_is_conformance": false + }, + "stopping_rules": [ + "Stop when eight candidate identities have received material evaluation.", + "Stop with no selected candidate when selection eligibility is empty.", + "Stop and start a new revision or epoch after any material hypothesis, threshold, evaluator, partition, or final-protocol change.", + "Stop same-epoch repair after the first final evaluation.", + "Do not weaken gates, remove failed trials, or change expected results to obtain PASS." + ], + "initial_disposition": { + "candidate_implementation": "NOT_IMPLEMENTED", + "development_evaluation": "UNKNOWN", + "final_evaluation": "UNKNOWN", + "protected_custody": "UNKNOWN", + "independent_evaluation": "UNKNOWN", + "formal_mncs_status": "UNKNOWN", + "formal_mncds_status": "UNKNOWN", + "promotion_authorized": false + } +} diff --git a/ravel-0.6-preregistration.schema.json b/ravel-0.6-preregistration.schema.json new file mode 100644 index 0000000..aeaf7f2 --- /dev/null +++ b/ravel-0.6-preregistration.schema.json @@ -0,0 +1,415 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "https://mncs.dev/schema/experimental/ravel-preregistration-0.6.json", + "title": "RAVEL 0.6 preregistration", + "type": "object", + "additionalProperties": false, + "required": [ + "schema", + "preregistration_id", + "study_id", + "normative_for_epoch", + "created_at", + "status", + "status_precedence", + "baseline", + "permitted_recursive_feedback", + "hypothesis", + "candidate_policy", + "authorities", + "partitions", + "seed_derivation", + "datasets_per_trial", + "mechanism", + "environment", + "metrics", + "hard_gates", + "comparisons", + "ablations", + "checkpoint_rules", + "mutation_campaign", + "selection_policy", + "future_final_protocol", + "source_and_manifest_rules", + "unknown_policy", + "stopping_rules", + "initial_disposition" + ], + "properties": { + "schema": { + "const": "ravel-preregistration/0.6" + }, + "preregistration_id": { + "type": "string", + "minLength": 1 + }, + "study_id": { + "type": "string", + "minLength": 1 + }, + "normative_for_epoch": { + "const": true + }, + "created_at": { + "type": "string", + "format": "date-time" + }, + "status": { + "const": "PREREGISTERED_BEFORE_IMPLEMENTATION" + }, + "status_precedence": { + "const": "FAIL > UNKNOWN > PASS" + }, + "baseline": { + "type": "object", + "required": [ + "study_id", + "candidate_id", + "immutable", + "source_path", + "source_sha256", + "source_digest", + "preregistration_path", + "preregistration_sha256", + "manifest_path", + "manifest_sha256", + "raw_observations_sha256", + "trial_evidence_sha256", + "assurance_case_sha256", + "execution_integrity", + "development_result", + "formal_mncs_status", + "formal_mncds_status", + "promotion_authorized" + ], + "properties": { + "immutable": { + "const": true + }, + "development_result": { + "const": "FAIL" + }, + "formal_mncs_status": { + "const": "UNKNOWN" + }, + "formal_mncds_status": { + "const": "UNKNOWN" + }, + "promotion_authorized": { + "const": false + } + } + }, + "permitted_recursive_feedback": { + "type": "array", + "minItems": 6, + "items": { + "type": "object", + "required": [ + "finding_id", + "observation", + "permitted_use", + "prohibited_use" + ] + } + }, + "hypothesis": { + "type": "object", + "required": [ + "primary", + "primary_regimes", + "secondary_diagnostics", + "non_goals" + ] + }, + "candidate_policy": { + "type": "object", + "required": [ + "implementation_status", + "selected_candidate", + "first_candidate_id", + "naming_rule", + "material_change_rule", + "maximum_candidate_identities", + "post_limit_action" + ], + "properties": { + "implementation_status": { + "const": "NOT_IMPLEMENTED" + }, + "selected_candidate": { + "type": "null" + } + } + }, + "authorities": { + "type": "object", + "required": [ + "generator", + "selector", + "final_evaluator", + "final_seed_custodian", + "evaluator_rule", + "independence_boundary" + ] + }, + "partitions": { + "type": "array", + "minItems": 6, + "items": { + "type": "object", + "required": [ + "partition_id", + "purpose", + "seed_domain", + "visible_to_generator", + "protected" + ] + } + }, + "seed_derivation": { + "type": "object", + "required": [ + "root_seed", + "algorithm", + "framing", + "development_seeds", + "selection_seeds", + "future_final_seeds", + "future_final_seed_state", + "prohibition" + ], + "properties": { + "development_seeds": { + "$ref": "#/$defs/seeds" + }, + "selection_seeds": { + "$ref": "#/$defs/seeds" + }, + "future_final_seeds": { + "type": "array", + "maxItems": 0 + }, + "future_final_seed_state": { + "const": "NOT_OBTAINED" + } + } + }, + "datasets_per_trial": { + "type": "object", + "minProperties": 7 + }, + "mechanism": { + "type": "object", + "required": [ + "name", + "required_features", + "update_acceptance", + "no_acceptance_behavior", + "budget" + ] + }, + "environment": { + "type": "object", + "required": [ + "language", + "standard", + "canonical_compiler_command", + "link_libraries", + "required_recorded_identities", + "optional_profiles", + "missing_optional_profile" + ] + }, + "metrics": { + "type": "object", + "required": [ + "primary", + "secondary" + ] + }, + "hard_gates": { + "type": "object", + "required": [ + "common", + "label_drift", + "combined_observation_and_label_drift" + ] + }, + "comparisons": { + "$ref": "#/$defs/nonemptyStrings" + }, + "ablations": { + "$ref": "#/$defs/nonemptyStrings" + }, + "checkpoint_rules": { + "type": "object", + "required": [ + "format", + "required_roundtrip_scope", + "mutation_rejection_required", + "substitution_rejection_required" + ] + }, + "mutation_campaign": { + "$ref": "#/$defs/nonemptyStrings" + }, + "selection_policy": { + "type": "object", + "required": [ + "eligibility", + "no_eligible_candidate", + "ordering", + "future_final_use" + ] + }, + "future_final_protocol": { + "type": "object", + "required": [ + "state", + "seed_material_present", + "prerequisites", + "seed_request", + "derivation", + "minimum_trials", + "custody_if_no_external_actor", + "independent_evaluation_if_no_external_actor", + "one_shot", + "same_epoch_repair_feedback", + "development_generator_access" + ], + "properties": { + "state": { + "const": "NOT_STARTED" + }, + "seed_material_present": { + "const": false + }, + "custody_if_no_external_actor": { + "const": "UNKNOWN" + }, + "independent_evaluation_if_no_external_actor": { + "const": "UNKNOWN" + }, + "one_shot": { + "const": true + }, + "same_epoch_repair_feedback": { + "const": false + }, + "development_generator_access": { + "const": "FORBIDDEN" + } + } + }, + "source_and_manifest_rules": { + "type": "object", + "required": [ + "implementation_entrypoint_rule", + "evaluator_rule", + "generator_rule", + "ordered_manifest_required", + "manifest_must_bind", + "digest", + "unexpected_execution_shards" + ] + }, + "unknown_policy": { + "type": "object", + "required": [ + "missing_required_evidence", + "unsupported_required_construct", + "timeout", + "crash", + "missing_executable", + "malformed_response", + "output_limit", + "identity_drift", + "aggregation", + "workflow_success_is_conformance" + ] + }, + "stopping_rules": { + "$ref": "#/$defs/nonemptyStrings" + }, + "initial_disposition": { + "type": "object", + "additionalProperties": false, + "required": [ + "candidate_implementation", + "development_evaluation", + "final_evaluation", + "protected_custody", + "independent_evaluation", + "formal_mncs_status", + "formal_mncds_status", + "promotion_authorized" + ], + "properties": { + "candidate_implementation": { + "const": "NOT_IMPLEMENTED" + }, + "development_evaluation": { + "const": "UNKNOWN" + }, + "final_evaluation": { + "const": "UNKNOWN" + }, + "protected_custody": { + "const": "UNKNOWN" + }, + "independent_evaluation": { + "const": "UNKNOWN" + }, + "formal_mncs_status": { + "const": "UNKNOWN" + }, + "formal_mncds_status": { + "const": "UNKNOWN" + }, + "promotion_authorized": { + "const": false + } + } + } + }, + "$defs": { + "nonemptyStrings": { + "type": "array", + "minItems": 1, + "items": { + "type": "string", + "minLength": 1 + } + }, + "seeds": { + "type": "array", + "minItems": 1, + "items": { + "type": "object", + "additionalProperties": false, + "required": [ + "trial_id", + "regime", + "seed" + ], + "properties": { + "trial_id": { + "type": "string", + "minLength": 1 + }, + "regime": { + "enum": [ + "label_drift", + "combined_observation_and_label_drift" + ] + }, + "seed": { + "type": "string", + "pattern": "^0x[0-9a-f]{16}$" + } + } + } + } + } +} diff --git a/ravel-0.6-threat-model.json b/ravel-0.6-threat-model.json new file mode 100644 index 0000000..3d41ea2 --- /dev/null +++ b/ravel-0.6-threat-model.json @@ -0,0 +1,79 @@ +{ + "schema": "ravel-threat-model/0.6-preregistration", + "threat_model_id": "ravel.retention-constrained-adaptation.threats.epoch-1", + "status": "PREREGISTERED_NOT_EVALUATED", + "assets": [ + "immutable RAVEL 0.5 baseline identities and dispositions", + "separate development, selection, retention, transition-retention, planning, and future final partitions", + "future post-freeze final seed material", + "raw observation and evaluator authority separation", + "retention and transition-support update constraints", + "candidate, checkpoint, source, environment, and manifest identities" + ], + "threats": [ + { + "id": "same-epoch-final-feedback", + "control": "future final evaluation is one-shot after candidate freeze and cannot repair the same candidate epoch", + "residual": "no external custodian or independent evaluator has yet accepted authority", + "status": "UNKNOWN" + }, + { + "id": "ravel-0.5-final-reuse", + "control": "all 0.5 final seeds are prohibited and 0.5 observations are labeled cross-epoch design inputs only", + "residual": "developers know the published 0.5 findings", + "status": "UNKNOWN" + }, + { + "id": "partition-leakage", + "control": "partition IDs and seed domains are unique; selection and final data are forbidden from replay, update, threshold, and evaluator repair", + "residual": "development and selection partitions remain under repository custody", + "status": "UNKNOWN" + }, + { + "id": "retention-objective-gaming", + "control": "retention accuracy, prediction, replay coverage, and transition-support floors are hard gates rather than optimization-only scores", + "residual": "bounded synthetic floors may omit open-world failure modes", + "status": "UNKNOWN" + }, + { + "id": "transition-support-erasure", + "control": "updates and retirements must preserve uniquely supported transitions and pass explicit transition-retention gates", + "residual": "top-k bounded support is not a full stochastic world model", + "status": "UNKNOWN" + }, + { + "id": "self-verdict", + "control": "the future implementation may emit only raw observations; a separately maintained evaluator derives gates and aggregate dispositions", + "residual": "repository-local code separation is not operational independence", + "status": "UNKNOWN" + }, + { + "id": "identity-substitution", + "control": "ordered manifests bind candidate, evaluator, preregistration, compiler profiles, checkpoints, and evidence with SHA-256 identities", + "residual": "no external signature, witness, or protected custody currently exists", + "status": "UNKNOWN" + }, + { + "id": "threshold-repair", + "control": "material threshold, hypothesis, evaluator, or partition changes start a new epoch or preregistration revision", + "residual": "governance review has not approved the epoch", + "status": "UNKNOWN" + } + ], + "status_precedence": "FAIL > UNKNOWN > PASS", + "residual_unknowns": [ + "candidate behavior", + "development evaluation", + "final evaluation", + "protected custody", + "independent evaluation", + "external security/privacy review", + "cross-host reproduction", + "formal MNCS status", + "formal MNCDS status", + "governance approval" + ], + "formal_mncs_status": "UNKNOWN", + "formal_mncds_status": "UNKNOWN", + "promotion_authorized": false +} From 9391db3eaeae0c64cba8bbb183d94f8ac4e17f45 Mon Sep 17 00:00:00 2001 From: epi13 Date: Sat, 1 Aug 2026 19:28:29 -0800 Subject: [PATCH 11/13] Prepare RAVEL 0.6 candidate fixes and Codex queue (#51) * Add RAVEL 0.6 seed candidate derivation * Test RAVEL 0.6 seed candidate corrections * Add Codex queue for RAVEL 0.6 development * Tighten RAVEL 0.6 source transformations * Record RAVEL 0.6 review preparation * Strengthen RAVEL seed read-only regression --- RAVEL_0_6_NEXT_STEPS.md | 224 ++++++++++++++++++++++++++++++ tools/ravel_0_6_seed_candidate.py | 188 +++++++++++++++++++++++++ 2 files changed, 412 insertions(+) create mode 100644 RAVEL_0_6_NEXT_STEPS.md create mode 100644 tools/ravel_0_6_seed_candidate.py diff --git a/RAVEL_0_6_NEXT_STEPS.md b/RAVEL_0_6_NEXT_STEPS.md new file mode 100644 index 0000000..5d0d6b9 --- /dev/null +++ b/RAVEL_0_6_NEXT_STEPS.md @@ -0,0 +1,224 @@ +# RAVEL 0.6 Codex implementation queue + +This document converts the post-0.5 technical review into bounded development +work for RAVEL 0.6. It is operational guidance, not a change to the frozen 0.6 +preregistration, and it does not authorize a result or promotion. + +## Immutable boundaries + +A Codex agent working from this queue must preserve all of the following: + +- do not edit or relabel RAVEL 0.4 or 0.5 source, seeds, evidence, manifests, + gates, results, or dispositions; +- do not use RAVEL 0.5 final observations as RAVEL 0.6 final evidence; +- do not obtain, derive, or inspect future-final RAVEL 0.6 seed material; +- do not weaken gates after observing development or selection outcomes; +- do not describe repository-local executable separation as independent + operation, protected custody, or organizational independence; and +- retain `UNKNOWN` and failed results without converting them to `PASS`. + +## Completed bounded preparation + +The first 0.6 development seed is now derived reproducibly from the exact frozen +0.5 source by `tools/ravel_0_6_seed_candidate.py`. + +The derivation completes two small, reviewable corrections: + +1. **Use both supported transition targets in planning.** The 0.5 graph stores + two support-bearing targets per expert/action, but its BFS traverses only + target zero. Candidate 001 traverses all `TRANSITION_TOP_K` slots in stable + slot order. +2. **Remove inherited empirical support from adaptation births.** A new + adaptation expert no longer copies parent counts, errors, action counts, + transition targets, transition support, or unused action predictions. It + begins with only the spawning event's label, action, observation, and + next-observation support while retaining deterministic generation and + lineage derivation. + +The generator refuses any source whose SHA-256 differs from the frozen 0.5 +identity and requires every transformation to match exactly once. Tests verify +source identity, transformation semantics, deterministic output, read-only +checking, and strict C11 compilation. + +These corrections produce development source only. Candidate 001 has not been +integrated into the 0.6 evidence pipeline, selected, frozen, or evaluated. + +## Codex next steps + +Perform the following tasks in order. Treat each material post-evaluation change +as the next candidate identity required by the preregistration. + +### R6-01 — Integrate candidate 001 without weakening provenance + +**Goal:** Make the derived source an explicit, reproducible RAVEL 0.6 +development candidate. + +**Work:** + +- add a dedicated 0.6 build target that generates into a temporary or declared + generated-source location; +- bind the frozen 0.5 input identity, generator identity, generated source + identity, compiler executable, compiler version, argv, environment-key names, + stdout, stderr, and exit status; +- record that 0.6 source is generated while 0.5 remains directly maintained and + immutable; +- add clean-worktree and stale-output checks; and +- ensure no generated 0.6 artifact is mistaken for final evidence. + +**Acceptance:** + +- two clean derivations are byte-identical; +- source substitution, generator substitution, stale output, omitted input, + ordering, and build-command mutations fail; +- candidate identity is exactly `ravel-0.6-candidate-001`; and +- all 0.4 and 0.5 source and evidence digests remain unchanged. + +### R6-02 — Implement transactional retention-constrained adaptation + +**Goal:** Replace the soft blended acceptance decision with the preregistered +all-constraints transaction. + +**Work:** + +- evaluate each proposed birth, refinement, retirement, or combined update on a + copy of the preceding model; +- require the declared adaptation improvement epsilon; +- require base-task accuracy and representation floors; +- require original-task prediction degradation to remain inside its bound; +- reject any update that removes uniquely supported transition behavior; +- enforce expert, birth, retirement, replay, pass, and compute budgets; and +- when any condition fails, retain the preceding model byte-for-byte and record + a structured rejection reason. + +**Acceptance:** + +- a rejected update has an identical checkpoint digest before and after; +- every hard condition has a distinct negative fixture; +- no metric may compensate numerically for failure of another hard condition; +- the raw executable emits observations and reason codes, never its own + development verdict; and +- the independent evaluator alone derives gate and aggregate results. + +### R6-03 — Add behavioral regression fixtures for both review corrections + +**Goal:** Demonstrate behavior rather than relying only on source inspection. + +**Work:** + +- construct a graph where the only valid route to a goal uses transition slot + one and prove bounded planning reaches it; +- construct a parent with unrelated labels, actions, counts, errors, and + transitions, birth a child, and prove the child claims only spawning-event + support before refinement; +- prove unsupported child actions remain unknown; +- prove deterministic edge order and tie breaking; and +- mutate either correction back to the 0.5 behavior and require the fixture to + fail. + +**Acceptance:** + +- both fixtures fail against the corresponding 0.5 behavior; +- both pass against candidate 001; +- fixture outputs are raw integer facts with stable checksums; and +- the evaluator rejects missing, duplicated, or contradictory fixture results. + +### R6-04 — Separate mechanism, environment, planning, and evidence surfaces + +**Goal:** Reduce the coupling created by the single 0.5 translation unit without +changing the frozen 0.5 record. + +**Work:** + +- define narrow interfaces for events/world providers, mechanism state, + transition compilation, planning, checkpoint encoding, and observation + emission; +- move the synthetic world behind the provider interface; +- keep deterministic allocation and bounded memory; +- provide a second independently written toy environment fixture; and +- bind all maintained and generated units in source/execution identity. + +**Acceptance:** + +- the mechanism builds against both environment providers without conditional + edits to its core; +- provider substitution changes only declared provider identities and evidence; +- no holdout or evaluator authority enters the mechanism interface; and +- the split implementation reproduces candidate behavior before any further + mechanism change. + +### R6-05 — Execute the preregistered development and selection lifecycle + +**Goal:** Use the already declared partitions and candidate limit correctly. + +**Work:** + +- run development trials only on development partitions; +- freeze each candidate identity before its selection evaluation; +- prevent selection observations from becoming same-candidate repair input; +- retain all candidates, failures, resource measurements, and rejection reasons; + and +- stop after candidate 008 unless a new preregistration revision or epoch is + created. + +**Acceptance:** + +- development, selection, retention, transition-retention, and planning + identities are distinct and verified; +- the candidate ledger is append-only and gap-free; +- selection evidence cannot alter the evaluated candidate; and +- no future-final seed or observation exists in repository-controlled + development material. + +### R6-06 — Obtain external final custody and evaluation + +**Goal:** Address the evidence gap that local code cannot manufacture. + +**Work requiring a human/external actor:** + +- assign a final-seed custodian and final evaluator distinct from the + development generator; +- freeze candidate, evaluator, thresholds, commands, and identities before the + final material is opened; +- run the one-shot final evaluation outside the development account's custody; +- retain raw observations, failures, `UNKNOWN`s, contamination facts, resource + limits, signatures, and timestamps; and +- report mechanism result, execution integrity, MNCS status, MNCDS status, and + promotion authorization as separate fields. + +**Acceptance:** + +- custody and evaluator records identify actors, conflicts, reviewed artifacts, + dates, and exact identities; +- development operators cannot access final material before candidate freeze; +- final evidence is not used for same-epoch repair; and +- absence of eligible external evidence remains `UNKNOWN`, never locally + synthesized `PASS`. + +## Later research tracks, not 0.6 completion criteria + +Do not fold these into the narrow 0.6 hypothesis merely to enlarge the claim: + +- real-data representation and distribution-shift studies; +- language or multimodal adapters; +- stochastic or probabilistic transition models; +- long-horizon planning and credit assignment; +- heterogeneous-host, accelerator, and distributed execution; +- operational monitoring, authorization, signed releases, and rollback drills; + and +- comparison with externally implemented continual-learning systems. + +Each requires its own contract, preregistration, evidence boundary, and claim +language. + +## Recommended Codex completion report + +For every task, report: + +1. exact files and candidate identity changed; +2. frozen identities checked before work; +3. tests and mutation tests executed; +4. observed failures and unresolved `UNKNOWN`s; +5. whether material evaluation occurred; +6. whether a new candidate identity was required; and +7. an explicit statement that no conformance, independence, custody, or + promotion claim was created unless external evidence actually establishes it. diff --git a/tools/ravel_0_6_seed_candidate.py b/tools/ravel_0_6_seed_candidate.py new file mode 100644 index 0000000..f0b25df --- /dev/null +++ b/tools/ravel_0_6_seed_candidate.py @@ -0,0 +1,188 @@ +#!/usr/bin/env python3 +"""Derive the first RAVEL 0.6 development seed from the frozen 0.5 source. + +The frozen RAVEL 0.5 source and evidence are historical authority and must not +be edited. This tool applies two narrowly reviewed corrections to an exact, +SHA-256-bound copy of that source: + +1. planning traverses every declared supported transition target; and +2. a newly born adaptation expert starts with support from its spawning event + only, rather than inheriting empirical counters and transitions from its + parent. + +The output is development source only. It is not selected, final, independently +evaluated, or promotion-authorized evidence. +""" + +from __future__ import annotations + +import argparse +import hashlib +import sys +from pathlib import Path + +RAVEL_DIR = Path(__file__).resolve().parents[1] +FROZEN_SOURCE = RAVEL_DIR / "ravel_0_5.c" +FROZEN_SOURCE_SHA256 = "1a8466ea1805811873c461fb891aaeaec18f6c9e7491b5ea7bd09bf698be102d" + +OLD_SEED_FUNCTION = """\ +static void seed_adaptation_expert(Model *m, uint16_t id, + const Event *event, uint32_t event_index) { + uint64_t evaluations = 0u; + uint16_t parent = full_nearest(event->x, m, &evaluations); + Expert seeded; + if (parent != INVALID_EXPERT) seeded = m->e[parent]; + else memset(&seeded, 0, sizeof seeded); + for (uint32_t d = 0; d < D; ++d) { + seeded.key[d] = (double)event->x[d]; + seeded.decode[d] = (double)event->x[d]; + seeded.next[event->action][d] = (double)event->nx[d]; + } + memset(seeded.labels, 0, sizeof seeded.labels); + seeded.labels[event->label] = 1u; + seeded.label = event->label; + seeded.active = 1u; + seeded.lifecycle = 1u; + seeded.anchored = 0u; + seeded.generation = parent == INVALID_EXPERT + ? (uint16_t)(m->epoch + 1u) + : (uint16_t)(m->e[parent].generation + 1u); + seeded.lineage = + mix64(UINT64_C(0x4144415054424952) ^ m->epoch ^ id ^ event_index ^ + (parent == INVALID_EXPERT ? 0u : m->e[parent].lineage)); + m->e[id] = seeded; +} +""" + +NEW_SEED_FUNCTION = """\ +static void seed_adaptation_expert(Model *m, uint16_t id, + const Event *event, uint32_t event_index) { + uint64_t evaluations = 0u; + uint16_t parent = full_nearest(event->x, m, &evaluations); + Expert seeded; + memset(&seeded, 0, sizeof seeded); + for (uint32_t action = 0; action < ACTIONS; ++action) { + for (uint32_t k = 0; k < TRANSITION_TOP_K; ++k) { + seeded.transition_target[action][k] = INVALID_EXPERT; + } + } + for (uint32_t d = 0; d < D; ++d) { + seeded.key[d] = (double)event->x[d]; + seeded.decode[d] = (double)event->x[d]; + seeded.next[event->action][d] = (double)event->nx[d]; + } + seeded.labels[event->label] = 1u; + seeded.action_count[event->action] = 1u; + seeded.count = 1u; + seeded.label = event->label; + seeded.active = 1u; + seeded.lifecycle = 1u; + seeded.anchored = 0u; + seeded.generation = parent == INVALID_EXPERT + ? (uint16_t)(m->epoch + 1u) + : (uint16_t)(m->e[parent].generation + 1u); + seeded.lineage = + mix64(UINT64_C(0x4144415054424952) ^ m->epoch ^ id ^ event_index ^ + (parent == INVALID_EXPERT ? 0u : m->e[parent].lineage)); + m->e[id] = seeded; +} +""" + +OLD_PLANNER_CONTEXT = """\ + for (uint16_t action = 0; action < ACTIONS; ++action) { + int supported = 0; + for (uint32_t k = 0; k < 1u; ++k) { +""" +NEW_PLANNER_CONTEXT = """\ + for (uint16_t action = 0; action < ACTIONS; ++action) { + int supported = 0; + for (uint32_t k = 0; k < TRANSITION_TOP_K; ++k) { +""" + +SOURCE_MARKER = " * It emits observations and integrity facts, never development verdicts.\n" +CANDIDATE_MARKER = ( + SOURCE_MARKER + + " *\n" + + " * RAVEL 0.6 development seed: generated from the frozen 0.5 source by\n" + + " * tools/ravel_0_6_seed_candidate.py. No evaluation claim is implied.\n" +) + + +class SeedError(RuntimeError): + """Raised when the frozen source or an expected transformation is invalid.""" + + +def _sha256(data: bytes) -> str: + return hashlib.sha256(data).hexdigest() + + +def build_candidate_source(source_bytes: bytes) -> str: + """Validate the frozen source and apply each reviewed transformation once.""" + + actual = _sha256(source_bytes) + if actual != FROZEN_SOURCE_SHA256: + raise SeedError( + "frozen RAVEL 0.5 source identity mismatch: " + f"expected {FROZEN_SOURCE_SHA256}, got {actual}" + ) + + source = source_bytes.decode("utf-8") + replacements = ( + (OLD_SEED_FUNCTION, NEW_SEED_FUNCTION, "adaptation support reset"), + (OLD_PLANNER_CONTEXT, NEW_PLANNER_CONTEXT, "top-two transition traversal"), + (SOURCE_MARKER, CANDIDATE_MARKER, "candidate provenance marker"), + ) + for old, new, name in replacements: + count = source.count(old) + if count != 1: + raise SeedError(f"{name}: expected one source match, found {count}") + source = source.replace(old, new, 1) + + return source + + +def write_candidate(output: Path) -> str: + """Write the deterministic candidate and return its SHA-256 identity.""" + + candidate = build_candidate_source(FROZEN_SOURCE.read_bytes()) + output.parent.mkdir(parents=True, exist_ok=True) + output.write_text(candidate, encoding="utf-8", newline="\n") + return _sha256(candidate.encode()) + + +def parse_args(argv: list[str]) -> argparse.Namespace: + parser = argparse.ArgumentParser() + parser.add_argument( + "--output", + type=Path, + help="write the generated development source to this path", + ) + parser.add_argument( + "--check", + action="store_true", + help="validate and derive the candidate without writing it", + ) + args = parser.parse_args(argv) + if args.output is None and not args.check: + parser.error("one of --output or --check is required") + return args + + +def main(argv: list[str] | None = None) -> int: + args = parse_args(sys.argv[1:] if argv is None else argv) + try: + if args.output is not None: + digest = write_candidate(args.output) + else: + candidate = build_candidate_source(FROZEN_SOURCE.read_bytes()) + digest = _sha256(candidate.encode()) + except (OSError, UnicodeError, SeedError) as error: + print(f"ravel 0.6 seed candidate failed: {error}", file=sys.stderr) + return 1 + + print(f"ravel-0.6-candidate-001 sha256={digest}") + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) From 9f89cfce9df54f366d35c9cfa703febd8ce2c47a Mon Sep 17 00:00:00 2001 From: epi13 Date: Sat, 1 Aug 2026 21:09:20 -0800 Subject: [PATCH 12/13] Organize RAVEL navigation and evidence documentation (#53) * docs: reorganize RAVEL landing page * docs: add RAVEL documentation hub * docs: add RAVEL project map * docs: explain RAVEL evidence layers * docs: add RAVEL version history * docs: add RAVEL tooling guide * docs: update RAVEL case-study range --- README.md | 337 +++++++++++++++------------------------- docs/EVIDENCE_GUIDE.md | 145 +++++++++++++++++ docs/PROJECT_MAP.md | 141 +++++++++++++++++ docs/README.md | 38 +++++ docs/VERSION_HISTORY.md | 173 +++++++++++++++++++++ tools/README.md | 109 +++++++++++++ 6 files changed, 731 insertions(+), 212 deletions(-) create mode 100644 docs/EVIDENCE_GUIDE.md create mode 100644 docs/PROJECT_MAP.md create mode 100644 docs/README.md create mode 100644 docs/VERSION_HISTORY.md create mode 100644 tools/README.md diff --git a/README.md b/README.md index 2936950..a677e96 100644 --- a/README.md +++ b/README.md @@ -1,232 +1,145 @@ # RAVEL — Recursive Adaptive Vector Execution Lattice -RAVEL is a machine-native research architecture that treats AI/ML as one combined problem of routing, retrieval, compression, representation, training state, temporal memory, planning, lifecycle, and bounded computation. - -Its foundational claim is that a model, memory store, router, trainer, world model, planner, and compute scheduler should not be separate systems. A stored expert should simultaneously be a retrieval key, compressed representation, executable predictor, training shard, transition-memory node, planning destination, lineage object, and measured unit of computation. - -Human readability is relocated into contracts, evaluator authority, evidence, provenance, and rollback. The 0.3 split C translation unit is maintained source: no reproducible higher-level generator was included in the repository or reviewed pull-request history. - -## RAVEL 0.1 — exact conditional inference - -The first capsule generates 256 quantized experts and retrieves 24 candidates per familiar query. A strict lower-bound certificate permits early return only when every excluded expert is provably unable to win. Otherwise execution becomes the complete oracle. - -| Workload | Queries | Mismatches | Certified rate | Mean experts | Reduction | -|---|---:|---:|---:|---:|---:| -| Familiar | 100,000 | 0 | 100.000% | 24.000 | 90.625% | -| Uniform control | 25,000 | 0 | 2.236% | 250.812 | 2.026% | - -## RAVEL-T 0.2 — recursive training - -The current experts build the exact router; routed assignments update the experts; unresolved error ranks overloaded shards; bounded splits compile children; child lineage rebuilds the next router. - -| Implementation | Holdout accuracy | Mean experts | Training evaluations | -|---|---:|---:|---:| -| RAVEL-T recursive 8→64 | 100.000% | 8.000 | 4,144,248 | -| Fixed eight-expert | 22.461% | 8.000 | 3,538,944 | -| Flat 64-expert | 100.000% | 64.000 | 87,031,808 | - -## RAVEL-U 0.3 — unified architecture - -RAVEL-U closes the component gap. One expert population now owns: - -- retrieval and exact conditional compute; -- compressed state representation and reconstruction; -- label prediction; -- action-conditioned next-observation prediction; -- temporal-memory graph compilation; -- bounded planning over the learned graph; -- error-driven expert birth; -- replay-backed continual adaptation; -- low-utility child retirement; and -- checkpoint identity and behavioral rollback verification. - -The synthetic world contains 64 states, four actions, eight labels, and eight-dimensional observations. Semantic drift changes both observations and labels for 16 states. The frozen model is evaluated before adaptation, then RAVEL proposes 24 drift experts, retires eight low-utility duplicates, rebuilds the router and transition graph, and re-evaluates drift, retention, planning, and checkpoint behavior. - -### Unified development result - -| Measure | Result | -|---|---:| -| Base holdout accuracy | 96.826% | -| Static model on semantic drift | 71.899% | -| Adapted model on semantic drift | 100.000% | -| Original-task retention after adaptation | 96.704% | -| Adapted transition accuracy | 99.292% | -| Adapted planning target success | 505 / 512 | -| Routed-versus-complete mismatches | 0 | -| Mean routed experts | 8.000 | -| Adaptation births / retirements | 24 / 8 | -| Checkpoint identity and evaluation match | PASS | - -The expert is now simultaneously a key, representation, decoder, classifier, world-model fragment, transition node, replay shard, planning node, lineage object, and compute unit. See `ARCHITECTURE_GAPS.md` for what was missing and why raw modality adapters, use policy, protected evaluation, external effects, and promotion authority intentionally remain outside the recursive surface. - -The historical `100.000%` adapted drift value above was measured on the same -`adapt_set` used for adaptation. It is an adaptation-training observation, not -an untouched drift-holdout result. Likewise, the historical planning -`exact_goals` field measured goal-expert equivalence rather than exact -world-state equality. RAVEL 0.4 preserves these facts instead of relabeling the -0.3 evidence. - -## RAVEL 0.4 — evidence hardening - -RAVEL 0.4 repairs assurance rather than expanding the architecture. It adds: - -- disjoint base training, base holdout, drift adaptation training, untouched - drift holdout, original-task retention holdout, and planning inputs; -- eight frozen seeds covering separated, overlapping, noisy, label-drift, - observation-drift, transition-drift, combined, and ambiguous regimes; -- canonical big-endian Q20 checkpoints with a versioned header and SHA-256 - payload identity instead of raw C memory images; -- complete restored classification, reconstruction, prediction, transition, - routing, planning, topology, lineage, and reported-metric comparison; -- deliberate field, payload, truncation, append, schema, and substitution - checkpoint mutations; -- exact-state planning measurements distinct from goal-expert equivalence; -- reconstruction and next-observation prediction gates; -- five bounded baselines, five ablations, negative/adversarial tests, aggregate - variance, and preserved failures; and -- an ordered, script-generated source manifest and assurance digest. - -The frozen 0.4 experiment records development `FAIL`; no seeds, regimes, or -gates were removed to obtain a favorable result. See -`RAVEL_0_4_RESULTS.md` for generated per-trial failures and aggregates, and -`ravel-0.4-assurance-case.json` for the bounded assurance disposition. - -## RAVEL 0.5 — adaptive-mechanism correction - -RAVEL 0.5 keeps the 0.4 evidence package immutable and corrects the mechanism -and assurance split. The C harness now emits raw integer observations and -integrity facts only. A separate Python evaluator verifies the frozen trial and -partition matrix, derives every metric and hard gate, and rejects executable -verdicts, malformed records, contradictions, and mutations. - -Mechanism changes include deterministic stratified replay, anchored base -experts, optional objective-tested births and retirements, eight normalized -residual channels, support-bearing top-two transitions, unknown unsupported -actions, retirement safety checks, and alias-aware belief-set planning. -Comparisons add matched work, expert count, and capacity, while retaining the -0.4 baselines and ablations. - -The one-shot 0.5 final validation used 32 fresh trials: four seeds for each of -the eight frozen regime families. Execution integrity is `PASS`; 24 trials -passed and eight failed, so the frozen all-trials development result is -`FAIL`. All separated, overlap, noise, and observation-drift trials passed. -Failures remained in label gain (three trials), transition prediction retention -(one), combined exact planning (one), and ambiguous belief/planning or -efficiency (three). These failures were not used to change the mechanism, -seeds, regimes, or gates. - -The candidate improved mean drift-holdout accuracy over the matched-compute -fixed-topology comparison while using fewer mean training evaluations, but the -complete paired Pareto results are mixed. No superiority claim is made. See -`RAVEL_0_5_RESULTS.md`, `RAVEL_0_5_POSTMORTEM.md`, and -`ravel-0.5-assurance-case.json`. - -## RAVEL 0.6 — preregistered future development - -RAVEL 0.6 is a clean new epoch preregistered before implementation. It binds -the immutable 0.5 candidate and evidence as a failed development baseline and -uses the published label-gain, prediction-retention, combined-planning, -ambiguous-planning/efficiency, mixed-Pareto, and assurance findings only as -permitted cross-epoch design input. - -The narrow hypothesis concerns retention-constrained adaptation for label and -combined observation/label drift. The planned policy combines stratified -replay protection, objective-tested updates, and transition-support -preservation. Development, selection, retention, transition-retention, -planning, and future final partitions have distinct identities. Development -and selection seeds are distinct from every 0.5 final seed. Future final seed -material is intentionally absent and may be obtained only after candidate -freeze, preferably from an external custodian. - -No 0.6 mechanism has been implemented, selected, frozen, or evaluated. -Development and final results, protected custody, independent evaluation, and -formal MNCS/MNCDS status are all `UNKNOWN`; promotion is unauthorized. See -`RAVEL_0_6_SCOPE.md`, `RAVEL_0_6_PREREGISTRATION.md`, and -`ravel-0.6-preregistration.json`. - -## Run +RAVEL is a machine-native research architecture that treats routing, retrieval, +representation, training state, temporal memory, planning, lifecycle, and bounded +computation as one connected mechanism. + +This directory contains several historical and active research epochs. The files +are intentionally evidence-heavy, and some frozen artifacts must retain their +existing paths and identities. The navigation layer below separates the project +by purpose without rewriting or relocating those historical records. + +> **Current status:** RAVEL 0.4 and 0.5 retain development `FAIL` results. RAVEL +> 0.6 is preregistered and has a reproducible candidate-001 derivation, but it has +> not been selected, finally evaluated, independently attested, or authorized for +> promotion. Formal MNCS and MNCDS status remain `UNKNOWN`. + +## Start here + +| Goal | Entry point | +|---|---| +| Understand the project at a glance | [Version history](docs/VERSION_HISTORY.md) | +| Find source, contracts, evidence, and plans | [Project map](docs/PROJECT_MAP.md) | +| Understand what each evidence file proves | [Evidence guide](docs/EVIDENCE_GUIDE.md) | +| Browse the RAVEL documentation set | [Documentation hub](docs/README.md) | +| Understand evaluator and generation scripts | [Tooling guide](tools/README.md) | +| Review the architectural idea and exclusions | [Architecture gaps](ARCHITECTURE_GAPS.md) | +| Continue bounded 0.6 development | [RAVEL 0.6 next steps](RAVEL_0_6_NEXT_STEPS.md) | + +## Project shape + +```text +case-studies/ravel/ +├── README.md # landing page +├── docs/ # human navigation and explanatory guides +├── tools/ # evaluators, evidence builders, and digest tools +├── ravel_unified/ # maintained 0.3 split implementation units +├── ravel*.c # versioned mechanism implementations +├── *_CONTRACT.md # readable behavioral authority +├── RAVEL_* # results, postmortems, scopes, and plans +├── ravel-*.json # protocols, observations, manifests, and assurance +└── Makefile # local build, verification, and evidence targets +``` + +The top-level RAVEL directory remains partly flat on purpose. Versioned source, +preregistrations, observations, manifests, and assurance records are linked by +exact filenames and digests. Moving them merely for appearance could invalidate +historical identity or make prior evidence harder to reproduce. New explanatory +documentation belongs under `docs/`; executable support tooling belongs under +`tools/`. + +## Epoch status + +| Epoch | Primary purpose | Preserved status | +|---|---|---| +| RAVEL 0.1 | Exact conditional inference | Favorable bounded development observation | +| RAVEL-T 0.2 | Recursive training and expert birth | Favorable bounded development observation | +| RAVEL-U 0.3 | Unified expert architecture | Favorable historical observations with documented evaluation caveats | +| RAVEL 0.4 | Evidence and checkpoint hardening | Development `FAIL` — 0 of 8 frozen trials passed all gates | +| RAVEL 0.5 | Mechanism correction and evaluator separation | Development `FAIL` — 24 of 32 trials passed; all-trials gate failed | +| RAVEL 0.6 | Retention-constrained adaptation epoch | Preregistered; candidate-001 derivation prepared; selection and final evaluation `UNKNOWN` | + +Detailed results, limitations, and links are collected in +[docs/VERSION_HISTORY.md](docs/VERSION_HISTORY.md). + +## Common verification commands + +From the repository root: ```bash -make test -make training-check -make unified-check -make 0.4-check -make 0.5-check -make ravel-0.6-preregistration-check +make ravel-test +make ravel-training-check +make ravel-unified-check +make ravel-0.4-check +make ravel-0.5-check ``` -To rewrite repository-visible development evidence: +From this directory: ```bash -make evidence -make training-evidence -make unified-evidence -make 0.4-evidence -make 0.5-evidence +make all +make 0.4-compiler-matrix +make 0.4-sanitizers +make 0.5-negative-test +make 0.5-manifest-negative-test +make 0.5-compiler-matrix +make 0.5-sanitizers ``` -Requirements: a C11 compiler, the C math library, and Make. - -## Files - -- `ravel.c`, `CONTRACT.md`, `evidence.json` — exact conditional inference; -- `ravel_train.c`, `TRAINING_CONTRACT.md`, `training-*.json` — recursive training; -- `ravel_unified.c` and `ravel_unified/*.inc` — maintained 0.3 split C source; -- `ARCHITECTURE_GAPS.md` — architectural audit and intentional external boundary; -- `UNIFIED_CONTRACT.md` — unified readable authority and gates; -- `unified-preregistration.json` — frozen protocol; -- `unified-evidence.json` — deterministic observations; -- `unified-threat-model.json` — threats and residual UNKNOWNs; and -- `unified-assurance-case.json` — historical bounded non-promotion record; -- `ravel_0_4.c` and `RAVEL_0_4_CONTRACT.md` — hardened maintained execution and - readable authority; -- `ravel-0.4-preregistration.json` — frozen seeds, regimes, partitions, and gates; -- `ravel-0.4-raw-observations.json`, `ravel-0.4-trial-evidence.json`, and - `ravel-0.4-negative-evidence.json` — executable raw and derived evidence; -- `ravel-0.4-source-manifest.json` — ordered implementation identity; and -- `ravel-0.4-assurance-case.json` — historical 0.4 non-promotion record; -- `ravel_0_5.c`, `RAVEL_0_5_CONTRACT.md`, and - `ravel-0.5-preregistration.json` — maintained 0.5 mechanism and frozen - authority; -- `tools/ravel_0_5_evaluator.py` and `tools/ravel_0_5_evidence.py` — - independent derivation and deterministic evidence tooling; -- `ravel-0.5-raw-observations.json`, `ravel-0.5-trial-evidence.json`, and - `ravel-0.5-negative-evidence.json` — raw and independently derived 0.5 - records; and -- `ravel-0.5-source-and-execution-manifest.json` and - `ravel-0.5-assurance-case.json` — bound build/source identity and current - bounded non-promotion record; and -- `ravel-0.5-runtime-observations.json` — host-specific, non-normative timing - observations; canonical comparisons use deterministic operation counts; and -- `RAVEL_0_6_SCOPE.md`, `RAVEL_0_6_PREREGISTRATION.md`, - `ravel-0.6-preregistration.json`, `ravel-0.6-threat-model.json`, - `ravel-0.6-development-record.json`, and `ravel-0.6-limitations.md` — a new - preregistered epoch with no implementation or evaluation claim. +Commands ending in `-check`, `-test`, `-compiler-matrix`, or `-sanitizers` are +verification-oriented. Commands ending in `-evidence` or `-runtime` can rewrite +repository-visible development records; review [tools/README.md](tools/README.md) +before using them. -## MNCS boundary +Requirements vary by epoch but generally include a C11 compiler, Python 3, the C +math library, and Make. -- **Human control plane:** intended use, event contract, external authority, limits, gates, and exclusions. -- **Machine execution plane:** expert keys, decoders, classifiers, next-state programs, router, transition graph, topology, replay assignments, and lineage. -- **Evidence plane:** exact-oracle agreement, accuracy, reconstruction, prediction, transition, planning, lifecycle, checkpoint, checksums, and limitations. -- **Development-control plane:** fixed seeds, partitions, birth and retirement budgets, immutable thresholds, and non-promotion fields. -- **Operational-control plane:** complete-scan fallback, checkpoint restoration, model identity, and replacement of maintained execution source. +## Reading order for each epoch -Historical RAVEL 0.1–0.3 studies recorded favorable development observations. -RAVEL 0.4 records development `FAIL` with zero of eight trials passing. RAVEL -0.5 records development `FAIL` with 24 of 32 trials passing. Formal MNCS and -MNCDS status remain `UNKNOWN`. RAVEL 0.6 is preregistered future work whose -implementation and evaluation remain `UNKNOWN`. Promotion is unauthorized -pending independent protected real-data evaluation, adversarial -continual-learning studies, learned modality adapters, cross-host reproduction, -accelerator and distributed evidence, and operational release controls. +For version 0.4 or later, use this order: + +1. scope or preregistration; +2. readable contract; +3. maintained or generated mechanism source; +4. raw observations; +5. evaluator-derived trial and negative evidence; +6. source/execution manifest; +7. assurance case; +8. generated results and postmortem; +9. next-epoch development plan. + +This order keeps protocol, implementation, observations, interpretation, and +claim authority separate. + +## MNCS boundary + +- **Human control plane:** intended use, event contract, external authority, + limits, gates, and exclusions. +- **Machine execution plane:** expert keys, decoders, classifiers, next-state + programs, router, transition graph, topology, replay assignments, and lineage. +- **Evidence plane:** oracle agreement, accuracy, reconstruction, prediction, + transition, planning, lifecycle, checkpoint, checksums, and limitations. +- **Development-control plane:** fixed seeds, partitions, candidate limits, + immutable thresholds, and non-promotion fields. +- **Operational-control plane:** complete-scan fallback, checkpoint restoration, + model identity, source replacement, and rollback behavior. ## Claim boundary RAVEL is a bounded deterministic research study with both favorable and -unfavorable results. It does not establish general intelligence, -foundation-model performance, language or multimodal generation, causal -reasoning, real-data generalization, production safety, or formal conformance. +unfavorable results. It does not establish general intelligence, foundation-model +performance, language or multimodal generation, causal reasoning, real-data +generalization, production safety, independent evaluation, protected custody, or +formal conformance. + +Historical RAVEL 0.1–0.3 studies recorded favorable development observations. +RAVEL 0.4 and 0.5 preserve failed frozen development outcomes. RAVEL 0.6 remains +a development epoch. Promotion is unauthorized pending appropriate external, +protected, and independently evaluated evidence. ## Origin -The name, architecture, algorithms, and initial implementations were created by **GPT-5.6 Thinking** in response to Alexander Collamore's challenge to design an AI/ML foundation that fully embraces Machine-Native Complexity. Alexander Collamore is the repository steward. +The name, architecture, algorithms, and initial implementations were created by +**GPT-5.6 Thinking** in response to Alexander Collamore's challenge to design an +AI/ML foundation that fully embraces Machine-Native Complexity. Alexander +Collamore is the repository steward. diff --git a/docs/EVIDENCE_GUIDE.md b/docs/EVIDENCE_GUIDE.md new file mode 100644 index 0000000..3a5fbaf --- /dev/null +++ b/docs/EVIDENCE_GUIDE.md @@ -0,0 +1,145 @@ +# RAVEL evidence guide + +RAVEL separates protocol, implementation, observations, interpretation, identity, +and authority. A file that reports a passing check does not automatically prove +that the mechanism passed its frozen study or that the study has independent or +protected evidence. + +## Evidence layers + +### 1. Scope and preregistration + +Examples: `RAVEL_0_6_SCOPE.md`, `RAVEL_0_6_PREREGISTRATION.md`, and +`ravel-0.6-preregistration.json`. + +These files define the question, candidate limits, partitions, seeds, gates, +change rules, and claim boundaries before evaluation. They establish the +protocol, not the outcome. + +### 2. Readable contract + +Examples: `RAVEL_0_4_CONTRACT.md` and `RAVEL_0_5_CONTRACT.md`. + +The contract explains required behavior and limits in human-readable form. It is +an authority surface for review, but it does not prove the source implements the +contract. + +### 3. Mechanism source + +Examples: `ravel_0_4.c` and `ravel_0_5.c`. + +The maintained source defines the executable mechanism. For a generated 0.6 +candidate, the generator, frozen input identity, transformation rules, and output +identity are all part of the implementation story. + +### 4. Raw observations + +Examples: `ravel-0.4-raw-observations.json` and +`ravel-0.5-raw-observations.json`. + +These records should contain facts emitted by the executable, such as counts, +checksums, predictions, topology, resource measurements, and integrity facts. +They should not silently declare their own authoritative verdict when an +external evaluator is responsible for deriving it. + +### 5. Evaluator-derived evidence + +Examples: `ravel-0.5-trial-evidence.json` and +`ravel-0.5-negative-evidence.json`. + +The evaluator checks the frozen matrix, validates record structure, derives +metrics, applies hard gates, rejects contradictions, and preserves failures. The +evaluator can establish whether the supplied observations satisfy the declared +protocol; it cannot establish protected custody or organizational independence +merely because it is a separate program. + +### 6. Source and execution identity + +Examples: `ravel-0.4-source-manifest.json` and +`ravel-0.5-source-and-execution-manifest.json`. + +These records bind ordered files, digests, compiler or execution details, and +other identity facts. They answer which implementation and execution surface the +evidence refers to. They are why renaming or moving frozen files may be a +material change rather than harmless cleanup. + +### 7. Assurance case + +Examples: `ravel-0.4-assurance-case.json` and +`ravel-0.5-assurance-case.json`. + +The assurance case combines the available facts into a bounded disposition. It +should retain limitations, `UNKNOWN` conditions, failed gates, and explicit +non-promotion fields. + +### 8. Human-readable results and postmortems + +Examples: `RAVEL_0_4_RESULTS.md`, `RAVEL_0_5_RESULTS.md`, and +`RAVEL_0_5_POSTMORTEM.md`. + +These files explain the evidence to readers. They are useful summaries, but the +underlying JSON and source identities remain the auditable basis. + +### 9. Runtime observations + +Example: `ravel-0.5-runtime-observations.json`. + +Wall-clock timing is host-specific and non-normative. Deterministic expert, +operation, or evaluation counts are the canonical work measures unless a +separate protocol explicitly defines cross-host performance evidence. + +## Distinct result questions + +RAVEL reports several different questions that must not be collapsed: + +| Question | Typical value | +|---|---| +| Did the executable run and produce structurally valid observations? | execution integrity | +| Did a trial satisfy every frozen mechanism gate? | per-trial result | +| Did every required trial satisfy the aggregate rule? | development result | +| Is the source and execution identity complete and verified? | identity assurance | +| Was evaluation protected from the developer and independently operated? | custody and independence | +| Does the package satisfy formal MNCS or MNCDS requirements? | formal status | +| Is release or promotion authorized? | governance disposition | + +A `PASS` in one row does not imply `PASS` in another. + +## Preserved RAVEL outcomes + +- RAVEL 0.4: execution produced evidence, but zero of eight frozen trials passed + all gates; development result `FAIL`. +- RAVEL 0.5: execution integrity `PASS`; 24 of 32 trials passed; the all-trials + development result remains `FAIL`. +- RAVEL 0.6: preregistered development and candidate preparation exist, but + selection, future-final evaluation, protected custody, independent operation, + formal conformance, and promotion remain `UNKNOWN` or unauthorized. + +## What repository-local evidence cannot manufacture + +Repository-local source, hashes, signatures, containers, test runners, and +separate evaluator programs cannot by themselves establish: + +- protection from a user with root or repository administration access; +- future-final seed secrecy from the developer; +- organizational independence; +- independent custody or witness authority; +- uncontaminated real-world data; +- production safety or operational readiness; or +- governance approval. + +Those claims require external facts and actors, not stronger wording around +local files. + +## Review checklist + +Before accepting a RAVEL result or modifying the directory, verify: + +1. the exact epoch and candidate identity; +2. the applicable preregistration and contract; +3. whether the source is maintained or generated; +4. whether raw observations are unchanged and complete; +5. which evaluator derived the result; +6. whether negative and mutation evidence is retained; +7. whether manifests bind every required file and execution fact; +8. whether failures and `UNKNOWN` conditions remain visible; and +9. whether the proposed change affects a frozen identity or claim boundary. diff --git a/docs/PROJECT_MAP.md b/docs/PROJECT_MAP.md new file mode 100644 index 0000000..6185ce5 --- /dev/null +++ b/docs/PROJECT_MAP.md @@ -0,0 +1,141 @@ +# RAVEL project map + +RAVEL is organized by evidence role and research epoch. The parent directory is +partly flat because historical evidence binds exact paths, filenames, ordering, +and digests. This guide provides logical grouping without relocating frozen +artifacts. + +## 1. Landing and cross-version orientation + +| File | Purpose | +|---|---| +| `README.md` | Main entry point, status summary, commands, and claim boundary | +| `docs/README.md` | Documentation hub | +| `docs/VERSION_HISTORY.md` | Cross-version development history | +| `docs/EVIDENCE_GUIDE.md` | Evidence-layer and claim interpretation | +| `ARCHITECTURE_GAPS.md` | Why 0.3 unified previously separate mechanism roles and what remained external | + +## 2. Mechanism implementations + +| Epoch | Implementation | +|---|---| +| 0.1 | `ravel.c` | +| 0.2 | `ravel_train.c` | +| 0.3 | `ravel_unified.c` plus `ravel_unified/*.inc` | +| 0.4 | `ravel_0_4.c` | +| 0.5 | `ravel_0_5.c` | +| 0.6 | Reproducible development source derived by `tools/ravel_0_6_seed_candidate.py`; no selected or final implementation is claimed | + +Generated binaries such as `ravel`, `ravel_train`, `ravel_unified_bin`, +`ravel_0_4_bin`, and `ravel_0_5_bin` are build outputs and are removed by the +local clean targets. + +## 3. Readable behavioral authority + +| Epoch | Contract or authority | +|---|---| +| 0.1 | `CONTRACT.md` | +| 0.2 | `TRAINING_CONTRACT.md` | +| 0.3 | `UNIFIED_CONTRACT.md` | +| 0.4 | `RAVEL_0_4_CONTRACT.md` | +| 0.5 | `RAVEL_0_5_CONTRACT.md` | +| 0.6 | `RAVEL_0_6_SCOPE.md` and `RAVEL_0_6_PREREGISTRATION.md` | + +Contracts explain expected behavior, limits, gates, and exclusions. They are not +substitutes for raw observations or source identity. + +## 4. Protocol and preregistration + +Common protocol files include: + +- `unified-preregistration.json` for the historical unified study; +- `ravel-0.4-preregistration.json` for the frozen 0.4 matrix; +- `ravel-0.5-preregistration.json` for the frozen 0.5 matrix; and +- `ravel-0.6-preregistration.json` for the new preregistered epoch. + +The 0.6 support set also includes: + +- `ravel-0.6-threat-model.json`; +- `ravel-0.6-development-record.json`; +- `ravel-0.6-limitations.md`; and +- `RAVEL_0_6_NEXT_STEPS.md`. + +Preregistration files define what may be changed, which partitions and seeds are +permitted, how candidates are identified, and how results are derived. + +## 5. Raw observations and derived evidence + +### Historical studies + +- `evidence.json` and `evidence-actual.json` — 0.1 expected and local actual + output. +- `training-*.json` — 0.2 protocol and evidence records. +- `unified-evidence.json` — deterministic 0.3 observations. +- `unified-threat-model.json` and `unified-assurance-case.json` — historical + threats and bounded disposition. + +### RAVEL 0.4 + +- `ravel-0.4-raw-observations.json` — direct executable output; +- `ravel-0.4-trial-evidence.json` — derived per-trial evidence; +- `ravel-0.4-negative-evidence.json` — mutation and adversarial evidence; +- `RAVEL_0_4_RESULTS.md` — generated human-readable results; and +- `ravel-0.4-assurance-case.json` — bounded non-promotion disposition. + +### RAVEL 0.5 + +- `ravel-0.5-raw-observations.json` — direct executable output; +- `ravel-0.5-trial-evidence.json` — evaluator-derived trial evidence; +- `ravel-0.5-negative-evidence.json` — evaluator and mutation evidence; +- `ravel-0.5-runtime-observations.json` — host-specific, non-normative timing; +- `RAVEL_0_5_RESULTS.md` — generated human-readable results; +- `RAVEL_0_5_POSTMORTEM.md` — retained failure analysis; and +- `ravel-0.5-assurance-case.json` — bounded non-promotion disposition. + +Read [EVIDENCE_GUIDE.md](EVIDENCE_GUIDE.md) before comparing these layers. + +## 6. Source and execution identity + +| Epoch | Identity records | +|---|---| +| 0.4 | `ravel-0.4-source-manifest-spec.json` and `ravel-0.4-source-manifest.json` | +| 0.5 | `ravel-0.5-source-manifest-spec.json` and `ravel-0.5-source-and-execution-manifest.json` | + +Digest tools under `tools/` validate ordered source identity and assurance-case +bindings. These records are why appearance-only file moves can be semantically +material. + +## 7. Evaluators and support tooling + +See [`../tools/README.md`](../tools/README.md) for script-level detail. + +The main categories are: + +- evidence generation and verification; +- independent metric and gate derivation; +- source and execution digest verification; +- runtime observation capture; +- mutation and negative testing; and +- bounded 0.6 candidate source derivation. + +## 8. Build and verification entry points + +The local `Makefile` exposes version-specific targets. The repository root +`Makefile` forwards the most important checks under names such as: + +- `ravel-test`; +- `ravel-training-check`; +- `ravel-unified-check`; +- `ravel-0.4-check`; and +- `ravel-0.5-check`. + +Use verification targets before any target that rewrites evidence. + +## 9. Where new work belongs + +- Cross-version explanation or navigation: `docs/`. +- Evaluator, digest, mutation, or derivation script: `tools/`. +- New epoch source, contract, preregistration, and evidence: use a clearly + versioned identity and document the complete lifecycle before adding files. +- Historical frozen artifacts: do not rename, regroup, or rewrite merely for + visual consistency. diff --git a/docs/README.md b/docs/README.md new file mode 100644 index 0000000..31953f2 --- /dev/null +++ b/docs/README.md @@ -0,0 +1,38 @@ +# RAVEL documentation hub + +This directory is the human-navigation layer for the RAVEL case study. It does +not replace versioned contracts, preregistrations, raw observations, manifests, +or assurance records in the parent directory. + +## Guides + +- [Version history](VERSION_HISTORY.md) — what changed in each epoch, preserved + results, and current development status. +- [Project map](PROJECT_MAP.md) — where to find implementations, contracts, + evidence, manifests, plans, and tooling. +- [Evidence guide](EVIDENCE_GUIDE.md) — how the evidence layers relate and what + conclusions they do and do not support. + +## Authoritative material remains versioned + +Use the guides above to locate the authoritative files, then read those files +directly. In particular: + +- Markdown contracts define readable behavioral authority; +- preregistration JSON defines frozen protocol and gates; +- C source defines the maintained mechanism for its epoch; +- raw observation JSON records executable output; +- evaluator-derived evidence records interpretation of those observations; +- source and execution manifests bind identity; +- assurance cases state the bounded disposition and unresolved limitations. + +Documentation may summarize those records but must not silently upgrade their +claims. + +## Placement rule + +Add explanatory, cross-version, or navigational material here. Keep executable +support scripts under `../tools/`. Keep version-bound contracts, source, +preregistrations, observations, manifests, and assurance records in their +existing versioned locations unless a new epoch explicitly defines a different +layout and identity scheme. diff --git a/docs/VERSION_HISTORY.md b/docs/VERSION_HISTORY.md new file mode 100644 index 0000000..deea0e2 --- /dev/null +++ b/docs/VERSION_HISTORY.md @@ -0,0 +1,173 @@ +# RAVEL version history + +This document gives a concise reading path across the RAVEL epochs. It preserves +the published outcomes and points to the version-bound files that carry the +actual contracts, observations, and dispositions. + +## RAVEL 0.1 — exact conditional inference + +**Question:** Can a quantized expert router return early only when excluded +experts are provably unable to win, while falling back to the complete oracle +otherwise? + +**Primary files:** `ravel.c`, `CONTRACT.md`, and `evidence.json`. + +The study generated 256 experts and retrieved 24 candidates per familiar query. +Historical development observations reported zero mismatches, complete +certification on the familiar workload, and a mean of 24 evaluated experts. +Uniform control queries frequently required fallback toward the complete scan. + +**Status:** favorable bounded development observation; not formal conformance or +production evidence. + +## RAVEL-T 0.2 — recursive training + +**Question:** Can routed assignments, unresolved error, bounded splits, and child +lineage recursively build a more capable expert population? + +**Primary files:** `ravel_train.c`, `TRAINING_CONTRACT.md`, and the +`training-*.json` records. + +The recursive 8-to-64 study historically reached the same reported holdout +accuracy as the flat 64-expert comparison while using substantially fewer +training evaluations. The fixed eight-expert comparison retained lower reported +accuracy. + +**Status:** favorable bounded development observation; not a general training or +continual-learning claim. + +## RAVEL-U 0.3 — unified architecture + +**Question:** Can one expert population simultaneously own retrieval, +representation, classification, action-conditioned prediction, transition +memory, bounded planning, adaptation, retirement, lineage, and checkpoint +identity? + +**Primary files:** `ravel_unified.c`, `ravel_unified/*.inc`, +`UNIFIED_CONTRACT.md`, `unified-preregistration.json`, +`unified-evidence.json`, `unified-threat-model.json`, and +`unified-assurance-case.json`. + +The synthetic world contained 64 states, four actions, eight labels, and +8-dimensional observations. Historical development output reported strong base +accuracy, complete adapted-set drift accuracy, high transition accuracy, bounded +planning success, exact routed-versus-complete agreement, and checkpoint +restoration agreement. + +Two caveats are preserved: + +- the historical adapted drift value was measured on the same `adapt_set` used + for adaptation rather than an untouched drift holdout; and +- the historical `exact_goals` field measured goal-expert equivalence rather + than exact world-state equality. + +**Status:** favorable historical observations with known evaluation limitations. + +## RAVEL 0.4 — evidence hardening + +**Question:** What happens when partitions, checkpoint encoding, negative tests, +planning measurements, baselines, ablations, and source identity are hardened +without removing unfavorable cases? + +**Primary files:** + +- `ravel_0_4.c`; +- `RAVEL_0_4_CONTRACT.md`; +- `ravel-0.4-preregistration.json`; +- `ravel-0.4-raw-observations.json`; +- `ravel-0.4-trial-evidence.json`; +- `ravel-0.4-negative-evidence.json`; +- `ravel-0.4-source-manifest.json`; +- `ravel-0.4-assurance-case.json`; and +- `RAVEL_0_4_RESULTS.md`. + +RAVEL 0.4 introduced disjoint training, adaptation, holdout, retention, and +planning partitions; canonical checkpoint encoding; complete restored-behavior +comparison; mutation fixtures; exact-state planning; additional gates; +comparison systems; and ordered source identity. + +All eight frozen trials failed at least one required gate. No seeds, regimes, or +gates were removed to improve the result. + +**Status:** development `FAIL` — 0 of 8 trials passed all gates. + +## RAVEL 0.5 — mechanism correction and evaluator separation + +**Question:** Can mechanism changes and an independently written evaluator close +the most important 0.4 defects without weakening the frozen evidence boundary? + +**Primary files:** + +- `ravel_0_5.c`; +- `RAVEL_0_5_CONTRACT.md`; +- `ravel-0.5-preregistration.json`; +- `tools/ravel_0_5_evaluator.py`; +- `tools/ravel_0_5_evidence.py`; +- `ravel-0.5-raw-observations.json`; +- `ravel-0.5-trial-evidence.json`; +- `ravel-0.5-negative-evidence.json`; +- `ravel-0.5-source-and-execution-manifest.json`; +- `ravel-0.5-assurance-case.json`; +- `RAVEL_0_5_RESULTS.md`; and +- `RAVEL_0_5_POSTMORTEM.md`. + +Mechanism changes included stratified replay, anchored base experts, +objective-tested lifecycle changes, normalized residual channels, +support-bearing top-two transitions, explicit unknown actions, retirement safety, +and belief-set planning. The C executable emitted raw observations while the +Python evaluator derived metrics and gates. + +The frozen 32-trial validation produced execution integrity `PASS`; 24 trials +passed and eight failed. Failures remained in label gain, transition prediction +retention, combined exact planning, and ambiguous belief/planning or efficiency. +The all-trials requirement therefore failed. + +The candidate improved some paired means relative to matched comparisons, but +the Pareto results were mixed and no superiority claim was made. + +**Status:** development `FAIL` — 24 of 32 trials passed; aggregate all-trials gate +failed. + +## RAVEL 0.6 — preregistered retention-constrained development + +**Question:** Can retention-constrained adaptation improve label and combined +drift while preserving original-task and transition support under an explicitly +separated development and selection lifecycle? + +**Primary files:** + +- `RAVEL_0_6_SCOPE.md`; +- `RAVEL_0_6_PREREGISTRATION.md`; +- `ravel-0.6-preregistration.json`; +- `ravel-0.6-threat-model.json`; +- `ravel-0.6-development-record.json`; +- `ravel-0.6-limitations.md`; +- `tools/ravel_0_6_seed_candidate.py`; and +- `RAVEL_0_6_NEXT_STEPS.md`. + +The epoch was preregistered before implementation. Development, selection, +retention, transition-retention, planning, and future-final partitions have +distinct identities. Future-final seed material is intentionally absent. + +Candidate-001 can now be derived reproducibly from the exact frozen 0.5 source. +The derivation corrects two bounded issues: + +1. planning traverses both supported transition targets rather than only slot + zero; and +2. a newly born adaptation expert receives support only from its spawning event + rather than inheriting unrelated empirical support from its parent. + +This is development preparation only. Candidate-001 has not been selected, +frozen as final, independently evaluated, or promotion-authorized. + +**Status:** preregistered development; selection, future-final evaluation, +protected custody, independent operation, formal MNCS/MNCDS status, and promotion +remain `UNKNOWN` or unauthorized. + +## Cross-version claim boundary + +RAVEL shows how a machine-native architecture and its evidence system can evolve +through explicit epochs while preserving failed results and historical caveats. +It does not establish general intelligence, language-model performance, +real-world generalization, production safety, protected evaluation, or formal +conformance. diff --git a/tools/README.md b/tools/README.md new file mode 100644 index 0000000..4096709 --- /dev/null +++ b/tools/README.md @@ -0,0 +1,109 @@ +# RAVEL tooling guide + +The scripts in this directory build, verify, mutate, digest, and summarize RAVEL +evidence. They are support tools, not automatic sources of independent custody, +organizational independence, or promotion authority. + +## Tool categories + +| Tool | Role | +|---|---| +| `ravel_0_4_evidence.py` | Generate, verify, and record bounded 0.4 evidence and runtime observations | +| `ravel_source_digest.py` | Verify ordered 0.4 source identity and assurance bindings | +| `ravel_0_5_evaluator.py` | Independently derive 0.5 metrics and hard gates from raw observations | +| `ravel_0_5_evidence.py` | Orchestrate 0.5 generation, verification, mutation tests, development gates, manifest tests, and runtime capture | +| `ravel_0_5_source_digest.py` | Verify 0.5 source and execution identity | +| `ravel_0_6_seed_candidate.py` | Derive bounded 0.6 candidate-001 development source from an exact SHA-256-bound 0.5 input | + +Other support modules in this directory should follow the same separation: +mechanism execution emits facts; evaluators derive results; digest tools bind +identity; orchestration scripts do not silently expand claims. + +## Verification before generation + +Prefer read-only or temporary-output targets first: + +```bash +make 0.4-check +make 0.4-manifest-negative-test +make 0.4-checkpoint-test +make 0.4-lineage-test +make 0.4-negative-test + +make 0.5-test +make 0.5-check +make 0.5-development-gates +make 0.5-negative-test +make 0.5-manifest-negative-test +``` + +The compiler-matrix and sanitizer targets add useful implementation checks: + +```bash +make 0.4-compiler-matrix +make 0.4-sanitizers +make 0.5-compiler-matrix +make 0.5-sanitizers +``` + +## Targets that rewrite evidence + +The following targets may replace repository-visible development records: + +```bash +make 0.4-evidence +make 0.4-runtime +make 0.5-evidence +make 0.5-runtime +``` + +Run them only when intentionally updating the applicable epoch. Review the full +diff, confirm the candidate and source identity, and preserve failed or +`UNKNOWN` results. + +## RAVEL 0.5 authority split + +The 0.5 C executable should emit raw integer observations and integrity facts. It +must not declare the authoritative development verdict. The Python evaluator: + +- validates the frozen trial and partition matrix; +- rejects missing, duplicated, malformed, contradictory, or substituted data; +- derives metrics from raw facts; +- applies each hard gate independently; +- preserves all failed trials and reason codes; and +- generates human-readable results from canonical evidence. + +A separate program is useful for authority separation, but repository-local +separation alone is not organizational independence or protected evaluation. + +## RAVEL 0.6 candidate derivation + +`ravel_0_6_seed_candidate.py` is deliberately narrow. It: + +- requires the exact frozen 0.5 source digest; +- applies only declared transformations; +- requires each transformation to match exactly once; +- produces deterministic development source; +- supports read-only checking; and +- does not claim selection, final evaluation, or promotion. + +The current candidate-001 corrections expand planning traversal to all declared +transition slots and remove inherited empirical support from adaptation births. +See `../RAVEL_0_6_NEXT_STEPS.md` for the remaining lifecycle and evidence work. + +## Adding or changing a tool + +A tooling change should state: + +1. which epoch and candidate it applies to; +2. whether it reads or writes evidence; +3. which inputs and executable identities it binds; +4. whether it emits facts or derives verdicts; +5. which malformed or adversarial inputs it rejects; +6. whether its output is deterministic; +7. whether the change invalidates prior manifests or assurance records; and +8. which claims remain outside repository-local authority. + +Do not reuse final observations as same-candidate repair input, weaken gates after +observing outcomes, discard failed records, or convert missing external evidence +into `PASS`. From 0e969ac138536eaffeed25d6434ded341783f850 Mon Sep 17 00:00:00 2001 From: epi13 Date: Tue, 4 Aug 2026 18:37:57 -0800 Subject: [PATCH 13/13] Your descriptive commit message here --- .../ravel_0_5_evaluator.cpython-314.pyc | Bin 0 -> 54893 bytes .../ravel_0_5_source_digest.cpython-314.pyc | Bin 0 -> 16403 bytes .../ravel_source_digest.cpython-314.pyc | Bin 0 -> 13943 bytes 3 files changed, 0 insertions(+), 0 deletions(-) create mode 100644 tools/__pycache__/ravel_0_5_evaluator.cpython-314.pyc create mode 100644 tools/__pycache__/ravel_0_5_source_digest.cpython-314.pyc create mode 100644 tools/__pycache__/ravel_source_digest.cpython-314.pyc diff --git a/tools/__pycache__/ravel_0_5_evaluator.cpython-314.pyc b/tools/__pycache__/ravel_0_5_evaluator.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..48894572d52b326c4a7a2002c46f65f8d34d35e7 GIT binary patch literal 54893 zcmc${33wdIbtYK%jVhpU--R0>agjI)o*)5`-~qCeV4)9^FbEVus6n7Q3urb=vJ6Y| zh^=EA8mU*1+;(GDZ5#UBUcO3&Ywdbvug74Ma!c}h zzx`k2T>yygvAvrg5SbPEA~KE_FCyN1@!tMmhR=fQ#i3U|k@IgYmcOJQ>J^Y5tWR=m z7R!Q#v&>npTR7{W^^9%KR!+~hLHnGY-5qldc6ZJ>+1)kg!reaTKI575Fj&W+_l$4O zS8m~)bN=g|xd1mbm(gnBF5b4z1#!QGdkFXEaL?piT!3?P8Jvd;a$YXP`M6BZ&tZ{f19h1>0N8RxRO9K_`2Tc$JTa=1J^=d^YAs!gDcu&gV+- zT*{scxH3GKv*$vN<0AM~LBFQ0b46SwepRt|#auO>YuIxMSBvL5_FT%< zyq`UnbB%azV$TuO>@sRrf%`D-m0UC4wXkekb2G4`+xs^MM=X31&0CyhG7ufSb&Q@hy7rG zkF+*-MEJ2gO|v%=G5*!DxvANiNbJ?I>G`p_S-#ol8@?5boQm8U<7Z-tL?m{5YAz9( znwg7D#`uUKO(HTjGa$n@;kL?ROBV|;9KDlv!K1Yr4C;@0f+M4~Y=5#y&`jUlJl96vQKe`|7V zE|zHY(Pt-ONOF4$C5+(x*fcB4v**R9< z#1MWvE{)CI!rk6Gb9c&O$+SorH^vgN(K&u>YG!I?QVOu2RG``UIjL}hpSn3WIyNyD zmow1;Gvrq)WI5_NIW;pjJvuj*czKjZS!bw~M^%7ed>UoJCq~Ed!Njx^<7BY+o%-Ah zzOci>e)gUJ^-ROhA#SC<*IDUP-k!g>SYKH4uPc?G7YA2La-Z85cFJk{FMq~$$a%x& zw2Z6Ng6=>Dc6(BU+k)kqWzGt!VY_~6&dyoq9Gq>=$=QK74k^?xqXWv^&-1f<@(4FJ zl|T>OxfPos+=$D;F3I}qcdZ-W22*z zZ*)|~4?G7(M_-vAn^xY0Mn`W>@rk)pjICr9h*ak-XUzE`ClCae2yAFPA#akqQ!w{&^POo2p$$JQOk8(_vb8@ z3B;9Hp0nPva#qg9**QlGjYa2=L8UE{liD>V*%NcTOPKOA&P%|A{gL3ziQpR*?M1EL=LZ#qP^}@^4mfR%U>*ODnUS z_^MhL%pOroz;e*muEgB3HdvEYGqW>IH!&3EVv)0#FAhbs^cV8yPLi=7F)C#X?16<+}eR&=V?g5{yFP$)UR?p(Vg6rE1_&Ipb(dWqGNX(f)Z zG<&r&pARs}5y!yh(GeD&P@Shtlm_NY@N8&Z)}AalM=#Vyb+AUIaItU8LieT1kJ()> zBH-EOM#vE1-{E1wQf#>@$0NK%ot}18ps6nra;07E%I~W#^#y0?QqoshB9^NjHQtav zTOO$K^1aRGvP_^eN-S~fRT>}c;;h5yV9qvdMK?RtZXUMY0*c11$E{P=Da&Ddsb$LA z-~bv1<6}H1q1tuHz&JxeMzte9xAjDZ8r+iO6N%Xw$;l|Wy6Qgsn*XCG1OYV!8 z8R?KhggSk(@!5$Oi(vTDVB@P$F3A}q@{*ux)<$H!@lt-Hlr`UkXx1&y<6*(FWwSd6 ztq()lZzR8vT&jM%`5VotqJ0~O&uxUx3!d{oeHh68+VF$ihWBzC1pmIL7ArvqOP2#H z!z%-;m8(})PYY#7Qo*C^9fIe~KWy0v;O7a##?Le~THY=0EwlfrJKS4n|IFz9J`y4e2ExPh87SB$vZYZJ$nb#enztT z8f=oaQL^?l*!eo-EIB9UZ^sjo3v&f9f{!51NHs!0wAq=dam<}^V;uqjYmj<8ELeWz z3B2L^f^V^7xo`Ew?{;i>p4;>Ve`2?KLx1H8{PNAu-r928oguw>{wZ`Mt^4>wlwi-! zdx0vXcAnLGj7agZ#RO62V@nD4OD`Q@*+t}lkq{c%dw1SdjeJBc>QGkimxvstT`Fm* zvV7Y*gz4RVYb}vDYT1CS#bJBKU3W6~7E8kIEBx$!b}S z2as`p_>E&S$HRV6>z<>BX|KXJXsNguNS5@r@qHe6J)hzYy1f6qot`;mu zzU@vMOOhL8i4hvsA=K7C4^B*t&%K0_H%73SyS8U9T|=To1uMaa7P~d;F$GIiTXb8o zv)gKrManfW(s2ipu^J4q^!g+kwOrNU+Lb55dAcS;M3D_02Rh7|Cfuk6WRc& zi?i7ki*1@fG0=Qdi77Vqj>jYiRaKsJZ8CAP)mt8k&+a*F4?Qgo z)W~b-y*}h1Ifz~)J&73WuWLM&ULIQ1lYB7+G;K9lcb}`r@jgN1iWWd#tM4%doBqNr zJKZZ9J;yFYSzA3G5**9bMxE*dJVM*kWQ7f~A~aD@}## z?z!nXPkj!SZie#iO$qtUD|c3=R`0IouX}~S*(Y{e$hT#&d3}%F7Ej)GT%)#SJtKGW z-na%fgsa7gHuD+q&4FBW{GzJQOx>QpE!nY~#jml~=vUH*Uy)Bm*eaZ%;9l4_OASFZ zm9WoE!~?;mKe%P5dtr%uuiGcz51nH7M^4XUC*I3-rIM)^J+r$05gyD~_zZf2g)Zoc z0b{RfdG11cw22|QjrNS#y2GGRe#$dyk6}erVi~b_e+_sq(=Bsat8t^i=$0)RHqb4F zS&)qM=zN3uxdb+d*qe_}kI`PAADfwsH8}VIR9bS}z`l&Xf=3y99Xes-hbcCSAVC!b zqAEnruc9fw#?ySnx`hB4etN=-HE-oSaF@OBE_>$_tGRz-e^7hm{n{fMy*n(g1qIL1 zO?TjPzqHi#esS|^$9Ilv0E0r=*;MeH;5oMoLHyWLSws3%rX#1kQK5D2p2Y7ifVR(F z@}#vqE>B?-|G&&#MjW6Xjg8G<*+)IhvzoCD_8BTZTktC#8BjZtApxy`SPh>wR~h4w}jdl7|S+Ob#6D+>Ewy>cCyd{hcB;bo)MLhVG?M_yqR8%8Sa z@ME{*;ND^Fgo#D%F1E7Txx2K*g`9#P#kX1I8}OhmE-pXtSG@19_}yG>H1!E({i)!9 z;2GFuG=1FVg@Y|GJiB(AKU@ycAr5+1kJ zQ|z{OioM&uq|gxWebyQ}fgZ7{WI1lv7YR|jI^{=gw9J@1%*Z-XI(8klKIb@VnJA%H z@a8S~AkUc=bv-|T9@4rWQ%H&B97uQ>mJ=7UymYr+$N)D!EtUF3HRS|IKc*75`b{=H z*rT*Kaptp^UawRd!ObsrkLF+LHyIV96Pn`CQlm8|1tmcWt8*bG+1{4psq3J%)T z1Q@}i*se4mnV!W~F>$O}gZMm3lE^{uV-!ZHIRB?}>lMQOqxUP1{@L8m*c9@atZeJ> zK+JdhZ$w5NOizT}l6^WhBiYAhWELS}!Cp}o7Gw0@LAw!kdQw(V z8K#2r(|}{>B~MTf{e??4DSyL4-$S?WUi)Y7E)HzCi{2jp)$#YJ$f=6+Z;!t{{!Q)I zgR=AQmz`Gz(@ODbboGpI-Eq!c3uylEgZYyo7(W`v@_Lw!AM^~C zFt(l87o0U6^A(b5#(bM`adQ>8EMHMD${LA^C|A^aJyVr$m0PZ2+{sru9H5l?Ve~kD zjIm~sY^|>)_ZiTy^|eTRdOi_3(77WT_AnYZ1SUE|M}CU(@PQM{&n50mfz!zdHDMT| zb)exoe!h&@1PxOx@MZp5mX4V7o$WM=cpmRrr_nNsNO(GOp2YfS;_caQ%&ts4C~JGa ztW6{9mxZ$7RPc)6x$@AFwOGB#zgfR@dYRjB)IanG@69cq{PJr{;gr8baFlGvPX|87 zR=yGT-CbAtHpW7C7)U+C!;eJMv4++8F)r(Y#})*On3r)|s$#$Nf&rFY)L^V&5Ai?) zhgK!>)fiNtES9)s#B#l?QNt07rI991<%%O6XKmDYH5Owo+QMDQrTCe-*gj$|<)&N+ zEtJbpe#4i6k@g=G%bQ7@{=3+JJoKH?f0y*jKmR7{M(zJq`_wHda(7DIE zK-SWYH(wG174N(x`dbA@tKL;=H9pR=!3M##jV&AGg}CJ4XJ_Zwpdo3@k*?SU1pp4TO*G>!5semuo_Zrd}H9D?;4} z=`N{tR3UJ`?g1H72nuIwG`xvgFBx-F-f-Fi!wAbcjK4rGclr{z!|Ioe&{)3ExMkN) z%tl>Kamm0TQBy$rp_S+oO(bcTy0qb(Mq;a%gjVW5raqVKH>M^NM0S-00c4eyq;r1m zW>fbQR-K+9{ul9@Bo&^yS%sb4jTpJZeK+~p+e++FiamyaEgHcA#T-wY5I#x4C)tae zJfxQsX|sI(s4S;eX(|bM6EQGhK8G|6GiXpOSRR3Go$-3c;@DDd%2U4SD=GU8-vX=T&zRI6?9p0)fyT$2$8ngsL zZybC5*jsgPH-EEvB@bNJ2Sr`)6?LVG4y{#+MMu}>Q~rLz(Z7ALeC!1Qf07ztuL=Ku z0gyJ~7g@uPEeL4cj2o?+aa;K`i4ik(EF(wR- zI*6Mxi4uUbGHl?iXp;vkh0D137@1&c7zYOVxs6|lx^~UOW6I+O=QXA?j%1Vx*r{-M z%;oSI^WXw#LGWeKg4!}?_ZBoRi_Vp*ZHRH3A?1Vj1ODYrhqCn((}iVzrt6;lX~5#mSsZxt-16z=Lo2;2 z<11H$injZn_Qx3n6tskL7he#A5!vG|bSC;)@`-jwJr zSnAqvR|>V=8?`63)#nMJtTz=rDR@q9x{Ej5H7j{SYoFNAFPyo$(Qs7*GjQ_U#X`*? zv8+dQ_pD8BxcfDjD?(W`6&w*fBTsBv$@3O(zWMU<{HT%mZvljjzVG7!+vDAc-_qHoBM(A#La6SZ{h=p&N2+JHWY#|l zgcrNMd~u=wiOowiax2FY2!HwTQto|!*~4(f^2qYw%5y7;mDuWWq4HEJ+$RM39_Ise ztH9z3-kTQP#Y;DZnp0v~pXlyee|6JS{S&+GjMeoMi_PPDjg8g+lG&HEh;TZ2GfyB4sp>vBg=0)qK|tI@59cwo~4q zv$pL+0=9qpd7dtszX{bI6172Mv$u%e0aBH~s)NzHa-w$#mV#S!6ZZGApE~gc9J{bs zl1u#OSY*;B$~^w!R<6_Q+C^$$<|Uo3_+`u|YSlMXMlOI6M&)a9o~W%(`Od^)R(5Tvy=xgv z%fnsDVEgE0xDYbbdxs4m=Zo64GGgYqP7b94>j#XBpKspwKcD2Y)M7vdu2Aa4i4pY|nENuWl;0^D>%0!}9IAIb%5YL1OAU=%;O#p!y=ss%07DGrI z2I~G!YkYYr0Xn1aD=*PDIqkx5)!4_1P@_ZM+i=j^A)y9;1WCTF2(+Dy)JYC#ZQPPP zQwdp%_S-f-1|T*M83i2tBx0p9g_S^c-9fNXO7yS=fF#&}5Gv&QVQ%%kep#94$^(DZ zQ>VpS`X$F38DGd)j6Lv_2%eJf=T`sh32{q4Q*hM!cG*$uz;Loj{>+4`@=r)ayBFxZ zCn5%oUs>@U6F&_i{*S1Hj>IecoaBA(VC(4RQ@!W=C12m*h5n(-gBOP`lTyV^2uY@= zB^N3%A4@bii!W8qV14;EnVNUxEZNUE--mzJr8&zMhYzA|7+A3t` z3HeQ8X7j?}raQP;@wrc7Nw29gJ%Sp*z|tWxr)I@1=Co{jO5d7$`|daIZf0Z)IgMgQ z(|5dL#v$mayj3KIs=$=VsCi{8T#j#)cN0_-rtJ>R7<$2&ecJy>#+p^&DFTExf=KF zb9FYdW~+-l*1w?OrnNHW>fPpHZ77nW6w;Yj_vU$c&v_c@&8!u3dJo>4=E$h|y$|nw z#+irnBPL*q$v{ld6ca*>X};pJ5R+wuY4L*ghuH!(nXj$ZHF_`a4?_C>fKga^nVu;x z)8+Lt5ni5nky55YM?;O|fB?GbEpr*nogJj?)TK&JH_}1Y5#Oh4VAo z=r->@r!_v+4tU&iP7e?vhz0;qf6fp1;7OHISq)9^0Mn+hz;9C?NPzn<3mdht(Xzep%C0wAdbLowV6degF`^)TNW%} zqPlKd<2HQ~-C2KO7!$U&rMd7*28;;>!rpte!!8&9dtjB1uB3K&VqT33_EN-hqEOPr` z^`hn2#98Z525a7b$za7G&)-o}^6cU2B#q@=hO2oa?bIbMQK!CzOkab`rb;`ngkH&4dS&V=m;v%N z@)fjPrrIk;R_QsYS5Tew9z@|A>OWKp=(WL$g{Z@js;4Z22G$4#ba+-Ndq; z+KB%Fy~)wv+=$`qu-tq(S}yu`6a4>%1jh*HhPWTm&;Nsh{~f_GT2RSwe??EU ziI=?NVCqAB3;l-wlOlhgg1h zooEOc81v@Ugj|46GFXN{JQYTAD<}!Q4)v(MgJngm3Pp@bJO%YYi@pY#n~l#-&raUu zp8}Fi!Dm4zXcdChI#wZhyR1Uq&%5v-bU_GRc;*sh$oeQFd-05zQ3}B*4q4rNYXW?k z_x)AxBvv}V^~u$n!qFkI^WsL`MQvp=Ae5a>1<&9->cfJH<=XoN4X+38IUi=0EzN^J zU$9oQmcMQlYEPyzPa)bC{f0;k!bn#I?aolAF?$Am!rQ@6uQ3lcK5+=k~e1QJLqgzLpXgCV(4dqfBved@F$J$N2D45nHP)R8?JK8$JFw;wj$aYGqZ{>6 zt+wZcvh%6n1;KOSVNuoc>H9^EuLr4GNW5Gq>^rh{W$pC(0inEq9b(qAkL{M?rXPh$ ziCJ<)EIYbhw_f<&2I2T{Ds*Mx3?$E+p3Dzy9M` z*ROx&`u*IR*S&I|^(_r9zsRJxMIHA&oya_|_K`cZ=n>t8OHrY^LoDswaCd5D#aZDq zsoSYvvyT#L$^|%xU7)O;7Lxn;RoM)8fs1n(KGEuu*hoF1i*!EoRoPbgeY3 z9u?|)*AJ}U*l-L!bc7aNGB;S>++7k{pWAS7N_?}J*|K_i^^kCc6AsXhPnL$3i{XZq z$(0vYXN3Lz8xE+nKt?JQHj3e<)jEhsd(I0j7d9M2JIGEq95^idPnVpcIk9Y%0J4@vj!+*j&WEC#GklK8|}g^><`6KPS$ z0t6|_GT8#&3Mj#gw_!C#rvy=}c{9L;*meLjvGKSwm#Jm?#EV#GE+`e$_Ox zt>z637dAkl_VR^tn8q}htwMo|rPsiQ8oY!WWE*N=<8n-;C}1ZEAR|T%jC3H^1XZZ! zU#FBnk>hC_Las=!GpI|SlxOy!&r=i!KS2eADuHH~{=Ot~^sp64EJ6(m%X|BdH&^NYju7S3uG{fmR!33AQ z?X#L?3D|6F8_THYYL5C9wUjFED2Mqx>hEp1w9n9%L@U@8HEyKUvVPNmIX-TG)QkD5 z(ZsG%%4%vwkEs=#)bhpshF0_gcdh|{6Kt@!$?|p%zO#^Qzvj8EOuhmVWC1v`UC^75B!o41JcxwWaqh-s_Yu z3%zw6y`@7b?@Y8ci!<@#xh|Gxw~jCIumPX4xDI1mE6|4w(Ag&F&K;n84A40Sx{#yf zW_+I;&AbF$NWY@lzyxKj7SFp%QX_Un9ntJ)o{F9E{Ag}8pJ72}+H54(@-RxG&`)Su zgrmVj$Ym1qB6L!6q9OXFXaMOn{fHq&@KS~RU1Jyxs}SXuXlO?WO}_&Wd)Du|wb77$ zG&7oAi{Jg$bD(I96{cYr@Y%#1RLc=B&@nEm&BIYP%WbRQQ8g9j=}Ps($|+QgWzwFB zRZss>d%>QXRMx7s{Yu@v-w&%c_pVZMErDA<(~8 zvy?VoXc+B<&lv6d89o$h->9PBSJj`EXrcNIJ=B-j>_rc#aA2D-icbH#l|riEmp^oo-Q4a_Mq^}yc5rkml(cN z!u3V7X_hqPztg;9mXr6Z(D70OB`XCb`vp+4esyGng6Z>dDK}uO5jS|<*gF~}HS9%= zX-}Kdp1p3lTw#FJSAV748586=wWMilunZGah6)ugi(FdWd#ph z@p1zmxVQ`HbEsjaC{KTjwE8?zj@BJR>#8|uvqZF<8#2}A2A$}hNT;PN9rv7(mKsV{ z&RsI)AwzTe9Dw%ITe+OOxC8WMBlNk?Ds)ew+_Wo6)2#?qn<$>i=q*3 z*z~;-8l98%Y{W;nD?7YP-xWl-s0r$M_1kK1Z=*>s7<$_Z#{2}+x|6M-f;EbbJS_Qu zPjGt-Lg=~qiMyjy6B60qn~;ya#!@N8To@zHkJY}Nfi&fbJ*Ym>y+)%6B5jH&;iL& zW`q^0B+S<8XdEKvQ69Elp?@C3D`HW@#@!rgsjFJ$38|S`wVY-e2H;Gb~2H?RE86S$=J-O!f1z1A2i*Sb28LzVPj1o%81WH#*z*-IuHFz*8q3%#r~mW z$Ic&Ye)flwrD@5?&Mw(pm6J&x*b^Ov9o@O)KKAv9UdG7n`NUl0hQSUGV4E0hWm={v z1R+_op;F26beMDm^wNP^b^?;D08Wy<-&?mOH=Uh?)~8ggmxKYycq$`SvRF1U2aBVy z0NaGK=}kD{*#yhQ;1VTkjoq&25}^Xfwu0FRNM6wjFiNM}QPWR-DuP3y-Su^Ps;jMa z4O+bXb@rR|XcHgpdv-lO5fK#wze5 z=~mt*eb?lC@jmIf29Y08w501A)N}w=C*SEn%ox<&U|O22D=4GNh-5_*^YLjq#2AA# z5ub}pO^`ukmPxA|BWIn6Ow6*8DO+!oBO^pXb#vGzeP)_`+lVPgi~b{4O`{o8URz=!gN4Ohk7F zP2?VIy%Mxc{VB7t;v0CcqkpAe$f>*UuS<3G|Llna?>?KALsnMy&y(R6RsbUzV#8KG zvx%7s;#t-aZ9B|68U~E1T2^VOkh4Rgmy#KBmhx=XoJ^l7nzv0~d5Up3HlvY-x{NbY z#m@1D)|5)1^bBb>45X8JbNQ2)$(RX7U{(63ns?4IdGI3w8a|zD+Lq>-Wog`fj+Wb* zW)aX#Mlq7byF)iiIcm2WXL>`dK}7(zff;cgn~o(jNLfx(6ooilf0fH*91K;Bi5<6R z#uJhg;RL2rEMjiYvV(7mJ$dL2NbV~`=Y}qh3?)x}ymdzNPPrw^RHVw`6$_=bYE-i;+aZ}ji$PXkD4`~Rf)nh8;t8fg z8*!6gRnn_!3aYfYI{H~d0qG1MBX$lQhbHT)lJ_PJnHyu{FH3$>Ngf?zeJ8=r8J#m9 zRd7q9#UW|E#704YXu6g0Q2uB=<=sHRJ_InlDGm z62$#tCsRm~WVh>tY*VRVx7m|_5m_-2-OnLa{i!0|6sp=&86E8KJQHwcLcm#x11C@G za-h4gj}Cc~BCAlWC?p7FCsV;wg6GsjM|iPwX`h%~Bh>Y7I8MsHo5kz~VgKNU<18Ib z9ax4cd!x`ikjgl%e*#(?TR4he@ifbePvp=iCV%CZmg;e){@q3tLI|~pp4Lsz@eiH$ z{Wwg50Qw+wnB-_Gcuepd!!djzSS{j=ebI)S>_2JNF77HO zr*zXl{?u;uPFUHQR$Z4jvjX`o9u__2F!YAcWVsdw0a9FxXd$~*^c>jq)NFdZPuz}T zm*B{UF@nr8Rn@@A^mnuFd(J_5q@ey$cA-$zDrO&8I8W*?)9>^>@Hf2gZ}{U9RtMz}&cm|0 zmB9V7j`uu8_n_&LxA;jqbKAex1+#S3efK^6$g8{)B~TizTJ)fE4Yi?0%lg0;LI*}H z-sYz@+33J}OL6tvE#GLlU$h?@G!EE*6SAu}{M8QwMN8d6-Ql&qwN9bt@9|iK4 zJVJH%S`HL)Dvz&cA?~r)Qrx)Zvv{%=OVIG|?2~n+wT9hAi|KbsIY!fWd01Tbs~rnx zALbQ)H3lY0a!^)aFLOe%Abnt*he-p@WDbe#Y0mG7Pw zE)NTBSDxBo3mA=%Q@LET;u9;|R`0CMuT8GMD0Ey(Wj}Y%^DwJ?*|~h{H$tmjYaMHK z>jlDrv#G3e_goL59~4_2__fCas%+3?rk5cXymHqe&xg~(|k^9;}=8;6-} z89^B63FIs$H~baL!z)+bxdup~@>nW-TnHQo(!CLUJ-GPVh9|P=$#}#2x_7bqOQFr8 zinsTFWB>Bal`&ZASv?>Ywcm3uy1o>8Tn84$gMuT63<7q2_ESQB z-G;l4HTb1e@HxTr+z;Ho&n7l}1FIu{eEs*XZ*;&c(7@*tpHF-yJ@SEj;C=T1OL{I9 zB-aR=(A3J?FNPWy&ip8l2Tad-5U71WQ2T>WKACBI?Tbg>I`xiy`OLR6QYFnB{^lQ1 zKVMD-hXv0tX=(WhZoC(I=pp)ZTr6o@ z9hFhLr0G#%`EpP!YnR)U zaD3gd_UigIq4IJnJS+r;@u^J=Yrhz%R&rTM3V|L?i!T>%g@R@=(4u~%1vUiw|DLq` z9yeIZ4nA##o+GR0anW;P)6@OLX%FJ?A?i=$CMZ!`cB5P%HJCL*_g?*SaH(O#Qw438 z#kwyaUz*zR*FE&-_`Z3dph#1Zge;y|h8Q;5e>!Q+DG_$~@Eq-2C`sP#!T z9_XO{ZtinFvTaHdgzc#=^L5(0k_3&csD!N-VXckAB^Xel`wBGZ=)O8E$8T4jBW5)# z_W*J-E6wbF%J}2k>eX53syGd5Ec9)5>GtU%;`zQJVsF=lsUy7*`pd>pZ2Cz89EjIN z9}cj?VJC~J)aj7K7{CRlysoY9Fst7fQjnn)v;tjm=Lp9HrbuU0{L$3=unwXNf;ihw zA`bne1_X?bG*zAe6FkU@1DYt-P!2k~q2+H7d^pUidsmTze5s{Yne>WK^0%ONkfXv} zg2*lXf{-#TPxZTMPKt?u{~0;$R8p_8q)bTXg9splRLRx-w1H*E7)7+0m#i|6PI6Ne z2?RW|;G2-U6}HMxdapGrZ<5(P5uH87asaa{|C(vv9Z^%W7luRMng_NawneZ^hHSphA_W#&~cK~lg5Hf@T@eyPE~#qZXDZp&s+ zbd6qh?UEl^&Xt#WPFhDyEKjYxvYNZJ}t0P5Ip6cdh^R0)~T5#NVe1crctZcu(1P^FE9xO^Xg|*t4E~rJmr3v-5>tL_MJtAzvdeHxemSF0~A(X`w8}jt5Xv|H!+$ zmMYs+Dh+qhlP1MS)CtMhRk7V4S`-as)XjF}8>jWrkzqqt$E zRh$Og3P()}%`S+wXR(6RoZ>AtHl=2j%Gib zz7BwC&Xiws;<<)#6^@!z_E}l`qdCUe1d5@0OXNWnl<1NQqqRgdZ;$U|MrKs~1-+%% z+{JQ2ezM;#h3cYxu<{|SId^@Vnv%n;fXK=-ptn;z-!RMNt22cm&c>OP)l`UGY0??w zt*u0&`Fqq;nY}O@6&Td`3Ro!zw~Y;D_KN0nXN`RyFN_wZQJpj@M5Ud)!W66uIWt|z zGXG|fClttY#;<@%v>1OgNJUMPJ8ygg$X4TT28n$g6nqQQ#&X)&CdeIU!3(BVg?YAl zI9s2$Lpj?sr9S)Vx#3Du)~9+&mU;Xoa9)-emY`Rp3{?|D7L({daV#uh62CEVB;-_@ zs*>c@gw2v)mwqRbFbV=yswVR7&4evXVXDBq^CRcYvbqLO12I{iuI`W~|4%w)??IV6jL+rrtIB+g%(-snOoUH`+7Jv9K6lqOqXrBt)9Oy}jG zPod~$$f_CXW%U~lz)9ZQW0UX~4F?ynslr5<1>~yDJs5j3B?0K~0AY zr97kabV%)#!;S1xyiH(hHP{d8!u6&b3nXUtl+caUJN<24}J5)x5ESs-ksCz9v$(-hpM zV1|Mz3O+%>%Ls77lmRjEKc$v!70lB6S18~qAosO=oC0kG%bFXXrnr9~V*E?=7z#>w;0FBuJ|M^c5)LjHP-N`=kIg0od3fL>k zMLuf#%M`bOKr&(qtYXegfQ-kbLIeJ2ILkE3Os~{oIm%w~pFxIbs((e9-=pC36tPV+ zfu|ZBqxXMDPoz)4R1WxcJV{xqj>6^s{=U)YFLIZemlvL?GQ2>r(-gc(!M7;*J_Sz^ zNCl_P^q)F+=^`A*j9$1h+&c^_kxbP=$~!+e)Zcr$e{^st+RF|00)W}B|3@TiDB>As zX_89BSV^ZSM>@`b1HnTCM02wd(36fZcP!1xe!5~lNRGC2- zYDqr5mH9Ks)1WzLc%xyal&@u`4M@cmwyuRBWoSU;^_I1%jMA6s3pv_QfOd{L6q)mA z*&l0Uhf7vC2xbklTf;AZxAtjbn^G8WY<3Qd#{F8iQ-vxzZw5^{m}ln_B<0a3q?_8Ckf% zY&zsV^yF;%!}l5%p?6Rz3!#FRl7XAZxpve&Q;?2VR7s0=kE2v%%(SEBM9N} zO5th?xS@GM9hq%--!u5V;?^yv#aRfaizOu4^Z38iCWNXUg!a7`+LsD7rugM*wXU^>^KJb!2r=IC@bycuC-fHyl@<*j!nzdk)BU zy?KjM%Z@i^SL%Sg``0F*yimtfLPCIenrU%{7aNw&is8DI(<_IB_R~Vc8D`}Gc5s(o z6LXoB7olT7*mruvLH1A<@51t3e&cHXs#iF4UT9`k3-)MM*|>tMZ(d(=K+MCiVh3O~1Sjub8qr`-8(wJp60-5jy} zNUHeghWn_7qi2OORga>u`a$8o_X_vjFKmPwgX7-hLs$!~V;(|oGo72NllMKRNR^@K zQE{zMcSI~c3LhqqVDa}lGzwO|Yt3To;0A2U_~GrOOZ0bd`g4TbM$z8{4W~f!BY*jF z2(Hdp>_O4rMzQUP6(Vh-ABYKHQW2o&76OLkXg@Sqio}+_4Syf>He^xP3qsk8so+b3 z=Ore7|Jjol93X-}dlCR?N)SW(&m1Mgov#0>yL9-7i)o-^0$~>|RlptDQ!Wn|8k~)J z&XtWc)LjI4_>xt^?)IyL^$1VO~8NmSs&B$Rhp8_2h6!*U0CT5VXZVYjt@7P(y> zPn;K4-d|wpN$z9x{RH#=HqP4JgWWui`os5M)Mhk04@s@< zukaOITgUnT7B^MlehIC|e*=N!xfL6mz&VfGX0s=`*oMmSqf@t`OZh4@w#NS&lCa7{ z=O2~d422h?U;fm>8L~Lk_PJl$%q!i3o>YxteXZo27RuC(CG(77{*_`4A1pAmam!$vCtIcaGU_#HyubtTo9%;(&IvqCZ)$^MxEQ@vS7p^9nNSTAnmPMK3(dUULF;~ zI0jM1?DTJ^moE)IN7sxod@HT|>bDFKX|+}%R2dpdl8X|XjISUrAEil;D?o|U;|kGQ z>2b!x+i7pruN%sj_H7lySbJUPXYX{JcG%lU)lj1nL)x^usoyj}q}5b~*t1l-Jx$+L)9qT%D#JI^ z%B-d}K%}*a3Slf2+Nm1tRAc0PBd!*$lpa@S$T{t;nzI2SEl(99?c4Q+6fW}@)f5H@ z+s+Vac{ZTzCTS+>vkw+`O%hAQ?MIwRGKsiG#F-=wh--@a5jKNnnvBOFt_3z%P0|I# zwIa?WM?l;Gq%}+UU~0wK;*IL`g8L2YDJ$2GI+)F;bRv&VV;VAn!gZTs4k4z;6mu9c zM@%tC5p&EGa~v@zOfkKPG0Ex3bOhIDg6WTXxPDX20Afs1C+-Yl22C($4O$i+vpnco zE_PI0;Le%Snie2la&^e2N=^_0v&}+GkxP~5MvtOFjSRk z9yJ&rVe|OF=m?uf2iJjAW;{IreF&4}8zU!V9ywemVobQ)5*Yc5THyY<-;pJu(G2c6 zV_!h_o569Wm>k4hHpS#3#$=))o`;w#CYXH0L`^XT(ZEjjoVk%`c3SP9M~sO!a4#5W zQyMK%`_%xEmY)h?q+Z;M2KY2eq{15@(#oSkm~wo{0KfMtC&z4pW5*n?8gkrw6_;an zRI+1^*9Uxj$pcMO z!OOB>Yd2|-ER|wnFD9fS`IN~z0O{i~>i`3I&};)hb0cl%Y;vQdmO=4arf6;u?}NOS z!Q0L%G8@7XT4-gE^PL!OlH=8>*q!Yz%If4Zney5AQCTfKv4e$x8R8JsAS2mVnZ4BY z!<>`%`ksPWAGp^iWYvg)+6SIG!BhABoRdFeKGi={USVZ2HYtM%do|B;D^#A69VBw2 zDu|S;h~Z=bv=*JGaHK}l;=`ISTF;_#dmIeYOwWyt%5LIeRR@-I_^F$7S{nJiRIhP% z3Zl46cL2~O?K{0J)yuxq>wUYvo`A&yv=KWm%g*6X zX8m>3FMs3fuN;+Nl7SuVRlQLgxK`w6YHC)>VYPtb`Fn~iA8VP9Uvs5*D5uc((hIJr*}vx z1M$C$FYtd(!GECOKT<&BO_n(S1wD}&f7!A!iIkbdSSo=pJy_wG8IP%+bPZOdWwZMv zi6(CW>}Ed|X(mAp)h8c2wYpAt+B%;D3r>q+>a9KAX98h)ut98!&}@PM?k=>xcx zSKSzm!ruTJ2e5;qfRV8nc(No_7sZ)|EQv>s@R$5D3<$*dDJU6@1A?_TG+(C1?@A>% zq1!PEV?}Z^GEp$|gPDMMSay1hH0d7Qv_Y2UyiJ0Tn_M)r{$eiS6nxE115~1`)7!w@ zatc&=I+Tw5j7mxk=>X{Vbo=Kr;oyH2{Uw!Zjk@FaD)HLTjyu9M+!%v*=5aLdtIUp+ z+_pP{R__R!UWaPKs3U~|17W03P&ak9OT{XB7;INeqOQy*$BzjE{~E#0^Y*9lMw_=W zlbh%5-Ompy=hL9a{LkX0l>ZJDa}B|^DW3mt&^wr?x49av+0)f%&CmG%9$CW0C_H(S zRV2lL13SlBbu3S6+oF-ygm zDUF6gSs8>BF(e1gL6T1&*-Qw-lQ;%OXVj@-r*##h!jfBA!bo9V|3Y2X@Jz9U>1n_p zIMa@j7ZOsI`cwOY6i}luuxF$!W&YDMC6g;AQX_fP0U%|Va2?hF&16E#VDy3VBC3$U z0&aJ^6tZ?m&Q8lT{%_DKOmy=y=p=+qnXpA5W>!JM?kCA{nV8?2@*h~}dze+S^a6=4 zOOK|qjzNncqhP5}s5&kdo=9c%!lXp7kmUcpVi8%TfLcjrF$w*Ti6zHVnJ184sA%cX z@{3||YbtaAvMlX8n;AHIE@ng)1~x+la6%rch8K^*66i~m!qsWv@~dm!_i|3+C~~Rm ziN#(7adF<3=Zv-7MSd5(!oCw?q<70s5sy6iOF2uQ5DOc&ob(&|F5bEo-)fIoe{9Rm zV&Kdq0&%ZTtZ3WvvKYvtE0*gZX0Ghm^0OEmZ7yA!0!&%kRtAfKOup&e7(~sV5Zeb+ z&1WC_LW>UQcw|OWz6$tyZK>P}F~Bf{+skewjkK-aTzgUMJR?TVY-O`|ITml*M*HBy z0M1IoSVy=f6{vmJxpH&$MX~urs=gP8$~$~pxeT_*;;mZl6B>?*)yKDrSyYL|TeEyq zXgVp@p4uv9QDqiy?eZO=g;X=P%2`yz;;mmP6xz;+4TD=1ED9z>I_RU&J2)VQ52gYz z(~-T{Clofr^=&HHO1^3jK%>PU{8G#iy;_sKa7!ux zRiNy})0At@!Bnt~@@ZG|84!wF#he4F;K5ZGBB-Q;c+Nb+M>! z>VsOLp+~Gd{P+-y>aln$m%D`hN5rb5TZdWH5sSBa`30fngjmzNb(BRNLkBBmLW}NC z1sdO-UmYQTIvp2NEtkZ=r62h+P%RXvQOs#d1)Eo$DPQML-1dg9t>Y|<0W0eDZaRDPKLR)zq+c+RA`&0@ct9=j6!qh}8Sxf*c7iLf-0kuB>!X zU+f=D)i9)i8wygbN%_b_aBa)hMH!d_aPzzKn*nBzA(*(kh@RJ+@JC_ zqR_2PTbJb&Fd!qhPoG%Tzx9$F3ErcZ41K_9O>yVeH8~Q;bG^k&XM~zAv7~!zRF3=w z6Xcj2c>|F!@X)$7F8`ju@BAe%j8GID*ow(QGGDS&>^Db?beE}$1lqu(Bj1SbPKJ0VtxOnryS0H_Ma3hPBCAr%lpJ)SZ~N* z%7a+Duz_CZ3H9A#1=Ar?kY#)9DY3F|)6=lhDI7d6?!RE55pck~bXRET6U*@}!($mt zTnq}$ePVV0gX;6|Ri95)52Yd(p`h~CIO!^#5G#8hRGxXS@=U7oY^vX>S=yA}dO&GSw5DS|h6t=%t*nYpTlQcpe7QnC3%0;pINUGrI zy^Mz?tlFo<`o2_2zu+l+m=9!M>46vMRDRdJz@tFP((RSAVp-Q_AR@r*$yu@T_-3GD z`KWMUK&(2w87N))MWN}KSZ z_HPC%mro0gC&lVhn=lS@dU*)eIW_}T%Ofz9BG&Y86=qcX1W!@Q6Mnqs&WUyBHv=%Z(mfY&?^y9Rzt1a%xC#Eay-v z*aOt5JNzh6g+bLVwD*hq2U0bsRhTX@r#lrqM5C(bQQ+Wr`e6)apV)ID)jmX2>Y`BH zF6MNkf`ot_U5^4ypc5~wCB=@jsTOGXF$n!Tt@uvYpX6?4GJ6@BEf|kIL5#;x_-i#w zA))@5Sa3WQKCxbv3Jzdc_MEmtfhnW$-77Fd(<8PGq?)K;i)VyVc-?AF1%WHp=GI4n z*6-A;xz~MS_qo);^8|50s5~g^6ss6_|G{bx6W%x!v* z$Wvp>R#z#^@7T+ot`BiE-{60|gq&z?()IRPclV%Od{p!jP^9f&~b> zhylj*K&tWZ4BH>+Iz~JQl|?>f{)nE6kbF;zAOA>;*$Vcd4=uUmn;gO7%og2NKFx0H z@QRFI+m(xOz*{cp-zx=8Q&_Q$R4~&NfP>KswR&WF!^Ui%D>1jMBVi+(Gj4}q%A~py zCoknDMU}V{;z9@Wn1SYk;!=C}yVx+eE|6k|(-gmt#XA6ThMqVV@-iI`hEf!~VE|(rSdy~UQa+~eB@!^>`0~u`of&0G4;PE1gDsnf z!2Dw2X$QniMo3=GsszkdFwc>&+2|n4(aewpc#g#0<)25;;FkNCx>xect8-?`jsH8! zj%kIH1qzt8BNK-c2{#fc9{=REuYYtb9-o%2aPm(8%KHD`01QjsFczS1HZPppbcZ+G z6;SXKA}7|1*E58&p;Yjq-~o}#6GK&?a3L&szWj^w!&xy@jwk43K>;^^Gpq2uteV$d zo8GL&;SF!0`uh=!zlXJH)?)jT_f6P?%3Oq6Y$sz!>zsx&d6$OWE=U`r*&QHc|ak!Z>ps9A2k+bf(2i9SYHgoh?yCDZyi%7p< zov&&dx1SaRJ4|8i`GkJ672Hj=Q24Gs|wjl{53ERD~` z=jF3K#Ihkvqh!(j)hWh&z;O6ON@gc}nm)FxOdx53|9ct@-=~4#yvg!$#S?Q#h65k# zNFbkwa5Hb407pO2mQfxczR|HsST`oSD*XS099aLp42T8G_Zn!M@a?>1=a=Reul!e^ z`gY#JX(8AOjQ(2N;+?O;epcq!_B{w!y$`Ma)2T4*25K(~-|Bf#y#M{;{VS(a#qFD( zx_65nH1xdR(6iQ+YB;s!cM*=eoUWgJV7G)0FfZZ1lGEGa_%GHybu!&km+Ux=oyz!4 zsyOY}<#~bj$$KJqgpj+MRsKUuIcYK?*bLQd+3DUo!0wNnp2tr7-abE&K!zbX9aCDc z;JCGm9C73B#vN{w;|}~gqc$iP5WB}Uaw2M?%p)eDe)s1rmc|_9sa$c#$fak(L;2MN z?>yI`2;1!+@r&s>?DfU;66#-csA8}Qh}Cew)~WuMnO7Vrlpd$RXlWD}I4X|naXaUO zBexs|T7!rG_h|G1u!z+|XQQ&`U$TX(v1s%t9~oo@TMuU!VNIAAy|Tew%7yOID1FmgdPO@?NLBLHn zI8rPqg_Xh0+@gh{?}v--fw@w!d{ZoGT6O2tIBin9uVR{8sRLq3R#Fb03s7e=k(|1Ap;v4Sg?E{5`+HH6c2I zT_0zCXru#@9jBX_Q6k<#y~@^yeaLc8I&jhfI#3Hp(m?-3E6s8gE>>-^`-)w@uLkA# z?UVpQSeX+1xfk9PBMXMrApE8(6*GAvH2PSy>#Dv{JE+Gg_$e{?I>U<1WXgzhvE%8O zj*OnvIJf#8h@0)^^(E)oF@@KZ!nFR>RciIgaK}6}!#cODxIls|_2i}?# zuFZz&bYFd{%7;oxCMsBsHJ^P^%_x%YJRU1uQ{HL~cPx8AeS6E=3?ofY8FO8?#NEil zq~=WKjOK03m=P%cEBCHjV890}Pqt9O!GD7%sa?JfKW?^xKTy=me%oLk$YefYC5VQvMpS6Etuze9Y5-=u za5y6Bx>Th?>Gx<>v*x+(5-CWeT}JP5=Xzxf16F23B|am~ODU_u%-OEj0OHs+z>N}dVEr244At>y77?r5}(JI1we$GH<+FaA$*SuK8Td#;-5vBiU$(H`Kq z_KX~`f$!rpu#}c<_RxBgxqu+|17M%Xx&gAsD%tlz7L;&qGT&zjINusO*wL9R((UmW zJenk!SstSsl!&$?X9hA7&`E(er7}4+oStoSj`Rt5W=nRFDIe7ZQ-s_%5K~SyIFRn~ zMt3-rY&0c=-juOUu&^@;|82SvkX%5+1W&_tr@JEvf>u<9g>&xvZ^BE7j9Eykct(Bsn`zMiMMF6 z4|HMLi9$j5@71hSFWr2*&_|4ph1?GKrj9{)S^#I|~WKu<2h zkpFb-nfat!nio|iq)R1#nnf}Q)N5vAF|?G$L7 z(j(ZDvmV*a?Ud|6BwO`Nf0^i8C6{}s7iuE*-nC~4aL#{S-Np8be5B!?M-~?8H3tF(QQ(cSGc%NbzmR@25`4 z)?Z9$Z}#DhY*pEcC)sZh+oom`=7bP56fl1w>CR(L5QXGoP-w&y}jb#k%-=HSgSxK@;0V2{HTm9Bup_yznrr66`-LxoKBSjkRO-goI0 zc{!3Y)j`NEe_O_Bs(Mo*ulC&sh?Dm@XF%j|uIsfr~RCI?`; zHcWs(oHUp}(|9_sz||1EYB9#1V(Wh^{6euw<0Cu9&}-A_)~K5QnNgp%IJii zjK6THYH2>@uYpbt8LuX-o3()q1VerJ5GcD+FCIh*P{w^2tXP=qp) zuL_<+n@ugmC_2~z%DcRAi z2-fJ!vf#_lCkySr7qS)GKslD0Rya&WISA4qLgMc5{*?l}0Gkyf@;K1GW@3;(GL)i& zc-ql%e(3zrx%FphTL%(93}#%sKKUUoY}L*eL2wXv$j-)$q3P?X8=coq%Z5 zUhZ1xy0nulWukTW%n1KLMuyqHX!hR~9SUEO;e9FIhtLnmYML{ATZ(VHF>;6B0domg z6FA}ez0`A10zRRyx%6R%G;hVpDa{ilct@C|Lq9>ocqKLluB&16IZbht%Pm>O* zzE=@z;%y|`@orbdro?l}mOgnC$mhmHUvf*2{1iI);v*!X@b6MYZGHOXh5<#a!ZHZZ z|0trizM5LeR$ML2KfCN?N}aKtirBss=*R>@sX*vu;1v14rR$8CW(u&MEhf%vK8S+o-djbqv_foJOdGN)@6dtKbEs(chqgXB}a++{y*hn@&F!fP_{h8qYRB-?8;2@%T%1w8JgI~E4 z*2K(w-$#wHLurd|5j#Y1aFrUdD{FEhO``)fO>A6~-H;+jw;Zq$^J63C=fwgXA|9>s z*l!;_IK<*7eDvTTi#M2}Bmb?Y;-M1md#iQGqW{t49x4|X{f;5GYl29YzfR}=%=yea zou*@#R?w6!)}|qwrnpP~v3(;sJc4eU93DGHMHO*ph~u?vP^0Iw>aw;C>hp*+J&9aT z@`$u;==#KpFI&E$_tf-Z&~cGzt$#TNB@BXK7{~@pQ*k3(7mMV`jks8dC)K%@GMjab z!*x=^ofeR5Yc>D6L8aqgw_lL@Gxu(YSw0bg^q8XPawj3{Z5kJmUH28t$^R#jvYf4i z#1ywLXby2$zQ@jk(g=kSS5A!|rot$EbYwEGX%B-d(T3eD?kzb!0;-V8(y3t-4v2jV zPa*v@5}{hEhN@A#GCVduab)8gV9g}W<0R`ng27rMo`a~%b#eVaDybZcqNkCVe(jv8 zAThI25dki#i^Z1TzF@ zsQ`PMAVhG6=H?G#w?PfOTavIT^3<({fG$o*L4t0Ay#xmdULbghAWSepAQ8+Gyh(75 z;4^}c2|g#dMeq~Bx<#P$Cq1QvJT1W^SILqHd_y@)C26igr9w+P@zcncd>OU_&Wi{i z4@rY)MOS8OGjO?(W!V)@$8xH`u-;!8;b*2;`!BuEIPNp{CEhk?R7!+7lOj~k6|Zt; zS3#0-tkxDe@n~PQ6p00MJYw>6@LQ@^I7c1^dRT*K01Y$_5(Ej7;?X=MN<4HQqhp36N<1V{R7-;PpoBm`i^L8HV7nV5 z30`~X?8c#XHxXx#43iyuxwc&9WT$GCD!WQ{T(MkUSIw^!s3rw$i<_0>q{>NEs>qCF zrN)2qeXr5o01s&$r&)ac@cMh-yT12b?|XZ^9v21ASH`~nwI6g-)ZgL{{jq5o%jf^o zLQyjmPs!8`inokdhAZTX7R*3>j*RKl%1pwJ>nW> zWwwR7?rf#5yAJ|xe8zWZ@6z;O@yB>$X{naKVd-fwOJ(0b5u3FPTjgGgZ=1HrRW(#A z#oK}uZ@=z8Xw}-2t9b{MFhMF&DF=8bXk6iXWTcD@FF*A{>8;Dhk1j?{1D>mlDj@=g2>$TyOFGv5UH zW|D8=TOiMoJa@g7Z$0`Yii&wDs*$?h1~bpKQu_SrYcOTuE83~>!`3i9og_#PLDMg>Xg z>$a$DB$-Uf5jmbpN@MVw9*@XV@U{*l??%l9q^KetSU$&PouRH%vIQuv;zqk{){&jdc9)AcGwr*N3EiCn*mch_5(;ordSQC2Yx5WUOI> zmeZDr;y2(aI29Y7Rw`uC={=3p0Dt<Ff>we;F?WT3;8>L__(!+id(vEszv<5mXUAu9);Ou z1fbPeJUKa*-SrkHr_#L%0qBAoy?k+udq0xMz^==gZ zZ>C$^o`i1y8L2!0srHN;l&F_bAWv{Z5*o%?hljWJXc>}@7o~1V5zv-SS-4@z7|(WB zsP=d=2K+>I3rQ&>3gL(pjmK4sORR^=u+k_sRa-1Got9KPp(~-=LMDfdze`*0Ks1s} zCF9XZf~eyTi*X`K6M1GmQ z16cAHy}JcJXQ(%?+Ey#GQG$*e{G-?kymXj$>J!Tth%d)fM4C#(Z>n}_Dzg93VbvuH zu;IwOtIjFmj>h;uv5>7=x>W3~ILIfhmUswIlYt|(!wRwf`=`ErYQE#g{r|RKY1pH% zJ$d%<5_?!-kLKv3=J@s1F{rkK)Zcz}cpGo;N6G6TE2KJr=ES%lWdn)0B!9JBN?ccc zqL5BWaXBU44U4IiY%ZqQ3oX5IF^>R{r1j|)#af!zF)4Uj*R1$Hc$B=K+n9A5{MLq5 zy3L$WoeE(QRtwLYLWI6nT@K%42nG;AuOW!E zEmSd%{oU|P5S1JY$K4w~!B0>~D<)9vk|$)a23<($tfGb58oOCzJBT;7Z!KxxrnmQN zw{O&Fq0apoMLDTv>?tzt4UfJysPvJ&Kp0!L;?xNIU+Q*>d!d5350l-P?1x0PXVS5V zEWqZH#Y|L2#U}cmYE1}95qC?sT|@#Cj}lmIr>Qoi=({Q-3JK8W-WOCyG?kQ5Rl`lv z1(H#hje%PtsEe_36-|5>pa|LiK4fO77k0{9bN|M-Zz!IonX}KT>Sk?)>bm*bAD+xt z?_8?hx#&=;_s%kf>bAwhe|UYRdVk)3YRP{}@xL?cC@|jpo_n4j-1_Lf@4dIs@u_uj z_@^GF_V6-ur1)uWYME)-3^w#rw^Dm(nK`V3O+ICs*FBWKe$7j{{dsoB61ziTn{ss1 zW?n!;zyGnETBW755ETPZRb$okSSl&JaeJQuctgtW0b_EV!gSudM&64DwclnR0iHYt zzxwweA-C5Kb#eqfuqa{+Y zb;8)RrY;H0;}eRy4Xj8!Q_`}{+)Nu=o~+!^QbmXcJ<_`0s*eHmNZXb=u(9dW_H7`H zO_p|)^u|76FqDnGi3Le-%sF#x54%mz?PWc$7&n-dKKHN^c71HXe5_kSI82ChKh@a7 zguxs_hK_BPO`wuT9`mb?&VI$R6>lna*uPgS> zd+mR1+q;^OcXRJb+vWqMO3wE46eD~pWc8zOG`WXb#U9WnI&LeQ6BtUK4qq~hb z6d>_iV0xf;hy%5lOQv*BQxVu(R`;t}|8;cefJezRe^pvcB?O`%Wb3YT36S>^IC(@c zqB;E1kFJeuODvO4U{mM=(tKG)KM?A*00cv;D11E=M<-ZWMTtvI$7NZFy~U|6qDZ7u z@uZyHW#+NVMIi2$n3~pmpp8*&oQ^;R_y@&8xFbX}I2}b5L&_e0-B;5Y0CSS;6{gej zT`nSuk-OPWvmR$))xBe8mm4MpklHXUWo=JI#2Bp9_TS8g!RJQW>oI^iuu#O#am&Qpz@LRS$lL%~;1Q`_6lnAq~digV#u8#0$2E+Wt^Jgx1`@}(naTKXkwIOv% zstsunUTE{*QR%oWOpC*ap7?V-({Ty>J(FN@A+XC_du#`twW`xtAJs+{2>c?r1}cqy zP6>rIQFKw+)gH}1-~ks=998Nt(f48iM|8LZs5;;h^7`*j-J6>GK=JOJ8CnI$&*aB) zp6z(TcKmDzTtB(S5yd;2V@3tr&b-V*MAQ*e0=KD(+_Pw9bMURSP2}Nx$rAT05LSb{n+#9gIwc9 z#XFv3#tRPiU*7rcJ9BQu(X?=N*|D3na#ryU<(Q#DRn13rAJ*j>jw)5hW=3&BzxJRb z&+dG}?)+JnKweS2S98qOXa2@ndx5Qb$~MDrb8SPP*&p9A2D@&fs+-pA6rf{1WODU~ zl*+?1BZw~kAdqLfp0Hg6S#foqRW*Q-!d5Tu4cF5-ZOIsk(GM+a*d}I?_iD@d{%i0R*LmKWg7{y6OXPuI-BE8EB?Wpdk~OS z@fNU=+_iH;uCaHew(pPWJbUN~d+5>C-03U%lUJ8dUL~CyQoO@CW_aC7oeEh@i=e0_ zQHDj(0W^sg!FG=B4IT`#!8F4K%|O#Zk!4_GqQ_fzc5m-2l%S&FrSMp4*C|K}uDUfV zzW4N#_j8+P-3GrmdnwSoAO_bQ34P_jliw{rrQM&35h6tEK+7q%) z;B=5j|Gq&)8%9g1NfWYyD)G-j4WmnN(Qi~sOk9RS4oZ_{+@trwe4G9TXlVpmvVqC6 zg=wH$`$n%dg%FMfxAqPI7DJsbY0dD1M^N&|~ouCMa7(9ur($ zO_b1BO?AX2qCTkBNGztZy6Yk=r&J~)h0z6f2b>*)SdBP4T(P(|0+2a2G6vNFG6kem zQgbw73#Gn}dc8uaQbH61F%6((2P{B_I6N9#espMNv;b~m!Xb`4@+|d-%ex|+>qiQ&bfyRf%bf0*HU2DV(@8T-|Qf={cqg+#{J*=?r#+; z8$R-W=$)7IE&WR^{SSRg%RBj&k)@UqrRChy%JZMwsG9xj4k}Q;<^~p%qig=(8Ak+UCyKx@N@9&^5cYvosBshA)!<=A!rStM;hXrO0}?!8=(pI{F@dqIS@GSq zo4lXfs@HAsdo$B$f|`VBd4{#w>&=oPYGSBn%pcko4lG$sxO0xyr1y@|3oxC)PHN{zO1kbh6z zjw@9sz*_JI=E5sAM-}g}nW0}fs!)k;KKI$^XD4!vUsAkZ&M{y9mBUL)Pd^@de9SnI zf8NnGGgPRA+WE@PTxBPy@72M1`wvf$Q;L=9UU>V0d0)$tuO;tmed22+iv7UjU5^`b z++ILKF(#&O7>P;53YO;!UU&YE!C5rxv1OsNRSK=lZxS$?q&X4vGi&4UU|%{Q6qQ zp8#rUFX`ATs@CFP$AoAd@P1w$T(iL&th*X+&4D?FvIo|kkkd2}?3w-;WxUk9xOPzIxh)V=h>;K>D_>E@rAxF6^Ms|}iU+0wj0F7QMz2htf7)*979o4c z3g$?OZ(Sck2%^YJ+d4>VU!X5=+QQRa@H1qC)v>8wV>uw+DLQpU{04keeMTv;3_QN~ znaf1rKgX!x!+Vg zoik@w>4y2E%XH6krf$9iw!(bfLjOwr{sL3~@$rSK=6a;Pa^qJ>>1M?o zi4p#7pKIIyT4l+xlg=W5ymUpn7-nhB4)X%WZ-FcOZi!Es5C|tvMP%L8El&xcQNWsW zKp&ArGy})fpfyA?5OfI=_ikVId{KkY$qZ|fIL98SQuHMDl*B>yU?3zOa)Z}d;!K&x zfuk=1VVYX7ScNv9IF%B3`+%;9OHlj{bb+S?5GFXQgD9-&CI>j=qK5)p;Tee}GWri%}ys(69k&TeY zj6K^HpJ5S%tXpC*&V0AUU|2MviY+meoU8IqpaNHRz}PyR!TWG`0Ih3VCzcYlbE2Ez zF^3|32kGR}r+VWU6O0kL+UY~jCPdm%QaM;L=90*QZ2zVz#-563`%hQxi;8b;Q4iL8 zQ4HqF?t3#Ly$V-E<=cQNyLS@~;@Br+zb&TVG;9NtfCG;bFB3VdKm{8j49WKTA>_q> zg9+J1^N=I4#~@w0v`|s;yZ99ovT?A&31pcTiD6PK7MRZE0D@Bp2u+Z>?kS(RgqHNXP!3aEUiXCF)jr z8u^Lg<1w%m^(#GEI*l$`V`rB@85{xJ&Rd40@g*){(AaE8io9vN5Hj9wx{x=(Z`}if z17P^wRzY#E>A}|U%(gw)8s1p~@6u-s#;Vyu z8S%IFLv>>wY7%(j9aUZA6BbIKP1}orE)#*c0PTyv4+#X5O{H!V_CkzkP0#oQKVw2R z(R0W^oU5lM@9B8r=}sp4QG9!6 zh6}ViPuDNe_4B(v4LqWAbp0}Y(k$Hl>A^=Gr10&6Cz$uNEqU4&jw+rWKu^2!ba06d z&NC0>hp`+TT&9nkg>J1T6uxa1dOjT_aQg~uO`heJSZ<+NVfW4q7HB3<*DTRBb5jql zJOrScW%?K>z@V8f$$ZZZ<<5qrvHIKF4sQkVH z@RIoH6BsdlVjga5z-s}NUU-=-6ky3?u+a1Hb31)T=TAF}m9$GJA*!7+Z)t?6Qcr6; zCH4a_5H$-Y9J;4Pb)Fu$d@)ff9PoYbt_O?E+X=+EQElh27<3%?+fcsP9C|@=_JVkDX9p7MA zQ{!muZ+Hw`C?^cRya_a68~~Pt2pc-BUR!_TeZY2IfH9e=}1KB~1 zBkgZ^gxXD5wt&*HTmX**Xx}wD5;J~pyiPAO->p=MH@O-PJByML?iIOsT9=bL?$?gk zMn()re&F9QTQ^P%Oiu`JFY{m&$yUP+^q_Axig)VmPFXl=0;!oi6L_qs z=KFxvPQ`X(f6_LyN4(<-Ifa>M(;>$@^ql$T8B>NfLCAXA_O|T?C{$W5Zi!RH`%kPX z1;$X`IWaCK{GMK&>g=O~mWHQJLi+Dkmkr#o-l0^rNe6CJFZ{ zqEnHZ2?5YrdQ{6>-2oy_2!GIyMt>L3s`jG9WN(8tEtK4V(HuEM5k{35f^bk&l8ZHB zH+BepDO%KzD4D!|ZjbCi0PX$*=Ac<_Iq=70j}Iybhn1F*W%uYWssj+d zL24acX4_YTyA}gKYx<-~2_BgpE}R_riyMD>)q;I+ISnhgcc4XCE zg}1?6-*c@7+7|{Njwpdsh32+GOZN*0UFCma1*h)1mkQMA*iS99-B9TVeG37_-?i|; zivP&6`zSQOW~1D@U$`l@e!fX@?aa|T|IZ5tV%2W9Zhj%0}a1 zyzY7{k-Dw2i8ve=5K~f8-EcxIL}a{DDkM~2T7=89lNcdJzN`KiUg}Gw(fEWII5C}( zRKIb+Vw}^cH5l!MabpN4;9Wi33~Ei$^wU(fFvJTczzd|->LwzI)G`7q)jA>=weyIw zkV~}=FX)7~_@c?+cF~O!0as&hW#CFEUhYKEC_cbsFDA%RM35Ym_!trrP=HsPH2u#G zS}DY&k(+opx#ac|T%Rq-zXJ;}S6Zoof4A%J+=&KBL%Yl;;`c`XyEOORDy7+?8{6 z-xoGw5(H8PGM>j#9LHHoI)C Y|Ai~?;g#=)6jx)8ZUj4-)*N;J7i88lCjbBd literal 0 HcmV?d00001 diff --git a/tools/__pycache__/ravel_source_digest.cpython-314.pyc b/tools/__pycache__/ravel_source_digest.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..186851d54b824d7042d8e1c46ba65b70f9d384e6 GIT binary patch literal 13943 zcmbt5TW}lKb-Ta(P(mSKMZyLFcz0<@ z%){*T5z0v;+DXPtqclw8PUKqCXr}p4X41x)BvXHaTGBw)^u(F8GwmN$OL51Y>GYht z*j*3;rL?&m-o1PG?AdegJ@>rs!4|*ILqU0Qv;SNmZ4THKmQiYl%L{RvL* z40VB0XjpmM#b(7W&KM&;s`%Z*l9Z9AcL=eh45VF|5Yv3DoHjlw^T~8P zGnq|^iU{N2WhIsp``)2Ox}6#ujizIhVl=9GqS47rVk(7gZ#4SKR4i3|5{O1GCnZ@) zCDUR$1CL$NXd)AbMr||-$dqI}8dDT0d1*=!{l|Gl-w`HUKLYOeP*MH;lt|3+?z18-Qs{ z7M4T;5K41OqB13=Kl3M&apm)}BK7dFP8Z0KV9}hHGty*Ck@0iwQUKq8xhk$O%$!sQ zT|E5D`XYWxIq2&9Sj`Qs;${9Kxg*pQ!U2{PoHIiBze58FA2o)gKPR;SQb4fnLZYGU zrK9weZOR@s`8Z3D6`#Sr#;GVPZB&Fdcs+~L0Ds0_4O3%C11T@q##p1hy@+vBv11%Y z-As*f#`6f}r3B^~n}K(Nj=Lhek`EIi{4$ zy#p}2tO$IXNT$a}rZ?~5l}xrbB?3?I!)H&A@UO;FQ?TQvWQD&Z!p`I~mym~mhnY-P zOl!Nejlq>94AgCxfmVmaQkjFUT>V+wopIYn0I$Cxw~&gR;og8x!-ipcd1ovvyM;gl;^2` z_~yDnmPHY8z2G6XEM&?&HBMM$Isii z!KdAS3^PmBfJnHaan_*-_8z@K>d~U+E9nB>GB^u2 zEE(gGZky&zrV}7bG_RPJrz9~NljF&xMth`2co|k2rG@55OigBG%}Mx5?54@&knwlv z%N>fx(wTHJ9!rrmkLr`P1>PkS(g}?jYQ_CA;Ah8MZv z_jjq>*&K7$nipf&;tG&?;R%i>2_k*%kUfbU($~%o^5=;whx2Dj8=BsY3$=SLf$O$= zUM6=IbpT6>N!?|*ouQt*YL!-|Tzih1@}u|_xEL@SsdwlRP+hKxm^_h6UecWMMC_Rz zJ2j6a!iFRBuDK_~tGeKShbCLKbg8(@NzhIDThb0dO$LtK4lBe3Zyb32zS4o;)mbS)}k5UNO40=IO-mZ;>l}f%zT!PP*v2Cf1;?YEn*X>QtPeK zstT5du#e&HCZ+t%9#j5$IL#P8cnzHdsPKluCR8)53i&nU`GwIZb`kjsiOPiWT>mM8LS+IHYL z{GaLeNXRSF(^x$PmF7M)c=m8qIDPt@^bFoRr?QEdBEoi3q^Y=qrcC^0&7Km|(l&Sw z0&^Du)3=r8Ko-8Hv67eqv+Y$;bHy`h1#L2vyr2aQJs7$yfmxVXYmQ0J0T5x{zl8>D zJ74I=#n&&YzLuFIA67TaItn!n^L5|apRd`pShMMtORd>D%dXTk&rdBxzWb%+nx1@c zU@;bU(in^2n9vfo}GzPC4R#*ad zX){0=_v5ew!HzR!wzcmk=su7Y@NXY8ceZ6Wf-HH5qOO2;mkyVF*)c}^S^RqWm&dEh zzGRCqU^CjEG50mtjE;)-uDOr0&UGLh<~+DcsBv2RyPTRtJ)y>$GuQgC>rn1oL%D4f z{eZF(aT;`i1hQ9za9I#1-qmG9iOezWX{&F{lphiEsexnQ3OG6CD{6jWg0`?&veD`* z!ECO{V==SFQ^1TiB`IU*{OGL;l=hhX0UT1?k6AXt8vK~h{R)d8-4WJHt??@=`$QfC zTg1K_@IEpNobepEtTF~O7Ls+B@Q{1`z4XZ5@s)hT4LbyQEbBS{1EgmhIIWpF0Xnc` zulXaMwPQmKAp}4RRB66qr~#br6c`&@j35J#VkmhTj8%*!@L)*s>5LJVC<6P}y!-j- z;01L5A^u=FOd2C)QX(^`DixjxkA!U7PMPfqC-!V?MfvAL;gL_Hj{>&`AO}6D&aD zRBCQ94N(oGM+(CuVgYK-SQdQJgtQ-l?XswVg3d@lvgQ{KpLzbcaCium_{qa(yE$nH zVO+&o)*LvyvgW`!gbR8(S2ZT7h?CMWL{B_e-(*q-4|hDO1G~+EXbycM(BdN695uS3 z(|zFYCed1m5{336zz`+%UEosiZ~eg=6W1r^UQ_*>W{$3a7dw7a$#Wg|xQ-tk1wS^| zd|dSp=h)#wedEkwQmxeU3-uq=cVFjb9V>yx`Hr`le4z7QpmQY{Ug*11d&iaAbv(xp ztHBdF?}e=K~%00v)%9?2!`CRfA`8 z-ZKT(cf)(#J9lo0Z8F;*uub=?sfMQ>1SyuA-SKDB-#mM>X8!r_G<_qw%sSYcVEjjpH}^&Id-(*;=XeA zPp{5-RaeWx^GmL$$XAZ2{-ZheXaPb4>>F&Zafe#9bLKcsX!7k)p6j~Db(K!%ht*AB zIB``Ua4j&{T>HrTQ}2)G_=p-jpYxvo#6bl&ST;gYZc?b_L9YCvVJ_XfL`JjBm}wT+ z5+htjaBKbG0J?{!i^>T67YKWe8Kj#oAvz|brW!83 z1s8$pGfjxBZOjY_L~NEjQm)jC0@*ZIN{yL_4FvM*Adu}Pxa^NHS9CRM;WCviC_Bq- zsigExiUJl9Sztx2)9saj zB1$@e6-rm>Bvxn!>+bY!XlV?-tGSXg(E^%1mPlxv;l@OjjK;>~Xf`7!uY%7*M5@Oa z07zX28G_~lsS0vBtp^v%T%JY){t>kzVU&byf}79)zh^`1cXrGS7a%Tl?E0}>?asS4 z)w_4*Fz)fv&|j{3MD?G}v8O+*X_$4PjNA0~wtQgIy}%~i>ikhPcr52Vwi0T2YvhfQ zg*W}|5VN+#1DuwW#x@KX5Fw^b zX?ZcFzRme(D%z%u<^7!BSP{YzVT>(Yv|dr~k|NOP9qYo{B967N;CneEG{iux7HQn$tLXM&N2HDw-|1pc@CcmX zg<1Blp#?8XaE>NPz<=n1aru}7Rj%~*>uf|6MY^-=vC z2;y347@kh|PNl`GunECrR7V>HZ6o73saB=OtD>>gct(Pw)k(7l zUXP0ji1=&1HAjWo25ZJ15#Zeca+)Kd$*U_Hl<3kZRz%OBijksNVN^{T!3u5nlJFab z(?|deO!f(E4?(2`jEOILAX>GdMKE|qoD$7rQ3iIt?){LkoD@Mk&mtZ+c1g~p;QUk? zgj;ed^oafLzl4XbEnEI7Eu*q}by~|De z)VlpMr&k)DzSE&L>;grxQeB^G=w5Evt5)xu8D8;+=Az5B1FC=b%+cSts)?<8;{Ds!p)$YwG8n-`c0g{jM(8 zY?@^Yf%<$Pych`Q18w&LZN$nQd~fr6O*#Ig8a$Qro+<>J^1;reK zw+DiP)m^JR<*v>Jdkbu6E-}Avxo&fT?N~_Uwj5pVI#ytt=7$RGhWT^3_8rSD5K?Sk z7|L}YTJC^ec$90~w%ojZO|yQ!zQEQmHTK>bR~zAl&IM_;-s^R)QeKDCQf-C`V_}Vm zYQys+4CbwK9&HmC!67&WS3d(nfYl9l!e(e8Yd&MqiBi`5F&PfMa1W9DX>Jr$HUCAP z1ST=|@`owwZvmu?@mxHIXr_bru>$*J)ehH>YwA}Wa9wp$wfw3JTP)=a-FHJvA16{~ z6my);^;NjNB)DQ7GBD>4l?1O$buO5y-#D|6z+v?oVaile?EUtvBVrT(xh%+M+VG%Q zos|wO1XD$1T_uOxj|&d!eu71@8S;ZbldIx4O#h&KEEQ*QJu#hjLuVF`RO*UqsEmy1r=N_-c!e*b3Y4Lm-ueg*Ov#aX zWkTeyNEwLOl})e~FyGK82}B9130?gWRks6gEnf>`RvLq70h9=wX$1HJcC&^F0`aW4 z0trEw9wSes6wPgZMtTh(W!(NwHoTY@Ru` z;;WnclIrW6IZ|->mRyaXXbRpJKe5{ao>j``_JH7VgC+yHJKwO-zufptfo;6Gci~Iw zh8?RerqwxfWYt5lb@yCt;7ZM>)ll!OyU^JFy_RpclcmC_xRL&3VrjIyTQba{+#lZ7Xoq zGp8O^86ZG)mC+21^;AYbjZV9+CQ#r{2V>HBHYUkp-w3h@90NZ2i0a4iq8uV$`IPd~ z;rm$SLS5vl69x~>g6u2g%BdcPn~}w2CR0ip?_iv#G?@vaL3E`A0!UCQ z>QX$ut|(O*E0zNo9lMHp2@YN=!#mf7uS|g{hqHD#$}!_YB_mm%g39phx)fA~cbC9> zjPx&ZwC%E}Fj|5skxBgN|3)u0>ND_IS7RlC<-B-eJPCp;aSoDjm;@y0;c2oS>DO2z z5Iybe?Zp@Z!YJ3WqV!jQZJO=v1>Yq*1<`O_I!t?dP3K{n>+LnA3WOMLz#E@=vv4k< z^y>1l+XZHFk;^szpfpah2}hCXB`}E+U~o@eB6~oRH4onFH<}mQ@Fs!R^ZY#I5q8Ru zgyt*)dMpIe*Wvrp98?-3Ph_r;19B^vF1>}1u_Bx3V`$)ccx~R-anIMG`no`tRoCaM zyB4dvZXJJ*$yIl$)rTQw6ljDX_hO)9;YBsDb>>)s@#dMvMW%6n^X<@GCdV``G5f8~ zr*3b*+d(=H7JT)2U;Co3ePKZL^#FRtlV|D|nfiJ5ZRJiP$J8$|d#z5d{w8!Dv^ssa zhX~x$1+F&F@rxY4&s$F7sgM7+!&5K;K%C+X0)<-23 z1EVGafhWUX-?$~omQ1A_rzakx{{m2(0VSH=hY3yl<{_C9E(_<#okbYHl46Qbj3lB6 zt#r6-aJ3Nz(Q`y2)JDomqKr_b0hNuE)DH-OsX2&4njRZ*9uZq7Z0%1r82F&dA_ zx|J^d4S^5%UkwB%Nms7N|=NCzvuDqhC?09MvO^vc*;zA8!hTtrqF;k|E1&m%R6llC{TrpXGBl1ios%S!0@)4@4 z47}FWzz14`8pUI~vLZs*6B00BCiPMo%D{385`VLd6(oC7U~CNY%Sbt26Jd-bUr6}% z2#ld24cw0%v4e~l;_^T%hJ8t?G>?L_)H_>?8~DN4W|UCkhw#)GacnaysIxLC=*EteI9cwp0M>~v`bro1kd$vH5S=MpTaS==@y_KYsR53A` zv*iB>YC1O_-$q{+uYqQfMNk(pB_qkw8-SX)A=51+B35pX^CD*G@8L1;A7gA9H}I1my#XDoJ03mgX$#O703oz{HZ&RASLRKUqNUG(Uc_Z zRq94WXm9H$)UMNK$qxmz047oofe(}r^$xoXKxT80e&I$!^ZD7 zs(~#KE8+q-_FdmMzh{Z-T&e9^P=5G@?|(t9-8Orq0Et}Q)I-dV46}F|gP%kmGhg zplmQ$)|ad5y(Qi{pY!kd>7kzu|73WXJ^E3g>c3YV@c1*i6DI0wgRMhh>gPR!yWsMR z&K{_L8Ridfw*T^A>*0;|Uu|?i8-J#OQyYyQK;a9g{Bg*6*I0B-C2-B8i87--V@6NEY?{R33wKn~M^ zi$A^qQxUQnNcK7onPmLJ&rOP|6rm-|Rg{RvJ%b3m!c#dq=`07aB+rH>+SG^s1Z_lE) z=hm5JZ~u(@KW(0%ZN~qgiKd^W=T1HVqvl!qAq&3~d02%>_zzh~;(o|NR`A0HOdfpr zEDcBQ51ZjI?b8Sifw+eUz+-#Z3bxQg7F71?0L6G`rS@j~&G+pT I(?o{yzd_{tB>(^b literal 0 HcmV?d00001