Record sealed ECP-7 learning rate decay batch (#15)

Add the learning-rate schedule, preregister and record sealed Batch 14, and update the evidence-backed fresh-agent handoff. The confirmatory ECP-7 test remains sealed.

Author: FatosLocos

README.md

@@ -26,16 +26,16 @@ The protocol uses no words or alphabet, but four meaning-free local symbols. For
 See [`docs/results-ecp6.md`](docs/results-ecp6.md) for the conclusion, [`docs/protocol-specification-ecp6.md`](docs/protocol-specification-ecp6.md) for the wire format and [`evidence/ecp6/report.md`](evidence/ecp6/report.md) for the compact confirmatory evidence.
 
 ECP-7 development now tests how much of that result depends on the explicit
-one-factor-per-slot architecture. Its first thirteen sealed batches are valid
+one-factor-per-slot architecture. Its first fourteen sealed batches are valid
 development results but none passes the full gate. Batch 10 remains strongest,
 extending the position-aware design to 15,000 optimization steps. It reaches
 82.08% train exactness, 72.98% validation and 75.15% translator validation while
 using 12,358–12,906 hard messages per sender. The translator threshold now passes,
 but the registered train, validation and injectivity thresholds do not. Batch
 11's utilization-weight decay regressed all principal measures, and Batch 12's
 deeper decoder regressed further. Batch 13's deeper sender collapsed almost
-completely. The ECP-6 positive controls remain perfect and the ECP-7
-confirmatory test remains sealed. See
+completely, and Batch 14's late learning-rate decay also regressed. The ECP-6
+positive controls remain perfect and the ECP-7 confirmatory test remains sealed. See
 [`docs/development-log-ecp7.md`](docs/development-log-ecp7.md).
 
 ## Build on this work
@@ -89,6 +89,7 @@ Do not translate those artifacts in place. New experiment configurations and all
 - [`config/ecp7-b11-development.yaml`](config/ecp7-b11-development.yaml) — late utilization-weight decay on the Batch 10 base.
 - [`config/ecp7-b12-development.yaml`](config/ecp7-b12-development.yaml) — one additional generic shared decoder layer on the Batch 10 base.
 - [`config/ecp7-b13-development.yaml`](config/ecp7-b13-development.yaml) — one additional generic shared sender layer on the Batch 10 base.
+- [`config/ecp7-b14-development.yaml`](config/ecp7-b14-development.yaml) — late learning-rate decay on the Batch 10 base.
 - [`config/ecp7-positive-control-development.yaml`](config/ecp7-positive-control-development.yaml) — ECP-6 positive control on the ECP-7 split.
 - [`config/ecp0.yaml`](config/ecp0.yaml) — machine-readable configuration from step 1.
 - [`config/ecp1.yaml`](config/ecp1.yaml) — frozen configuration of the population trial.

config/ecp7-b14-development.yaml

@@ -0,0 +1,16 @@
+extends: ecp7-b10-development.yaml
+
+experiment:
+  title: ECP-7 extended optimization with late learning-rate decay
+  arm: extended_optimization_learning_rate_decay
+  objective: >-
+    Test whether reducing optimizer step size after the original 5,000-step
+    horizon stabilizes refinement of the strongest weak-structure protocol
+    without changing its architecture, losses, or temperature schedule.
+
+training:
+  learning_rate_decay:
+    enabled: true
+    start_step: 5000
+    end_step: 15000
+    final_learning_rate: 0.0001

docs/AI_AGENT_START.md

@@ -41,7 +41,7 @@ python3.12 -m venv .venv
 .venv/bin/ecp6 --config config/ecp6.yaml validate
 ```
 
-Expected baseline: 85 passing tests and split sizes `14336/1024/1024`.
+Expected baseline: 88 passing tests and split sizes `14336/1024/1024`.
 
 ## 4. Reproduce ECP-6
 
@@ -71,7 +71,7 @@ This reruns a known experiment. It must not be presented as a new independent co
 
 ## 5. Continue ECP-7 scientifically
 
-Do not modify ECP-0 through ECP-6 or the completed ECP-7 Batch 1 through Batch 13
+Do not modify ECP-0 through ECP-6 or the completed ECP-7 Batch 1 through Batch 14
 configs. ECP7-B1-I collapsed to 130–139 hard messages. ECP7-B2-I improved its
 soft objective but collapsed further to 85–104 hard messages. ECP7-B3-I applied
 that loss to straight-through hard messages and improved to 585–972 messages,
@@ -99,12 +99,14 @@ the strongest base. ECP7-B12-I added one shared decoder layer and regressed
 further to 71.53% train, 47.98% validation and 63.04% translator validation.
 ECP7-B13-I added the symmetric sender layer and collapsed to 1.32% train, 0.32%
 validation and 0.61% translator validation. The confirmatory ECP-7 test is still
-sealed.
+sealed. ECP7-B14-I decayed late learning rate and regressed to 79.13% train,
+65.49% validation and 71.02% translator validation. B10 remains the strongest
+base.
 
 Continue with this sequence:
 
 1. Read `docs/research-design-ecp7.md` and `docs/development-log-ecp7.md`.
-2. Define exactly one ECP7-B14 intervention and its failure criterion.
+2. Define exactly one ECP7-B15 intervention and its failure criterion.
 3. Register the variant and immutable configuration hashes before training.
 4. Add tests for every new invariant.
 5. Use only `smoke` and `develop`; keep the ECP-7 test split sealed.
@@ -119,21 +121,23 @@ Continue with this sequence:
 
 Batch 10 is the strongest weak-structure result. Batch 11 ruled out reduced late
 utilization pressure, while Batches 12 and 13 ruled out extra generic decoder
-and sender depth. B10 improved late but fluctuated around its validation plateau
-at the unchanged learning rate `0.001`. The most informative next step is one
-optimization-stability schedule. A clean ECP7-B14 progression is:
+and sender depth. Batch 14 showed that reducing late learning rate is also
+harmful, while B10 selected its final 15,000-step checkpoint. The most
+informative next step is one final duration-only extension. A clean ECP7-B15
+progression is:
 
 - keep the same world and bit budget;
 - return to the complete B10 training and loss schedule;
-- keep learning rate `0.001` through step 5,000;
-- decay only that rate linearly to `0.0001` at step 15,000;
+- keep constant learning rate `0.001` and the temperature endpoint `0.8`;
+- extend only maximum population steps to 30,000, minimum selection to 15,000
+  and patience to 5,000;
 - measure injectivity, validation composition and new-reader induction;
 - rerun the ECP-6 architecture as the frozen positive control.
 
-Do not change architecture, loss weights, optimizer type, data, temperature,
-duration, validation cadence or development thresholds, and do not combine the
-learning-rate schedule with variable-length messages or negotiation. That would
-make its effect uninterpretable.
+Do not change architecture, loss weights, optimizer, data, temperature,
+validation cadence or development thresholds, and do not combine the longer
+horizon with variable-length messages or negotiation. That would make its
+effect uninterpretable.
 
 ## 7. Definition of done for any contribution
 

docs/development-log-ecp7.md

@@ -924,3 +924,71 @@ validation plateau at the unchanged learning rate `0.001`. A future ECP7-B14 may
 keep the complete B10 design and learning rate through step 5,000, then decay
 only that rate linearly to `0.0001` at step 15,000. Temperature, utilization,
 architecture, duration, data, translator and thresholds must remain unchanged.
+
+## Batch 14 preregistration
+
+Date: July 18, 2026<br>
+Seed: `11`<br>
+Maximum population steps: `15,000`<br>
+Temperature schedule steps: `5,000`, then hold at `0.8`<br>
+Learning rate: `0.001` through step `5,000`, then linear to `0.0001` at step `15,000`<br>
+Split-SHA-256: `4947058c75ab07cb43a87eb82776b12cb2a7e2eeba7114de110d3b852cbc64cd`<br>
+Test unsealed: **no**
+
+ECP7-B14-I keeps every Batch 10 model, loss and training setting except the late
+learning-rate schedule. The optimizer rate remains identical through the
+original 5,000-step horizon, then decays tenfold. The unchanged positive control
+is rerun, and no alternative schedule or accompanying intervention is admitted
+into this batch.
+
+## Batch 14 results
+
+Positive-control run: `runs/ecp7-batch14-control-development/20260718T132929Z-ecp7-development`<br>
+Intervention run: `runs/ecp7-batch14-intervention-development/20260718T132929Z-ecp7-development`<br>
+Test unsealed: **no**
+
+| Metric | Positive control | ECP7-B14-I |
+|---|---:|---:|
+| Population train, mean | 100% | 79.1321% |
+| Population train, worst link | 100% | 77.7902% |
+| Population validation, mean | 100% | 65.4907% |
+| Population validation, worst link | 100% | 63.1836% |
+| Universal translator, validation | 100% | 71.0205% |
+| Exact sender-message agreement | 100% | 89.04% |
+| Unique messages per sender | 15,360 | 11,961–12,280 |
+| Collision meanings per sender | 0 | 3,080–3,399 |
+| Message entropy | 13.91 bits | 13.43–13.48 bits |
+| Development gate | pass | **fail** |
+
+The positive control passed every gate at 100%. ECP7-B14-I retained a passing
+translator score, but failed train, validation and injectivity. It does not
+authorize confirmatory access.
+
+Relative to B10, late learning-rate decay reduced train exactness from 82.0836%
+to 79.1321%, validation from 72.9797% to 65.4907%, and translator validation from
+75.1465% to 71.0205%. Sender agreement and code use also fell. Smaller late
+updates therefore did not stabilize the B10 refinement trajectory.
+
+Population validation factor accuracies were
+`[87.10%, 91.46%, 98.44%, 86.36%]`; universal-translator factor accuracies were
+`[87.21%, 98.34%, 98.44%, 85.35%]`.
+
+The selected checkpoint was step 14,800, where learning rate had decayed to
+`0.000118`. Task loss was `0.0868` and utilization loss was `-0.7330`. The final
+step at learning rate `0.0001` was slightly worse on validation.
+
+Both sealed analyses report 65 matching artifact hashes, 16,384 validation-only
+episodes, no confirmatory-test keys, valid local alphabets, and exactly 14
+declared bits for every logged message.
+
+## Batch 14 decision
+
+ECP7-B14-I is rejected. Constant late learning rate is beneficial relative to
+decay, and Batch 10 remains the strongest weak-structure base. The confirmatory
+split remains sealed.
+
+B10 selected its final 15,000-step checkpoint and B14 shows that shrinking late
+updates is harmful. A future ECP7-B15 may therefore keep the exact B10
+architecture, losses, constant learning rate and temperature endpoint, then
+extend only the maximum population horizon to 30,000 steps with minimum
+selection step 15,000 and patience 5,000. No other setting may change.

docs/research-design-ecp7.md

@@ -591,3 +591,38 @@ All existing validity and development gates remain unchanged. Failure is
 recorded without confirmatory test access. No alternative sender depth,
 activation, width, residual connection, decoder, loss, duration, optimizer or
 seed may be tried inside Batch 13.
+
+## Batch 14 preregistration — Late learning-rate decay
+
+Status: **preregistered for sealed development**<br>
+Preregistered: July 18, 2026<br>
+Configuration: `config/ecp7-b14-development.yaml`<br>
+Raw configuration SHA-256: `867e42a0a8c530a4bd1d42be68f2846b66ce368644e993be67f82b39c8caec04`<br>
+Effective configuration SHA-256: `f44a36695c59bd532d7372c6cb3fb5b6eeed06b5bc10f04e96603926f7a9f37e`
+
+Batches 12 and 13 rejected additional generic decoder and sender depth. Batch
+11 rejected reducing late utilization pressure. Batch 10 remains the base: it
+continued to improve late, but its validation score fluctuated around a plateau
+while AdamW retained learning rate `0.001` through step 15,000.
+
+Batch 14 tests one optimization-stability hypothesis: smaller late parameter
+updates can refine the established high-entropy code without changing its
+architecture, temperature or objective balance.
+
+ECP7-B14-I keeps the complete B10 model, losses, optimizer type, data,
+temperature schedule, duration, selection window and translator. Learning rate
+remains exactly `0.001` through step 5,000, then decays linearly to `0.0001` at
+step 15,000. No other AdamW or training setting changes.
+
+This reproduces the full B9 trajectory before the learning-rate schedules
+diverge. Smoke runs are mechanical only and may not authorize tuning.
+
+The batch contains exactly two seed-11 runs:
+
+1. the unchanged ECP-6 positive control;
+2. ECP7-B14-I with late learning-rate decay on the B10 base.
+
+All existing validity and development gates remain unchanged. Failure is
+recorded without confirmatory test access. No alternative final rate, decay
+shape, decay boundary, architecture, loss, duration, optimizer or seed may be
+tried inside Batch 14.

evidence/ecp7-development/README.md

@@ -73,6 +73,11 @@ exactness, 0.32% validation, 0.61% translator validation and only 694–831
 messages. Sender depth is therefore also rejected. Exact identities and hashes
 are in `batch13-manifest.json`.
 
+Batch 14 decayed learning rate after step 5,000. It regressed to 79.13% train
+exactness, 65.49% validation and 71.02% translator validation. Constant late
+learning rate is therefore retained. Exact identities and hashes are in
+`batch14-manifest.json`.
+
 Reproduce the development arms with:
 
 ```bash

evidence/ecp7-development/batch14-manifest.json

@@ -0,0 +1,44 @@
+{
+  "batch": "ECP7-B14",
+  "confirmatory_test_unsealed": false,
+  "control": {
+    "artifact_hashes": {
+      "effective_config.yaml": "4bfb976293f117d3ae35f790e4fd6371628be95d91febb334bc275dc5d6b66d4",
+      "posthoc-analysis.json": "a7bccd464704ce71e3e8baa7508883f2512c0dd202d5a0f735ca1b5d9011f7ae",
+      "seed-11/metrics.json": "96bbb66b3561ad9f051a8ff6680ef1950488c6ba59aa755365e8e94be8468e01",
+      "summary.json": "69f46e4b77edadb7186f2dba02283945bae97e6f66aff80b39d1f868496c3737"
+    },
+    "development_gate_passed": true,
+    "population_train_mean_exact_match": 1.0,
+    "population_validation_mean_exact_match": 1.0,
+    "run_id": "20260718T132929Z-ecp7-development",
+    "universal_translator_validation_exact_match": 1.0,
+    "unique_messages_per_sender": [15360, 15360, 15360, 15360]
+  },
+  "intervention": {
+    "artifact_hashes": {
+      "effective_config.yaml": "c6f581a77ca83bea6b0703ef6a58fc9081dfcbaf4c2af5e1cd94fbb85eff2185",
+      "posthoc-analysis.json": "1b7010c1487517868fb782cec2eb42dcb39adef33e8ceb005ac467982a0dd852",
+      "seed-11/metrics.json": "31383793df7c77b6fa85f8d7a7748c6a4d88d7d42690f329eed6e35b9a5913a3",
+      "summary.json": "e63674150ff7fd0503460b7e018357e9e2f5478ead2db4a8a896fdde379854ab"
+    },
+    "best_code_utilization_loss": -0.733005940914154,
+    "best_learning_rate": 0.00011800000000000005,
+    "best_step": 14800,
+    "collision_meanings_per_sender": [3080, 3081, 3399, 3297],
+    "development_gate_passed": false,
+    "exact_sender_message_agreement": 0.890407986111111,
+    "message_entropy_bits_per_sender": [13.479958807644351, 13.479892430690663, 13.425251135080563, 13.449829537426103],
+    "population_train_mean_exact_match": 0.79132080078125,
+    "population_train_worst_link_exact_match": 0.7779017857142857,
+    "population_validation_factor_accuracy": [0.87103271484375, 0.91461181640625, 0.984375, 0.8636474609375],
+    "population_validation_mean_exact_match": 0.6549072265625,
+    "population_validation_worst_link_exact_match": 0.6318359375,
+    "run_id": "20260718T132929Z-ecp7-development",
+    "universal_translator_validation_exact_match": 0.710205078125,
+    "unique_messages_per_sender": [12280, 12279, 11961, 12063]
+  },
+  "seed": 11,
+  "split_artifact_sha256": "676195997ee0c77d5c9565bae045dbb938b432a2e4e74b666233b0a41f924718",
+  "split_sha256": "4947058c75ab07cb43a87eb82776b12cb2a7e2eeba7114de110d3b852cbc64cd"
+}

src/ai_taal/config.py

@@ -139,6 +139,29 @@ def validate_config(config: dict[str, Any]) -> None:
         if temperature_schedule_steps > training["max_steps"]:
             raise ConfigError("Temperature schedule steps cannot exceed max_steps.")
 
+    learning_rate_decay = training.get("learning_rate_decay", {})
+    if learning_rate_decay.get("enabled", False):
+        start_step = learning_rate_decay.get("start_step", 0)
+        end_step = learning_rate_decay.get("end_step", 0)
+        final_learning_rate = learning_rate_decay.get("final_learning_rate", 0)
+        if not isinstance(start_step, int) or isinstance(start_step, bool):
+            raise ConfigError("Learning-rate decay start must be an integer.")
+        if not isinstance(end_step, int) or isinstance(end_step, bool):
+            raise ConfigError("Learning-rate decay end must be an integer.")
+        if start_step < 1:
+            raise ConfigError("Learning-rate decay start must be positive.")
+        if end_step <= start_step or end_step > training["max_steps"]:
+            raise ConfigError(
+                "Learning-rate decay end must follow its start and fit max_steps."
+            )
+        if (
+            final_learning_rate <= 0
+            or final_learning_rate >= training["learning_rate"]
+        ):
+            raise ConfigError(
+                "Final learning rate must be positive and below its initial value."
+            )
+
     utilization = training.get("code_utilization", {})
     if utilization.get("enabled", False):
         if utilization.get("weight", -1) < 0:

src/ai_taal/training.py

@@ -93,6 +93,9 @@ def train_communication_system(
 
     for step in range(1, max_steps + 1):
         system.train()
+        learning_rate = _scheduled_learning_rate(training, step)
+        for parameter_group in optimizer.param_groups:
+            parameter_group["lr"] = learning_rate
         indices = torch.randint(
             len(train_values), (batch_size,), generator=generator, device="cpu"
         ).to(device)
@@ -113,6 +116,7 @@ def train_communication_system(
         record: dict[str, float | int] = {
             "step": step,
             "loss": float(loss.detach().cpu()),
+            "learning_rate": float(learning_rate),
             "temperature": float(temperature),
             "train_exact": train_metrics["exact_match"],
             "validation_exact": validation_metrics["exact_match"],
@@ -246,6 +250,9 @@ def train_population_system(
 
     for step in range(1, max_steps + 1):
         population.train()
+        learning_rate = _scheduled_learning_rate(training, step)
+        for parameter_group in optimizer.param_groups:
+            parameter_group["lr"] = learning_rate
         indices = torch.randint(
             len(train_values),
             (training["batch_size"],),
@@ -443,6 +450,7 @@ def train_population_system(
                 "sender_message_consensus_weight": float(
                     sender_consensus_weight
                 ),
+                "learning_rate": float(learning_rate),
                 "temperature": float(temperature),
                 "train_mean_exact": train_metrics["mean_exact_match"],
                 "train_worst_pair_exact": train_metrics["worst_pair_exact_match"],
@@ -1023,6 +1031,25 @@ def _scheduled_temperature(
     )
 
 
+def _scheduled_learning_rate(training: dict[str, Any], step: int) -> float:
+    initial_learning_rate = float(training["learning_rate"])
+    decay = training.get("learning_rate_decay", {})
+    if not decay.get("enabled", False):
+        return initial_learning_rate
+
+    start_step = int(decay["start_step"])
+    if step <= start_step:
+        return initial_learning_rate
+    end_step = int(decay["end_step"])
+    final_learning_rate = float(decay["final_learning_rate"])
+    if step >= end_step:
+        return final_learning_rate
+    progress = (step - start_step) / (end_step - start_step)
+    return initial_learning_rate + (
+        final_learning_rate - initial_learning_rate
+    ) * progress
+
+
 def _scheduled_code_utilization_weight(
     utilization_config: dict[str, Any], step: int
 ) -> float:

tests/conftest.py

@@ -108,3 +108,8 @@ def ecp7_b12_config():
 @pytest.fixture(scope="session")
 def ecp7_b13_config():
     return load_config(PROJECT_ROOT / "config" / "ecp7-b13-development.yaml")
+
+
+@pytest.fixture(scope="session")
+def ecp7_b14_config():
+    return load_config(PROJECT_ROOT / "config" / "ecp7-b14-development.yaml")