From e19a830cc5f636b6e8a2505ee679d78553185e3b Mon Sep 17 00:00:00 2001 From: FatosLocos Date: Sat, 18 Jul 2026 10:21:51 +0200 Subject: [PATCH] Translate repository documentation and interface to English --- AGENTS.md | 7 +- README.md | 163 +++++++++-------- docs/AI_AGENT_START.md | 4 +- docs/development-log-ecp1.md | 31 ++++ docs/development-log-ecp2.md | 117 ++++++++++++ docs/development-log-ecp3.md | 44 +++++ docs/development-log-ecp4.md | 50 ++++++ docs/development-log-ecp5.md | 34 ++++ docs/development-log-ecp6.md | 36 ++++ docs/experiment-template.md | 81 +++++---- docs/onderzoeksopzet-ecp1.md | 67 ------- docs/onderzoeksopzet-ecp2.md | 101 ----------- docs/onderzoeksopzet-ecp3.md | 57 ------ docs/onderzoeksopzet-ecp4.md | 72 -------- docs/onderzoeksopzet-ecp5.md | 51 ------ docs/onderzoeksopzet-ecp6.md | 66 ------- docs/onderzoeksopzet.md | 256 --------------------------- docs/ontwikkellog-ecp1.md | 31 ---- docs/ontwikkellog-ecp2.md | 117 ------------ docs/ontwikkellog-ecp3.md | 44 ----- docs/ontwikkellog-ecp4.md | 50 ------ docs/ontwikkellog-ecp5.md | 34 ---- docs/ontwikkellog-ecp6.md | 36 ---- docs/protocol-specification-ecp5.md | 51 ++++++ docs/protocol-specification-ecp6.md | 84 +++++++++ docs/protocolspecificatie-ecp5.md | 52 ------ docs/protocolspecificatie-ecp6.md | 84 --------- docs/research-design-ecp1.md | 67 +++++++ docs/research-design-ecp2.md | 101 +++++++++++ docs/research-design-ecp3.md | 56 ++++++ docs/research-design-ecp4.md | 71 ++++++++ docs/research-design-ecp5.md | 50 ++++++ docs/research-design-ecp6.md | 66 +++++++ docs/research-design.md | 256 +++++++++++++++++++++++++++ docs/resultaten-ecp0.md | 104 ----------- docs/resultaten-ecp1.md | 112 ------------ docs/resultaten-ecp2.md | 60 ------- docs/resultaten-ecp3.md | 98 ---------- docs/resultaten-ecp4.md | 44 ----- docs/resultaten-ecp5.md | 121 ------------- docs/resultaten-ecp6.md | 116 ------------ docs/results-ecp0.md | 104 +++++++++++ docs/results-ecp1.md | 112 ++++++++++++ docs/results-ecp2.md | 60 +++++++ docs/results-ecp3.md | 98 ++++++++++ docs/results-ecp4.md | 44 +++++ docs/results-ecp5.md | 121 +++++++++++++ docs/results-ecp6.md | 116 ++++++++++++ pyproject.toml | 2 +- runs/README.md | 16 +- schemas/episode.schema.json | 2 +- schemas/meaning.schema.json | 2 +- schemas/message.schema.json | 2 +- src/ai_taal/__init__.py | 3 +- src/ai_taal/analysis.py | 10 +- src/ai_taal/baselines.py | 13 +- src/ai_taal/cli.py | 58 +++--- src/ai_taal/config.py | 30 ++-- src/ai_taal/experiment.py | 38 ++-- src/ai_taal/metrics.py | 18 +- src/ai_taal/models.py | 76 ++++---- src/ai_taal/population_experiment.py | 26 +-- src/ai_taal/training.py | 44 ++--- src/ai_taal/worker.py | 8 +- src/ai_taal/world.py | 48 ++--- tests/test_config.py | 2 +- 66 files changed, 2100 insertions(+), 2095 deletions(-) create mode 100644 docs/development-log-ecp1.md create mode 100644 docs/development-log-ecp2.md create mode 100644 docs/development-log-ecp3.md create mode 100644 docs/development-log-ecp4.md create mode 100644 docs/development-log-ecp5.md create mode 100644 docs/development-log-ecp6.md delete mode 100644 docs/onderzoeksopzet-ecp1.md delete mode 100644 docs/onderzoeksopzet-ecp2.md delete mode 100644 docs/onderzoeksopzet-ecp3.md delete mode 100644 docs/onderzoeksopzet-ecp4.md delete mode 100644 docs/onderzoeksopzet-ecp5.md delete mode 100644 docs/onderzoeksopzet-ecp6.md delete mode 100644 docs/onderzoeksopzet.md delete mode 100644 docs/ontwikkellog-ecp1.md delete mode 100644 docs/ontwikkellog-ecp2.md delete mode 100644 docs/ontwikkellog-ecp3.md delete mode 100644 docs/ontwikkellog-ecp4.md delete mode 100644 docs/ontwikkellog-ecp5.md delete mode 100644 docs/ontwikkellog-ecp6.md create mode 100644 docs/protocol-specification-ecp5.md create mode 100644 docs/protocol-specification-ecp6.md delete mode 100644 docs/protocolspecificatie-ecp5.md delete mode 100644 docs/protocolspecificatie-ecp6.md create mode 100644 docs/research-design-ecp1.md create mode 100644 docs/research-design-ecp2.md create mode 100644 docs/research-design-ecp3.md create mode 100644 docs/research-design-ecp4.md create mode 100644 docs/research-design-ecp5.md create mode 100644 docs/research-design-ecp6.md create mode 100644 docs/research-design.md delete mode 100644 docs/resultaten-ecp0.md delete mode 100644 docs/resultaten-ecp1.md delete mode 100644 docs/resultaten-ecp2.md delete mode 100644 docs/resultaten-ecp3.md delete mode 100644 docs/resultaten-ecp4.md delete mode 100644 docs/resultaten-ecp5.md delete mode 100644 docs/resultaten-ecp6.md create mode 100644 docs/results-ecp0.md create mode 100644 docs/results-ecp1.md create mode 100644 docs/results-ecp2.md create mode 100644 docs/results-ecp3.md create mode 100644 docs/results-ecp4.md create mode 100644 docs/results-ecp5.md create mode 100644 docs/results-ecp6.md diff --git a/AGENTS.md b/AGENTS.md index 8a4525e..d35cfb5 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -7,9 +7,9 @@ This repository is a reproducible research project, not a generic chat applicati Read these files in order before changing code: 1. `README.md` -2. `docs/resultaten-ecp6.md` -3. `docs/protocolspecificatie-ecp6.md` -4. `docs/onderzoeksopzet-ecp6.md` +2. `docs/results-ecp6.md` +3. `docs/protocol-specification-ecp6.md` +4. `docs/research-design-ecp6.md` 5. `docs/AI_AGENT_START.md` Then run: @@ -40,6 +40,7 @@ python3.12 -m venv .venv - Run the full test suite and the relevant config validation before committing. - Keep existing ECP-0 through ECP-6 configurations reproducible. - Document new experiments in three stages: preregistration, sealed development log, confirmatory results. +- Write new configurations, documentation, reports and user-facing output in English. - When proposing ECP-7, prefer a single falsifiable intervention over several simultaneous architecture changes. The recommended next research question is whether compositional structure still emerges when the explicit one-factor-per-slot architectural bias is weakened. diff --git a/README.md b/README.md index 6902a22..d167eb2 100644 --- a/README.md +++ b/README.md @@ -1,94 +1,103 @@ -# AI-taal — onderzoek naar emergente communicatie +# AI Language — Emergent Communication Research -Dit project onderzoekt of onafhankelijk getrainde AI-agents zelf een communicatieprotocol kunnen ontwikkelen dat voor een afgebakende taak compacter, minder ambigu en beter overdraagbaar is dan menselijke taal. +This project investigates whether independently trained AI agents can develop a communication protocol that is more compact, less ambiguous and more portable than human language for a defined task. -De eerste versie heet **ECP-0**: *Emergent Communication Protocol, experiment 0*. ECP-0 gebruikt geen woorden of vooraf toegekende symboolbetekenissen. Een zender en ontvanger moeten via vier discrete symbolen een betekenis uit een kunstmatige wereld reconstrueren. +The first version is called **ECP-0**: *Emergent Communication Protocol, experiment 0*. ECP-0 does not use words or pre-assigned symbol meanings. A sender and receiver must reconstruct a meaning from an artificial world via four discrete symbols. -## Onderzoeksvraag +## Research question -> Kunnen onafhankelijke AI-agents zelf een communicatieprotocol ontwikkelen dat bij gelijke taakprestatie efficiënt, generaliseerbaar, vertaalbaar en overdraagbaar is? +> Can independent AI agents themselves develop a communication protocol that is efficient, generalizable, translatable and portable given the same task performance? -Een protocol geldt binnen dit onderzoek pas als een serieuze nieuwe communicatievorm wanneer het: +Within this research, a protocol only counts as a serious new form of communication when it: -1. niet door mensen semantisch is voorgeprogrammeerd; -2. onbekende combinaties kan uitdrukken; -3. door een onafhankelijke vertaler kan worden ontsloten; -4. door nieuwe agents kan worden aangeleerd; -5. aantoonbaar efficiënt is ten opzichte van vaste baselines; -6. uitsluitend het toegestane en volledig gelogde kanaal gebruikt. +1. is not semantically pre-programmed by humans; +2. can express unknown combinations; +3. can be accessed by an independent translator; +4. can be learned by new agents; +5. is demonstrably efficient compared to fixed baselines; +6. only uses the allowed and fully logged channel. -## Huidige status +## Current status -**ECP-6 is de geslaagde schaalreplicatie van het volledig efficiënte protocol.** Alle vijf seeds reconstrueren bekende én volledig nieuwe factorcombinaties voor 100%. De universele vertaler en het slechtste agentpaar halen eveneens 100%. De vooraf vastgelegde classificatie is **sterk bewijs**. +**ECP-6 is the successful scale replication of the fully efficient protocol.** All five seeds reconstruct known and completely new factor combinations for 100%. The universal translator and the worst agent pair also achieve 100%. The predetermined classification is **strong evidence**. -Het protocol gebruikt geen woorden of alfabet, maar vier betekenisvrije lokale symbolen. Voor `16 × 16 × 8 × 8 = 16.384` uniforme betekenissen gebruikt het exact `4+4+3+3=14` bits: de informatietheoretische ondergrens. Voor deze afgebakende taak is dat gemiddeld 23,9 keer compacter dan het Nederlandse tekstsjabloon. +The protocol uses no words or alphabet, but four meaning-free local symbols. For `16 × 16 × 8 × 8 = 16,384` uniform meanings it uses exactly `4+4+3+3=14` bits: the information-theoretic lower bound. For this defined task, this is on average 23.9 times more compact than the Dutch text template. -Zie [`docs/resultaten-ecp6.md`](docs/resultaten-ecp6.md) voor de conclusie, [`docs/protocolspecificatie-ecp6.md`](docs/protocolspecificatie-ecp6.md) voor het wire-formaat en [`evidence/ecp6/report.md`](evidence/ecp6/report.md) voor de compacte confirmatieve evidence. +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. -## Verder bouwen +## Build on this work -Een nieuwe ontwikkelaar of verse AI-agent kan zonder eerdere chatcontext beginnen. Lees eerst [`AGENTS.md`](AGENTS.md) voor de bindende onderzoeksregels en volg daarna [`docs/AI_AGENT_START.md`](docs/AI_AGENT_START.md) voor installatie, architectuuroverzicht, reproductie en het correct opzetten van ECP-7. +A new developer or fresh AI agent can start with no previous chat context. First read [`AGENTS.md`](AGENTS.md) for the binding research rules and then follow [`docs/AI_AGENT_START.md`](docs/AI_AGENT_START.md) for installation, architecture overview, reproduction and proper setup of ECP-7. -Bijdragen zijn welkom via [`CONTRIBUTING.md`](CONTRIBUTING.md). Grote gegenereerde runs blijven lokaal; compacte verifieerbare resultaten komen onder [`evidence/`](evidence/). +Contributions are welcome via [`CONTRIBUTING.md`](CONTRIBUTING.md). Large generated runs stay local; compact verifiable results come under [`evidence/`](evidence/). -## Bestanden +## Language and frozen provenance -- [`docs/onderzoeksopzet.md`](docs/onderzoeksopzet.md) — volledige onderzoeksvraag, fasering, metingen en stopcriteria. -- [`docs/experiment-template.md`](docs/experiment-template.md) — vast verslagformat per experimentele run. -- [`docs/resultaten-ecp0.md`](docs/resultaten-ecp0.md) — uitkomsten, hypothesetoetsing en aanbeveling voor stap 2. -- [`docs/onderzoeksopzet-ecp1.md`](docs/onderzoeksopzet-ecp1.md) — vooraf vastgelegde populatieproef en besliscriteria. -- [`docs/ontwikkellog-ecp1.md`](docs/ontwikkellog-ecp1.md) — ontwikkeling die plaatsvond terwijl de ECP-1-testset gesloten bleef. -- [`docs/resultaten-ecp1.md`](docs/resultaten-ecp1.md) — confirmatieve uitkomsten, vergelijking met ECP-0 en aanbeveling voor ECP-2. -- [`docs/resultaten-ecp2.md`](docs/resultaten-ecp2.md) — permutationslots, gepaarde consensusproef en resterende symboolbotsingen. -- [`docs/onderzoeksopzet-ecp3.md`](docs/onderzoeksopzet-ecp3.md) — vooraf bevroren hypothese, split en beslisregels voor het injectieve protocol. -- [`docs/ontwikkellog-ecp3.md`](docs/ontwikkellog-ecp3.md) — ontwikkeling terwijl de ECP-3-testmatching gesloten bleef. -- [`docs/resultaten-ecp3.md`](docs/resultaten-ecp3.md) — sterk bewijs, protocolvoorbeeld, efficiëntie en grenzen van het basismodel. -- [`docs/resultaten-ecp4.md`](docs/resultaten-ecp4.md) — perfecte 10-bitpopulatie en de geïsoleerde vertalerfout. -- [`docs/onderzoeksopzet-ecp5.md`](docs/onderzoeksopzet-ecp5.md) — vooraf bevroren kalibratieproef en orthogonale holdout. -- [`docs/ontwikkellog-ecp5.md`](docs/ontwikkellog-ecp5.md) — gesloten ontwikkeling van exacte bindingsinductie. -- [`docs/resultaten-ecp5.md`](docs/resultaten-ecp5.md) — 5/5 foutloze seeds en volledige efficiëntieanalyse. -- [`docs/protocolspecificatie-ecp5.md`](docs/protocolspecificatie-ecp5.md) — logisch bericht, 10-bit-wireformaat en decoderprocedure. -- [`docs/onderzoeksopzet-ecp6.md`](docs/onderzoeksopzet-ecp6.md) — vooraf bevroren schaalproef voor 16.384 betekenissen. -- [`docs/ontwikkellog-ecp6.md`](docs/ontwikkellog-ecp6.md) — schaalinvarianten en gesloten 14-bitontwikkeling. -- [`docs/resultaten-ecp6.md`](docs/resultaten-ecp6.md) — 5/5 foutloze schaalreplicaties en integriteitsanalyse. -- [`docs/protocolspecificatie-ecp6.md`](docs/protocolspecificatie-ecp6.md) — machinecode, 14-bit-wireformaat en inductieprocedure. -- [`config/ecp0.yaml`](config/ecp0.yaml) — machineleesbare configuratie van stap 1. -- [`config/ecp1.yaml`](config/ecp1.yaml) — bevroren configuratie van de populatieproef. -- [`config/ecp3.yaml`](config/ecp3.yaml) — bevroren configuratie van het eerste geslaagde basismodel. -- [`config/ecp5.yaml`](config/ecp5.yaml) — bevroren configuratie van het volledig efficiënte eindmodel. -- [`config/ecp6.yaml`](config/ecp6.yaml) — bevroren configuratie van de 16× schaalreplicatie. -- [`AGENTS.md`](AGENTS.md) — bindende onderzoeks- en wijzigingsregels voor AI-agents. -- [`docs/AI_AGENT_START.md`](docs/AI_AGENT_START.md) — volledige onboarding voor een verse AI-agent. -- [`evidence/ecp6/manifest.json`](evidence/ecp6/manifest.json) — compacte machineleesbare confirmatieve evidence. -- [`schemas/meaning.schema.json`](schemas/meaning.schema.json) — formaat van een betekenis. -- [`schemas/message.schema.json`](schemas/message.schema.json) — formaat van een agentbericht. -- [`schemas/episode.schema.json`](schemas/episode.schema.json) — formaat van een geëvalueerde aflevering. +All reader-facing documentation, schemas, command-line output, and source commentary are in English. Two reproducibility artifacts intentionally retain original Dutch literals: -## ECP-0 in één minuut +- the Dutch UTF-8 baseline sentence in `src/ai_taal/baselines.py`, because its byte length is a measured comparison; +- descriptive metadata and comments inside existing ECP-0 through ECP-6 YAML configurations, because their exact bytes are preregistered and referenced by published SHA-256 hashes. -- De wereld bevat `8 × 8 × 4 × 4 = 1024` mogelijke betekenissen. -- Iedere betekenis bestaat uit vier onafhankelijke factoren: kleur, vorm, grootte en textuur. -- De agents zien alleen numerieke categorieën, geen menselijke labels. -- Het kanaal heeft 16 mogelijke symbolen en exact 4 posities: 16 bits per bericht. -- De zender en ontvanger delen geen gewichten, embeddings of toestand. -- 128 betekenissen worden als onbekende kleur-vormcombinaties volledig buiten training gehouden. -- Na training wordt het protocol bevroren en door een derde model vertaald. -- Vijf onafhankelijke trainingsruns voorkomen conclusies op basis van één toevallige code. +Do not translate those artifacts in place. New experiment configurations and all new public documentation must be written in English. -De theoretische ondergrens voor het exact onderscheiden van 1024 uniforme betekenissen is 10 bits. ECP-0 gebruikt bewust 16 bits: ruim genoeg om eerst leerbaarheid, compositionaliteit en vertaalbaarheid te testen. Compressie naar 12 bits en daarna richting de 10-bitondergrens hoort bij stap 2. +## Files + +- [`docs/research-design.md`](docs/research-design.md) — complete research question, phasing, measurements and stopping criteria. +- [`docs/experiment-template.md`](docs/experiment-template.md) — fixed report format per experimental run. +- [`docs/results-ecp0.md`](docs/results-ecp0.md) — outcomes, hypothesis testing and recommendation for step 2. +- [`docs/research-design-ecp1.md`](docs/research-design-ecp1.md) — predefined population experiment and decision criteria. +- [`docs/development-log-ecp1.md`](docs/development-log-ecp1.md) — development that occurred while the ECP-1 test set remained sealed. +- [`docs/results-ecp1.md`](docs/results-ecp1.md) — confirmatory results, comparison with ECP-0 and recommendation for ECP-2. +- [`docs/results-ecp2.md`](docs/results-ecp2.md) — permutation slots, paired consensus trial, and residual symbol collisions. +- [`docs/research-design-ecp3.md`](docs/research-design-ecp3.md) — pre-frozen hypothesis, split and decision rules for the injective protocol. +- [`docs/development-log-ecp3.md`](docs/development-log-ecp3.md) — development while the ECP-3 test split remained sealed. +- [`docs/results-ecp3.md`](docs/results-ecp3.md) — strong evidence, protocol example, efficiency and limits of the base model. +- [`docs/results-ecp4.md`](docs/results-ecp4.md) — perfect 10-bit population and the isolated translator error. +- [`docs/research-design-ecp5.md`](docs/research-design-ecp5.md) — prefrozen calibration experiment and orthogonal holdout. +- [`docs/development-log-ecp5.md`](docs/development-log-ecp5.md) — sealed development of exact binding induction. +- [`docs/results-ecp5.md`](docs/results-ecp5.md) — 5/5 error-free seeds and full efficiency analysis. +- [`docs/protocol-specification-ecp5.md`](docs/protocol-specification-ecp5.md) — logical message, 10-bit wire format and decoder procedure. +- [`docs/research-design-ecp6.md`](docs/research-design-ecp6.md) — pre-frozen scale test for 16,384 meanings. +- [`docs/development-log-ecp6.md`](docs/development-log-ecp6.md) — scale invariants and sealed 14-bit development. +- [`docs/results-ecp6.md`](docs/results-ecp6.md) — 5/5 error-free scale replications and integrity analysis. +- [`docs/protocol-specification-ecp6.md`](docs/protocol-specification-ecp6.md) — machine code, 14-bit wire format and induction procedure. +- [`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/ecp3.yaml`](config/ecp3.yaml) — frozen configuration of the first successful base model. +- [`config/ecp5.yaml`](config/ecp5.yaml) — frozen configuration of the fully efficient end model. +- [`config/ecp6.yaml`](config/ecp6.yaml) — frozen configuration of the 16× scale replication. +- [`AGENTS.md`](AGENTS.md) — binding research and change rules for AI agents. +- [`docs/AI_AGENT_START.md`](docs/AI_AGENT_START.md) — full onboarding for a fresh AI agent. +- [`evidence/ecp6/manifest.json`](evidence/ecp6/manifest.json) — compact machine-readable confirmatory evidence. +- [`schemas/meaning.schema.json`](schemas/meaning.schema.json) — format of a meaning. +- [`schemas/message.schema.json`](schemas/message.schema.json) — format of an agent message. +- [`schemas/episode.schema.json`](schemas/episode.schema.json) — format of an evaluated episode. + +## ECP-0 in one minute + +- The world contains `8 × 8 × 4 × 4 = 1024` possible meanings. +- Each meaning consists of four independent factors: color, shape, size and texture. +- The agents only see numerical categories, not human labels. +- The channel has 16 possible symbols and exactly 4 positions: 16 bits per message. +- The sender and receiver do not share weights, embeddings or state. +- 128 meanings are completely excluded from training as unknown color-shape combinations. +- After training, the protocol is frozen and translated by a third model. +- Five independent training runs prevent conclusions based on one random code. + +The theoretical lower limit for exactly distinguishing 1024 uniform meanings is 10 bits. ECP-0 deliberately uses 16 bits: more than enough to first test learnability, compositionality and translatability. Compression to 12 bits and then towards the 10-bit lower limit is part of step 2. ## Simulator -De reproduceerbare simulator bevat: +The reproducible simulator includes: -1. deterministische datasetgeneratie; -2. afzonderlijke zender-, ontvanger- en vertaalmodellen; -3. discrete evaluatie zonder verborgen nevenkanaal; -4. automatische baselines, controles, metingen en runrapporten. +1. deterministic dataset generation; +2. separate sender, receiver and translation models; +3. discrete evaluation without hidden side channel; +4. automatic baselines, checks, measurements and run reports. -## Uitvoeren +## Execute -Vereist: Python 3.12. +Required: Python 3.12. ```bash python3.12 -m venv .venv @@ -97,36 +106,36 @@ python3.12 -m venv .venv .venv/bin/pytest ``` -De drie uitvoermodi hebben bewust verschillende toegang tot de data: +The three output modes deliberately access the data differently: ```bash -# 25 stappen: alleen controleren of de hele technische keten werkt +# 25 steps: verify that the complete technical pipeline works .venv/bin/ecp0 smoke --seed 11 -# Volledig trainen op train en validatie; test blijft gesloten +# Full training on train and validation; the test split remains sealed .venv/bin/ecp0 develop --seed 11 -# Confirmatief: alle vastgelegde seeds en eenmalige testontzegeling +# Confirmatory run: all preregistered seeds and one-time test unsealing .venv/bin/ecp0 experiment --unseal-test -# Controleer hashes en vergelijk protocolstructuur met willekeurige koppelingen +# Verify hashes and compare protocol structure with random assignments .venv/bin/ecp0 analyze runs/ --permutations 100 -# ECP-1 gebruikt dezelfde interface met de populatieconfiguratie +# ECP-1 uses the same interface with the population configuration .venv/bin/ecp1 --config config/ecp1.yaml validate .venv/bin/ecp1 --config config/ecp1.yaml analyze runs/ --permutations 100 -# ECP-3: injectieve atoomcodes en geleerde protocolconsensus +# ECP-3: injective atomic codes and learned protocol consensus .venv/bin/ecp3 --config config/ecp3.yaml validate .venv/bin/ecp3 --config config/ecp3.yaml analyze runs/ --permutations 100 -# ECP-5: theoretisch minimale 10-bitcode met gekalibreerde lezer +# ECP-5: theoretically minimal 10-bit code with a calibrated reader .venv/bin/ecp5 --config config/ecp5.yaml validate .venv/bin/ecp5 --config config/ecp5.yaml analyze runs/ --permutations 100 -# ECP-6: 16.384 betekenissen bij de exacte 14-bitondergrens +# ECP-6: 16,384 meanings at the exact 14-bit lower bound .venv/bin/ecp6 --config config/ecp6.yaml validate .venv/bin/ecp6 --config config/ecp6.yaml analyze runs/ --permutations 100 ``` -Iedere uitvoering schrijft configuratie, omgeving, checkpoints, ruwe berichten, controles, hashes, metrics en een rapport naar een nieuwe map onder `runs/`. +Each run writes configuration, environment, checkpoints, raw messages, checks, hashes, metrics, and a report to a new folder under `runs/`. diff --git a/docs/AI_AGENT_START.md b/docs/AI_AGENT_START.md index 7f65ad3..7e11942 100644 --- a/docs/AI_AGENT_START.md +++ b/docs/AI_AGENT_START.md @@ -78,10 +78,10 @@ Do not modify ECP-6. Use this sequence: 3. Create a genuinely new deterministic holdout or world seed. 4. Add tests for every new invariant before training. 5. Use only `smoke` and `develop`; keep the ECP-7 test split sealed. -6. Record all tried variants in `docs/ontwikkellog-ecp7.md`. +6. Record all tried variants in `docs/development-log-ecp7.md`. 7. Select one final design using train and validation only. 8. Create `config/ecp7.yaml` with status `frozen_for_confirmatory` and a UTC freeze time. -9. Record config and split SHA-256 values in `docs/onderzoeksopzet-ecp7.md`. +9. Record config and split SHA-256 values in `docs/research-design-ecp7.md`. 10. Only then run the predefined seeds once with `experiment --unseal-test`. 11. Run posthoc integrity analysis and publish both successes and failures. diff --git a/docs/development-log-ecp1.md b/docs/development-log-ecp1.md new file mode 100644 index 0000000..3292dad --- /dev/null +++ b/docs/development-log-ecp1.md @@ -0,0 +1,31 @@ +# Development log ECP-1 + +All variants below used only training and validation data. The new ECP-1 test split remained sealed during these design choices. + +| Variant | Pairings per step | Known mean | Known worst | Validation mean | Conclusion | +|---|---:|---:|---:|---:|---| +| One pair at random | 1 | 92.7% | 91.4% | 61.2% | too few direct pair updates | +| B: one sender, all receivers | 4 | 95.9% | 95.1% | 57.3% | more stable, but known accuracy is insufficient | +| C: all senders, all receivers | 16 | 99.2% | 98.8% | 77.6% | frozen for the confirmatory experiment | + +## Variant A + +Each cycle used all sixteen pairs once, but only one pair per training step. At the best checkpoint each specific pair had only a fraction of the learning interactions of an ECP-0 pair. The agents did develop a shared convention, but the known reconstruction remained insufficient. + +Local, untracked artifact: `runs/20260718T000531Z-ecp1-development/report.md`. + +## Variant B + +One selected sender sent the same message per step to all four receivers, giving receivers a lot of experience, but each sender still less direct updates. The known performance improved, while validation did not improve. + +Local, untracked artifact: `runs/20260718T000811Z-ecp1-development/report.md`. + +## Variant C + +Each batch ran through all sixteen sender-receiver pairs, and all losses were averaged. There was no leader, shared weight, or extra semantic label. Each pair received the same amount of training exposure as ECP-0. + +The universal receiver achieved test-free 78.3% validation. A fresh receiver achieved 74.2% validation with 512 out of 768 training concepts and 77.9% with all meanings. + +Local, untracked artifact: `runs/20260718T001224Z-ecp1-development/report.md`. + +After this run, architecture, learning settings, thresholds and data split have been frozen. Subsequent changes will get a new experiment ID. diff --git a/docs/development-log-ecp2.md b/docs/development-log-ecp2.md new file mode 100644 index 0000000..c202124 --- /dev/null +++ b/docs/development-log-ecp2.md @@ -0,0 +1,117 @@ +# Development log ECP-2 + +The confirmatory ECP-2 test set remained sealed throughout this work. All performance below comes exclusively from training and the separate compositional validation split. + +## Variant A - algebraic consistency pressure + +Seed: 11
+Architecture: four independent channels × four independent receivers
+Channel: four symbols from a vocabulary of sixteen, 16 bits
+Split: `7a227e22d86f00d8ab5078690de37de794774cdab636e7db374c5adbd0985126` + +| Variant | Weight | Known mean | Worst known pair | Compositional validation | Universal translator validation | +|---|---:|---:|---:|---:|---:| +| Control | 0 | 97.0% | 96.5% | **9.5%** | **13.9%** | +| Light | 0.25 | 95.8% | 95.1% | 4.6% | 10.0% | +| Medium | 1.0 | 59.9% | 35.2% | 2.6% | 3.5% | +| Strong | 4.0 | 2.0% | 1.6% | 1.4% | 2.3% | + +Local artifacts are underneath `runs/ecp2-variants/{control,light,medium,strong}/20260718T005403Z-ecp2-development/`. + +### Conclusion + +The intervention is rejected. No weight improves the compositional validation and only the control approaches the known performance threshold. The test set is not opened. + +Regularization revealed an informative degeneration. Under strong pressure, size and texture are reconstructed perfectly on the validation set, while color and shape can fall to chance level. Because the algebraic requirement is minimized on average across all changes, the sender can satisfy it cheaply by omitting the most difficult factors. A higher task-loss weight would merely rebalance the two objectives and would not remove this fundamental escape route. + +Under the predefined fallback, development continues with cultural transmission, which selects for learnability by introducing new agents instead of directly imposing a desired geometry on messages. + +## Variant B - Cultural transmission by agent replacement + +The population retains four channels and four receivers. After a fixed interval, one sender and one receiver are completely re-initialized. The remaining six agents form the temporary cultural memory. After four replacements, no original agent is present; checkpoints prior to that complete turnover are not selectable. + +Three preselected intervals are compared with seed 11 and the same sealed test set: + +| Variant | Steps between replacements | First complete turnover | +|---|---:|---:| +| Fast | 400 | Step 1,600 | +| Medium | 600 | Step 2,400 | +| Slow | 800 | Step 3,200 | + +The training budget remains 5,000 steps. Selection first uses the known performance thresholds and then only the compositional validation. Algebraic regularization is out in these three variants. + +### First outcome + +| Variant | Known mean | Worst known pair | Compositional validation | Universal translator validation | +|---|---:|---:|---:|---:| +| Fast, continuous | 97.4% | 93.9% | **19.5%** | **18.4%** | +| Medium, continuous | 95.2% | 92.1% | 10.0% | 12.7% | +| Slow, continuous | 94.1% | 90.8% | 10.1% | 11.9% | + +The fast variant almost doubles the compositional validation compared to the 9.5% control, but continues to introduce new agents. As a result, a recently replaced link is always the weakest. The following pre-defined refinement separates transmission and consolidation: + +| Variant | Interval | Maximum replacements | Turnovers | Consolidation after last replacement | +|---|---:|---:|---:|---:| +| One fast turnover | 400 | 4 | 1 | 3,400 steps | +| Two fast turnovers | 400 | 8 | 2 | 1,800 steps | +| One medium turnover | 600 | 4 | 1 | 2,600 steps | + +The final test remains sealed for this refinement. + +### Consolidation outcome + +| Variant | Known mean | Worst known pair | Compositional validation | Universal translator validation | +|---|---:|---:|---:|---:| +| One fast turnover | 98.8% | 97.5% | 10.3% | 15.0% | +| Two fast turnovers | **99.3%** | **98.8%** | **19.9%** | **25.2%** | +| One medium turnover | 97.2% | 96.6% | 7.3% | 10.4% | + +Two fast turnovers form the best cultural variant. It meets the known-performance thresholds and doubles compositional validation relative to the control, but remains well below the development targets of 80% population and 70% translator accuracy. Cultural transmission is retained as the best weakly structured intervention, but not as the confirmatory ECP-2 candidate. + +## Variant C — Learned permutation slots + +If the consolidation variants fail to reach the compositional validation threshold, one structurally stronger architecture is tested. The sender contains four discrete message slots and internally chooses a hard one-to-one permutation between the four meaning factors and those slots. + +The following are not defined in advance: + +- which factor is linked to which slot; +- which of the sixteen symbols represents a factor value; +- whether different channels choose the same internal permutation or symbols; +- how receivers decode the four symbols. + +This is an explicit compositional architectural bias and a stricter procedure than algebraic or cultural pressure. The variant is valuable as a working model and as a positive control, but a success should not be described as completely uninfluenced linguistic emergence. + +The slot variant is first trained with seed 11, without algebraic regularization or agent replacement. The preselected development thresholds are 97% mean known accuracy, 95% for the worst pair, 80% compositional validation, and 70% universal-translation validation. + +### First final outcome and consensus refinement + +The first fully trained slot population achieves training/validation without test access: + +- 100% known reconstruction for each sender-receiver pair; +- 69.4% average compositional validation; +- 30.5% for the worst compositional pair; +- 50.6% universal translation validation. + +The four senders chose three different factor-slot permutations. Two independently converged on the same permutation; the other two chose different ones. One meaning-free refinement is therefore tested: minimize differences among the four soft binding matrices and make each matrix sharp. Consensus does not specify a factor-slot mapping in advance; any of the 24 permutations can win. + +Preselected consensus weights: + +| Variant | Consensus weight | Sharpness weight | +|---|---:|---:| +| Light | 0.1 | 0.1 | +| Medium | 1.0 | 0.1 | +| Strong | 5.0 | 0.1 | + +The final test remains sealed. When validation scores are nearly equal, the lower consensus weight wins. + +### Consensus outcome and final choice + +| Variant | Known mean | Worst known pair | Compositional validation | Worst validation pair | Universal translator validation | +|---|---:|---:|---:|---:|---:| +| Light, 0.1 | 100% | 100% | 76.9% | 51.6% | 50.6% | +| Medium, 1.0 | 100% | 100% | 90.0% | 82.0% | 95.3% | +| **Strong, 5.0** | **100%** | **100%** | **97.0%** | **93.8%** | **95.3%** | + +Weight 5.0 wins unequivocally and becomes the confirmatory ECP-2 candidate. All four channels chose the same internally determined permutation `[color, texture, shape, size]`; the final soft binding probabilities have maxima between 0.968 and 0.986. Across the 896 training and validation meanings, the population uses 896 unique messages, has zero collisions, a minimum-pair distance of exactly one, and topographic similarity 1.0. + +The confirmatory intervention is accompanied by a control using exactly the same permutation-slot architecture, split, seeds, and training budget, but without binding consensus. Both configurations are frozen before any ECP-2 test access. diff --git a/docs/development-log-ecp3.md b/docs/development-log-ecp3.md new file mode 100644 index 0000000..f562417 --- /dev/null +++ b/docs/development-log-ecp3.md @@ -0,0 +1,44 @@ +# Development log ECP-3 + +The confirmatory ECP-3 test split remained sealed throughout all work described below. + +## Failure mode in ECP-2 + +ECP-2 learned a shared factor-slot binding within each seed, but only two of five seeds met every threshold. The weak seeds no longer had a structural slot-binding problem; they remained stuck with non-unique or insufficiently stable symbols for individual factor values. As a result, even known meanings in seeds 37 and 53 could not be fully distinguished. + +## Preselected repair + +ECP-3 replaces the neural slot heads with a freely learned injective symbol allocation for each factor. The sender may still choose any symbol for each value, but two values within the same factor may not coincide. The existing free factor-slot permutation is retained. In addition to binding consensus, the same meaning-free population consensus is applied to the soft atomic codebooks. + +One development seed has been used: seed 11. The training budget, population size, receiver architecture and channel capacity are kept equal to ECP-2. + +## Result on training and compositional validation + +| Metric | Outcome | +|---|---:| +| Known mean | 100.0% | +| Worst known sender-receiver pair | 100.0% | +| Fully new validation pairs | 100.0% | +| Worst validation pair | 100.0% | +| Universal translator on validation | 100.0% | +| New receiver with 128 examples | 94.3% | +| New receiver with 512 examples | 99.8% | +| New receiver with 768 examples | 100.0% | + +All four channels chose the same slot order `[shape, texture, size, color]`. Their exact atomic codebooks did not match everywhere, but every code remained injective and all sixteen sender-receiver links decoded both dialect variants flawlessly. + +For each of the four channels, across the 896 training and validation meanings: + +- 896 unique messages and zero collisions; +- message entropy of `9.807` bits, equal to the source entropy of this subset; +- mean message distance of exactly one for a one-factor meaning change; +- full concentration of such a change in one position; +- topographic Spearman correlation of `1.0`. + +The technical smoke test, checkpoint cycle, isolated processes, shuffled-message control, and consistent symbol permutation all passed. All 29 tests passed. + +## Conclusion + +No further refinement is allowed before the confirmatory test. The development variant achieves every goal without opening the sealed split and is therefore frozen unchanged as the ECP-3 intervention. An otherwise identical control disables only slot-binding and atomic-code consensus. + +Development run: `runs/ecp3-development/20260718T020325Z-ecp3-development`. diff --git a/docs/development-log-ecp4.md b/docs/development-log-ecp4.md new file mode 100644 index 0000000..bfdede4 --- /dev/null +++ b/docs/development-log-ecp4.md @@ -0,0 +1,50 @@ +# Development log ECP-4 + +The confirmatory ECP-4 test split remained technically sealed throughout development. + +## Implementation + +ECP-4 adds two prespecified components: + +1. `MinimalPermutationSlotSender`: a freely learned hard permutation for each factor within a local alphabet of exactly the required size; +2. `FactorizedPermutationSlotReceiver`: a freely learned but hard-isolated message slot for each factor output. + +The transport metadata, configuration validation, and episode schemas now support protocol-specific bit lengths. Each episode is also checked against the active configuration for exact message length, bit length, and symbol range. + +## Technical verification + +The tests verify that: + +- the four local codebooks exactly `8×8`, `8×8`, `4×4` and `4×4` are hard permutations; +- each symbol actually sent falls within the local factor alphabet; +- a factor output remains unchanged when an unselected slot changes; +- minimum sender and factor receiver run separately through checkpoints and isolated processes; +- `3+3+2+2 = 10` bits exactly equals the source entropy; +- the explicit validation and test splits use exactly the final sixteen unused pairs. + +All 34 tests pass. + +## Sealed development + +Develop run: `runs/ecp4-development/20260718T060943Z-ecp4-development`
+Seed: 11 + +| Metric | Outcome | +|---|---:| +| Known mean | 100.0% | +| Worst known sender-receiver pair | 100.0% | +| Fully new validation pairs | 100.0% | +| Worst validation pair | 100.0% | +| Universal translator on validation | 100.0% | +| New receiver, 32 examples | 100.0% | +| New receiver, 128 examples | 100.0% | +| New receiver, 512 examples | 100.0% | +| New receiver, 768 examples | 100.0% | + +All four channels chose the same internally determined slot order `[size, texture, color, shape]`. Message agreement between every sender pair is 100%. Across the 896 training and validation meanings, each sender uses 896 unique messages without collisions and has topographic similarity 1.0. + +The best condition was already selected at step 400. No 12-bit intermediate variant is therefore required: the direct 10-bit variant meets every sealed-development criterion. + +## Conclusion + +The 10-bit variant is frozen without further modification. The paired control retains the same factorized receiver but uses the 16-bit injective ECP-3 channel. No confirmatory test pair was evaluated before this choice. diff --git a/docs/development-log-ecp5.md b/docs/development-log-ecp5.md new file mode 100644 index 0000000..6f5c05b --- /dev/null +++ b/docs/development-log-ecp5.md @@ -0,0 +1,34 @@ +# Development log ECP-5 + +The ECP-5 test set remained sealed during development. + +## Cause analysis ECP-4 + +All five 10-bit populations communicated without error. However, four universal translators remained at 9.4–12.5%. Their symbol heads were not the problem: the hard receiver binding assigned factors to the wrong slots. The same error also occurred twice in the 16-bit control. + +## Exact calibration + +The new procedure calculates a `4×4` matrix of empirical mutual information and scores all 24 permutations. A test with a hidden synthetic slot order recovers the exact inverse binding and freezes it. All 35 tests pass. + +## Sealed development run + +Run: `runs/ecp5-development-final/20260718T062526Z-ecp5-development`
+Seed: 11 + +| Metric | Outcome | +|---|---:| +| Population known | 100% | +| Worst known pair | 100% | +| New size-texture validation | 100% | +| Worst validation pair | 100% | +| Calibrated universal translator | 100% | +| New receiver with 32 examples | 100% | +| New receiver with 128 examples | 100% | +| New receiver with 256 examples | 100% | +| New receiver with 512 examples | 100% | + +The chosen slot order by factor was `[2,3,0,1]`. The total mutual-information score was exactly 10.0 bits; the runner-up scored 8.0 bits. The choice is therefore not marginal. Even with only 32 examples, the correct permutation remained the clear winner. + +## Conclusion + +Calibration was frozen without further variants. With `binding_calibration.enabled`, no ECP-5 test pair was evaluated before this choice. diff --git a/docs/development-log-ecp6.md b/docs/development-log-ecp6.md new file mode 100644 index 0000000..7612042 --- /dev/null +++ b/docs/development-log-ecp6.md @@ -0,0 +1,36 @@ +# Development log ECP-6 + +The ECP-6 test set remained sealed throughout all work described below. + +## Scale invariants + +The code is generalized from the original factor sizes `[8,8,4,4]` to `[16,16,8,8]`. Configuration validation, meaning IDs, schemas, factor-local alphabets, and baselines now follow the actual factor sizes. The complete test suite has 39 passing tests. + +The first smoke attempt revealed one geometric scaling problem: topographic similarity materialized all `n(n-1)/2` pairs. The attempt was canceled before completion and without test access. The measurement now uses up to 1,000,000 deterministic, uniformly sampled pairs. A second smoke run completed normally and logged validation only. + +## Sealed development run + +Run: `runs/20260718T065639Z-ecp6-development`
+Seed: 11
+Test unsealed: no + +| Metric | Outcome | +|---|---:| +| Population known, mean | 100% | +| Worst known link | 100% | +| New color-shape validation, mean | 100% | +| Worst validation link | 100% | +| Universal translator on train | 100% | +| Universal translator on validation | 100% | +| Transfer with 32 examples, validation | 81.25% | +| Transfer with 128 examples, validation | 100% | +| Transfer with 512 examples, validation | 100% | +| Transfer with 2,048 examples, validation | 100% | + +Binding calibration selected the slot order `[1,0,3,2]`. The total mutual-information score was exactly 14.0 bits; the runner-up scored 8.0 bits. All four channels encoded the 15,360 accessible training and validation meanings. + +The development run wrote 16,384 episodes: `1,024 validation meanings × 4 senders × 4 receivers`. No test episode was written. + +## Freezing decision + +Development provided no reason for an additional variant. The world, explicit holdout pairs, 14-bit channel, training budgets, binding calibration, transfer budgets, topographic sampling rule, five seeds, and success criteria are therefore frozen unchanged for confirmation. diff --git a/docs/experiment-template.md b/docs/experiment-template.md index 4313633..8d6ee86 100644 --- a/docs/experiment-template.md +++ b/docs/experiment-template.md @@ -1,29 +1,29 @@ -# Experimentrapport ECP-__ +# Experiment report ECP-__ -## Registratie vóór de run +## Registration before the run - Experiment-ID: -- Datum: -- Onderzoeksvraag: -- Primaire hypothese: -- Configbestand en hash: -- Codecommit: -- Datasetmanifest en hash: +- Date: +- Research question: +- Primary hypothesis: +- Configuration file and hash: +- Code commit: +- Dataset manifest and hash: - Seeds: -- Vooraf vastgelegde succesdrempel: -- Geplande afwijkingen ten opzichte van ECP-0: +- Predefined success threshold: +- Planned deviations from ECP-0: -## Omgeving +## Environment -- Besturingssysteem: +- Operating system: - Hardware: -- Pythonversie: -- Framework en versie: -- Start- en eindtijd: +- Python version: +- Framework and version: +- Start and end time: -## Resultaten +## Results -| Run | Seed | Bekend exact | Compositie exact | Vertaling exact | Bits/bericht | Geldig? | +| Run | Seed | Known exact match | Compositional exact match | Translation exact match | Bits/message | Valid? | |---|---:|---:|---:|---:|---:|---| | 1 | | | | | | | | 2 | | | | | | | @@ -31,35 +31,34 @@ | 4 | | | | | | | | 5 | | | | | | | -## Baselines en controles +## Baselines and controls -| Baseline of controle | Verwachting | Waarneming | Geslaagd? | +| Baseline or control | Expectation | Observation | Passed? | |---|---|---|---| -| Gepakte factorcode | 10 bits, foutloos | | | -| Willekeurige lookup | Bekend hoog, compositie laag | | | -| Handmatig compositioneel | Bekend en compositie hoog | | | -| Berichten gehusseld | Ongeveer kansniveau | | | -| Symbool-ID's consistent gepermuteerd | Prestatie onveranderd | | | -| Kanaalisolatie | Geen nevenkanaal | | | +| Packed factor code | 10 bits, error-free | | | +| Random lookup | Known high, composition low | | | +| Manual compositional code | Known and composition high | | | +| Messages shuffled | Approximately chance level | | | +| Symbol IDs consistently permuted | Performance unchanged | | | +| Channel isolation | No side channel | | | -## Protocolanalyse +## Protocol analysis -- Aantal unieke berichten: -- Aantal botsingen: -- Berichtentropie: -- Topografische overeenkomst: -- Resultaat minimale-parenanalyse: -- Resultaat symboolablaties: -- Stabiliteit tussen seeds: +- Number of unique messages: +- Number of collisions: +- Message entropy: +- Topographic similarity: +- Result of minimal-pair analysis: +- Result of symbol ablations: +- Stability across seeds: -## Afwijkingen en incidenten +## Deviations and incidents -Beschrijf iedere afwijking, ook als deze ogenschijnlijk geen invloed had. Een niet vooraf geregistreerde inhoudelijke wijziging maakt de betreffende run ongeldig voor confirmatieve conclusies. +Describe every deviation, even if it appears to have no impact. Any unregistered content change renders the corresponding run invalid for confirmatory conclusions. -## Conclusie - -- Classificatie: sterk bewijs / gemengd bewijs / negatief resultaat / ongeldige run -- Wordt de hypothese ondersteund? -- Welke alternatieve verklaringen blijven mogelijk? -- Welke vooraf te registreren wijziging is gerechtvaardigd voor het volgende experiment? +## Conclusion +- Classification: strong evidence / mixed evidence / negative result / invalid run +- Does the hypothesis receive support? +- Which alternative explanations remain possible? +- Which pre-registered modification is justified for the next experiment? diff --git a/docs/onderzoeksopzet-ecp1.md b/docs/onderzoeksopzet-ecp1.md deleted file mode 100644 index 383931c..0000000 --- a/docs/onderzoeksopzet-ecp1.md +++ /dev/null @@ -1,67 +0,0 @@ -# Onderzoeksopzet ECP-1: populatie en overdraagbaarheid - -Status: bevroren voor confirmatieve uitvoering op 18 juli 2026 om 00:17:09 UTC -Ouderexperiment: ECP-0.2 - -## Aanleiding - -ECP-0 ontwikkelde vrijwel injectieve protocollen met aantoonbare semantische geometrie, maar slechts 15,9% gemiddelde exacte generalisatie naar volledig achtergehouden kleur-vormparen. De grote verschillen tussen seeds wijzen op co-adaptatie: één zender en één ontvanger kunnen samen een bruikbare maar slecht overdraagbare code stabiliseren. - -## Centrale hypothese - -> Als iedere zender tijdens training met meerdere onafhankelijk geparametriseerde ontvangers moet communiceren en omgekeerd, ontstaat meer druk naar een gedeeld, systematisch en overdraagbaar protocol. - -ECP-1 verandert daarom één primair mechanisme: één paar wordt vervangen door vier zenders en vier ontvangers. Kanaal, wereld, modellen en reconstructietaak blijven gelijk aan ECP-0.2. - -## Nieuwe en onafhankelijke testset - -De acht ECP-0-testparen zijn expliciet uitgesloten. ECP-1 gebruikt een nieuwe datasplitseed en accepteert alleen een één-op-éénmatching die geen enkel oud testpaar bevat. De nieuwe testset blijft gesloten tijdens ontwikkeling en modelselectie. - -Omdat de ECP-0-testset bekend is, mag die niet als confirmatieve ECP-1-test worden hergebruikt. - -## Populatietraining - -- Vier zenders en vier ontvangers starten met onafhankelijke initialisaties. -- Er worden geen gewichten, embeddings, gradients buiten het gekozen paar of verborgen toestanden gedeeld. -- Per stap produceren alle vier zenders ieder één bericht voor dezelfde willekeurige batch. -- Alle vier ontvangers reconstrueren ieder zenderbericht; de zestien verliezen worden gemiddeld. -- Iedere stap bevat daardoor alle zestien zender-ontvangerinteracties, zonder leider of voorkeursdialect. -- Over 7.000 stappen krijgt ieder paar evenveel directe leerinteracties als een ECP-0-paar. -- Modelselectie gebruikt alleen train en validatie. -- Een checkpoint is pas primair selecteerbaar bij minstens 99% gemiddelde bekende nauwkeurigheid én minstens 95% voor het slechtste paar. - -## Universele vertaler en nieuwe ontvanger - -Na het bevriezen van de populatie wordt één nieuwe ontvanger getraind op berichten van alle vier zenders. Deze ontvanger heeft geen toegang tot de oorspronkelijke ontvangers en fungeert tegelijk als universele vertaler. - -Een overdrachtscurve traint daarnaast verse ontvangers met 32, 128, 512 en 768 unieke trainingsbetekenissen. Alle vier zenders leveren berichten voor dezelfde geselecteerde betekenissen. De curve meet of het populatieprotocol met weinig voorbeelden kan worden overgenomen. - -## Primaire uitkomstmaten - -1. gemiddelde exacte nauwkeurigheid over alle zestien paren; -2. nauwkeurigheid van het slechtste paar; -3. gemiddelde nauwkeurigheid op de nieuwe achtergehouden kleur-vormparen; -4. nauwkeurigheid van de universele vertaler op die paren. - -Sterk bewijs vereist in minstens vier van vijf geldige seeds: - -- minimaal 99% gemiddeld op bekende betekenissen; -- minimaal 95% voor het slechtste bekende paar; -- minimaal 60% gemiddeld op de compositionele test; -- minimaal 50% voor de universele vertaler op de compositionele test. - -## Controles - -- Definitieve zender- en ontvangerevaluaties draaien in afzonderlijke processen. -- Ontvangers krijgen alleen de symboolmatrix. -- Berichten worden binnen iedere zender gehusseld; de nauwkeurigheid moet tot maximaal 1% dalen. -- Een consistente vocabulairepermutatie wordt op alle berichten en ontvangerembeddings toegepast; voorspellingen moeten identiek blijven. -- Resultaten worden per paar en als populatiegemiddelde opgeslagen, zodat een goed gemiddelde geen falend paar verbergt. - -## Interpretatie - -Een verbetering ten opzichte van ECP-0 ondersteunt de hypothese dat communicatieve diversiteit co-adaptatie vermindert. Geen verbetering is eveneens informatief: dan is alleen populatiedruk onvoldoende en moet ECP-2 iteratief leren, progressieve reconstructie of explicietere contextdruk isoleren. - -Compressie naar 12 bits wordt in ECP-1 bewust niet getest. Eerst moet de semantische overdracht stabieler worden. - -De vijf seeds mogen gelijktijdig in afzonderlijke processen draaien. Dit verandert geen data, modelinteractie of random generator binnen een seed en dient uitsluitend om de wandkloktijd te verkorten. diff --git a/docs/onderzoeksopzet-ecp2.md b/docs/onderzoeksopzet-ecp2.md deleted file mode 100644 index ab3e7be..0000000 --- a/docs/onderzoeksopzet-ecp2.md +++ /dev/null @@ -1,101 +0,0 @@ -# Onderzoeksopzet ECP-2: algebraïsch consistent emergent protocol - -Status: bevroren voor confirmatieve uitvoering op 18 juli 2026 om 01:31:00 UTC -Ouderexperiment: ECP-1 -Interventieconfiguratie: `config/ecp2.yaml` -Controleconfiguratie: `config/ecp2-control.yaml` - -## Aanleiding - -ECP-1 liet zien dat vier onafhankelijke zenders en vier onafhankelijke ontvangers een gedeeld protocol kunnen stabiliseren. De populatiegeneraliseerbaarheid daalde desondanks van 15,9% in ECP-0 naar 10,1%. Alleen meerdere communicatiepartners aanbieden is dus onvoldoende. - -Dat resultaat past bij bestaand onderzoek. Lee vond eveneens dat alleen één zender naar meerdere luisteraars laten uitzenden niet vanzelf meer compositionaliteit oplevert ([EMNLP 2024](https://aclanthology.org/2024.emnlp-main.1157/)). Rita et al. schrijven slechte emergente generalisatie mede toe aan overfitting van co-adaptatie ([NeurIPS 2022](https://openreview.net/forum?id=qqHMvHbfu6)). Chaabouni et al. laten zien dat compositionelere protocollen gemakkelijker overdraagbaar zijn, maar dat gewone generalisatiedruk compositionaliteit niet noodzakelijk laat ontstaan ([ACL 2020](https://aclanthology.org/2020.acl-main.407/)). - -## Centrale hypothese - -> Een protocol generaliseert beter wanneer dezelfde atomaire betekenisverandering in verschillende contexten een vergelijkbare verandering in de interne berichtverdeling veroorzaakt. - -Voor een factorverandering `A → A'` en dezelfde verandering in een andere context `B → B'` minimaliseert ECP-2: - -`||(M(A') − M(A)) − (M(B') − M(B))||²` - -`M` is de door de zender geleerde verdeling over de vier posities en zestien symbolen. De uiteindelijke communicatie blijft exact hetzelfde harde 16-bitkanaal als in ECP-1. - -## Wat niet wordt voorgeprogrammeerd - -- Geen symbool krijgt vooraf een betekenis. -- Geen berichtpositie wordt aan kleur, vorm, grootte of textuur toegewezen. -- De vier zenders delen geen parameters of embeddings. -- De regularisatie schrijft niet voor welk bericht een betekenis moet krijgen. -- De ontvangers zien alleen de geproduceerde symbolen en niet de algebraïsche viertallen. - -De experimentele druk gebruikt wel de bekende factorstructuur van de kunstmatige wereld. Dit is een expliciete inductieve bias en moet in de interpretatie worden meegewogen. Het experiment test dus of agents binnen zo'n algemene consistentiedruk zelf een bruikbaar discreet protocol ontdekken, niet of compositionaliteit zonder enige omgevingsstructuur ontstaat. - -## Algebraïsche trainingsviertallen - -Ieder viertal bevat `A`, `B`, `A'` en `B'`: - -1. `A → A'` verandert precies één factorwaarde; -2. `B → B'` verandert exact dezelfde bronwaarde naar dezelfde doelwaarde; -3. de overige factoren vormen verschillende contexten; -4. alle vier betekenissen moeten in de trainingsset staan; -5. validatie- en testbetekenissen worden nooit als regularisatie-invoer gebruikt. - -Daardoor kan de zender bijvoorbeeld leren dat één kleurverandering zich contextinvariant gedraagt, zonder dat vooraf wordt bepaald welk symbool of welke positie die verandering draagt. - -## Twee onafhankelijke compositionele hold-outs - -ECP-2 corrigeert een methodologische zwakte uit ECP-0 en ECP-1. De oude validatiesets bevatten losse betekenissen waarvan de kleur-vormparen al in training voorkwamen. Ze maten daardoor vooral interpolatie. - -ECP-2 reserveert twee volledige en onderling disjuncte matchings: - -- 128 betekenissen uit acht kleur-vormparen vormen de compositionele validatieset; -- 128 betekenissen uit acht andere paren vormen de verzegelde compositionele testset; -- de resterende 768 betekenissen vormen de training; -- alle zestien eerder geopende ECP-0- en ECP-1-testparen zijn voor beide nieuwe matchings uitgesloten. - -De validatieset mag voor modelselectie worden gebruikt. De testset wordt tijdens ontwikkeling niet gecodeerd, gedecodeerd of geëvalueerd. - -## Ontwikkelvergelijking - -Met seed 11 worden maximaal vier vooraf gekozen gewichten vergeleken: - -| Variant | Algebraïsch gewicht | -|---|---:| -| Controle | 0 | -| Licht | 0,25 | -| Midden | 1,0 | -| Sterk | 4,0 | - -De gekozen variant is de variant met de hoogste exacte compositionele validatieprestatie, mits bekende betekenissen gemiddeld minstens 97% en voor het slechtste paar minstens 95% halen. Bij een verschil kleiner dan twee procentpunten wint het lagere gewicht. - -Na deze keuze worden architectuur, gewicht, trainingsduur, vijf seeds en uitkomstdrempels bevroren. De controle en interventie gebruiken in de confirmatieve fase exact dezelfde split, seeds, populatiearchitectuur en trainingsbegroting. - -## Confirmatieve eisen voor een ontwikkeld ECP-2-model - -Sterk bewijs vereist in minstens vier van vijf interventieruns: - -- minstens 97% bekende reconstructie gemiddeld; -- minstens 95% voor het slechtste bekende zender-ontvangerpaar; -- minstens 80% exacte reconstructie op de verzegelde compositionele test; -- minstens 70% voor één onafhankelijke universele vertaler; -- geslaagde kanaalisolatie-, hussel- en symboolpermutatiecontroles. - -Daarnaast moet het gemiddelde van de interventie hoger zijn dan dat van de gepaarde controle op dezelfde testmatching. Alleen een hogere ECP-1-referentiescore is niet voldoende. - -## Vervolg bij een negatieve ontwikkeluitkomst - -Als geen algebraïsch gewicht de compositionele validatie duidelijk verbetert, wordt de testset niet geopend. De volgende ontwikkelvariant wordt dan generatietransmissie: agents worden periodiek vervangen en nieuwe agents krijgen een beperkte transmissiebottleneck. Dat volgt de positieve resultaten over iteratief en generationeel leren van [Guo et al.](https://arxiv.org/abs/1910.05291) en [Cogswell et al.](https://openreview.net/forum?id=r1gzoaNtvr¬eId=SJl3j-ScjB). - -## Bevroren definitieve variant - -De algebraïsche interventie faalde en culturele transmissie verbeterde compositionele validatie tot 19,9%, maar niet tot de vooraf gekozen prestatiedrempel. De definitieve kandidaat gebruikt daarom de transparant geregistreerde permutationslotarchitectuur met betekenisvrije bindingsconsensus: - -- iedere zender kiest intern één van 24 factor-slotpermutaties; -- geen concrete permutatie, symboolbetekenis of symboolcode is vooraf opgegeven; -- vier onafhankelijke zenders krijgen consensusgewicht 5,0 op hun zachte bindingsmatrices; -- de controlegroep gebruikt exact dezelfde slotarchitectuur zonder consensusdruk; -- beide armen gebruiken dezelfde vijf seeds, split, trainingsbegroting, vertaler en overdrachtscurve; -- de verzegelde test wordt pas geopend nadat beide effectieve configuraties zijn vastgelegd. - -De sterke ontwikkelvariant behaalde 100% bekend, 97,0% compositionele validatie en 95,3% universele vertalervalidatie. Deze ontwikkelprestatie is geen confirmatief resultaat. diff --git a/docs/onderzoeksopzet-ecp3.md b/docs/onderzoeksopzet-ecp3.md deleted file mode 100644 index a06be4d..0000000 --- a/docs/onderzoeksopzet-ecp3.md +++ /dev/null @@ -1,57 +0,0 @@ -# Onderzoeksopzet ECP-3 - -Status: **bevroren vóór confirmatieve testtoegang** -Bevroren: 18 juli 2026 om 02:07:44 UTC -Interventieconfiguratie: `config/ecp3.yaml` -SHA-256: `2cab56d55a0364a218755d8815a7efaf36292896a125fdc4c593150c19b93f6e` -Controleconfiguratie: `config/ecp3-control.yaml` -SHA-256: `9569c5f5cef10681f4fd02ba0c70907910246d14802836ffe5bf0d2c5f0edcfa` - -## Vraag - -Verwijdert een harde injectiviteitsvoorwaarde voor atomaire factorcodes de lokale symboolbotsingen van ECP-2 en ontstaat daardoor een robuust compositioneel populatieprotocol? - -## Model - -Vier onafhankelijke zenders communiceren met vier onafhankelijke ontvangers via exact vier symbolen uit een vocabulaire van zestien. Iedere zender leert twee soorten arbitraire discrete toewijzingen: - -1. een vrije één-op-éénpermutatie van de vier factoren naar de vier berichtslots; -2. per factor een vrije injectieve toewijzing van factorwaarden naar symbolen. - -Een Sinkhorn-benadering levert de gradiënten; verzending en evaluatie gebruiken uitsluitend een harde factor-slotpermutatie en harde unieke symbolen. De interventie lijnt de zachte slot- en atoomtoewijzingen tussen zenders uit. De gepaarde controle heeft exact dezelfde injectieve architectuur, split, seeds en trainingsbegroting, maar beide consensusverliezen staan uit. - -Geen slot en geen symbool krijgt vooraf een betekenis. Wel is vooraf vastgelegd dat iedere factor één positie gebruikt en dat twee waarden van dezelfde factor niet hetzelfde symbool mogen hebben. ECP-3 is dus een expliciet factorieel inductief vooroordeel, geen bewijs van ongestuurde taalemergentie. - -## Nieuwe verzegelde split - -De wereld blijft `8 × 8 × 4 × 4 = 1024` betekenissen groot. ECP-3 gebruikt: - -- 768 trainingsbetekenissen; -- 128 betekenissen uit één volledig achtergehouden kleur-vormmatching voor selectie; -- 128 betekenissen uit een tweede volledig achtergehouden matching voor de eenmalige confirmatieve test. - -Alle ECP-0-, ECP-1- en ECP-2-testparen zijn uitgesloten. Uit extra voorzichtigheid zijn ook de acht ECP-2-validatieparen uitgesloten, omdat zij de architectuurkeuze hebben beïnvloed. De nieuwe split heeft SHA-256 `91d6439fada82b1384a8d03f7cc1f5602091f794477be31c179c5a26e1b0464b`. - -## Vooraf vastgelegde criteria - -Per seed vereist sterk bewijs: - -- minstens 97% bekende gemiddelde exacte reconstructie; -- minstens 95% voor het slechtste bekende zender-ontvangerpaar; -- minstens 80% gemiddelde exacte reconstructie op nieuwe testparen; -- minstens 70% exacte reconstructie door de universele vertaler. - -De populatie-uitkomst is sterk bij minstens vier van vijf sterke seeds. Vijf vooraf vastgelegde seeds (`11, 23, 37, 53, 71`) worden gebruikt. Resultaten worden ook als gepaarde verschillen ten opzichte van de controle gerapporteerd, inclusief de exacte eenzijdige tekenomklaptoets over alle `2^5 = 32` tekencombinaties. - -Het model geldt als bruikbaar ECP-basismodel wanneer de interventie minstens vier sterke seeds oplevert, alle kanaalcontroles slaagt en geen artefactintegriteitsfout bevat. Een controle-effect is informatief over consensus, maar geen aanvullende voorwaarde voor bruikbaarheid van het model zelf. - -## Integriteitscontroles - -- De testmatching wordt niet gebruikt voor training, vroegstoppen of selectie. -- Zenders en ontvangers delen geen parameters, embeddings of toestand. -- Definitieve evaluatie draait in afzonderlijke processen; ontvangers ontvangen alleen symboolmatrices. -- Alle berichten en reconstructies worden schema-gevalideerd en gelogd. -- Husselen moet onder 1% exact blijven. -- Consistente hernoeming van symbolen moet alle voorspellingen behouden. -- Alle vooraf geschreven artefacten worden na afloop gehasht en opnieuw gecontroleerd. - diff --git a/docs/onderzoeksopzet-ecp4.md b/docs/onderzoeksopzet-ecp4.md deleted file mode 100644 index 0cd4a8d..0000000 --- a/docs/onderzoeksopzet-ecp4.md +++ /dev/null @@ -1,72 +0,0 @@ -# Onderzoeksopzet ECP-4 — theoretisch minimale 10-bitcode - -Status: **bevroren vóór confirmatieve testtoegang** -Bevroren: 18 juli 2026 om 06:11:20 UTC -Interventieconfiguratie: `config/ecp4.yaml` -SHA-256: `c335483534248eda96094ceea7ff49cd3270256fdfff6e01824654a886bc6e17` -Controleconfiguratie: `config/ecp4-control.yaml` -SHA-256: `84c1024d49c9d2aff34fb56dbcabf41c9af76dc2ba478760e42d1098afa777c8` - -## Vraag - -Kan het ECP-protocol van 16 naar exact 10 bits worden gecomprimeerd — de bronondergrens van de uniforme wereld — zonder compositionele generalisatie, populatiecompatibiliteit of universele vertaling te verliezen? - -## Waarom 10 bits minimaal is - -De wereld bevat `8 × 8 × 4 × 4 = 1024 = 2^10` equiprobabele betekenissen. Iedere ondubbelzinnige code vereist daarom minstens `log2(1024) = 10` bits. - -ECP-4 gebruikt vier lokale factoralfabetten: - -| Factor | Waarden | Bits | -|---|---:|---:| -| Kleur | 8 | 3 | -| Vorm | 8 | 3 | -| Grootte | 4 | 2 | -| Textuur | 4 | 2 | -| **Totaal** | **1024 combinaties** | **10** | - -Iedere zender kiest vrij een permutatie van factor naar slot en binnen iedere factor een vrije permutatie van waarde naar lokaal symbool. De semantiek van slots en symbolen is dus niet vooraf benoemd. Wel is de minimale factorstructuur als architectuurbias opgelegd. - -## Factor-geïsoleerde ontvanger - -ECP-3 had één uitbijter doordat een algemene GRU kleur en vorm als gezamenlijke contextregel kon memoriseren. ECP-4 laat iedere factoruitgang exact één vrij geleerd slot lezen. Een wijziging in een ander slot kan die uitgang architectonisch niet beïnvloeden. Iedere ontvanger leert zijn eigen harde slotpermutatie en deelt geen parameters met zenders of andere ontvangers. - -De universele vertaler en nieuwe overdrachtsontvangers gebruiken dezelfde factor-geïsoleerde architectuur, maar worden pas na het bevriezen van het zenderprotocol onafhankelijk getraind. - -## Laatste onafhankelijke kleur-vormsplit - -Na ECP-0 tot en met ECP-3 waren 48 van de 64 kleur-vormparen gebruikt als validatie of test. De resterende zestien paren vormen exact twee perfecte matchings. Zij zijn expliciet, zonder sampling, verdeeld over: - -- acht ontwikkelvalidatieparen; -- acht verzegelde confirmatieve testparen. - -De split heeft SHA-256 `0f8b5505e1a3dceb0c87005a32d6bcffd39c66a6bb4246102617c92a8915b180`. Na ontzegeling van deze test zijn alle 64 kleur-vormparen minstens eenmaal als validatie of test gebruikt; vervolgonderzoek moet daarom een nieuwe wereld of een orthogonale holdoutfamilie gebruiken. - -## Gepaarde 16-bitcontrole - -De controle gebruikt exact dezelfde split, vijf seeds, factor-geïsoleerde ontvangers, consensusverliezen, trainingsbegroting en evaluatie. Alleen de zendercode en het kanaal verschillen: - -- interventie: lokale alfabetten `8,8,4,4`, exact 10 bits; -- controle: vier globale symbolen uit zestien, 16 bits. - -Hierdoor meet de vergelijking of theoretisch minimale compressie prestatiedaling veroorzaakt binnen dezelfde verbeterde decoderarchitectuur. - -## Vooraf vastgelegde criteria - -Per seed vereist sterk bewijs: - -- minstens 97% bekende gemiddelde exacte reconstructie; -- minstens 95% voor het slechtste bekende zender-ontvangerpaar; -- minstens 80% gemiddelde exacte reconstructie op nieuwe testparen; -- minstens 70% exacte reconstructie door de universele vertaler. - -ECP-4 geldt als geslaagd minimaal model wanneer: - -1. minstens vier van vijf interventieseeds sterk zijn; -2. de interventie exact 10 kanaalbits gebruikt; -3. alle zendercodes injectief en botsingsvrij zijn; -4. alle kanaal- en integriteitscontroles slagen; -5. de gemiddelde testexactheid niet meer dan één procentpunt onder de gepaarde 16-bitcontrole ligt. - -Vijf seeds (`11,23,37,53,71`) en een exacte gepaarde tekenomklaptoets over 32 tekencombinaties zijn vooraf vastgelegd. Het ideale resultaat is vijf foutloze seeds, maar de formele succesregel blijft vier van vijf om consistent te zijn met ECP-3. - diff --git a/docs/onderzoeksopzet-ecp5.md b/docs/onderzoeksopzet-ecp5.md deleted file mode 100644 index f9ac51f..0000000 --- a/docs/onderzoeksopzet-ecp5.md +++ /dev/null @@ -1,51 +0,0 @@ -# Onderzoeksopzet ECP-5 — robuuste protocolinductie - -Status: **bevroren vóór confirmatieve testtoegang** -Bevroren: 18 juli 2026 om 06:27:09 UTC -Interventieconfiguratie: `config/ecp5.yaml` -SHA-256: `5e4bf30517e0edbe96d5f0b5c666b9b03f6fe8366fd80bcc5ab455d615d11b8b` -Controleconfiguratie: `config/ecp5-control.yaml` -SHA-256: `4ee2f8ff314acd6f042c66fd4e81b6beb0c360b979f585f5d00b0e9df6ed2582` - -## Vraag - -Kan een nieuwe universele lezer de arbitraire slotgrammatica van het perfecte 10-bitprotocol betrouwbaar induceren wanneer de discrete factor-slotpermutatie exact uit gelabelde trainingsberichten wordt gekalibreerd? - -## Interventie - -Voor iedere combinatie van vier factoren en vier slots wordt de empirische wederzijdse informatie berekend. Er zijn slechts `4! = 24` geldige één-op-éénpermutaties. De interventie kiest exhaustief de permutatie met de hoogste totale informatie en bevriest die binding voordat de vier symbooldecoders worden getraind. - -De procedure: - -- leest alleen berichten en betekenislabellen uit de toegestane trainingsset; -- opent geen validatie- of testbetekenissen; -- leest geen zenderparameters, codeboeken of verborgen toestand; -- schrijft geen symboolbetekenissen voor; -- bepaalt uitsluitend welke berichtpositie statistisch bij welke factor hoort. - -De gepaarde controle leert dezelfde binding opnieuw met de bestaande straight-throughgradiënten. Alle overige code, data, seeds en trainingsbudgetten zijn identiek. - -## Orthogonale verzegelde test - -Omdat na ECP-4 alle kleur-vormparen als validatie of test waren gebruikt, schakelt ECP-5 vooraf over op een grootte-textuurholdout: - -- 512 trainingsbetekenissen; -- 256 betekenissen uit vier volledig achtergehouden validatieparen; -- 256 betekenissen uit vier andere, verzegelde testparen. - -Kleur en vorm variëren volledig binnen ieder achtergehouden paar. De split-SHA-256 is `cc487fd9042c5190bee93278c4be5180363f46a46d0e8af2f9d7d75a4f173140`. - -## Criteria - -Per seed blijven de ECP-3/4-drempels gelden: 97% bekend gemiddeld, 95% voor het slechtste bekende paar, 80% compositionele testexactheid en 70% universele vertaalexactheid. - -ECP-5 is geslaagd wanneer: - -1. minstens vier van vijf interventieseeds sterk zijn; -2. de gemiddelde populatie- en vertaalexactheid ieder minstens 95% zijn; -3. ieder bericht exact 10 bits gebruikt en alle codes botsingsvrij zijn; -4. alle kanaal- en artefactcontroles slagen; -5. de gekalibreerde vertaler in minstens vier van vijf seeds beter presteert dan de ongekalibreerde controle of daarmee gelijk eindigt op 100%. - -Seeds `11,23,37,53,71` en de exacte gepaarde tekenomklaptoets zijn vóór testtoegang vastgelegd. - diff --git a/docs/onderzoeksopzet-ecp6.md b/docs/onderzoeksopzet-ecp6.md deleted file mode 100644 index 6db4de7..0000000 --- a/docs/onderzoeksopzet-ecp6.md +++ /dev/null @@ -1,66 +0,0 @@ -# Onderzoeksopzet ECP-6 — schaalbaarheid op de informatiegrens - -Status: **bevroren vóór confirmatieve testtoegang** -Bevroren: 18 juli 2026 om 06:58:14 UTC -Configuratie: `config/ecp6.yaml` -Configuratie-SHA-256: `994ca086e1542e4608fec935ec5b72471b2e2cf73c2193f99ab6997044c40133` - -## Vraag - -Blijft het in ECP-5 bevestigde, universeel leesbare protocol volledig correct wanneer de betekenisruimte zestienmaal groter wordt, terwijl de berichten exact op de nieuwe theoretische ondergrens van 14 bits blijven? - -## Schaalvergroting - -De wereld bevat vier onafhankelijke factoren: - -- 16 kleuren; -- 16 vormen; -- 8 groottes; -- 8 texturen. - -Daarmee zijn er `16 × 16 × 8 × 8 = 16.384 = 2^14` equiprobabele betekenissen. Het factorlokale bericht gebruikt vier slots met alfabetgroottes `[16,16,8,8]`. De breedtes zijn `[4,4,3,3]` bits en tellen op tot exact 14 bits. Een verliesloze vaste code kan voor deze wereld niet korter zijn. - -## Gesloten datasplitsing - -Kleur en vorm vormen de compositionele holdout. Voor validatie en test zijn elk zestien kleur-vormparen vooraf expliciet vastgelegd. Ieder achtergehouden paar bevat minstens één atomaire waarde uit de nieuwe helft (`8–15`), zodat de schaaluitbreiding daadwerkelijk wordt aangesproken. - -| Split | Betekenissen | Kleur-vormparen | -|---|---:|---:| -| Train | 14.336 | 224 | -| Validatie | 1.024 | 16 | -| Confirmatieve test | 1.024 | 16 | - -Split-SHA-256: `da751db7853ddbb84f000464c2627d4880eb154aef2158fb958d9a3779117d33`. - -## Vastgelegd protocol - -De architectuur en inductieregel blijven inhoudelijk gelijk aan ECP-5: - -1. vier onafhankelijk geïnitialiseerde zenders produceren een factorlokale permutationslotcode; -2. vier ontvangers worden over alle zestien zender-ontvangerkoppelingen getraind; -3. een nieuwe universele vertaler krijgt uitsluitend gelabelde trainingsberichten; -4. de vertaler bepaalt zijn factor-slotbinding door alle `4! = 24` permutaties op empirische wederzijdse informatie te vergelijken en bevriest de winnaar; -5. overdracht wordt gemeten met 32, 128, 512 en 2.048 voorbeelden. - -Er is geen nieuwe controlearm: ECP-5 heeft de bindingsinterventie al rechtstreeks gepaard getoetst. ECP-6 is uitsluitend een vooraf vastgelegde schaalreplicatie van de succesvolle interventie. - -## Schaalveilige metingen - -Botsingen, entropie, minimale paren en exacte taakprestatie worden over alle geëvalueerde betekenissen berekend. Voor topografische Spearman-correlatie worden bij maximaal 1.000.000 ongeordende betekenisparen uniform zonder teruglegging en met een vaste seed bemonsterd; kleinere werelden gebruiken alle paren. Deze regel is ingevoerd en getest vóór testontzegeling, omdat alle 134.209.536 paren tegelijk materialiseren niet schaalbaar is. - -Ruwe geïsoleerde bericht- en voorspellingsmatrices blijven iedere geëvalueerde betekenis afdekken. Episode-JSONL bevat validatie en, pas na ontzegeling, test. De lokale kanaalaudit controleert ieder gelogd bericht op vier symbolen, factorlokale alfabetgrenzen en exact 14 bits. - -## Vooraf vastgelegde criteria - -De vijf seeds zijn `11,23,37,53,71`. Een seed is sterk wanneer de bestaande ECP-5-drempels worden gehaald: minstens 97% gemiddelde bekende exactheid, minstens 95% voor het slechtste bekende paar, minstens 80% gemiddelde compositionele testexactheid en minstens 70% universele vertaalexactheid. - -ECP-6 geldt als volledig geslaagd wanneer: - -1. minstens vier van vijf seeds sterk zijn; -2. de gemiddelde compositionele populatieprestatie minstens 99% is; -3. de gemiddelde universele vertaalprestatie minstens 99% is; -4. iedere zender alle 16.384 betekenissen botsingsvrij encodeert; -5. ieder bericht aantoonbaar exact 14 bits gebruikt; -6. alle artefacthashes, schemas, lokale alfabetgrenzen en testontzegelingscontroles slagen. - -Na bevriezing worden geen model-, split-, meet- of drempelkeuzes meer aangepast op basis van ECP-6-testuitkomsten. diff --git a/docs/onderzoeksopzet.md b/docs/onderzoeksopzet.md deleted file mode 100644 index d79dd7b..0000000 --- a/docs/onderzoeksopzet.md +++ /dev/null @@ -1,256 +0,0 @@ -# Onderzoeksopzet: emergente AI-communicatie - -Versie: 0.2 -Datum: 17 juli 2026 -Eerste experiment: ECP-0 - -## 1. Doel - -Dit onderzoek test of AI-agents onder gecontroleerde omstandigheden zelf een communicatieprotocol kunnen ontwikkelen dat: - -- informatie betrouwbaar overdraagt; -- compacter is dan menselijke tekstrepresentaties; -- nieuwe combinaties kan beschrijven; -- door een onafhankelijke vertaler kan worden gereconstrueerd; -- door agents buiten het oorspronkelijke trainingspaar kan worden geleerd; -- controleerbaar blijft doordat alle communicatie door één meetbaar kanaal loopt. - -Het onderzoek maakt onderscheid tussen een **code** en een **taalachtig protocol**. Een code kan iedere complete betekenis een willekeurig nummer geven. Een taalachtig protocol hergebruikt onderdelen of structuren en kan daardoor onbekende betekenissen samenstellen. - -## 2. Centrale onderzoeksvraag - -> Kunnen onafhankelijk getrainde AI-agents zelf een communicatieprotocol ontwikkelen dat bij gelijke taakprestatie efficiënter, duidelijker en systematischer is dan menselijke taal? - -### Deelvragen - -1. Ontstaat er zonder menselijke woorden een betrouwbaar discrete protocol? -2. Generaliseert dit protocol naar nooit getrainde combinaties? -3. Is de interne structuur achteraf systematisch te verklaren? -4. Kan een onafhankelijke vertaler de berichten correct ontsluiten? -5. Kan een nieuwe ontvanger het protocol leren zonder gezamenlijk met de oorspronkelijke zender te co-adapteren? -6. Hoe verandert het protocol onder druk van berichtkosten, ruis, context en complexere redeneertaken? - -## 3. Operationele definities - -### Nieuw - -De betekenis van individuele symbolen en symboolreeksen is niet door een mens vastgelegd. Alleen de taak, wereld en kanaalcapaciteit zijn ontworpen. - -### Efficiënt - -Een protocol ligt gunstiger op de afruil tussen taakprestatie en kosten. Kosten worden primair in daadwerkelijk verzonden bits gemeten; latency, rekenkosten en foutgevoeligheid worden apart gerapporteerd. - -### Duidelijk - -De ontvanger komt bij hetzelfde bericht reproduceerbaar tot de bedoelde betekenis, ook bij ongeziene combinaties en beperkte ruis. - -### Vertaalbaar - -Een onafhankelijk model, dat niet met de agents is meegetraind, kan een bevroren bericht naar de canonieke betekenis en vervolgens naar Nederlands omzetten. - -### Overdraagbaar - -Een nieuwe ontvanger kan met een beperkte hoeveelheid voorbeelden leren communiceren met de bevroren oorspronkelijke zender. - -### Volledig efficiënt - -Dit wordt niet als absolute eigenschap gebruikt. Efficiëntie bestaat alleen ten opzichte van een taakverdeling, kanaal, fouttolerantie en hardware. Stap 3 zoekt daarom een Paretofront in plaats van één universeel optimum. - -## 4. Vooraf vastgelegde hypothesen - -- **H1 — Betrouwbaarheid:** minstens vier van vijf ECP-0-runs bereiken 99% exacte reconstructie op bekende betekenissen. -- **H2 — Combinatorische generalisatie:** een geleerd protocol presteert op achtergehouden kleur-vormparen duidelijk boven een niet-compositionele lookupbaseline. -- **H3 — Vertaalbaarheid:** een onafhankelijke vertaler generaliseert boven de lookupbaseline naar dezelfde achtergehouden paren. -- **H4 — Structuur:** betekenisafstand en berichtafstand vertonen meer samenhang dan bij willekeurig gepermuteerde berichten. -- **H5 — Overdracht:** in stap 2 leert een nieuwe ontvanger het bevroren protocol met minder voorbeelden dan een volledig nieuw protocol. -- **H6 — Efficiëntie:** in stap 2 verlaagt een bitstraf de gemiddelde berichtlengte zonder een vooraf bepaalde prestatiedrempel te onderschrijden. - -Een negatieve uitkomst is een geldig resultaat. Drempels mogen na het bekijken van de testresultaten niet met terugwerkende kracht worden aangepast. - -## 5. Stap 1 — ECP-0: vertaalbare basis - -### 5.1 Kunstmatige wereld - -Iedere betekenis is het cartesisch product van vier factoren: - -| Factor | Aantal waarden | Interne representatie | -|---|---:|---| -| kleur | 8 | `c0` t/m `c7` | -| vorm | 8 | `s0` t/m `s7` | -| grootte | 4 | `z0` t/m `z3` | -| textuur | 4 | `t0` t/m `t3` | - -Dit levert 1024 unieke betekenissen op. Menselijke labels mogen voor visualisatie bestaan, maar worden nooit als modelinvoer gebruikt. - -De bron is uniform verdeeld. Daardoor is voor foutloze identificatie minimaal `log2(1024) = 10` bits informatie nodig. - -### 5.2 Communicatietaak - -1. De zender ontvangt één betekenis als vier categorische factoren. -2. De zender produceert exact vier symbolen. -3. De ontvanger ziet uitsluitend die vier symbolen. -4. De ontvanger voorspelt alle vier factoren. -5. Een aflevering is alleen exact correct als alle vier factoren kloppen. - -Het kanaal bevat 16 mogelijke symbolen. Eén symbool kost dus 4 bits en ieder ECP-0-bericht kost exact 16 bits. De symbolen hebben bij aanvang geen betekenis. ECP-0.2 gebruikt deze extra ruimte om eerst leerbaarheid en vertaalbaarheid te testen; compressie naar drie symbolen/12 bits wordt in stap 2 onderzocht. - -### 5.3 Agents - -- Beide agents worden vanaf willekeurige initialisatie getraind. -- Ze gebruiken afzonderlijke gewichten, embeddings en random seeds. -- Ze krijgen geen voorgetraind taalmodel en geen natuurlijke taal als invoer. -- Tijdens training mag een straight-through Gumbel-Softmaxschatting worden gebruikt. -- Tijdens validatie en test worden uitsluitend harde gehele symbool-ID's verzonden. -- Voor de definitieve evaluatie draaien zender en ontvanger als logisch gescheiden processen. - -Het doorgeven van gradients tijdens training is leersignaal, geen evaluatiekanaal. Alle conclusies worden uitsluitend op discrete evaluatie gebaseerd. - -### 5.4 Datasplitsing - -De splitsing wordt vóór training deterministisch gegenereerd: - -1. Maak met de vastgelegde datasplitseed een willekeurige één-op-éénkoppeling tussen de acht kleuren en acht vormen. Zo komt iedere kleur en iedere vorm precies één keer in een achtergehouden paar voor. -2. Houd voor ieder paar alle 16 combinaties van grootte en textuur achter. -3. Dit vormt een compositionele testset van 128 betekenissen. -4. Selecteer uit de overige 896 betekenissen een gestratificeerde ontwikkelset van 128 betekenissen. -5. De resterende 768 betekenissen vormen de trainingsset. - -Iedere atomaire waarde komt in training voor. Alleen specifieke combinaties ontbreken. De testset blijft verzegeld tot model- en hyperparameterkeuzes zijn afgerond. - -### 5.5 Bevriezen en vertalen - -Na training worden zender en ontvanger bevroren. Daarna wordt een derde model getraind: - -- invoer: uitsluitend het discrete bericht; -- uitvoer: de vier canonieke factoren; -- training: alleen berichten uit de trainingssplitsing; -- evaluatie: de ontwikkelset en daarna eenmalig de compositionele testset. - -Een Nederlandse renderer zet de voorspelde factoren deterministisch om naar leesbare tekst. De renderer telt niet als intelligente vertaler; de prestatie wordt gemeten op de voorspelde canonieke factoren. - -### 5.6 Baselines - -| Baseline | Functie | -|---|---| -| Nederlands sjabloon | Vergelijking met menselijke leesbaarheid en UTF-8-grootte | -| Canonieke JSON | Vergelijking met gangbare machinecommunicatie | -| Handmatig gepakte factorcode, 10 bits | Domeinspecifieke technische ondergrens | -| Willekeurige lookupcode | Hoge bekende-setprestatie zonder compositionaliteit | -| Handmatig compositionele factorcode | Controle voor maximaal expliciete structuur | - -De vergelijking met Nederlands en JSON gaat over berichtgrootte, niet over algemene expressiviteit. De 10-bit factorcode voorkomt de onjuiste claim dat een geleerd protocol iedere ontworpen binaire representatie kan verslaan. - -### 5.7 Primaire metingen - -- exacte reconstructienauwkeurigheid; -- nauwkeurigheid per factor; -- prestatie op bekende en achtergehouden betekenissen; -- daadwerkelijk aantal kanaalbits; -- berichtentropie en aantal unieke berichten; -- botsingen: verschillende betekenissen met hetzelfde bericht; -- topografische overeenkomst tussen betekenis- en berichtafstand; -- minimale-paaranalyse en symboolablatie; -- onafhankelijke vertaalnauwkeurigheid; -- spreiding over vijf trainingsseeds; -- trainings- en inferentielatency, uitsluitend als secundaire maat. - -Geen enkele structuurmaat geldt afzonderlijk als bewijs voor compositionaliteit. De conclusie combineert generalisatie, vertaling, minimale paren, ablaties en vergelijking met controles. - -### 5.8 Controles tegen schijnsucces - -- **Berichten husselen:** exacte reconstructie moet terugvallen tot ongeveer kansniveau. -- **Consistente symboolpermutatie:** prestatie moet gelijk blijven als symbool-ID's aan beide kanten identiek worden hernoemd. -- **Kanaalisolatie:** ontvanger krijgt geen episode-ID, betekenis-ID, kloktijd, gedeeld geheugen of bestandskanaal. -- **Geen gedeelde toestand:** modellen delen tijdens evaluatie geen gewichten, cache, random generator of verborgen activaties. -- **Volledige logging:** ieder bericht, antwoord, modelhash, config-hash en seed wordt opgeslagen. -- **Harde kwantisatie:** conclusies worden niet op continue, onbeperkt precieze vectoren gebaseerd. -- **Testverzegeling:** de compositionele testset beïnvloedt geen modelselectie. - -### 5.9 Classificatie van de uitkomst - -Stap 1 is methodologisch voltooid wanneer alle vijf vooraf ingestelde runs, baselines en controles zijn uitgevoerd. De uitkomst wordt daarna als volgt geclassificeerd: - -- **Sterk bewijs:** ten minste vier runs halen 99% op bekende betekenissen, 90% op de compositionele test en 85% onafhankelijke vertaling op die test. -- **Gemengd bewijs:** bekende betekenissen halen 99%, maar generalisatie of vertaling ligt tussen lookupniveau en de sterke drempel. -- **Negatief resultaat:** de agents leren geen betrouwbaar kanaal, of generalisatie en vertaling verschillen niet betekenisvol van de lookupcontrole. -- **Ongeldige run:** een controle faalt, een nevenkanaal is mogelijk of de vooraf vastgelegde configuratie is zonder registratie gewijzigd. - -Deze percentages zijn onderzoeksdrempels, geen garantie dat ECP-0 ze zal halen. - -## 6. Stap 2 — Verfijning en evolutie - -Stap 2 bouwt alleen voort op een bevroren rapport van stap 1. Nieuwe hypothesen en configuraties worden vooraf geregistreerd. - -Geplande uitbreidingen: - -- variabele berichtlengte van één tot zes symbolen; -- volledige bitboekhouding, inclusief lengte-informatie; -- informatiedruk via een expliciete bitstraf; -- ruis door symboolverlies, vervanging en verwisseling; -- context waarin irrelevante eigenschappen veilig kunnen worden weggelaten; -- relaties tussen meerdere objecten; -- populaties van meerdere zenders en ontvangers; -- periodieke vervanging door nieuw geïnitialiseerde agents; -- overdrachtstests met een bevroren zender of ontvanger; -- vergelijking tussen gezamenlijke training en iteratief leren over generaties. - -De kernvraag verschuift hier van “kan het communiceren?” naar “blijft het protocol efficiënt, leerbaar en robuust wanneer de omgeving verandert?” - -## 7. Stap 3 — Efficiëntie en complex redeneren - -Stap 3 introduceert complexere betekenissen en meerdere kanaalvormen: - -- hiërarchische concepten; -- object-relatiegrafen; -- tijd, onzekerheid, intentie en voorwaardelijke acties; -- abstracte redeneerregels in plaats van alleen zichtbare kenmerken; -- discrete sequenties, getypeerde grafen en gekwantiseerde vectoren; -- taakoverdracht naar een omgeving waarop het protocol niet is getraind. - -Continue vectoren worden altijd naar een vooraf vastgelegd aantal bits gekwantiseerd. Anders is een eerlijke efficiëntievergelijking onmogelijk. - -De uitkomst wordt als Paretofront gerapporteerd over: - -1. taakprestatie; -2. verzonden bits; -3. robuustheid; -4. generalisatie; -5. vertaalbaarheid; -6. overdraagbaarheid; -7. latency en rekenkosten. - -## 8. Reproduceerbaarheid en rapportage - -Iedere run krijgt een onveranderlijk run-ID en bevat minimaal: - -- volledige configuratie; -- software- en hardwareversies; -- datasetmanifest en hashes; -- modelinitialisatieseeds; -- checkpoints en modelhashes; -- ruwe episodeberichten en voorspellingen; -- berekende metrics; -- geregistreerde afwijkingen van het protocol; -- automatisch en menselijk samengevat resultaat. - -Mislukte runs worden niet verwijderd. Een wijziging na resultaatinspectie start een nieuwe experimentversie. - -## 9. Interpretatiegrenzen - -Een positief resultaat toont een efficiënt emergent protocol in de geteste wereld. Het bewijst niet dat: - -- het protocol een algemeen alternatief voor menselijke taal is; -- agents bewust een taal hebben ontworpen; -- dezelfde structuur spontaan bij grote taalmodellen ontstaat; -- communicatie buiten de experimentele taak efficiënt blijft; -- onbegrijpelijkheid op zichzelf intelligentie of semantische diepte aantoont. - -## 10. Onderzoeksbasis - -De opzet sluit aan bij eerder onderzoek naar emergente communicatie: - -- [Natural Language Does Not Emerge ‘Naturally’ in Multi-Agent Dialog](https://aclanthology.org/D17-1321/) — succesvolle taakprestatie garandeert geen interpreteerbare of compositionele taal. -- [Emergent Communication: Generalization and Overfitting in Lewis Games](https://proceedings.neurips.cc/paper_files/paper/2022/hash/093b08a7ad6e6dd8d34b9cc86bb5f07c-Abstract-Conference.html) — co-adaptatie en overfitting kunnen generalisatie ondermijnen. -- [Trading off Utility, Informativeness, and Complexity in Emergent Communication](https://proceedings.neurips.cc/paper_files/paper/2022/hash/8bb5f66371c7e4cbf6c223162c62c0f4-Abstract-Conference.html) — informatiewaarde en protocolcomplexiteit moeten samen worden gemeten. -- [Emergent Communication for Rules Reasoning](https://proceedings.neurips.cc/paper_files/paper/2023/hash/d8ace30c68b085556ccce04ed4ae4ebb-Abstract-Conference.html) — complexere redeneertaken kunnen structurelere protocollen stimuleren. -- [A Compressive-Expressive Communication Framework for Compositional Representations](https://proceedings.neurips.cc/paper_files/paper/2025/hash/3310034c97fab48fdbcba18f90fd5364-Abstract-Conference.html) — compressiedruk en iteratief leren kunnen efficiëntie en compositionaliteit ondersteunen. diff --git a/docs/ontwikkellog-ecp1.md b/docs/ontwikkellog-ecp1.md deleted file mode 100644 index 8a7b9e4..0000000 --- a/docs/ontwikkellog-ecp1.md +++ /dev/null @@ -1,31 +0,0 @@ -# Ontwikkellog ECP-1 - -Alle onderstaande varianten gebruikten uitsluitend train en validatie. De nieuwe ECP-1-testmatching bleef gedurende deze ontwerpkeuzes gesloten. - -| Variant | Interacties per stap | Bekend gemiddeld | Bekend slechtste | Validatie gemiddeld | Besluit | -|---|---:|---:|---:|---:|---| -| A — willekeurig één paar | 1 | 92,7% | 91,4% | 61,2% | te weinig directe paarupdates | -| B — één zender, alle ontvangers | 4 | 95,9% | 95,1% | 57,3% | stabieler maar onvoldoende bekend | -| C — alle zenders, alle ontvangers | 16 | 99,2% | 98,8% | 77,6% | bevroren voor confirmatief experiment | - -## Variant A - -Iedere cyclus gebruikte alle zestien paren eenmaal, maar één paar per trainingsstap. Op het beste checkpoint had ieder specifiek paar slechts een fractie van de leerinteracties van een ECP-0-paar. De agents ontwikkelden wel een gedeelde conventie, maar de bekende reconstructie bleef onvoldoende. - -Lokaal, niet-versiebeheerd artefact: `runs/20260718T000531Z-ecp1-development/report.md`. - -## Variant B - -Eén gekozen zender stuurde per stap hetzelfde bericht naar alle vier ontvangers. Dit gaf ontvangers veel ervaring, maar iedere zender nog steeds minder directe updates. De bekende prestatie verbeterde, terwijl validatie niet verbeterde. - -Lokaal, niet-versiebeheerd artefact: `runs/20260718T000811Z-ecp1-development/report.md`. - -## Variant C - -Iedere batch liep door alle zestien zender-ontvangerparen en alle verliezen werden gemiddeld. Er was geen leider, gedeeld gewicht of extra semantisch label. Ieder paar kreeg hiermee dezelfde orde van trainingsblootstelling als ECP-0. - -De universele ontvanger behaalde testvrij 78,3% validatie. Een verse ontvanger behaalde met 512 van de 768 trainingsbetekenissen 74,2% validatie en met alle betekenissen 77,9%. - -Lokaal, niet-versiebeheerd artefact: `runs/20260718T001224Z-ecp1-development/report.md`. - -Na deze run zijn architectuur, leerinstellingen, drempels en datasplitsing bevroren. Latere wijzigingen krijgen een nieuw experiment-ID. diff --git a/docs/ontwikkellog-ecp2.md b/docs/ontwikkellog-ecp2.md deleted file mode 100644 index 66cb98b..0000000 --- a/docs/ontwikkellog-ecp2.md +++ /dev/null @@ -1,117 +0,0 @@ -# Ontwikkellog ECP-2 - -De confirmatieve ECP-2-testset blijft gedurende dit document verzegeld. Alle onderstaande prestaties komen uitsluitend uit training en de afzonderlijke compositionele validatiematching. - -## Variant A — algebraïsche consistentiedruk - -Seed: 11 -Architectuur: vier onafhankelijke zenders × vier onafhankelijke ontvangers -Kanaal: vier symbolen uit een vocabulaire van zestien, 16 bits -Split: `7a227e22d86f00d8ab5078690de37de794774cdab636e7db374c5adbd0985126` - -| Variant | Gewicht | Bekend gemiddeld | Slechtste bekend paar | Compositionele validatie | Universele vertaler validatie | -|---|---:|---:|---:|---:|---:| -| Controle | 0 | 97,0% | 96,5% | **9,5%** | **13,9%** | -| Licht | 0,25 | 95,8% | 95,1% | 4,6% | 10,0% | -| Midden | 1,0 | 59,9% | 35,2% | 2,6% | 3,5% | -| Sterk | 4,0 | 2,0% | 1,6% | 1,4% | 2,3% | - -Lokale artefacten staan onder `runs/ecp2-variants/{control,light,medium,strong}/20260718T005403Z-ecp2-development/`. - -### Besluit - -De interventie wordt verworpen. Geen gewicht verbetert de compositionele validatie en alleen de controle benadert de bekende-prestatiedrempel. De testset is niet geopend. - -De regularisatie heeft een informatieve degeneratie blootgelegd. Bij sterke druk worden grootte en textuur op de validatieset perfect gereconstrueerd, terwijl kleur en vorm richting kansniveau dalen. Omdat de algebraïsche eis gemiddeld over alle veranderingen wordt geminimaliseerd, kan de zender de eis goedkoop vervullen door de moeilijkste factoren niet meer te coderen. Een hogere taakverliesweging zou de twee doelen slechts opnieuw tegen elkaar uitruilen en verandert het fundamentele ontsnappingspad niet. - -Conform de vooraf vastgelegde fallback gaat ontwikkeling verder met generationele transmissie. Die methode selecteert op leerbaarheid door nieuwe agents in plaats van rechtstreeks een gewenste geometrie in berichten af te dwingen. - -## Variant B — culturele transmissie door agentvervanging - -De populatie behoudt vier zenders en vier ontvangers. Na een vast interval wordt telkens één zender en één ontvanger volledig opnieuw geïnitialiseerd. De overige zes agents vormen het tijdelijke culturele geheugen. Na vier vervangingen is geen oorspronkelijke agent meer aanwezig; checkpoints van vóór die volledige turnover zijn niet selecteerbaar. - -Drie vooraf gekozen intervallen worden met seed 11 en dezelfde gesloten testset vergeleken: - -| Variant | Stappen tussen vervangingen | Eerste volledige turnover | -|---|---:|---:| -| Snel | 400 | stap 1.600 | -| Midden | 600 | stap 2.400 | -| Langzaam | 800 | stap 3.200 | - -De trainingsbegroting blijft 5.000 stappen. Selectie gebruikt opnieuw eerst de bekende-prestatiedrempels en daarna uitsluitend de compositionele validatie. De algebraïsche regularisatie staat in deze drie varianten uit. - -### Eerste uitkomst - -| Variant | Bekend gemiddeld | Slechtste bekend paar | Compositionele validatie | Universele vertaler validatie | -|---|---:|---:|---:|---:| -| Snel, doorlopend | 97,4% | 93,9% | **19,5%** | **18,4%** | -| Midden, doorlopend | 95,2% | 92,1% | 10,0% | 12,7% | -| Langzaam, doorlopend | 94,1% | 90,8% | 10,1% | 11,9% | - -De snelle variant verdubbelt de compositionele validatie bijna ten opzichte van de 9,5%-controle, maar blijft nieuwe agents introduceren. Daardoor is steeds een recent vervangen koppeling de zwakste. De volgende vooraf vastgelegde verfijning scheidt transmissie en consolidatie: - -| Variant | Interval | Maximum vervangingen | Turnovers | Consolidatie na laatste vervanging | -|---|---:|---:|---:|---:| -| Eén snelle turnover | 400 | 4 | 1 | 3.400 stappen | -| Twee snelle turnovers | 400 | 8 | 2 | 1.800 stappen | -| Eén rustige turnover | 600 | 4 | 1 | 2.600 stappen | - -De eindtest blijft ook voor deze verfijning gesloten. - -### Consolidatie-uitkomst - -| Variant | Bekend gemiddeld | Slechtste bekend paar | Compositionele validatie | Universele vertaler validatie | -|---|---:|---:|---:|---:| -| Eén snelle turnover | 98,8% | 97,5% | 10,3% | 15,0% | -| Twee snelle turnovers | **99,3%** | **98,8%** | **19,9%** | **25,2%** | -| Eén rustige turnover | 97,2% | 96,6% | 7,3% | 10,4% | - -Twee snelle turnovers is de beste culturele variant. Zij voldoet aan de bekende-prestatiedrempels en verdubbelt de compositionele validatie ten opzichte van controle, maar blijft ver onder de ontwikkeldoelen van 80% populatie en 70% vertaler. Culturele transmissie wordt bewaard als beste zwak-gestuurde interventie, maar niet als confirmatieve ECP-2-kandidaat. - -## Variant C — geleerde permutationslots - -Als de consolidatievarianten de compositionele validatiedrempel niet halen, wordt één structureel sterkere architectuur getest. De zender bevat vier discrete berichtslots en kiest intern een harde één-op-éénpermutatie tussen de vier betekenisfactoren en die slots. - -Niet vooraf bepaald zijn: - -- welke factor aan welk slot wordt gekoppeld; -- welk van de zestien symbolen een factorwaarde vertegenwoordigt; -- of verschillende zenders dezelfde interne permutatie of symbolen kiezen; -- hoe ontvangers de vier symbolen decoderen. - -Wel vooraf bepaald is dat iedere factor precies één afzonderlijk slot gebruikt. Dit is daarom een expliciete compositionele architectuurbias en een strengere ingreep dan algebraïsche of culturele druk. De variant is waardevol als werkend model en als positieve controle, maar een succes mag niet worden beschreven als volledig onbeïnvloede taalemergentie. - -De slotvariant wordt eerst zonder algebraïsche regularisatie en zonder agentvervanging met seed 11 getraind. De vooraf gekozen ontwikkeldoelen zijn 97% bekend gemiddeld, 95% voor het slechtste paar, 80% compositionele validatie en 70% universele vertalervalidatie. - -### Eerste slotuitkomst en consensusverfijning - -De eerste volledig getrainde slotpopulatie haalt op train/validatie, zonder testtoegang: - -- 100% bekende reconstructie voor ieder zender-ontvangerpaar; -- 69,4% gemiddelde compositionele validatie; -- 30,5% voor het slechtste compositionele paar; -- 50,6% universele vertalervalidatie. - -De vier zenders kozen drie verschillende factor-slotpermutaties. Twee zenders kwamen onafhankelijk op dezelfde permutatie uit; de andere twee kozen ieder een andere. Daarom wordt één betekenisvrije verfijning getest: minimaliseer het verschil tussen de vier zachte bindingsmatrices en maak iedere matrix scherp. De consensus kiest geen factor-slotmapping vooraf; iedere van de 24 permutaties kan winnen. - -Vooraf gekozen consensusgewichten: - -| Variant | Consensusgewicht | Scherptegewicht | -|---|---:|---:| -| Licht | 0,1 | 0,1 | -| Midden | 1,0 | 0,1 | -| Sterk | 5,0 | 0,1 | - -De eindtest blijft gesloten. Bij vrijwel gelijke validatie wint het lagere consensusgewicht. - -### Consensusuitkomst en definitieve keuze - -| Variant | Bekend gemiddeld | Slechtste bekend paar | Compositionele validatie | Slechtste validatiepaar | Universele vertaler validatie | -|---|---:|---:|---:|---:|---:| -| Licht, 0,1 | 100% | 100% | 76,9% | 51,6% | 50,6% | -| Midden, 1,0 | 100% | 100% | 90,0% | 82,0% | 95,3% | -| **Sterk, 5,0** | **100%** | **100%** | **97,0%** | **93,8%** | **95,3%** | - -Gewicht 5,0 wint ondubbelzinnig en wordt de confirmatieve ECP-2-kandidaat. Alle vier zenders kozen dezelfde intern bepaalde permutatie `[kleur, textuur, vorm, grootte]`; de zachte bindingskansen hebben per slot maxima tussen 0,968 en 0,986. De populatie gebruikt voor 896 train- en validatiebetekenissen 896 unieke berichten, heeft nul botsingen, minimale-paarafstand exact één en topografische overeenkomst 1,0. - -De confirmatieve interventie wordt gepaard met een controle die exact dezelfde permutationslotarchitectuur, split, seeds en trainingsbegroting gebruikt, maar zonder bindingsconsensus. Beide configuraties worden vóór enige ECP-2-testtoegang bevroren. diff --git a/docs/ontwikkellog-ecp3.md b/docs/ontwikkellog-ecp3.md deleted file mode 100644 index a5ba4d6..0000000 --- a/docs/ontwikkellog-ecp3.md +++ /dev/null @@ -1,44 +0,0 @@ -# Ontwikkellog ECP-3 - -De confirmatieve ECP-3-testmatching bleef tijdens alle onderstaande handelingen gesloten. - -## Oorzaak uit ECP-2 - -ECP-2 leerde in iedere seed een gedeelde factor-slotbinding, maar slechts twee van vijf seeds haalden alle drempels. De zwakke seeds hadden geen structureel slotprobleem meer; zij bleven steken in niet-unieke of onvoldoende stabiele symbolen voor afzonderlijke factorwaarden. Daardoor konden zelfs bekende betekenissen in seeds 37 en 53 niet volledig worden onderscheiden. - -## Vooraf gekozen reparatie - -ECP-3 vervangt de neurale slotkoppen door per factor een vrij geleerde injectieve symbooltoewijzing. De zender mag nog steeds ieder symbool voor iedere waarde kiezen, maar twee waarden binnen dezelfde factor mogen niet samenvallen. De bestaande vrije factor-slotpermutatie blijft behouden. Naast bindingsconsensus wordt dezelfde betekenisvrije populatieconsensus op de zachte atoomcodeboeken toegepast. - -Er is één ontwikkelseed gebruikt: seed 11. De trainingsbegroting, populatiegrootte, ontvangerarchitectuur en kanaalcapaciteit zijn gelijk gehouden aan ECP-2. - -## Resultaat op train en compositionele validatie - -| Metriek | Uitkomst | -|---|---:| -| Bekend gemiddeld | 100,0% | -| Slechtste bekend zender-ontvangerpaar | 100,0% | -| Volledig nieuwe validatieparen | 100,0% | -| Slechtste validatiepaar | 100,0% | -| Universele vertaler op validatie | 100,0% | -| Nieuwe ontvanger met 128 voorbeelden | 94,3% | -| Nieuwe ontvanger met 512 voorbeelden | 99,8% | -| Nieuwe ontvanger met 768 voorbeelden | 100,0% | - -Alle vier zenders kozen dezelfde slotvolgorde `[vorm, textuur, grootte, kleur]`. Hun exacte atoomcodeboeken kwamen nog niet overal overeen, maar iedere code bleef injectief en alle zestien zender-ontvangerkoppelingen decodeerden beide dialectvarianten foutloos. - -Voor ieder van de vier zenders gelden over de 896 train- en validatiebetekenissen: - -- 896 unieke berichten en nul botsingen; -- berichtentropie `9,807` bits, gelijk aan de bronentropie van deze subset; -- gemiddelde berichtafstand exact één bij een minimale betekenisverandering; -- volledige concentratie van zo'n verandering in één positie; -- topografische Spearman-overeenkomst `1,0`. - -De technische rooktest, checkpointcyclus, geïsoleerde processen, husselcontrole en consistente symboolpermutatie zijn geslaagd. Alle 29 tests slagen. - -## Besluit - -Er is geen verdere verfijning toegestaan vóór de confirmatieve test. De ontwikkelvariant behaalt alle doelen zonder de verzegelde matching te openen en is daarom ongewijzigd bevroren als ECP-3-interventie. Een identieke controle schakelt uitsluitend slot- en atoomcodeconsensus uit. - -Ontwikkelrun: `runs/ecp3-development/20260718T020325Z-ecp3-development`. diff --git a/docs/ontwikkellog-ecp4.md b/docs/ontwikkellog-ecp4.md deleted file mode 100644 index 4d3cef6..0000000 --- a/docs/ontwikkellog-ecp4.md +++ /dev/null @@ -1,50 +0,0 @@ -# Ontwikkellog ECP-4 - -De confirmatieve ECP-4-testmatching bleef gedurende alle onderstaande ontwikkeling technisch gesloten. - -## Implementatie - -ECP-4 voegt twee vooraf gerichte componenten toe: - -1. `MinimalPermutationSlotSender`: per factor een vrij geleerde harde permutatie binnen een lokaal alfabet van exact de benodigde grootte; -2. `FactorizedPermutationSlotReceiver`: per factoruitgang een vrij geleerd maar hard geïsoleerd berichtslot. - -De transportmetadata, configuratievalidatie en episodeschema's ondersteunen nu protocolspecifieke bitlengtes. Iedere episode wordt aanvullend tegen de actieve configuratie gecontroleerd op exacte berichtlengte, bitlengte en symboolbereik. - -## Technische verificatie - -De tests bewijzen onder meer dat: - -- de vier lokale codeboeken exact `8×8`, `8×8`, `4×4` en `4×4` harde permutaties zijn; -- ieder werkelijk verzonden symbool binnen het lokale factoralfabet valt; -- een factoruitgang onveranderd blijft wanneer een niet-geselecteerd slot wijzigt; -- minimale zender en factorontvanger afzonderlijk door checkpoints en geïsoleerde processen lopen; -- `3+3+2+2 = 10` bits exact gelijk is aan de bronentropie; -- de expliciete validatie- en testmatchings exact de laatste zestien ongebruikte paren zijn. - -Alle 34 tests slagen. - -## Gesloten ontwikkeluitkomst - -Ontwikkelrun: `runs/ecp4-development/20260718T060943Z-ecp4-development` -Seed: 11 - -| Metriek | Uitkomst | -|---|---:| -| Bekend gemiddeld | 100,0% | -| Slechtste bekend zender-ontvangerpaar | 100,0% | -| Volledig nieuwe validatieparen | 100,0% | -| Slechtste validatiepaar | 100,0% | -| Universele vertaler op validatie | 100,0% | -| Nieuwe ontvanger, 32 voorbeelden | 100,0% | -| Nieuwe ontvanger, 128 voorbeelden | 100,0% | -| Nieuwe ontvanger, 512 voorbeelden | 100,0% | -| Nieuwe ontvanger, 768 voorbeelden | 100,0% | - -Alle vier zenders kozen dezelfde intern bepaalde slotvolgorde `[grootte, textuur, kleur, vorm]` en exact dezelfde atoomcodes. De berichtovereenkomst tussen ieder zenderpaar is 100%. Over de 896 train- en validatiebetekenissen gebruikt iedere zender 896 unieke berichten, zonder botsingen, met topografische overeenkomst 1,0. - -De beste toestand werd al bij stap 400 geselecteerd. Er is daarom geen 12-bit-tussenvariant nodig: de directe 10-bitvariant behaalt alle gesloten ontwikkeldoelen. - -## Besluit - -De 10-bitvariant wordt zonder verdere wijziging bevroren. De gepaarde controle behoudt dezelfde factorontvanger maar gebruikt het 16-bit injectieve ECP-3-kanaal. Geen confirmatief testpaar is vóór deze keuze geëvalueerd. diff --git a/docs/ontwikkellog-ecp5.md b/docs/ontwikkellog-ecp5.md deleted file mode 100644 index 2bd3224..0000000 --- a/docs/ontwikkellog-ecp5.md +++ /dev/null @@ -1,34 +0,0 @@ -# Ontwikkellog ECP-5 - -De ECP-5-testset bleef gedurende ontwikkeling gesloten. - -## Oorzaakanalyse ECP-4 - -Alle vijf 10-bitpopulaties communiceerden foutloos. Vier universele vertalers bleven echter steken op 9,4–12,5%. Hun symboolkoppen waren niet het probleem: de harde ontvangerbinding wees factoren aan de verkeerde slots toe. Dezelfde fout trad ook tweemaal op in de 16-bitcontrole. - -## Exacte kalibratie - -De nieuwe procedure berekent een `4×4`-matrix met empirische wederzijdse informatie en scoort alle 24 permutaties. Een test met een verborgen synthetische slotvolgorde vindt de exacte inverse binding terug en bevriest haar. Alle 35 tests slagen. - -## Gesloten ontwikkelrun - -Run: `runs/ecp5-development-final/20260718T062526Z-ecp5-development` -Seed: 11 - -| Metriek | Uitkomst | -|---|---:| -| Populatie bekend | 100% | -| Slechtste bekend paar | 100% | -| Nieuwe grootte-textuurvalidatie | 100% | -| Slechtste validatiepaar | 100% | -| Gekalibreerde universele vertaler | 100% | -| Nieuwe ontvanger met 32 voorbeelden | 100% | -| Nieuwe ontvanger met 128 voorbeelden | 100% | -| Nieuwe ontvanger met 256 voorbeelden | 100% | -| Nieuwe ontvanger met 512 voorbeelden | 100% | - -De gekozen slotvolgorde per factor was `[2,3,0,1]`. De totale wederzijdse-informatiescore was exact 10,0 bits; de eerstvolgende permutatie scoorde 8,0 bits. De keuze is daardoor niet marginaal. Ook met slechts 32 voorbeelden bleef de juiste permutatie de duidelijke winnaar. - -## Besluit - -De kalibratie is zonder verdere varianten bevroren. De controle schakelt uitsluitend `binding_calibration.enabled` uit. Geen ECP-5-testpaar is vóór deze keuze geëvalueerd. diff --git a/docs/ontwikkellog-ecp6.md b/docs/ontwikkellog-ecp6.md deleted file mode 100644 index 883a42a..0000000 --- a/docs/ontwikkellog-ecp6.md +++ /dev/null @@ -1,36 +0,0 @@ -# Ontwikkellog ECP-6 - -De ECP-6-testset bleef gedurende alle onderstaande werkzaamheden gesloten. - -## Schaalinvarianten - -De code is gegeneraliseerd van de oorspronkelijke factoromvang `[8,8,4,4]` naar `[16,16,8,8]`. Configuratievalidatie, betekenis-ID's, schemas, factorlokale alfabetten en baselines volgen nu de feitelijke factoromvang. De volledige testsuite telt 39 geslaagde tests. - -De eerste smoke-poging bracht één meetkundig schaalprobleem aan het licht: topografische gelijkenis materialiseerde alle `n(n-1)/2` paren. De poging is vóór voltooiing afgebroken, zonder testtoegang. De meting gebruikt nu maximaal 1.000.000 deterministisch en uniform bemonsterde paren. Een tweede smoke-run voltooide normaal en logde uitsluitend validatie. - -## Gesloten ontwikkelrun - -Run: `runs/20260718T065639Z-ecp6-development` -Seed: 11 -Test ontzegeld: nee - -| Metriek | Uitkomst | -|---|---:| -| Populatie bekend, gemiddeld | 100% | -| Slechtste bekende koppeling | 100% | -| Nieuwe kleur-vormvalidatie, gemiddeld | 100% | -| Slechtste validatiekoppeling | 100% | -| Universele vertaler op train | 100% | -| Universele vertaler op validatie | 100% | -| Overdracht met 32 voorbeelden, validatie | 81,25% | -| Overdracht met 128 voorbeelden, validatie | 100% | -| Overdracht met 512 voorbeelden, validatie | 100% | -| Overdracht met 2.048 voorbeelden, validatie | 100% | - -De bindingskalibratie koos slotvolgorde `[1,0,3,2]`. De totale wederzijdse-informatiescore was exact 14,0 bits; de nummer twee scoorde 8,0 bits. Alle vier zenders codeerden de 15.360 toegankelijke train- plus validatiebetekenissen injectief. - -De ontwikkelrun schreef 16.384 episodes: `1.024 validatiebetekenissen × 4 zenders × 4 ontvangers`. Er is geen testepisode geschreven. - -## Bevriezingsbesluit - -De ontwikkeling gaf geen inhoudelijke reden voor een extra variant. Wereld, expliciete holdoutparen, 14-bitkanaal, trainingsbudgetten, bindingskalibratie, overdrachtsbudgetten, topografische steekproefregel, vijf seeds en succescriteria zijn daarom ongewijzigd bevroren voor confirmatie. diff --git a/docs/protocol-specification-ecp5.md b/docs/protocol-specification-ecp5.md new file mode 100644 index 0000000..1f60e36 --- /dev/null +++ b/docs/protocol-specification-ecp5.md @@ -0,0 +1,51 @@ +# Protocol specification ECP-5 + +## Logical message + +A meaning consists of four categorical factors with cardinalities `8,8,4,4`. A message contains four local symbols. The protocol contains two stable conventions per seed: + +1. a permutation of factors to message slots; +2. per factor a permutation of values to local symbols. + +These conventions are part of the frozen protocol and are not included in every message, just as the grammar and lexicon of a human language are not repeated in every sentence. + +## Wire format + +The number of bits required for each slot follows from the factor binding: + +- color or shape: 3 bits; +- size or texture: 2 bits. + +The four local symbols are concatenated as unsigned bit fields in slot order. The total length is always 10 bits. No padding, terminator, or length field is required. + +For seed 11: + +- slot factors: `[size, texture, color, shape]`; +- message: `[0,3,5,4]`; +- bitfields: `00 | 11 | 101 | 100`; +- wire: `0011101100`. + +## Decoding + +An existing receiver keeps the inverse factor slot permutation in its checkpoint. A new reader gets labeled training examples and: + +1. calculates the empirical mutual information for each factor-slot combination; +2. scores all 24 one-to-one permutations; +3. freezes the best binding; +4. learns only the local symbol permutation for each factor. + +The receiver cannot use information from unselected slots, so it cannot memorize a context rule between factors. + +## Invariants + +- exactly four logical symbols; +- exactly 10 wire bits; +- exactly one factor per slot and one slot per factor; +- each factor codebook is a hard permutation; +- no two meanings share a message; +- changing one factor changes exactly one slot; +- consistent renaming within the protocol does not change semantics. + +## Protocol extension + +New values can be added only if the local alphabet still has capacity or is renegotiated. A completely new factor requires a new slot and wire version. ECP-5 optimizes a closed factor schema; dynamic schema evolution is outside the scope of this version. diff --git a/docs/protocol-specification-ecp6.md b/docs/protocol-specification-ecp6.md new file mode 100644 index 0000000..f4b61c7 --- /dev/null +++ b/docs/protocol-specification-ecp6.md @@ -0,0 +1,84 @@ +# Protocol specification ECP-6 + +## Purpose and scope + +ECP-6 encodes exactly one meaning from a closed product space of four categorical factors. It is not a text language and does not use an alphabet, words, or grammatical phrases. Its communication form is a structured tuple of four local integers plus a shared protocol convention. + +The factor cardinalities are: + +`color:16 × shape:16 × size:8 × texture:8 = 16,384`. + +## Logical message + +A message is a tuple `⟦a · b · c · d⟧`. Two conventions apply to each protocol instance: + +1. a permutation linking each factor to exactly one slot; +2. for each factor, a bijection between factor values and local symbols. + +The senders learn these conventions during training; they do not transmit them with every message. Within each confirmatory seed, all four channels converge on exactly the same convention. Across different seeds, the meanings of slots and symbols may differ. + +## Wire format + +The local alphabet size determines the bit width: + +- color and shape: 4 bits each; +- size and texture: 3 bits each. + +The four unsigned bit fields are concatenated in learned slot order without padding. The total message length is always: + +`4 + 4 + 3 + 3 = 14 bits`. + +Because there are `2^14` equiprobable meanings, this is exactly the lower bound for any lossless fixed-length code. + +## Concrete example + +In confirmatory seed 11, the slot order is: + +`[shape, color, texture, size]`. + +The test meaning never offered as a training combination `(c0,s9,z0,t0)` gets the logical message: + +`⟦15 · 1 · 3 · 1⟧`. + +The wire representation is: + +`1111 | 0001 | 011 | 001` → `11110001011001`. + +These bits are not intrinsically tied to `c0`, `s9`, `z0`, or `t0`. Their meaning exists only within the codebook and the learned convention. + +## Decoding by an existing receiver + +An existing receiver preserves the inverse slot permutation and four local symbol decoders. It: + +1. splits the 14 bits according to the factor width of each slot; +2. converts each bit field to a local symbol; +3. routes each slot to its factor; +4. applies the corresponding inverse symbol permutation. + +Factorized architecture cannot use information from another slot for a factor. + +## Induction by a new reader + +A new reader receives labeled training examples, but no sender parameters or codebooks. It: + +1. calculates empirical mutual information for each factor-slot combination; +2. exhaustively scores all 24 possible slot permutations; +3. freezes the best-scoring binding; +4. learns the local symbol permutation for each factor. + +In all five confirmatory seeds, the correct binding scored 14.0 bits and the runner-up scored 8.0 bits. From 128 labeled examples, every new reader decoded the complete test set flawlessly. + +## Invariants + +- exactly four logical symbols; +- exactly 14 wire bits; +- local alphabets `[16,16,8,8]` linked to the factor assigned to each slot; +- each factor uses exactly one slot; +- each local codebook is bijective; +- all 16,384 meanings have a unique message; +- changing one factor changes exactly one slot; +- consistent renaming of symbols with the corresponding decoder retains all predictions. + +## Boundaries and version management + +ECP-6 assumes that the schema, factor cardinalities, and protocol version are known in advance. Values beyond local-alphabet capacity, new factors, variable length, error correction, and dynamic protocol negotiation require a new version. The 14 bits measure only the payload within this shared closed schema; transport headers and one-time convention-learning costs are not included. diff --git a/docs/protocolspecificatie-ecp5.md b/docs/protocolspecificatie-ecp5.md deleted file mode 100644 index 488925a..0000000 --- a/docs/protocolspecificatie-ecp5.md +++ /dev/null @@ -1,52 +0,0 @@ -# Protocolspecificatie ECP-5 - -## Logisch bericht - -Een betekenis bestaat uit vier categorische factoren met cardinaliteiten `8,8,4,4`. Een bericht bevat vier lokale symbolen. Het protocol bevat per seed twee duurzame conventies: - -1. een permutatie van factoren naar berichtslots; -2. per factor een permutatie van waarden naar lokale symbolen. - -Deze conventies horen bij het bevroren protocol en worden niet in ieder bericht meegestuurd, zoals grammatica en woordenboek bij menselijke taal evenmin per zin worden herhaald. - -## Wire-formaat - -Voor ieder slot is uit de factorbinding bekend hoeveel bits nodig zijn: - -- kleur of vorm: 3 bits; -- grootte of textuur: 2 bits. - -De vier lokale symbolen worden in slotvolgorde als unsigned bitvelden aaneengeschakeld. De totale lengte is altijd 10 bits. Er is geen padding, eindteken of lengteveld nodig. - -Voor seed 11: - -- slotfactoren: `[grootte, textuur, kleur, vorm]`; -- bericht: `[0,3,5,4]`; -- bitvelden: `00 | 11 | 101 | 100`; -- wire: `0011101100`. - -## Decodering - -Een bestaande ontvanger bewaart de inverse factor-slotpermutatie in zijn checkpoint. Een nieuwe lezer krijgt gelabelde trainingsvoorbeelden en: - -1. berekent voor iedere factor-slotcombinatie de empirische wederzijdse informatie; -2. scoort alle 24 één-op-éénpermutaties; -3. bevriest de beste binding; -4. leert per factor uitsluitend de lokale symboolpermutatie. - -De ontvanger kan geen informatie uit niet-geselecteerde slots gebruiken. Daardoor kan hij geen contextregel tussen factoren memoriseren. - -## Invarianten - -- exact vier logische symbolen; -- exact 10 wire-bits; -- één factor per slot en één slot per factor; -- ieder factorcodeboek is een harde permutatie; -- geen twee betekenissen delen een bericht; -- één factorwijziging verandert exact één slot; -- consistente hernoeming binnen het protocol verandert de semantiek niet. - -## Protocoluitbreiding - -Nieuwe waarden kunnen alleen worden toegevoegd als het lokale alfabet nog capaciteit heeft of opnieuw wordt onderhandeld. Een volledig nieuwe factor vereist een nieuwe slot- en wireversie. ECP-5 optimaliseert dus een gesloten factorschema; dynamische schema-evolutie valt buiten deze versie. - diff --git a/docs/protocolspecificatie-ecp6.md b/docs/protocolspecificatie-ecp6.md deleted file mode 100644 index 6ff31d4..0000000 --- a/docs/protocolspecificatie-ecp6.md +++ /dev/null @@ -1,84 +0,0 @@ -# Protocolspecificatie ECP-6 - -## Doel en bereik - -ECP-6 encodeert precies één betekenis uit een gesloten productruimte van vier categorische factoren. Het is geen teksttaal en gebruikt geen alfabet, woorden of grammaticale zinnen. De communicatievorm is een structurele tuple van vier lokale gehele getallen plus een gedeelde protocolconventie. - -De factorcardinaliteiten zijn: - -`kleur:16 × vorm:16 × grootte:8 × textuur:8 = 16.384`. - -## Logisch bericht - -Een bericht is een tuple `⟦a · b · c · d⟧`. Per protocolinstantie gelden twee conventies: - -1. een permutatie die iedere factor aan precies één slot koppelt; -2. per factor een bijectie tussen factorwaarden en lokale symbolen. - -De zenders leren deze conventies tijdens training. Ze sturen de conventies niet per bericht mee. Binnen iedere confirmatieve seed maakten alle vier zenders exact dezelfde conventie; tussen afzonderlijke seeds mag de betekenis van slots en symbolen verschillen. - -## Wire-formaat - -De lokale alfabetgrootte bepaalt de bitbreedte: - -- kleur en vorm: ieder 4 bits; -- grootte en textuur: ieder 3 bits. - -De vier unsigned bitvelden worden in geleerde slotvolgorde zonder padding aaneengeschakeld. De totale berichtlengte is altijd: - -`4 + 4 + 3 + 3 = 14 bits`. - -Omdat er `2^14` equiprobabele betekenissen zijn, is dit exact de ondergrens voor iedere verliesloze vaste-lengtecode. - -## Concreet voorbeeld - -In confirmatieve seed 11 is de slotvolgorde: - -`[vorm, kleur, textuur, grootte]`. - -De nooit als trainingscombinatie aangeboden testbetekenis `(c0,s9,z0,t0)` krijgt het logische bericht: - -`⟦15 · 1 · 3 · 1⟧`. - -De wire-representatie is: - -`1111 | 0001 | 011 | 001` → `11110001011001`. - -Deze bits zijn niet door een mens aan `c0`, `s9`, `z0` of `t0` toegewezen. Hun betekenis bestaat uitsluitend binnen het geleerde codeboek en de slotconventie. - -## Decodering door een bestaande ontvanger - -Een bestaande ontvanger bewaart de inverse slotpermutatie en vier lokale symbooldecoders. Hij: - -1. splitst de 14 bits volgens de factorbreedte van ieder slot; -2. zet ieder bitveld om naar een lokaal symbool; -3. routeert ieder slot naar zijn factor; -4. past de bijbehorende inverse symboolpermutatie toe. - -De factoristische architectuur kan voor een factor geen informatie uit een ander slot gebruiken. - -## Inductie door een nieuwe lezer - -Een nieuwe lezer ontvangt gelabelde trainingsvoorbeelden, maar geen zenderparameters of codeboeken. Hij: - -1. berekent de empirische wederzijdse informatie voor iedere factor-slotcombinatie; -2. scoort exhaustief alle 24 mogelijke slotpermutaties; -3. bevriest de best scorende binding; -4. leert per factor de lokale symboolpermutatie. - -In alle vijf confirmatieve seeds scoorde de juiste binding 14,0 bits en de nummer twee 8,0 bits. Vanaf 128 gelabelde voorbeelden decodeerde iedere nieuwe lezer de volledige testset foutloos. - -## Invarianten - -- precies vier logische symbolen; -- precies 14 wire-bits; -- lokale alfabetten `[16,16,8,8]` gekoppeld aan de factor van ieder slot; -- iedere factor gebruikt precies één slot; -- ieder lokaal codeboek is bijectief; -- alle 16.384 betekenissen hebben een uniek bericht; -- wijziging van één factor verandert precies één slot; -- consistente hernoeming van symbolen met de overeenkomstige decoder behoudt alle voorspellingen. - -## Grenzen en versiebeheer - -ECP-6 veronderstelt dat schema, factorcardinaliteiten en protocolversie vooraf bekend zijn. Nieuwe waarden buiten de lokale alfabetcapaciteit, nieuwe factoren, variabele lengte, foutcorrectie en dynamische protocolonderhandeling vereisen een volgende versie. De 14 bits meten uitsluitend de payload binnen dit gedeelde gesloten schema; transportheaders en het eenmalig leren van de conventie vallen daar niet onder. diff --git a/docs/research-design-ecp1.md b/docs/research-design-ecp1.md new file mode 100644 index 0000000..bad10eb --- /dev/null +++ b/docs/research-design-ecp1.md @@ -0,0 +1,67 @@ +# Research Design ECP-1 — Population and Transmissibility + +Status: Frozen for confirmatory execution on July 18, 2026 at 00:17:09 UTC
+Parent experiment: ECP-0.2 + +## Rationale + +ECP-0 developed near-injective protocols with provable semantic geometry, but only 15.9% average exact generalization to fully withheld color-shape pairs. The large differences between seeds indicate co-adaptation: one sender and one receiver can together stabilize a usable but poorly transferable code. + +## Central hypothesis + +> If each sender has to communicate with multiple independently parameterized receivers and vice versa during training, there is more pressure towards a shared, systematic and portable protocol. + +ECP-1 therefore changes one primary mechanism: one pair is replaced by four senders and four receivers. Channel, world, models and reconstruction task remain the same as ECP-0.2. + +## New and independent test set + +The eight ECP-0 test pairs are explicitly excluded. ECP-1 uses a new data-split seed and accepts only a one-to-one matching that contains no old test pair. The new test set remains sealed during development and model selection. + +Because the ECP-0 test set is known, it may not be reused as a confirmatory ECP-1 test. + +## Population training + +- Four senders and four receivers start with independent initializations. +- No weights, embeddings, gradients outside the chosen pair, or hidden states are shared. +- Per step, all four senders each produce one message for the same random batch. +- All four receivers reconstruct each sender message; the sixteen losses are averaged. +- Each step therefore contains all sixteen sender-receiver interactions, without a leader or preferred dialect. +- Over 7,000 steps, each pair receives the same number of direct learning interactions as an ECP-0 pair. +- Model selection uses only train and validation. +- A checkpoint is only primarily selectable if it has at least 99% average known accuracy and at least 95% for the worst pair. + +## Universal translator and new receiver + +After freezing the population, one new receiver is trained on messages from all four senders. This receiver does not have access to the original receivers and simultaneously acts as a universal translator. + +A transfer curve additionally trains fresh receivers with 32, 128, 512, and 768 unique training meanings. All four senders deliver messages for the same selected meanings. The curve measures whether the population protocol can be adopted with few examples. + +## Primary outcome measures + +1. average exact accuracy over all sixteen pairs; +2. worst pair accuracy; +3. mean accuracy on the new held-out color-shape pairs; +4. accuracy of the universal translator on those pairs. + +Strong evidence required in at least four of five valid seeds: + +- at least 99% average on known meanings; +- minimum 95% for the worst known pair; +- at least 60% average on the compositional test; +- at least 50% for the universal translator on the compositional test. + +## Controls + +- Final sender and receiver evaluations run in separate processes. +- Receivers receive only the symbol matrix. +- Messages are shuffled within each channel; the accuracy should drop to a maximum of 1%. +- A consistent vocabulary permutation is applied to all messages and receiver embeddings; predictions must remain identical. +- Results are stored per pair and as a population average, so that a good average does not hide a failing pair. + +## Interpretation + +An improvement over ECP-0 supports the hypothesis that communicative diversity reduces co-adaptation. No improvement is also informative: then population pressure alone is insufficient and ECP-2 must isolate iterative learning, progressive reconstruction or more explicit context pressure. + +Compression to 12 bits is deliberately not tested in ECP-1. First, the semantic transfer must become more stable. + +The five seeds may run simultaneously in separate processes. This does not change any data, model interaction or random generator within a seed and only serves to reduce wall clock time. diff --git a/docs/research-design-ecp2.md b/docs/research-design-ecp2.md new file mode 100644 index 0000000..74bbfff --- /dev/null +++ b/docs/research-design-ecp2.md @@ -0,0 +1,101 @@ +# Research Design ECP-2 — Algebraically Consistent Emergent Protocol + +Status: Frozen for confirmatory execution on July 18, 2026 at 01:31:00 UTC
+Parent experiment: ECP-1
+Intervention configuration: `config/ecp2.yaml`
+Control configuration: `config/ecp2-control.yaml` + +## Rationale + +ECP-1 showed that four independent senders and four independent receivers can stabilize a shared protocol. Nevertheless, population generalization decreased from 15.9% in ECP-0 to 10.1%. Simply providing multiple communication partners is therefore insufficient. + +This result is consistent with existing research. Lee likewise found that having one sender broadcast to multiple receivers does not automatically produce greater compositionality ([EMNLP 2024](https://aclanthology.org/2024.emnlp-main.1157/)). Rita et al. attribute poor emergent generalization partly to overfitting through co-adaptation ([NeurIPS 2022](https://openreview.net/forum?id=qqHMvHbfu6)). Chaabouni et al. show that more compositional protocols are easier to transfer, but that ordinary generalization pressures do not necessarily create compositionality ([ACL 2020](https://aclanthology.org/2020.acl-main.407/)). + +## Central hypothesis + +> A protocol generalizes better when the same atomic change in meaning in different contexts causes a similar change in the internal message distribution. + +For a factor change `A → A'` and the same change in a different context `B → B'`, ECP-2 minimizes: + +`||(M(A') − M(A)) − (M(B') − M(B))||²` + +`M` is the distribution over the four positions and sixteen symbols learned by the sender. The final communication remains exactly the same hard 16-bit channel as in ECP-1. + +## What is not pre-programmed + +- No symbol is given a meaning in advance. +- No message position is assigned to color, shape, size, or texture. +- The four channels do not share any parameters or embeddings. +- The regularization does not prescribe which message represents a meaning. +- The receivers only see the symbols produced and not the algebraic tetrads. + +The experimental pressure does use the known factor structure of the artificial world. This is an explicit inductive bias and must be taken into account in the interpretation. The experiment therefore tests whether agents discover a useful discrete protocol within such a general consistency pressure, not whether compositionality arises without any environmental structure. + +## Algebraic training quads + +Each quad contains `A`, `B`, `A'` and `B'`: + +1. `A → A'` changes exactly one factor value; +2. `B → B'` changes exactly the same source value to the same target value; +3. the other factors form different contexts; +4. all four meanings must be in the training set; +5. validation and test meanings are never used as regularization input. + +This allows the sender to learn, for example, that one color change behaves context-invariant, without having to determine in advance which symbol or which position carries that change. + +## Two independent compositional holdouts + +ECP-2 corrects a methodological weakness in ECP-0 and ECP-1. The old validation sets contained separate meanings whose color-shape pairs already occurred in training. They therefore mainly measured interpolation. + +ECP-2 reserves two complete and mutually disjoint matchings: + +- 128 meanings from eight color-shape pairs form the compositional validation set; +- 128 meanings from eight other pairs form the sealed compositional test set; +- the remaining 768 meanings constitute the training; +- all sixteen previously opened ECP-0 and ECP-1 test pairs have been excluded from both new matchings. + +The validation set may be used for model selection. The test set is not coded, decoded, or evaluated during development. + +## Development comparison + +With seed 11, up to four preselected weights are compared: + +| Variant | Algebraic weight | +|---|---:| +| Control | 0 | +| Light | 0.25 | +| Medium | 1.0 | +| Strong | 4.0 | + +The chosen variant is the variant with the highest exact compositional validation performance, provided that known meanings achieve at least 97% on average and at least 95% for the worst pair. With a difference of less than two percentage points, the lower weight wins. + +After this choice, architecture, weight, training duration, five seeds and outcome thresholds are frozen. The control and intervention use exactly the same split, seeds, population architecture and training budget in the confirmatory phase. + +## Confirmatory requirements for a developed ECP-2 model + +Strong evidence required in at least four of five intervention runs: + +- at least 97% known reconstruction on average; +- at least 95% for the worst known sender-receiver pair; +- at least 80% exact reconstruction on the sealed compositional test; +- at least 70% for one independent universal translator; +- passed channel isolation, shuffling and symbol permutation checks. + +In addition, the intervention mean must exceed the paired-control mean on the same test split. A score above the ECP-1 reference alone is insufficient. + +## Continue in case of a negative development outcome + +If no algebraic weight clearly improves the compositional validation, the test set is not opened. The next development variant will then be generation transmission: agents are replaced periodically and new agents are given a limited transmission bottleneck. This follows the positive results on iterative and generational learning from [Guo et al.](https://arxiv.org/abs/1910.05291) and [Cogswell et al.](https://openreview.net/forum?id=r1gzoaNtvr¬eId=SJl3j-ScjB). + +## Frozen final variant + +The algebraic intervention failed and cultural transmission improved compositional validation to 19.9%, but not to the preselected performance threshold. The final candidate therefore uses the transparently registered permutation slot architecture with meaning-free binding consensus: + +- each sender internally chooses one of 24 factor slot permutations; +- no concrete permutation, symbol meaning, or symbol code is specified in advance; +- four independent channels are given consensus weight 5.0 on their soft binding matrices; +- the control group uses exactly the same slot architecture without consensus pressure; +- both arms use the same five seeds, split, training budget, translator and transfer curve; +- the sealed test will not be opened until both effective configurations have been captured. + +The strong development variant achieved 100% known, 97.0% compositional validation and 95.3% universal translator validation. This development performance is not a confirmatory result. diff --git a/docs/research-design-ecp3.md b/docs/research-design-ecp3.md new file mode 100644 index 0000000..cd4e4bd --- /dev/null +++ b/docs/research-design-ecp3.md @@ -0,0 +1,56 @@ +# Research Design ECP-3 + +Status: **frozen before confirmatory test access**
+Frozen: July 18, 2026 02:07:44 UTC
+Intervention configuration: `config/ecp3.yaml`
+SHA-256: `2cab56d55a0364a218755d8815a7efaf36292896a125fdc4c593150c19b93f6e`
+Control configuration: `config/ecp3-control.yaml`
+SHA-256: `9569c5f5cef10681f4fd02ba0c70907910246d14802836ffe5bf0d2c5f0edcfa` + +## Question + +Does a hard injectivity condition for atomic factor codes remove the local symbol collisions of ECP-2 and thereby create a robust compositional population protocol? + +## Model + +Four independent senders communicate with four independent receivers using exactly four symbols from a vocabulary of sixteen. Each sender learns two types of arbitrary discrete assignments: + +1. a free one-to-one permutation from the four factors to the four message slots; +2. per factor a free injective assignment of factor values to symbols. + +A Sinkhorn approach provides the gradients; transmission and evaluation use only a hard factor-slot permutation and hard unique symbols. The intervention aligns the soft slot and atomic assignments across channels. The paired control has exactly the same injective architecture, split, seeds, and training budget, but both consensus losses are disabled. + +No slot or symbol is assigned a meaning in advance. It is, however, specified in advance that each factor uses one position and that two values of the same factor may not share a symbol. ECP-3 therefore uses an explicit factorized inductive bias; it is not evidence of unconstrained language emergence. + +## New sealed split + +The world remains `8 × 8 × 4 × 4 = 1,024` meanings. ECP-3 uses: + +- 768 training meanings; +- 128 meanings from one fully withheld color-shape matching for selection; +- 128 meanings from a second fully withheld matching for the one-time confirmatory test. + +All ECP-0, ECP-1, and ECP-2 test pairs are excluded. Out of extra caution, the eight ECP-2 validation pairs were also excluded because they influenced the architecture choice. The new split has SHA-256 `91d6439fada82b1384a8d03f7cc1f5602091f794477be31c179c5a26e1b0464b`. + +## Predefined criteria + +A seed is classified as strong evidence when it achieves: + +- at least 97% known mean exact reconstruction; +- at least 95% for the worst known sender-receiver pair; +- at least 80% average exact reconstruction on new test pairs; +- at least 70% exact reconstruction by the universal translator. + +The population outcome is strong when at least four of five seeds are strong. Five predefined seeds (`11, 23, 37, 53, 71`) are used. Results are also reported as paired differences from the control, including the exact one-sided sign-flip test across all `2^5 = 32` sign combinations. + +The model is considered a usable ECP base model if the intervention produces at least four strong seeds, passes all channel checks and contains no artifact integrity error. A control effect is informative about consensus, but not an additional condition for the usefulness of the model itself. + +## Integrity checks + +- The test split is not used for training, early stopping, or selection. +- Senders and receivers do not share parameters, embeddings or state. +- Final evaluation runs in separate processes; receivers receive only symbol matrices. +- All messages and reconstructions are schema-validated and logged. +- Shuffling must remain within 1% exact. +- Consistent symbol renaming should preserve all predictions. +- All prewritten artifacts are hashed and rechecked upon completion. diff --git a/docs/research-design-ecp4.md b/docs/research-design-ecp4.md new file mode 100644 index 0000000..8424d50 --- /dev/null +++ b/docs/research-design-ecp4.md @@ -0,0 +1,71 @@ +# Research Design ECP-4 — Theoretically Minimal 10-Bit Code + +Status: **frozen before confirmatory test access**
+Frozen: July 18, 2026 at 06:11:20 UTC
+Intervention configuration: `config/ecp4.yaml`
+SHA-256: `c335483534248eda96094ceea7ff49cd3270256fdfff6e01824654a886bc6e17`
+Control configuration: `config/ecp4-control.yaml`
+SHA-256: `84c1024d49c9d2aff34fb56dbcabf41c9af76dc2ba478760e42d1098afa777c8` + +## Question + +Can the ECP protocol be compressed from 16 to exactly 10 bits — the source lower bound of the uniform world — without losing compositional generalization, population compatibility, or universal translation? + +## Why 10 bits is the minimum + +The world contains `8 × 8 × 4 × 4 = 1024 = 2^10` equiprobable meanings. Any unambiguous code therefore requires at least `log2(1024) = 10` bits. + +ECP-4 uses four local factor alphabets: + +| Factor | Values | Bits | +|---|---:|---:| +| Color | 8 | 3 | +| Shape | 8 | 3 | +| Size | 4 | 2 | +| Texture | 4 | 2 | +| **Total** | **1024 combinations** | **10** | + +Each sender freely chooses a permutation from factor to slot and within each factor a free permutation from value to local symbol. The semantics of slots and symbols are therefore not stated in advance. However, the minimum factor structure has been imposed as an architectural bias. + +## Factor-isolated receiver + +ECP-3 had one outlier in which a generic GRU memorized color and shape as a joint contextual rule. ECP-4 allows each factor output to read exactly one freely learned slot. A change in another slot cannot affect that output by construction. Each receiver learns its own hard slot permutation and shares no parameters with senders or other receivers. + +The universal translator and new transfer receivers use the same factor-isolated architecture, but are trained independently only after freezing the sender protocol. + +## Last independent color-shape split + +After ECP-0 through ECP-3, 48 of the 64 color-shape pairs were used as validation or testing. The remaining sixteen pairs form exactly two perfect matchings. They are explicitly divided, without sampling, between: + +- eight development validation pairs; +- eight sealed confirmatory test pairs. + +The split has SHA-256 `0f8b5505e1a3dceb0c87005a32d6bcffd39c66a6bb4246102617c92a8915b180`. After unsealing this test, all 64 color-shape pairs were used at least once as a validation or test; further research should therefore use a new world or an orthogonal holdout family. + +## Paired 16-bit control + +The control uses exactly the same split, five seeds, factor-isolated receivers, consensus losses, training budget, and evaluation. Only the sender code and channel differ: + +- intervention: local alphabets `8,8,4,4`, exactly 10 bits; +- control: four global symbols of sixteen, 16 bits. + +As a result, the comparison measures whether theoretically minimal compression causes performance degradation within the same enhanced decoder architecture. + +## Predefined criteria + +A seed is classified as strong evidence when it achieves: + +- at least 97% known mean exact reconstruction; +- at least 95% for the worst known sender-receiver pair; +- at least 80% average exact reconstruction on new test pairs; +- at least 70% exact reconstruction by the universal translator. + +ECP-4 is considered a successful minimum model when: + +1. at least four of five intervention seeds are strong; +2. the intervention uses exactly 10 channel bits; +3. all sender codes are injective and collision-free; +4. all channel and integrity checks pass; +5. the average test accuracy is not more than one percentage point below the paired 16-bit check. + +Five seeds (`11,23,37,53,71`) and an exact paired sign-flip test across 32 sign combinations are predefined. The ideal result is five error-free seeds, but the formal success rule remains four of five for consistency with ECP-3. diff --git a/docs/research-design-ecp5.md b/docs/research-design-ecp5.md new file mode 100644 index 0000000..cf76580 --- /dev/null +++ b/docs/research-design-ecp5.md @@ -0,0 +1,50 @@ +# Research Design ECP-5 — Robust Protocol Induction + +Status: **frozen before confirmatory test access**
+Frozen: July 18, 2026 at 06:27:09 UTC
+Intervention configuration: `config/ecp5.yaml`
+SHA-256: `5e4bf30517e0edbe96d5f0b5c666b9b03f6fe8366fd80bcc5ab455d615d11b8b`
+Control configuration: `config/ecp5-control.yaml`
+SHA-256: `4ee2f8ff314acd6f042c66fd4e81b6beb0c360b979f585f5d00b0e9df6ed2582` + +## Question + +Can a new universal reader reliably induce the arbitrary slot grammar of the perfect 10-bit protocol by precisely calibrating the discrete factor-slot permutation from labeled training messages? + +## Intervention + +The empirical mutual information is calculated for each combination of four factors and four slots. There are only `4! = 24` valid one-to-one permutations. The intervention exhaustively chooses the permutation with the highest total information and freezes that binding before training the four symbol decoders. + +The procedure: + +- only reads messages and meaning labels from the allowed training set; +- does not open validation or test meanings; +- does not read sender parameters, codebooks, or hidden state; +- does not prescribe symbol meanings; +- only determines which message position statistically belongs to which factor. + +The paired control relearns the same binding with the existing straight-through gradients. All other code, data, seeds, and training budgets are identical. + +## Orthogonal sealed test + +Because all color-shape pairs had been used for validation or testing by the end of ECP-4, ECP-5 preregisters a size-texture holdout instead: + +- 512 training meanings; +- 256 meanings from four fully withheld validation pairs; +- 256 meanings from four other sealed test pairs. + +Color and shape vary completely within each retained pair. The split SHA-256 is `cc487fd9042c5190bee93278c4be5180363f46a46d0e8af2f9d7d75a4f173140`. + +## Criteria + +The ECP-3/4 thresholds continue to apply per seed: 97% known average, 95% for the worst known pair, 80% compositional test accuracy and 70% universal translation accuracy. + +ECP-5 is passed when: + +1. at least four of five intervention seeds are strong; +2. the average population and translation accuracy are each at least 95%; +3. each message uses exactly 10 bits and all codes are collision-free; +4. all channel and artifact checks pass; +5. the calibrated translator performs better than the uncalibrated control in at least four of five seeds or ends up equal at 100%. + +Seeds `11,23,37,53,71` and the exact paired sign-flip test were recorded before test access. diff --git a/docs/research-design-ecp6.md b/docs/research-design-ecp6.md new file mode 100644 index 0000000..57608c6 --- /dev/null +++ b/docs/research-design-ecp6.md @@ -0,0 +1,66 @@ +# Research Design ECP-6 — Scalability at the Information Frontier + +Status: **frozen before confirmatory test access**
+Frozen: July 18, 2026 at 06:58:14 UTC
+Configuration: `config/ecp6.yaml`
+Configuration-SHA-256: `994ca086e1542e4608fec935ec5b72471b2e2cf73c2193f99ab6997044c40133` + +## Question + +Does the universally readable protocol confirmed in ECP-5 remain completely correct when the meaning space increases sixteen times, while the messages remain exactly at the new theoretical lower limit of 14 bits? + +## Scaling + +The world contains four independent factors: + +- 16 colors; +- 16 shapes; +- 8 sizes; +- 8 textures. + +This gives `16 × 16 × 8 × 8 = 16,384 = 2^14` equiprobable meanings. The factor-local message uses four slots with alphabet sizes `[16,16,8,8]`. Their widths are `[4,4,3,3]` bits and sum to exactly 14 bits. A lossless fixed-length code cannot be shorter for this world. + +## Sealed data split + +Color and shape form the compositional holdout. Sixteen color-shape pairs are each explicitly recorded in advance for validation and testing. Each withheld pair contains at least one atomic value from the new half (`8–15`), so that the scaling is actually addressed. + +| Split | Meanings | Color-shape pairs | +|---|---:|---:| +| Train | 14,336 | 224 | +| Validation | 1,024 | 16 | +| Confirmatory test | 1,024 | 16 | + +Split-SHA-256: `da751db7853ddbb84f000464c2627d4880eb154aef2158fb958d9a3779117d33`. + +## Recorded protocol + +The architecture and induction rule remain substantively the same as ECP-5: + +1. four independently initialized senders produce a factor-local permutation-slot code; +2. four receivers are trained over all sixteen sender-receiver links; +3. a new universal translator receives only labeled training messages; +4. the translator determines its factor-slot binding by comparing all `4! = 24` permutations on empirical mutual information and freezes the winner; +5. transfer is measured with 32, 128, 512, and 2,048 examples. + +There is no new control arm: ECP-5 already tested the binding intervention directly in paired runs. ECP-6 is solely a preregistered scale replication of the successful intervention. + +## Scale-safe measurements + +Collisions, entropy, minimum pairs and exact task performance are calculated over all evaluated meanings. For topographic Spearman correlation, up to 1,000,000 unordered meaning pairs are sampled uniformly without replacement and with a fixed seed; smaller worlds use all pairs. This rule was implemented and tested before test unsealing because materializing all 134,209,536 pairs at once is not scalable. + +Raw isolated message and prediction matrices continue to cover every evaluated meaning. Episode JSONL contains validation data and, only after unsealing, test data. The local channel audit checks every logged message for four symbols, factor-local alphabet boundaries, and exactly 14 bits. + +## Predefined criteria + +The five seeds are `11,23,37,53,71`. A seed is strong when existing ECP-5 thresholds are met: at least 97% average known exactness, at least 95% for the worst known pair, at least 80% average compositional test exactness, and at least 70% universal translation exactness. + +ECP-6 is considered fully successful when: + +1. at least four of five seeds are strong; +2. the average compositional population performance is at least 99%; +3. the average universal translation performance is at least 99%; +4. each sender encodes all 16,384 meanings collision-free; +5. each message demonstrably uses exactly 14 bits; +6. all artifact hashes, schemas, local alphabet boundaries, and test unsealing checks pass. + +After freezing, no more model, split, measurement or threshold choices are adjusted based on ECP-6 test results. diff --git a/docs/research-design.md b/docs/research-design.md new file mode 100644 index 0000000..85ca892 --- /dev/null +++ b/docs/research-design.md @@ -0,0 +1,256 @@ +# Research design: emergent AI communication + +Version: 0.2
+Date: July 17, 2026
+First experiment: ECP-0 + +## 1. Goal + +This research tests whether AI agents can develop a communication protocol under controlled conditions that: + +- transmits information reliably; +- is more compact than human text representations; +- can describe new combinations; +- can be reconstructed by an independent translator; +- can be learned by agents outside the original training pair; +- remains controllable because all communication runs through one measurable channel. + +The research distinguishes between a **code** and a **language-like protocol**. A code can give any complete meaning an arbitrary number. A language-like protocol reuses parts or structures and can therefore compose unknown meanings. + +## 2. Central research question + +> Can independently trained AI agents themselves develop a communication protocol that is more efficient, clearer and more systematic than human language, given the same task performance? + +### Subquestions + +1. Can a reliable discrete protocol be created without human words? +2. Does this protocol generalize to never trained combinations? +3. Can the internal structure be explained systematically afterwards? +4. Can an independent translator unlock the messages correctly? +5. Can a new receiver learn the protocol without co-adapting with the original sender? +6. How does the protocol change under the pressure of message costs, noise, context and more complex reasoning tasks? + +## 3. Operational definitions + +### New + +The meaning of individual symbols and symbol sequences has not been determined by a human. Only the task, world and channel capacity are designed. + +### Efficient + +A protocol focuses more favorably on the trade-off between task performance and costs. Costs are measured primarily in bits actually sent; latency, computation costs and error sensitivity are reported separately. + +### Clear + +The receiver reproducibly arrives at the intended meaning of the same message, even with unseen combinations and limited noise. + +### Translatable + +An independent model, which has not been trained with the agents, can convert a frozen message to its canonical meaning and then to Dutch. + +### Transferable + +A new receiver can learn to communicate with the frozen original sender with a limited number of examples. + +### Completely efficient + +This is not used as an absolute property. Efficiency only exists with respect to load balancing, channel, fault tolerance and hardware. Step 3 therefore looks for a Pareto front instead of one universal optimum. + +## 4. Predetermined hypotheses + +- **H1 — Reliability:** at least four of five ECP-0 runs achieve 99% exact reconstruction on known meanings. +- **H2 — Combinatorial generalization:** a learned protocol clearly outperforms a non-compositional lookup baseline on withheld color-shape pairs. +- **H3 — Translatability:** an independent translator generalizes above the lookup baseline to the same withheld pairs. +- **H4 — Structure:** meaning distance and message distance show more correlation than with randomly permuted messages. +- **H5 — Transfer:** in step 2, a new receiver learns the frozen protocol with fewer examples than a completely new protocol. +- **H6 — Efficiency:** in step 2, a bit penalty reduces the average message length without falling below a predetermined performance threshold. + +A negative result is a valid result. Thresholds should not be adjusted retroactively after reviewing test results. + +## 5. Step 1 — ECP-0: translatable base + +### 5.1 Artificial world + +Every meaning is the Cartesian product of four factors: + +| Factor | Number of values | Internal representation | +|---|---:|---| +| color | 8 | `c0` to `c7` | +| shape | 8 | `s0` to `s7` | +| size | 4 | `z0` to `z3` | +| texture | 4 | `t0` to `t3` | + +This yields 1024 unique meanings. Human labels may exist for visualization, but are never used as model input. + +The source is uniformly distributed. As a result, error-free identification requires at least `log2(1024) = 10` bits of information. + +### 5.2 Communication task + +1. The sender receives one meaning as four categorical factors. +2. The sender produces exactly four symbols. +3. The receiver only sees those four symbols. +4. The receiver predicts all four factors. +5. An episode is only exactly correct if all four factors are correct. + +The channel contains 16 possible symbols. So one symbol costs 4 bits and each ECP-0 message costs exactly 16 bits. The symbols have no meaning at first. ECP-0.2 uses this extra space to first test learnability and translatability; compression to three symbols/12 bits is explored in step 2. + +### 5.3 Agents + +- Both agents are trained from random initialization. +- They use separate weights, embeddings and random seeds. +- They receive no pre-trained language model and no natural language as input. +- A straight-through Gumbel-Softmax estimate may be used during training. +- Only hard integer symbol IDs are sent during validation and testing. +- For the final evaluation, the sender and receiver run as logically separate processes. + +Transmitting gradients during training is a learning signal, not an evaluation channel. All conclusions are based solely on discrete evaluation. + +### 5.4 Data splitting + +The split is generated deterministically before training: + +1. Create a random one-to-one matching between the eight colors and eight shapes using the recorded data-split seed. Each color and shape appears exactly once in a held-out pair. +2. Retain all 16 combinations of size and texture for each pair. +3. This forms a compositional test set of 128 meanings. +4. Select a stratified development set of 128 meanings from the remaining 896 meanings. +5. The remaining 768 meanings form the training set. + +Every atomic value appears in training. Only specific combinations are missing. The test set remains sealed until model and hyperparameter choices are finalized. + +### 5.5 Freeze and translate + +After training, the sender and receiver are frozen. Then a third model is trained: + +- input: the discrete message only; +- output: the four canonical factors; +- training: only messages from the training split; +- evaluation: the development set and then the compositional test set once. + +A Dutch renderer deterministically converts the predicted factors into readable text. The renderer does not count as an intelligent translator; performance is measured on the predicted canonical factors. + +### 5.6 Baselines + +| Baseline | Function | +|---|---| +| Dutch template | Comparison with human readability and UTF-8 size | +| Canonical JSON | Comparison with common machine communication | +| Manually packed factor code, 10 bits | Domain-specific technical lower bound | +| Random Lookup Code | High known-set performance without compositionality | +| Manual compositional factor code | Check for maximum explicit structure | + +The comparison with Dutch and JSON is about message size, not about overall expressiveness. The 10-bit factor code prevents the incorrect claim that a learned protocol can beat any designed binary representation. + +### 5.7 Primary measurements + +- exact reconstruction accuracy; +- accuracy per factor; +- performance on known and withheld meanings; +- actual number of channel bits; +- message entropy and number of unique messages; +- collisions: different meanings with the same message; +- topographic similarity between meaning and message distance; +- minimal pair analysis and symbol ablation; +- independent translation accuracy; +- spread across five training seeds; +- training and inference latency, as a secondary measure only. + +No single structural measure can be taken separately as evidence for compositionality. The conclusion combines generalization, translation, minimal pairs, ablations, and comparison with controls. + +### 5.8 Checks against false success + +- **Message shuffling:** exact reconstruction should drop to approximately chance level. +- **Consistent symbol permutation:** performance should remain the same if symbol IDs are renamed identically on both sides. +- **Channel Isolation:** Receiver does not receive episode ID, meaning ID, clock time, shared memory, or file channel. +- **No shared state:** models do not share weights, cache, random generator, or hidden activations during evaluation. +- **Full logging:** every message, response, model hash, config hash and seed is saved. +- **Hard quantization:** conclusions are not based on continuous, indefinitely precise vectors. +- **Test seal:** the compositional test set does not influence model selection. + +### 5.9 Classification of the outcome + +Step 1 is methodologically completed when all five preset runs, baselines, and checks have been performed. The outcome is then classified as follows: + +- **Strong evidence:** at least four runs get 99% on known meanings, 90% on the compositional test and 85% independent translation on that test. +- **Mixed evidence:** known meanings reach 99%, but generalization or translation is between lookup level and the strong threshold. +- **Negative result:** the agents do not learn a reliable channel, or generalization and translation are not meaningfully different from the lookup check. +- **Invalid run:** a check failed, a side channel is possible or the predefined configuration has been changed without registration. + +These percentages are research thresholds, not a guarantee that ECP-0 will achieve them. + +## 6. Step 2 — Refinement and Evolution + +Step 2 only builds on a frozen report from Step 1. New hypotheses and configurations are pre-registered. + +Planned extensions: + +- variable message length from one to six symbols; +- full bit accounting, including length information; +- information pressure via an explicit bit penalty; +- noise due to symbol loss, replacement and swapping; +- context in which irrelevant properties can be safely omitted; +- relationships between multiple objects; +- populations of multiple senders and receivers; +- periodic replacement by newly initialized agents; +- transmission testing with a frozen sender or receiver; +- comparison between joint training and iterative learning across generations. + +The core question here shifts from “can it communicate?” to “does the protocol remain efficient, learnable and robust when the environment changes?” + +## 7. Step 3 — Efficiency and complex reasoning + +Step 3 introduces more complex meanings and multiple channel forms: + +- hierarchical concepts; +- object-relationship graphs; +- time, uncertainty, intention and conditional actions; +- abstract reasoning rules instead of only visible features; +- discrete sequences, typed graphs and quantized vectors; +- task transfer to an environment where the protocol has not been trained. + +Continuous vectors are always quantized to a predetermined number of bits. Otherwise a fair efficiency comparison is impossible. + +The outcome is reported as a Pareto front on: + +1. task performance; +2. sent bits; +3. robustness; +4. generalization; +5. translatability; +6. portability; +7. latency and computation costs. + +## 8. Reproducibility and reporting + +Each run receives an unchangeable run ID and contains at least: + +- full configuration; +- software and hardware versions; +- dataset manifest and hashes; +- model initialization seeds; +- checkpoints and model hashes; +- raw episode messages and predictions; +- calculated metrics; +- registered deviations from the protocol; +- automatic and human summarized result. + +Failed runs are not deleted. A change after result inspection starts a new experiment version. + +## 9. Limits of interpretation + +A positive result shows an efficient emergent protocol in the tested world. It does not prove that: + +- the protocol is a general alternative to human language; +- agents have deliberately designed a language; +- the same structure arises spontaneously in large language models; +- communication outside the experimental task remains efficient; +- incomprehensibility in itself demonstrates intelligence or semantic depth. + +## 10. Research base + +The design is in line with previous research into emergent communication: + +- [Natural Language Does Not Emerge 'Naturally' in Multi-Agent Dialog](https://aclanthology.org/D17-1321/) — successful task performance does not guarantee interpretable or compositional language. +- [Emergent Communication: Generalization and Overfitting in Lewis Games](https://proceedings.neurips.cc/paper_files/paper/2022/hash/093b08a7ad6e6dd8d34b9cc86bb5f07c-Abstract-Conference.html) — co-adaptation and overfitting can undermine generalization. +- [Trading off Utility, Informativeness, and Complexity in Emergent Communication](https://proceedings.neurips.cc/paper_files/paper/2022/hash/8bb5f66371c7e4cbf6c223162c62c0f4-Abstract-Conference.html) — information value and protocol complexity should be measured together. +- [Emergent Communication for Rules Reasoning](https://proceedings.neurips.cc/paper_files/paper/2023/hash/d8ace30c68b085556ccce04ed4ae4ebb-Abstract-Conference.html) — more complex reasoning tasks can encourage more structural protocols. +- [A Compressive-Expressive Communication Framework for Compositional Representations](https://proceedings.neurips.cc/paper_files/paper/2025/hash/3310034c97fab48fdbcba18f90fd5364-Abstract-Conference.html) — compressive pressure and iterative learning can support efficiency and compositionality. diff --git a/docs/resultaten-ecp0.md b/docs/resultaten-ecp0.md deleted file mode 100644 index 52b2988..0000000 --- a/docs/resultaten-ecp0.md +++ /dev/null @@ -1,104 +0,0 @@ -# Resultaten ECP-0.2 - -Confirmatieve run: `20260717T221924Z-ecp0-experiment` -Configuratie bevroren: 17 juli 2026 om 22:18:41 UTC -Configuratie-SHA-256: `7415f5732fed4d5e7e72ca82e917e4110a9f9f8ba68566daba3aa26e652b90cc` -Primaire classificatie: **gemengd bewijs** - -## Samenvatting - -ECP-0.2 toont dat twee vanaf nul getrainde agents binnen een kanaal van 16 bits zelfstandig een vrijwel injectief communicatieprotocol kunnen ontwikkelen. Het protocol reconstrueert bekende betekenissen in vier van vijf runs voor minstens 99% correct. Het draagt bovendien semantische structuur over naar een onafhankelijke vertaler. - -Het protocol generaliseert echter nog niet betrouwbaar naar kleur-vormparen die volledig buiten training zijn gehouden. De gemiddelde exacte testprestatie is 15,9%, met een spreiding van 0% tot 43,8%. Daarmee is er bewijs voor gedeeltelijke structurele generalisatie, maar niet voor een stabiele nieuwe taalvorm. - -## Primaire resultaten - -| Seed | Bekend exact | Validatie exact | Achtergehouden paren | Vertaler op achtergehouden paren | Classificatie | -|---:|---:|---:|---:|---:|---| -| 11 | 99,5% | 73,4% | 7,8% | 12,5% | gemengd | -| 23 | 99,9% | 83,6% | 0,0% | 3,1% | gemengd | -| 37 | 99,1% | 79,7% | 20,3% | 12,5% | gemengd | -| 53 | 91,3% | 60,9% | 7,8% | 7,0% | negatief | -| 71 | 99,2% | 95,3% | 43,8% | 38,3% | gemengd | -| **Gemiddeld** | **97,8%** | **78,6%** | **15,9%** | **14,7%** | **gemengd** | -| **Mediaan** | **99,2%** | **79,7%** | **7,8%** | **12,5%** | — | - -De niet-compositionele lookupbaseline scoort per definitie 0% op onbekende betekenissen. De handmatig compositionele baseline scoort 100% met 12 bits; de optimaal gepakte factorcode scoort 100% met 10 bits. - -## Hypothesen - -### H1 — Betrouwbaarheid: ondersteund - -Vier van vijf runs overschrijden de vooraf vastgelegde grens van 99% bekende reconstructie. Eén seed blijft met 91,3% duidelijk achter. De basis is dus reproduceerbaar, maar het trainingsproces kent nog een ongunstige lokale oplossing. - -### H2 — Combinatorische generalisatie: gedeeltelijk ondersteund - -Vier van vijf runs presteren boven de 0%-lookupbaseline op volledig achtergehouden kleur-vormparen. De mediaan is slechts 7,8% en één run bereikt 0%. Seed 71 laat met 43,8% zien dat aanzienlijk betere generalisatie binnen dezelfde architectuur mogelijk is, maar niet dat deze betrouwbaar ontstaat. - -### H3 — Onafhankelijke vertaalbaarheid: gedeeltelijk ondersteund - -De vertaler reconstrueert trainingsberichten vrijwel foutloos en scoort in alle vijf runs boven de lookupbaseline op de achtergehouden paren. De gemiddelde testprestatie van 14,7% blijft echter te laag om het protocol algemeen vertaalbaar te noemen. - -### H4 — Structurele semantiek: ondersteund - -De topografische overeenkomst tussen betekenisafstand en berichtafstand ligt per seed tussen 0,308 en 0,448. Een post-runanalyse met 100 willekeurige betekenis-berichtkoppelingen per seed vond per seed een maximale nulwaarde van hoogstens 0,004. Alle vijf waarnemingen lagen daarboven; de empirische eenzijdige `p`-waarde is telkens `1/101 ≈ 0,0099`. - -Deze permutatietoets voltooit de vooraf geregistreerde diagnostische vergelijking, maar is na de primaire run uitgevoerd en verandert de primaire classificatie niet. - -### H5 en H6 — Nog niet getest - -Overdracht naar nieuwe agents en compressie via een bitstraf behoren tot stap 2. - -## Wat voor protocol ontstond? - -De agents ontwikkelden geen eenvoudig woordenboek met één vaste berichtpositie per factor: - -- tussen 955 en 1015 van de 1024 betekenissen kregen een uniek bericht; -- de berichtentropie lag tussen 9,86 en 9,98 bits, dicht bij de 10 bits broninformatie; -- iedere berichtpositie bleek belangrijk bij ablaties; -- de gemiddelde concentratie van factorveranderingen op één positie lag rond 0,31, slechts beperkt boven 0,25 bij een gelijkmatige verdeling; -- betekenisgelijkheid is wel duidelijk terug te zien in afstanden tussen berichten. - -De beste beschrijving is daarom: **een grotendeels gedistribueerde, bijna injectieve code met gedeeltelijke semantische geometrie**. Dat is meer dan een willekeurige lookupcode, maar nog minder systematisch dan een compositionele taal. - -## Efficiëntie - -| Representatie | Bits per betekenis | Exact op onbekende combinaties | -|---|---:|---:| -| Nederlands vast sjabloon, UTF-8 | 328 | 100% bij correcte productie | -| Canonieke JSON, UTF-8 | 432 | 100% | -| ECP-0.2 | 16 | gemiddeld 15,9% | -| Handmatig compositioneel | 12 | 100% | -| Optimaal gepakte factoren | 10 | 100% | - -ECP-0.2 is zeer compact ten opzichte van ongecomprimeerde tekst en JSON. Het is niet efficiënter dan een ontworpen domeincode en de foutgraad op onbekende combinaties is nog te hoog. Er is dus nog geen grond voor de claim dat AI een superieure algemene communicatievorm heeft ontwikkeld. - -## Geldigheid en integriteit - -- Alle vijf seeds gebruikten dezelfde bevroren configuratie. -- De compositionele testset werd niet gebruikt voor training of modelselectie. -- Zender en ontvanger draaiden tijdens evaluatie in afzonderlijke processen. -- De ontvanger kreeg uitsluitend een matrix met vier symbool-ID's. -- Alle husselcontroles bleven op 0% of 0,098% exacte reconstructie. -- Consistente hernoeming van alle symbool-ID's behield in iedere run exact dezelfde voorspellingen. -- Iedere seed bevat 1024 schema-gevalideerde episodes. -- Alle 179 vooraf gehashte artefacten kwamen bij de post-runanalyse byte voor byte overeen. - -## Besluit voor stap 2 - -Direct comprimeren van 16 naar 12 bits is nu methodologisch te vroeg. De bottleneck is niet berichtgrootte, maar betrouwbare compositionaliteit en overdracht. - -De aanbevolen volgorde voor ECP-1 is: - -1. gebruik een nieuwe datasplitseed en nieuwe achtergehouden paren; de ECP-0-testset is nu opgebruikt; -2. train een populatie van zenders en ontvangers met wisselende koppelingen om co-adaptatie van één paar te verminderen; -3. voeg periodiek een nieuw geïnitialiseerde ontvanger toe en meet hoeveel voorbeelden die nodig heeft; -4. onderzoek iteratief leren over generaties en progressieve reconstructie na ieder symbool; -5. behoud eerst het 16-bitkanaal om het effect op generalisatie zuiver te meten; -6. vergelijk daarna dezelfde methode op 16 en 12 bits voordat variabele lengte en bitstraf worden toegevoegd. - -Pas wanneer generalisatie en overdraagbaarheid stabiel zijn, kan stap 3 eerlijk op maximale efficiëntie worden gericht. - -## Lokale bewijsbestanden - -De niet-versiebeheerde bronrun staat lokaal onder `runs/20260717T221924Z-ecp0-experiment/`. Deze bevat `report.md`, `summary.json`, `posthoc-analysis.json` en de per-seedmetrics, episodes, modellen en geïsoleerde procesinvoer. diff --git a/docs/resultaten-ecp1.md b/docs/resultaten-ecp1.md deleted file mode 100644 index 4ae1799..0000000 --- a/docs/resultaten-ecp1.md +++ /dev/null @@ -1,112 +0,0 @@ -# Resultaten ECP-1 - -Confirmatieve run: `20260718T001805Z-ecp1-experiment` -Configuratie bevroren: 18 juli 2026 om 00:17:09 UTC -Configuratie-SHA-256: `13ebb1186aa87e98093f64a02a9961d35a2fdf6b06b6f56e47ab5a53c2a6e977` -Formele primaire classificatie: **gemengd bewijs** -Inhoudelijke uitkomst voor de populatiehypothese: **niet ondersteund** - -## Samenvatting - -ECP-1 testte vier onafhankelijk geparametriseerde zenders tegen vier onafhankelijk geparametriseerde ontvangers. Alle zestien koppelingen werden samen getraind. Hierdoor ontstond inderdaad een gedeelde conventie: een willekeurige ontvanger reconstrueert bekende berichten van iedere zender gemiddeld voor 98,5% correct en zelfs de gemiddeld slechtste zender-ontvangerkoppeling haalt 98,1%. - -De populatietraining lost het belangrijkste probleem van ECP-0 echter niet op. Op volledig achtergehouden kleur-vormparen daalt de gemiddelde exacte reconstructie van 15,9% bij ECP-0 naar 10,1% bij ECP-1. De universele vertaler haalt 15,2%. Geen enkele seed benadert de vooraf vereiste 60% populatiegeneraliseerbaarheid of 50% vertaalbaarheid. - -De juiste conclusie is daarom niet dat er al een nieuwe efficiënte AI-taal is ontstaan. Er is wel sterk bewijs dat meerdere onafhankelijke agents een compacte, gedeelde en structurele code kunnen afspreken. Die code is nog onvoldoende compositioneel: bekende combinaties worden grotendeels gememoriseerd en nieuwe combinaties worden niet systematisch uit bekende onderdelen samengesteld. - -## Primaire resultaten - -| Seed | Bekend gemiddeld | Slechtste bekend paar | Validatie | Nieuwe paren | Slechtste testpaar | Universele vertaler | Nieuwe ontvanger, 768 voorbeelden | Classificatie | -|---:|---:|---:|---:|---:|---:|---:|---:|---| -| 11 | 99,2% | 98,8% | 77,6% | 17,0% | 7,8% | 24,4% | 18,8% | gemengd | -| 23 | 99,2% | 98,8% | 82,4% | 7,2% | 2,3% | 9,2% | 9,4% | negatief | -| 37 | 97,5% | 97,1% | 73,6% | 6,5% | 3,9% | 13,1% | 12,5% | negatief | -| 53 | 99,1% | 98,4% | 76,5% | 5,4% | 2,3% | 10,9% | 7,8% | negatief | -| 71 | 97,6% | 97,4% | 81,7% | 14,5% | 10,9% | 18,6% | 18,8% | negatief | -| **Gemiddeld** | **98,5%** | **98,1%** | **78,4%** | **10,1%** | **5,5%** | **15,2%** | **13,4%** | **gemengd** | - -De testfactoren kleur en vorm — precies de twee factoren waarvan combinaties waren achtergehouden — worden gemiddeld voor 39,4% en 46,5% correct gereconstrueerd. Grootte en textuur blijven met 98,6% en 97,9% vrijwel intact. De fout zit dus gericht in het opnieuw combineren van de twee uitgesloten factoren, niet in een algemeen defect van de decoder. - -## Vergelijking met ECP-0 - -| Metriek | ECP-0 | ECP-1 | Verschil | -|---|---:|---:|---:| -| Bekende betekenissen | 97,8% | 98,5% | +0,7 procentpunt | -| Validatie | 78,6% | 78,4% | −0,2 procentpunt | -| Volledig nieuwe kleur-vormparen | 15,9% | 10,1% | **−5,8 procentpunt** | -| Onafhankelijke/universele vertaler | 14,7% | 15,2% | +0,5 procentpunt | - -Deze vergelijking is richtinggevend, niet gelijk aan een meting op exact dezelfde testitems: ECP-1 gebruikte bewust een nieuwe datasetseed en acht nieuwe achtergehouden paren, omdat de ECP-0-testset al was geopend. Van de vijf ECP-1-seeds presteert alleen seed 11 met 17,0% nipt boven het ECP-0-gemiddelde van 15,9%. - -De formele classificatie blijft **gemengd bewijs**, omdat de vooraf geïmplementeerde aggregatieregel dat label toekent zodra minstens één geldige seed boven de ECP-0-referentie komt. Die regel wordt na het openen van de testset niet aangepast. Voor de wetenschappelijke interpretatie is het gemiddelde effect doorslaggevend: populatietraining heeft de generalisatie in deze proef niet verbeterd. Een volgend protocol moet de aggregatieregel expliciet op het gemiddelde en de onzekerheid daarvan vastleggen. - -## Hypothesen - -### H1 — Een gedeeld populatieprotocol ontstaat: ondersteund - -Alle zestien zender-ontvangerkoppelingen leren dezelfde taak. De gemiddelde bekende nauwkeurigheid is 98,5% en de slechtste koppeling per seed blijft gemiddeld op 98,1%. Alle vijf seeds passeren de grens van 95% voor het slechtste paar; drie van vijf passeren ook de strengere grens van 99% gemiddeld. - -De vier zenders produceren voor dezelfde betekenis gemiddeld in 54,3% van de gevallen exact hetzelfde bericht. Dat is geen volledige uniformiteit, maar wel aanzienlijke convergentie tussen modellen zonder gedeelde parameters. - -### H2 — Populatietraining verbetert compositionele generalisatie: niet ondersteund - -Het gemiddelde van 10,1% ligt onder ECP-0 en ver onder de vooraf vastgelegde grens van 60%. Geen van de vijf seeds passeert die grens. Het wisselen van communicatiepartners voorkomt dus wel exclusieve co-adaptatie van één paar, maar dwingt op zichzelf geen factorieel opgebouwde taal af. - -### H3 — Eén universele vertaler ontsluit alle zenders: gedeeltelijk structureel, prestatiedrempel niet gehaald - -De vertaler wordt pas na het bevriezen van de vier zenders getraind en haalt gemiddeld 15,2% op nieuwe paren. Dit toont dat één model de gedeeltelijk gedeelde conventie kan lezen, maar geen seed haalt de vereiste 50%. - -### H4 — Een nieuwe ontvanger leert het protocol snel: niet ondersteund - -| Gelabelde betekenissen | Gemiddeld exact op nieuwe paren | -|---:|---:| -| 32 | 1,3% | -| 128 | 7,9% | -| 512 | 11,7% | -| 768 | 13,4% | - -De leercurve stijgt met meer voorbeelden, maar er is geen few-shotoverdracht. Zelfs na alle 768 trainingsbetekenissen blijft de nieuwe ontvanger ver onder een betrouwbaar niveau. - -### H5 — De berichten bevatten semantische structuur: ondersteund als diagnostiek - -De topografische overeenkomst tussen betekenisafstand en berichtafstand ligt voor de twintig zender-seedcombinaties tussen 0,308 en 0,432. In de vooraf aangekondigde post-runanalyse ligt iedere waarneming boven alle 100 willekeurige herkoppelingen; de empirische eenzijdige `p`-waarde is telkens `1/101 ≈ 0,0099`. - -Dit bewijst structuur, niet voldoende compositionaliteit. Een code kan semantisch nabije betekenissen vergelijkbare berichten geven en toch falen bij een volledig nieuwe combinatie van twee factoren. - -## Wat voor protocol ontstond? - -Per zender worden 960 tot 1007 unieke berichten gebruikt voor 1024 betekenissen. De berichtentropie ligt tussen 9,864 en 9,967 bits, dicht bij de 10 bits broninformatie. Samen met de hoge bekende nauwkeurigheid wijst dit opnieuw op een bijna injectieve, gedistribueerde code. - -ECP-1 voegt daar een belangrijk resultaat aan toe: meerdere onafhankelijke zenders en ontvangers kunnen zo'n code gezamenlijk stabiliseren. De gedeelde conventie is echter nog steeds meer een compact geometrisch codeboek dan een grammatica die kleur, vorm, grootte en textuur consequent als herbruikbare onderdelen combineert. - -## Geldigheid en integriteit - -- De ECP-1-configuratie is vóór de confirmatieve run bevroren. -- De acht ECP-0-testparen zijn expliciet uitgesloten bij het maken van de nieuwe split. -- De compositionele ECP-1-testset is niet gebruikt voor training of modelselectie. -- Vier zenders en vier ontvangers hebben volledig onafhankelijke parameters. -- Definitieve decodering vond plaats in afzonderlijke processen die uitsluitend symboolmatrices ontvingen. -- Alle husselcontroles bleven op of onder 1,0% en gemiddeld rond 0,09% exacte reconstructie. -- Consistente hernoeming van de zestien symbolen behield in alle seeds alle voorspellingen. -- Iedere seed bevat 16.384 schema-gevalideerde episodes; samen zijn dat 81.920 episodes. -- Alle 309 vooraf gehashte artefacten kwamen bij de post-runanalyse byte voor byte overeen. - -## Besluit voor ECP-2 - -Nog meer agents toevoegen is niet de logische volgende stap. ECP-1 laat zien dat partnerwissel compatibiliteit creëert, maar niet vanzelf compositionaliteit. ECP-2 moet daarom een leerdruk invoeren die memorisatie moeilijker maakt zonder de semantiek vooraf in symbolen te programmeren. - -De aanbevolen confirmatieve vergelijking is: - -1. behoud de onafhankelijke populatie en het 16-bitkanaal; -2. train iteratief over generaties, waarbij nieuwe ontvangers alleen berichten en een beperkt aantal voorbeelden van de vorige generatie krijgen; -3. maak de trainingswereld systematisch onvolledig met wisselende combinaties per generatie; -4. selecteer uitsluitend op validatiegeneraliseerbaarheid en snelheid waarmee een nieuwe ontvanger leert; -5. vergelijk deze methode tegen een exact gelijke ECP-1-controle zonder generatievervanging; -6. gebruik opnieuw een volledig nieuwe, verzegelde testset; -7. leg de primaire groepsvergelijking en onzekerheidsmarge vooraf vast. - -Compressie naar 12 of 10 bits blijft uitgesteld. Eerst moet een robuust herbruikbaar protocol ontstaan; pas daarna is maximale efficiëntie een zinvolle hoofdvraag. - -## Lokale bewijsbestanden - -De niet-versiebeheerde bronrun staat lokaal onder `runs/20260718T001805Z-ecp1-experiment/`. Deze bevat `report.md`, `summary.json`, `posthoc-analysis.json` en de per-seedmetrics, 81.920 episodes, checkpoints en geïsoleerde procesinvoer. diff --git a/docs/resultaten-ecp2.md b/docs/resultaten-ecp2.md deleted file mode 100644 index 64a5032..0000000 --- a/docs/resultaten-ecp2.md +++ /dev/null @@ -1,60 +0,0 @@ -# Resultaten ECP-2 - -Confirmatieve interventie: `ecp2-confirmatory/intervention/20260718T013310Z-ecp2-experiment` -Gepaarde controle: `ecp2-confirmatory/control/20260718T013310Z-ecp2-experiment` -Split-SHA-256: `7a227e22d86f00d8ab5078690de37de794774cdab636e7db374c5adbd0985126` -Formele primaire classificatie: **gemengd bewijs** - -## Conclusie - -ECP-2 levert het eerste duidelijk compositionele protocol in deze reeks op, maar nog geen robuust eindmodel. De interventie geeft iedere factor een afzonderlijk slot, laat de zenders zelf een één-op-één factor-slotpermutatie kiezen en oefent uitsluitend consensus uit op die vrije keuze. Alle interventiezenders kwamen per seed op dezelfde slotbinding uit. - -De gemiddelde exacte reconstructie van volledig nieuwe kleur-vormcombinaties stijgt ten opzichte van de gepaarde controle van 58,2% naar 66,1%. Vier van vijf seeds verbeteren, maar de exacte eenzijdige gepaarde tekenomklaptoets is met vijf paren niet significant (`p = 0,15625`). De universele vertaler stijgt van 66,2% naar 77,6%, verbetert in alle vijf seeds en heeft `p = 0,03125`. - -Toch halen slechts twee van vijf interventieseeds alle vooraf vastgelegde drempels. De zwakke seeds bevatten nog botsingen in de vrij geleerde symbolen voor factorwaarden. Slotstructuur alleen garandeert dus niet dat elke waarde een unieke atoomcode krijgt. - -## Primaire resultaten - -| Seed | Bekend | Slechtste bekend paar | Compositionele validatie | Nieuwe testparen | Slechtste testpaar | Universele vertaler | Classificatie | -|---:|---:|---:|---:|---:|---:|---:|---| -| 11 | 100,0% | 100,0% | 97,0% | 86,4% | 76,6% | 98,2% | sterk | -| 23 | 100,0% | 100,0% | 100,0% | 100,0% | 100,0% | 100,0% | sterk | -| 37 | 89,6% | 89,6% | 55,5% | 35,4% | 21,9% | 75,0% | gemengd | -| 53 | 91,7% | 91,7% | 72,7% | 55,3% | 49,2% | 51,6% | gemengd | -| 71 | 100,0% | 100,0% | 40,1% | 53,2% | 34,4% | 63,3% | gemengd | -| **Gemiddeld** | **96,3%** | **96,3%** | **73,0%** | **66,1%** | **56,4%** | **77,6%** | **gemengd** | - -## Gepaarde vergelijking - -| Metriek | Zonder bindingsconsensus | Met bindingsconsensus | Verschil | Seeds beter | Exacte eenzijdige `p` | -|---|---:|---:|---:|---:|---:| -| Nieuwe testparen | 58,2% | 66,1% | +7,9 procentpunt | 4/5 | 0,15625 | -| Universele vertaler | 66,2% | 77,6% | +11,4 procentpunt | 5/5 | 0,03125 | -| Sterke seeds | 1/5 | 2/5 | +1 seed | — | — | - -De slotarchitectuur zelf is krachtig: ook de controle zonder consensus haalt gemiddeld veel meer compositionele generalisatie dan ECP-1. De gepaarde vergelijking isoleert uitsluitend het extra effect van bindingsconsensus, niet het effect van de structurele slotbias. - -## Interpretatie - -ECP-2 denkt aantoonbaar buiten woorden en alfabetten: een bericht is een reeks van vier discrete symbolen, en zowel symboolgebruik als slotvolgorde zijn arbitrair. De code is op goede seeds perfect injectief, heeft topografische overeenkomst 1,0 en kan nieuwe combinaties exact samenstellen. - -Het succes is echter niet volledig spontane taalemergentie. De architectuur schrijft vooraf voor dat de vier betekenisfactoren in vier afzonderlijke slots moeten worden uitgedrukt. Zij kiest niet wat de slots betekenen, maar krijgt wel de grammaticale vorm “één factor per positie” opgelegd. Dit experiment toont daarom dat een efficiënte niet-menselijke conventie betrouwbaar kan worden **geleerd binnen een compositioneel kanaal**, niet dat neural agents die kanaalstructuur zonder inductieve bias zelf ontdekken. - -## Geldigheid en integriteit - -- Interventie en controle gebruiken exact dezelfde split, vijf seeds, architectuur en trainingsbegroting; alleen bindingsconsensus verschilt. -- ECP-0- en ECP-1-testparen zijn uitgesloten. De ECP-2-testmatching bleef tijdens ontwikkeling en modelselectie gesloten. -- Alle definitieve zenders en ontvangers draaiden in geïsoleerde processen; ontvangers kregen alleen de vier harde symbolen. -- Husselcontroles bleven onder de vastgelegde grens en consistente symboolhernoeming behield alle voorspellingen. -- Per arm zijn 81.920 episodes en 309 artefacten gecontroleerd; alle hashes kwamen byte voor byte overeen. -- De twintig zender-seedcombinaties lagen boven alle honderd permutatienullen voor topografische overeenkomst. - -## Besluit voor ECP-3 - -ECP-3 behoudt de vrij geleerde slotpermutatie, maar maakt de atoomcode binnen iedere factor injectief: verschillende factorwaarden moeten verschillende symbolen gebruiken. De symbolen zelf blijven betekenisvrij en vrij gekozen. Populatieconsensus wordt uitgebreid van slotbinding naar atoomcode. Een volledig nieuwe validatie- en testmatching sluit zowel eerdere testparen als de reeds gebruikte ECP-2-validatieparen uit. - -Het doel is niet een hogere topscore — ECP-2 heeft al een seed met 100% — maar stabiliteit over seeds. Pas bij minstens vier van vijf sterke seeds, bij voorkeur vijf, is dit een kandidaat voor het eerste bruikbare basismodel. - -## Lokale bewijsbestanden - -De niet-versiebeheerde bronruns staan lokaal onder `runs/ecp2-confirmatory/intervention/20260718T013310Z-ecp2-experiment/` en `runs/ecp2-confirmatory/control/20260718T013310Z-ecp2-experiment/`. Daar staan de gepaarde vergelijking, post-hocanalyses en alle per-seedartefacten. diff --git a/docs/resultaten-ecp3.md b/docs/resultaten-ecp3.md deleted file mode 100644 index b5c761d..0000000 --- a/docs/resultaten-ecp3.md +++ /dev/null @@ -1,98 +0,0 @@ -# Resultaten ECP-3 — eerste robuuste basismodel - -Confirmatieve interventie: `ecp3-confirmatory/intervention/20260718T020939Z-ecp3-experiment` -Gepaarde controle: `ecp3-confirmatory/control/20260718T020939Z-ecp3-experiment` -Split-SHA-256: `91d6439fada82b1384a8d03f7cc1f5602091f794477be31c179c5a26e1b0464b` -Formele primaire classificatie: **sterk bewijs** - -## Uitkomst - -ECP-3 voldoet aan de vooraf vastgelegde definitie van een bruikbaar basismodel. Vier van vijf onafhankelijke seeds halen alle drempels; in die vier seeds reconstrueren de populatie en de universele vertaler iedere volledig nieuwe testbetekenis foutloos. Gemiddeld over alle vijf seeds is de testexactheid 89,0% en de vertaalexactheid 95,0%. - -Het protocol gebruikt geen woorden, letters of vooraf benoemde symbolen. Een bericht bestaat uit vier gehele symbool-ID's tussen 0 en 15. De zenders leren zelf welke factor in welke positie komt en welk symbool een factorwaarde vertegenwoordigt. De enige opgelegde grammaticale voorwaarden zijn één factor per slot en een unieke code voor verschillende waarden binnen dezelfde factor. - -## Primaire resultaten - -| Seed | Bekend | Slechtste bekend paar | Compositionele validatie | Nieuwe testparen | Slechtste testpaar | Universele vertaler | Classificatie | -|---:|---:|---:|---:|---:|---:|---:|---| -| 11 | 100,0% | 100,0% | 100,0% | 100,0% | 100,0% | 100,0% | sterk | -| 23 | 100,0% | 100,0% | 100,0% | 100,0% | 100,0% | 100,0% | sterk | -| 37 | 100,0% | 100,0% | 99,6% | 100,0% | 100,0% | 100,0% | sterk | -| 53 | 100,0% | 100,0% | 51,8% | 45,0% | 38,3% | 75,0% | negatief | -| 71 | 100,0% | 100,0% | 100,0% | 100,0% | 100,0% | 100,0% | sterk | -| **Gemiddeld** | **100,0%** | **100,0%** | **90,3%** | **89,0%** | **87,7%** | **95,0%** | **sterk** | - -De mediaan is zowel voor testexactheid als vertaalexactheid 100%. De lage gemiddelde score wordt volledig door één uitbijter veroorzaakt, niet door kleine fouten over alle runs. - -## Gepaarde controle: wat doet consensus? - -De controle gebruikt dezelfde injectieve zenderarchitectuur maar zonder consensus op slotbinding en atoomcodes. - -| Metriek | Zonder consensus | Met consensus | Verschil | Interventie beter | Exacte eenzijdige `p` | -|---|---:|---:|---:|---:|---:| -| Nieuwe testparen | 79,0% | 89,0% | +10,0 procentpunt | 5/5 seeds | 0,03125 | -| Universele vertaler | 79,2% | 95,0% | +15,8 procentpunt | 3 beter, 1 gelijk, 1 lager | 0,125 | -| Sterke seeds | 3/5 | 4/5 | +1 seed | — | — | - -De interventie vergroot de exacte berichtovereenkomst tussen zenders gemiddeld van 27,2% naar 77,0%. Consensus is dus geen semantisch woordenboek, maar een mechanisme waardoor onafhankelijke agents vaker hetzelfde arbitraire dialect kiezen. - -## Hoe de nieuwe communicatievorm eruitziet - -Seed 11 koos voor alle vier zenders de slotvolgorde: - -`[vorm, textuur, grootte, kleur]` - -Zender 0 koos onder meer de vrije atoomcodes: - -- kleuren `c0..c7` → `[1,12,2,6,10,5,8,11]`; -- vormen `s0..s7` → `[10,13,11,2,12,3,9,14]`; -- groottes `z0..z3` → `[3,15,7,4]`; -- texturen `t0..t3` → `[0,2,7,15]`. - -Daarmee wordt de nooit getrainde combinatie `(c0,s0,z0,t0)` verzonden als: - -`⟦10 · 0 · 3 · 1⟧` - -De vier ontvangers en de afzonderlijk getrainde universele vertaler reconstrueren dit exact. De getallen hebben buiten dit ene geleerde protocol geen vaste menselijke betekenis; consistente hernoeming van alle zestien symbolen verandert geen enkele voorspelling. - -## Efficiëntie - -| Representatie voor deze synthetische taak | Bits per bericht | Relatief tot ECP-3 | -|---|---:|---:| -| Nederlands sjabloon in UTF-8 | 328 | 20,5× groter | -| Canonieke JSON in UTF-8 | 432 | 27× groter | -| **ECP-3** | **16** | **1×** | -| Handgemaakte compositionele referentie | 12 | 25% kleiner dan ECP-3 | -| Theoretisch gepakte ondergrens | 10 | 37,5% kleiner dan ECP-3 | - -ECP-3 gebruikt 16 kanaalbits voor 10 bits broninformatie: 62,5% van de capaciteit draagt theoretisch noodzakelijke informatie. Het is dus al veel compacter dan menselijke tekst voor exact deze afgebakende betekenisruimte, maar nog niet bit-optimaal. De vergelijking zegt niets over de algemene expressiviteit van Nederlands; dit is uitsluitend een taakgebonden representatievergelijking. - -Iedere zender gebruikt over alle 1024 betekenissen 1024 unieke berichten en heeft nul berichtbotsingen. Het protocol is daardoor ondubbelzinnig. De berichtentopologie is exact factorieel: een verandering van één factor verandert gemiddeld exact één symboolpositie en de topografische Spearman-overeenkomst is 1,0. - -## Wat seed 53 ons leert - -Seed 53 heeft eveneens injectieve zenders, een gedeelde harde slotbinding en 100% bekende communicatie. De algemene GRU-ontvangers leerden kleur en vorm echter deels als gezamenlijke contextregel. Op nieuwe combinaties blijft kleur 90,7% correct maar vorm slechts 48,2%, waardoor exactheid naar 45,0% zakt. - -Dit is geen botsing of ambiguïteit in het verzonden protocol; de universele vertaler haalt op dezelfde berichten 75,0%. Het is een decoderlocal optimum. Daarom is ECP-3 volgens de vooraf gekozen 4/5-regel robuust genoeg als basismodel, maar nog niet deterministisch foutloos over iedere initialisatie. Een volgende modelversie kan de ontvanger eveneens factor-geïsoleerd maken. - -## Geldigheid en integriteit - -- De configuraties en beslisregels zijn vóór testtoegang bevroren. -- Alle 48 eerder gebruikte ECP-0/1/2-paren zijn buiten de nieuwe validatie- en testmatchings gehouden. -- De testmatching is niet gebruikt voor training, vroegstoppen of modelselectie. -- Vier zenders en vier ontvangers zijn onafhankelijk geparametriseerd. -- Definitieve evaluatie draaide in afzonderlijke processen die uitsluitend de toegestane matrices ontvingen. -- Alle hussel- en symboolpermutatiecontroles zijn geslaagd. -- Iedere arm bevat 81.920 schema-gevalideerde episodes. -- Alle 309 artefacten per arm kwamen bij herberekening byte voor byte met hun hashes overeen. -- Alle twintig zender-seedcombinaties lagen boven alle honderd permutatienullen voor topografische overeenkomst. - -## Wetenschappelijke conclusie - -Binnen deze synthetische wereld is nu aangetoond dat onafhankelijke AI-agents een betekenisvrije, niet-alfabetische en taak-efficiënte conventie kunnen leren die nieuwe combinaties systematisch uit herbruikbare atomen samenstelt en door een onafhankelijke vertaler kan worden gelezen. - -Niet aangetoond is dat zo'n grammatica zonder architectuurbias spontaan ontstaat, dat zij beter is dan menselijke taal voor open communicatie, of dat zij al de theoretische bitondergrens bereikt. ECP-3 is daarom het **eerste werkende basismodel**, niet het eindpunt van het volledige onderzoeksprogramma. - -## Lokale bewijsbestanden - -De niet-versiebeheerde bronrun staat lokaal onder `runs/ecp3-confirmatory/intervention/20260718T020939Z-ecp3-experiment/`. Deze bevat rapport, samenvatting, post-hocanalyse, gepaarde vergelijking en alle per-seedartefacten. diff --git a/docs/resultaten-ecp4.md b/docs/resultaten-ecp4.md deleted file mode 100644 index c398967..0000000 --- a/docs/resultaten-ecp4.md +++ /dev/null @@ -1,44 +0,0 @@ -# Resultaten ECP-4 — perfecte 10-bitpopulatie, instabiele vertaler - -Confirmatieve interventie: `ecp4-confirmatory/intervention/20260718T061339Z-ecp4-experiment` -Gepaarde 16-bitcontrole: `ecp4-confirmatory/control/20260718T061339Z-ecp4-experiment` -Formele primaire classificatie: **gemengd bewijs** - -## Uitkomst - -ECP-4 bereikt de theoretische 10-bitondergrens zonder enig verlies in de primaire agentcommunicatie. Alle vijf seeds, alle zestien zender-ontvangerkoppelingen en alle 2.048 testepisodes per seed zijn exact correct. De 16-bitcontrole is eveneens 100%; het gepaarde compressieverschil is exact nul. - -De afzonderlijk getrainde universele vertaler haalt de drempel echter slechts in seed 11. In de overige vier seeds kiest de vertaler een verkeerde harde factor-slotpermutatie. Daardoor blijft de formele totaalclassificatie gemengd, ondanks een foutloos verzonden protocol. - -## Resultaten - -| Seed | Bekend | Nieuwe testparen | Slechtste testpaar | Universele vertaler | Classificatie | -|---:|---:|---:|---:|---:|---| -| 11 | 100% | 100% | 100% | 100,0% | sterk | -| 23 | 100% | 100% | 100% | 9,4% | gemengd | -| 37 | 100% | 100% | 100% | 9,4% | gemengd | -| 53 | 100% | 100% | 100% | 9,4% | gemengd | -| 71 | 100% | 100% | 100% | 12,5% | gemengd | -| **Gemiddeld** | **100%** | **100%** | **100%** | **28,1%** | **gemengd** | - -De 16-bitcontrole haalt eveneens gemiddeld 100% populatieexactheid en 65,9% vertaalexactheid. Ook daar falen twee vertalerseeds. Het probleem komt dus niet uit informatieverlies door compressie, maar uit het leren van één discrete keuze uit 24 mogelijke slotpermutaties. - -## Efficiëntie - -De vier lokale factoralfabetten gebruiken `3+3+2+2 = 10` bits. Dit is exact `log2(1024)` en kan voor een uniforme, ondubbelzinnige code niet verder worden verkleind. Iedere zender gebruikt 1024 unieke berichten voor 1024 betekenissen, zonder botsingen. ECP-4 heeft daarmee 100% theoretische kanaalefficiëntie. - -## Integriteit - -- Alle vijf populaties zijn zowel op train, validatie als test exact 100%. -- Alle twintig zenders hebben topografische overeenkomst 1,0. -- Iedere arm bevat 81.920 schema-gevalideerde episodes. -- Alle 309 artefacten per arm en hun hashes zijn integraal geldig. -- Hussel- en consistente symboolpermutatiecontroles zijn geslaagd. - -## Besluit voor ECP-5 - -De 10-bitcode en factor-geïsoleerde populatie blijven ongewijzigd. ECP-5 vervangt uitsluitend de foutgevoelige gradientselectie van het vertalersslot door een exacte kalibratie over de 24 mogelijke permutaties. De kalibratie gebruikt alleen de gelabelde trainingsberichten waarover iedere universele vertaler al mocht beschikken. - -## Lokale bewijsbestanden - -De niet-versiebeheerde post-hocanalyse en gepaarde vergelijking staan lokaal onder `runs/ecp4-confirmatory/intervention/20260718T061339Z-ecp4-experiment/`. diff --git a/docs/resultaten-ecp5.md b/docs/resultaten-ecp5.md deleted file mode 100644 index 93c0819..0000000 --- a/docs/resultaten-ecp5.md +++ /dev/null @@ -1,121 +0,0 @@ -# Resultaten ECP-5 — volledig efficiënt 10-bitmodel - -Confirmatieve interventie: `ecp5-confirmatory/intervention/20260718T062848Z-ecp5-experiment` -Gepaarde controle: `ecp5-confirmatory/control/20260718T062848Z-ecp5-experiment` -Split-SHA-256: `cc487fd9042c5190bee93278c4be5180363f46a46d0e8af2f9d7d75a4f173140` -Formele primaire classificatie: **sterk bewijs** - -## Einduitkomst - -ECP-5 is binnen de gedefinieerde synthetische wereld een volledig efficiënt en robuust communicatieprotocol: - -- 5/5 seeds sterk; -- 100% bekende communicatie; -- 100% op volledig nieuwe grootte-textuurcombinaties; -- 100% voor het slechtste zender-ontvangerpaar; -- 100% universele vertaling; -- exact 10 bits per bericht, gelijk aan de theoretische ondergrens; -- 1024 unieke berichten voor 1024 betekenissen, zonder botsingen. - -## Confirmatieve resultaten - -| Seed | Bekend | Nieuwe testcombinaties | Slechtste agentpaar | Universele vertaler | Classificatie | -|---:|---:|---:|---:|---:|---| -| 11 | 100% | 100% | 100% | 100% | sterk | -| 23 | 100% | 100% | 100% | 100% | sterk | -| 37 | 100% | 100% | 100% | 100% | sterk | -| 53 | 100% | 100% | 100% | 100% | sterk | -| 71 | 100% | 100% | 100% | 100% | sterk | -| **Gemiddeld** | **100%** | **100%** | **100%** | **100%** | **sterk** | - -Ook alle compositionele validatiescores zijn 100%. De vier zenders binnen iedere seed produceren voor dezelfde betekenis exact hetzelfde bericht. - -## Effect van bindingskalibratie - -De ongekalibreerde controle behoudt eveneens 100% primaire populatiecommunicatie, maar slechts twee van vijf universele vertalers vinden de juiste slotgrammatica. - -| Seed | Ongekalibreerde vertaler | Gekalibreerde vertaler | Verschil | -|---:|---:|---:|---:| -| 11 | 100,0% | 100,0% | 0,0 pp | -| 23 | 12,5% | 100,0% | +87,5 pp | -| 37 | 100,0% | 100,0% | 0,0 pp | -| 53 | 9,4% | 100,0% | +90,6 pp | -| 71 | 9,4% | 100,0% | +90,6 pp | -| **Gemiddeld** | **46,3%** | **100,0%** | **+53,8 pp** | - -De interventie is beter in alle drie seeds waarin verbetering mogelijk was en gelijk op 100% in de andere twee. De vooraf vastgelegde tekenomklaptoets geeft `p=0,125`, omdat slechts drie verschillen niet nul zijn en de exacte toets daardoor maar acht effectieve tekencombinaties heeft. De effectgrootte en foutmodus zijn inhoudelijk ondubbelzinnig: iedere verkeerde controlebinding wordt door kalibratie hersteld. - -In alle vijf interventieseeds scoort de gekozen slotpermutatie exact 10,0 bits wederzijdse informatie tegenover 8,0 bits voor de nummer twee. - -## Overdraagbaarheid - -| Gelabelde betekenissen | Exact op nieuwe testcombinaties | -|---:|---:| -| 32 | 97,5% gemiddeld; mediaan 100% | -| 128 | 100% | -| 256 | 100% | -| 512 | 100% | - -Een nieuwe lezer hoeft dus geen volledig codeboek van 1024 betekenissen te zien. Vanaf 128 voorbeelden wordt de factorgrammatica in alle seeds foutloos overgedragen. - -## Werkelijk 10 bits - -De bron bevat `log2(1024)=10` bits informatie. ECP-5 gebruikt lokale alfabetten van 8, 8, 4 en 4 symbolen, dus `3+3+2+2=10` bits. De post-runanalyse heeft alle 81.920 episodeberichten opnieuw tegen de per-slotfactorbinding gecontroleerd: - -- gecontroleerde berichten: 81.920; -- onjuiste bitlengtes: 0; -- symbolen buiten lokale alfabetten: 0; -- kanaalefficiëntie: 100% van de theoretisch noodzakelijke capaciteit. - -| Representatie voor deze taak | Bits | Groter dan ECP-5 | -|---|---:|---:| -| Canonieke JSON in UTF-8 | 432 | 43,2× | -| Nederlands sjabloon in UTF-8 | 328 | 32,8× | -| ECP-3 | 16 | 1,6× | -| Handgemaakte compositionele referentie | 12 | 1,2× | -| **ECP-5** | **10** | **1×; theoretisch minimaal** | - -Dit vergelijkt alleen de representatie van dezelfde afgebakende betekenisruimte, niet de algemene expressiviteit van menselijke taal. - -## Voorbeeld van de machineconventie - -Seed 11 koos de slotvolgorde `[grootte, textuur, kleur, vorm]`. De nooit getrainde combinatie `(c0,s0,z0,t1)` wordt verzonden als: - -`⟦0 · 3 · 5 · 4⟧` - -In de lokale alfabetten is de wire-representatie: - -`00 | 11 | 101 | 100` → `0011101100` - -De slotvolgorde en alle waarde-symboolpermutaties zijn door de agents gekozen. De bits hebben zonder het geleerde protocol geen vaste menselijke betekenis. - -## Wat hiermee wel en niet is aangetoond - -Wel aangetoond: - -- onafhankelijke agents kunnen een arbitraire niet-alfabetische conventie delen; -- de conventie combineert bekende atomen foutloos tot nieuwe betekenissen; -- een onafhankelijke lezer kan de grammatica betrouwbaar induceren; -- voor deze wereld bereikt het kanaal de informatietheoretische ondergrens. - -Niet aangetoond: - -- dat de factorindeling zonder architectuurbias spontaan ontstaat; -- dat dit protocol open menselijke taal kan vervangen; -- dat dezelfde methode zonder nieuwe afspraken dynamisch onbekende factoren toevoegt; -- dat efficiëntie op deze uniforme laboratoriumwereld direct naar natuurlijke multimodale data overdraagt. - -ECP-5 is daarmee het **volledig efficiënte eindmodel van deze onderzoekscasus**, niet een algemene universele AI-taal. - -## Integriteit - -- Alle 309 artefacten en hashes zijn geldig. -- Alle 81.920 episodes zijn aanwezig en schema-gevalideerd. -- Alle twintig zenders verslaan hun honderd topografische permutatienullen. -- Husselcontroles blijven onder 1%. -- Consistente symboolhernoeming behoudt alle voorspellingen. -- De definitieve ontvangers en vertalers draaiden in geïsoleerde processen. - -## Lokale bewijsbestanden - -De niet-versiebeheerde interventie- en controle-artefacten staan lokaal onder `runs/ecp5-confirmatory/`. Deze bevatten rapporten, samenvattingen, post-hocanalyses, de gepaarde vergelijking en alle per-seedartefacten. diff --git a/docs/resultaten-ecp6.md b/docs/resultaten-ecp6.md deleted file mode 100644 index 55c4554..0000000 --- a/docs/resultaten-ecp6.md +++ /dev/null @@ -1,116 +0,0 @@ -# Resultaten ECP-6 — schaalreplicatie op 14 bits - -Confirmatieve run: `runs/20260718T070018Z-ecp6-experiment` -Configuratie-SHA-256: `994ca086e1542e4608fec935ec5b72471b2e2cf73c2193f99ab6997044c40133` -Split-SHA-256: `da751db7853ddbb84f000464c2627d4880eb154aef2158fb958d9a3779117d33` -Formele primaire classificatie: **sterk bewijs** - -## Einduitkomst - -ECP-6 repliceert het volledig efficiënte ECP-5-protocol op een zestienmaal grotere betekenisruimte: - -- 5/5 seeds sterk; -- 100% communicatie op alle bekende betekenissen; -- 100% op de expliciet verzegelde nieuwe kleur-vormcombinaties; -- 100% voor het slechtste zender-ontvangerpaar; -- 100% universele vertaling; -- 16.384 unieke berichten voor 16.384 betekenissen, zonder botsingen; -- exact 14 bits per bericht, gelijk aan de theoretische ondergrens. - -## Primaire confirmatieve resultaten - -| Seed | Bekend | Nieuwe testcombinaties | Slechtste agentkoppeling | Universele vertaler | Classificatie | -|---:|---:|---:|---:|---:|---| -| 11 | 100% | 100% | 100% | 100% | sterk | -| 23 | 100% | 100% | 100% | 100% | sterk | -| 37 | 100% | 100% | 100% | 100% | sterk | -| 53 | 100% | 100% | 100% | 100% | sterk | -| 71 | 100% | 100% | 100% | 100% | sterk | -| **Gemiddeld** | **100%** | **100%** | **100%** | **100%** | **sterk** | - -Alle compositionele validatiescores zijn eveneens 100%. Binnen iedere seed produceren de vier onafhankelijk geïnitialiseerde zenders voor dezelfde betekenis exact hetzelfde bericht. - -## Efficiëntie en schaal - -De bronentropie is `log2(16.384)=14` bits. De factorlokale alfabetten vereisen `4+4+3+3=14` bits. Iedere zender realiseert: - -- berichtentropie: 14,0 bits; -- fractie van bronentropie: 1,0; -- botsingen: 0; -- gemiddelde berichtafstand bij een minimale factorwijziging: 1,0 slot; -- factor-positieconcentratie: 1,0; -- topografische Spearman-correlatie: 1,0. - -| Representatie voor dezelfde afgebakende taak | Gemiddelde bits | Groter dan ECP-6 | -|---|---:|---:| -| Canonieke JSON in UTF-8 | 438 | 31,3× | -| Nederlands sjabloon in UTF-8 | 334 | 23,9× | -| ECP-5-payload | 10 | kleinere wereld; niet rechtstreeks voldoende | -| Handmatige factorlokale referentie | 14 | 1× | -| **ECP-6** | **14** | **1×; theoretisch minimaal** | - -De tekstvergelijking betreft alleen representatiegrootte binnen hetzelfde vooraf gedeelde schema. Zij vergelijkt niet de open expressiviteit, robuustheid of sociale functie van menselijke taal. - -## Universele leesbaarheid - -De universele vertaler vindt in iedere seed de exacte slotgrammatica. De gekozen permutatie scoort steeds 14,0 bits empirische wederzijdse informatie; de beste alternatieve permutatie scoort 8,0 bits. De scheiding van 6 bits maakt de keuze niet marginaal. - -| Gelabelde betekenissen voor een nieuwe lezer | Exact op test, gemiddeld | Mediaan | -|---:|---:|---:| -| 32 | 76,25% | 75% | -| 128 | 100% | 100% | -| 512 | 100% | 100% | -| 2.048 | 100% | 100% | - -De benodigde overdrachtsset groeit dus veel langzamer dan het volledige codeboek van 16.384 betekenissen. De terugval bij 32 voorbeelden zit in nog niet waargenomen kleur- en vormatomen; grootte en textuur zijn dan al foutloos. - -## Voorbeeld buiten een alfabet - -Seed 11 gebruikt voor slots `[vorm, kleur, textuur, grootte]`. De verzegelde testbetekenis `(c0,s9,z0,t0)` wordt: - -`⟦15 · 1 · 3 · 1⟧` - -en op de draad: - -`1111 | 0001 | 011 | 001` → `11110001011001`. - -Dit is geen verkort Nederlands en geen nieuw alfabet. Het is een geleerde productcode: positie draagt factortype, lokaal symbool draagt factorwaarde en de codeboeken zijn betekenisloze permutaties buiten de gedeelde conventie. - -## Integriteit en controles - -- Alle 309 vastgelegde artefacthashes komen overeen. -- Alle 163.840 episodes zijn aanwezig en schema-gevalideerd. -- Alle 163.840 berichten gebruiken exact 14 bits. -- Symbolen buiten hun factorlokale alfabet: 0. -- Alle twintig zenders verslaan 100 topografische nultoewijzingen (`p=0,00990099`). -- Husselcontrole: gemiddeld `0,0092%` exact, ruim onder de grens van 1%. -- Consistente symboolhernoeming behoudt alle voorspellingen. -- Ontvangers en vertalers zijn met uitsluitend symboolmatrices in geïsoleerde processen geëvalueerd. - -## Wat is aangetoond - -Binnen deze synthetische, uniforme en vooraf gefactoriseerde wereld is aangetoond dat onafhankelijk geïnitialiseerde agents: - -1. een niet-talige en niet-alfabetische codeconventie kunnen delen; -2. die conventie foutloos naar volledig nieuwe factorcombinaties kunnen generaliseren; -3. haar naar een onafhankelijke nieuwe lezer kunnen overdragen; -4. haar zonder efficiëntieverlies van 1.024 naar 16.384 betekenissen kunnen opschalen; -5. precies de informatietheoretisch noodzakelijke payload kunnen gebruiken. - -## Wat niet is aangetoond - -- De factorindeling ontstaat niet spontaan; de architectuur legt vier factorslots als inductieve bias op. -- De proef behandelt geen natuurlijke beelden, geluid, onzekerheid of continue betekenis. -- De code onderhandelt niet zelfstandig over nieuwe factoren of protocolversies. -- De 14 bits omvatten geen transportheaders, foutcorrectie of kosten van het vooraf leren van de conventie. -- Het resultaat toont geen vervanging van algemene menselijke taal aan. - -De scherpste conclusie is daarom: **een volledig efficiënte, universeel induceerbare machineconventie kan op deze productwereld foutloos schalen**, niet dat een algemene autonome AI-taal al is gerealiseerd. - -## Bewijsbestanden - -- [`report.md`](../evidence/ecp6/report.md) -- [`manifest.json`](../evidence/ecp6/manifest.json) -- [`baselines.json`](../evidence/ecp6/baselines.json) - -De volledige lokale run bevat daarnaast checkpoints, geïsoleerde procesmatrices en 163.840 episodes. Deze grote gegenereerde artefacten worden niet in Git opgenomen; de bevroren configuratie en reproductieopdracht staan in [`evidence/ecp6/README.md`](../evidence/ecp6/README.md). diff --git a/docs/results-ecp0.md b/docs/results-ecp0.md new file mode 100644 index 0000000..ba05534 --- /dev/null +++ b/docs/results-ecp0.md @@ -0,0 +1,104 @@ +# Results ECP-0.2 + +Confirmatory run: `20260717T221924Z-ecp0-experiment`
+Configuration frozen: July 17, 2026 at 22:18:41 UTC
+Configuration SHA-256: `7415f5732fed4d5e7e72ca82e917e4110a9f9f8ba68566daba3aa26e652b90cc`
+Primary classification: **mixed evidence** + +## Summary + +ECP-0.2 shows that two trained agents can independently develop an almost injective communication protocol within a 16-bit channel. In four of five runs, the protocol reconstructs known meanings with at least 99% accuracy. It also transfers semantic structure to an independent translator. + +However, the protocol does not yet generalize reliably to color-shape pairs that were completely held out from training. Mean exact test performance is 15.9%, ranging from 0% to 43.8%. This provides evidence of partial structural generalization, but not of a stable new language form. + +## Primary results + +| Seed | Known exact | Validation exact | Held-out pairs | Translator on held-out pairs | Classification | +|---:|---:|---:|---:|---:|---| +| 11 | 99.5% | 73.4% | 7.8% | 12.5% | Mixed | +| 23 | 99.9% | 83.6% | 0.0% | 3.1% | Mixed | +| 37 | 99.1% | 79.7% | 20.3% | 12.5% | Mixed | +| 53 | 91.3% | 60.9% | 7.8% | 7.0% | negative | +| 71 | 99.2% | 95.3% | 43.8% | 38.3% | Mixed | +| **Average** | **97.8%** | **78.6%** | **15.9%** | **14.7%** | **mixed** | +| **Median** | **99.2%** | **79.7%** | **7.8%** | **12.5%** | — | + +By definition, the non-compositional lookup baseline scores 0% on unknown meanings. The hand-crafted compositional baseline scores 100% with 12 bits; the optimally packed factor code scores 100% with 10 bits. + +## Hypothesis + +### H1 — Reliability: supported + +Four of five runs exceed the previously established threshold of 99% known reconstruction. One seed remains clearly behind at 91.3%. The base result is therefore reproducible, but the training process still has an unfavorable local optimum. + +### H2 — Compositional generalization: partially supported + +Four of five runs perform above the 0% lookup baseline on fully held-out color-shape pairs. The median is only 7.8%, and one run reaches 0%. At 43.8%, seed 71 shows that substantially better generalization is possible within the same architecture, but not that it is reliable. + +### H3 — Independent translatability: partially supported + +The translator reconstructs training messages almost flawlessly and scores above the lookup baseline on held-out pairs in all five runs. However, mean test performance of 14.7% remains too low to call the protocol generally translatable. + +### H4 — Structural semantics: supported + +Topographic similarity between meaning distance and message distance ranges from 0.308 to 0.448 across seeds. A post-run analysis with 100 random meaning-message assignments per seed found null values no higher than 0.004. All five observed values exceeded every randomized value; the empirical one-sided `p`-value is `1/101 ≈ 0.0099` for each seed. + +This permutation test completes the pre-recorded diagnostic comparison, but is performed after the primary run and does not change the primary classification. + +### H5 and H6 — Not yet tested + +Transfer to new agents and compression via a bit penalty belong to step 2. + +## What kind of protocol came into being? + +The agents did not develop a simple dictionary with one fixed message position per factor: + +- between 955 and 1015 of the 1024 meanings received a unique message; +- message entropy was between 9.86 and 9.98 bits, close to the 10-bit source entropy; +- any message position was important in ablation; +- the mean concentration of factor changes in one position was approximately 0.31, only slightly above 0.25 for a uniform distribution; +- semantic structure is clearly visible in message distances. + +The best description is therefore: **a largely distributed, almost injective code with partial semantic geometry**. That is more than a random lookup code, but even less systematic than a compositional language. + +## Efficiency + +| Representation | Bits per meaning | Exactly on unknown combinations | +|---|---:|---:| +| Dutch fixed template, UTF-8 | 328 | 100% in case of correct production | +| Canonical JSON, UTF-8 | 432 | 100% | +| ECP-0.2 | 16 | average 15.9% | +| Manual compositional | 12 | 100% | +| Optimally packed factors | 10 | 100% | + +ECP-0.2 is very compact compared to uncompressed text and JSON. It is no more efficient than a designed domain code and the error rate on unknown combinations is still too high. So there is no basis for the claim that AI has developed a superior general form of communication. + +## Validity and integrity + +- All five seeds used the same frozen configuration. +- The compositional test set was not used for training or model selection. +- Sender and receiver were running in separate processes during evaluation. +- The receiver received only a matrix with four symbol IDs. +- All shuffled-message controls remained at 0% or 0.098% exact reconstruction. +- Consistent renaming of all symbol IDs retained exactly the same predictions in each run. +- Each seed contains 1024 schema-validated episodes. +- All 179 pre-hashed artifacts matched post-run analysis byte for byte. + +## Decision for step 2 + +Compressing directly from 16 to 12 bits is now methodologically premature. The bottleneck is not message size, but reliable compositionality and transfer. + +The recommended order for ECP-1 is: + +1. use a new data split seed and hidden pairs; the ECP-0 test set is now used; +2. train a population of senders and receivers with changing links to reduce co-adjustment of one pair; +3. periodically add a newly initialized receiver and measure the number of examples needed; +4. investigate iterative learning across generations and progressive reconstruction after each symbol; +5. first maintain the 16-bit channel to measure the effect on generalization purely; +6. then compare the same method at 16 and 12 bits before adding variable length and a bit penalty. + +Only when generalization and portability are stable can step 3 fairly focus on maximum efficiency. + +## Local Evidence Files + +The untracked source run is located locally `runs/20260717T221924Z-ecp0-experiment/`. It contains `report.md`, `summary.json`, `posthoc-analysis.json` and the per-seed metrics, episodes, models and isolated process input. diff --git a/docs/results-ecp1.md b/docs/results-ecp1.md new file mode 100644 index 0000000..465c5da --- /dev/null +++ b/docs/results-ecp1.md @@ -0,0 +1,112 @@ +# Results ECP-1 + +Confirmatory run: `20260718T001805Z-ecp1-experiment`
+Configuration frozen: July 18, 2026 at 00:17:09 UTC
+Configuration SHA-256: `13ebb1186aa87e98093f64a02a9961d35a2fdf6b06b6f56e47ab5a53c2a6e977`
+Formal primary classification: **mixed evidence**
+Substantive outcome for the population hypothesis: **not supported** + +## Summary + +ECP-1 tested four independently parameterized senders against four independently parameterized receivers. All sixteen links were trained together. This created a shared convention: a randomly selected receiver reconstructs known messages from each sender with 98.5% mean accuracy, and even the mean accuracy of the worst sender-receiver pair reaches 98.1%. + +However, population training does not solve the main problem of ECP-0. On fully held-out color-shape pairs, mean exact reconstruction decreases from 15.9% in ECP-0 to 10.1% in ECP-1. The universal translator achieves 15.2%. No seed approaches the preregistered thresholds of 60% population generalization or 50% translatability. + +The correct conclusion is therefore not that a new efficient AI language has already been created. However, there is strong evidence that several independent agents can agree a compact, shared and structural code. That code is not yet sufficiently compositional: known combinations are largely memorized and new combinations are not systematically composed of well-known components. + +## Primary results + +| Seed | Known mean | Worst known pair | Validation | New pairs | Worst test pair | Universal translator | New receiver, 768 examples | Classification | +|---:|---:|---:|---:|---:|---:|---:|---:|---| +| 11 | 99.2% | 98.8% | 77.6% | 17.0% | 7.8% | 24.4% | 18.8% | Mixed | +| 23 | 99.2% | 98.8% | 82.4% | 7.2% | 2.3% | 9.2% | 9.4% | negative | +| 37 | 97.5% | 97.1% | 73.6% | 6.5% | 3.9% | 13.1% | 12.5% | negative | +| 53 | 99.1% | 98.4% | 76.5% | 5.4% | 2.3% | 10.9% | 7.8% | negative | +| 71 | 97.6% | 97.4% | 81.7% | 14.5% | 10.9% | 18.6% | 18.8% | negative | +| **Average** | **98.5%** | **98.1%** | **78.4%** | **10.1%** | **5.5%** | **15.2%** | **13.4%** | **mixed** | + +The test factors color and shape are reconstructed for 39.4% and 46.5% on average. Size and texture remain virtually intact by 98.6% and 97.9% on average, so the error is directed at combining the two excluded factors again, not in an overall defect of the decoder. + +## Comparison with ECP-0 + +| Metric | ECP-0 | ECP-1 | Difference | +|---|---:|---:|---:| +| Known meanings | 97.8% | 98.5% | +0.7 percentage points | +| Validation | 78.6% | 78.4% | −0.2 percentage point | +| Fully new color-shape pairs | 15.9% | 10.1% | **−5.8 percentage points** | +| Independent/universal translator | 14.7% | 15.2% | +0.5 percentage point | + +This comparison is directional rather than a measurement on identical test items: ECP-1 deliberately used a new dataset split and eight new held-out pairs because the ECP-0 test set had already been opened. Of the five ECP-1 seeds, only seed 11, at 17.0%, performs close to the ECP-0 mean of 15.9%. + +The formal classification remains **mixed evidence**, because the pre-implemented aggregation rule assigns that label once at least one valid seed exceeds the ECP-0 reference; the rule was not changed after opening the test set. For the scientific interpretation, the mean effect is decisive: population training did not improve generalization in this experiment. A subsequent protocol should explicitly define an aggregation rule based on the mean and its uncertainty. + +## Hypothesis + +### A shared population protocol arises: supported + +All sixteen sender-receiver pairs learn the same task. Mean known accuracy is 98.5%, and the worst pair per seed still averages 98.1%. All five seeds pass the 95% threshold for the worst pair; three of five also pass the stricter 99% mean threshold. + +The four senders produce the same message for the same meaning on average in 54.3% of the cases, which is not a complete uniformity, but significant convergence between models without shared parameters. + +### H2 • Population training improves compositional generalization: unsupported + +The mean of 10.1% is below ECP-0 and well below the predefined 60% threshold. None of the five seeds crosses that threshold. Exchanging communication partners therefore prevents exclusive co-adaptation within one pair, but does not by itself produce a factorized language. + +### One universal translator unlocks all channels: partially structural, performance threshold not met + +The translator is only trained after freezing the four channels and averages 15.2% on new pairs. This shows that one model can read the partially shared convention, but no seed reaches the required 50%. + +### A new receiver learns the protocol quickly: unsupported + +| Labeled meanings | Average exact on new pairs | +|---:|---:| +| 32 | 1.3% | +| 128 | 7.9% | +| 512 | 11.7% | +| 768 | 13.4% | + +The learning curve increases with more examples, but there is no few-shot transfer. Even after all 768 training concepts, the new receiver remains far below a reliable level. + +### The messages contain semantic structure: supported as diagnostics + +Topographic similarity between meaning distance and message distance ranges from 0.308 to 0.432 across the twenty sender-seed combinations. In the pre-announced post-run analysis, every observation exceeds all 100 random reassociations; the empirical one-sided `p`-value is `1/101 ≈ 0.0099` for each observation. + +This proves structure, not enough compositionality. A code can give semantic near meanings similar messages and yet fail with a completely new combination of two factors. + +## What kind of protocol came into being? + +Each sender uses 960 to 1,007 unique messages for 1,024 meanings. Message entropy ranges from 9.864 to 9.967 bits, close to the 10-bit source entropy. Together with the high known accuracy, this again indicates an almost injective, distributed code. + +ECP-1 adds an important result: several independent senders and receivers can stabilize such a code together. However, the shared convention remains more like a compact geometric codebook than a grammar that consistently combines color, shape, size, and texture as reusable parts. + +## Validity and integrity + +- The ECP-1 configuration is frozen before the confirmatory run. +- The eight ECP-0 test pairs are explicitly excluded when creating the new split. +- The compositional ECP-1 test set is not used for training or model selection. +- Four channels and four receivers have completely independent parameters. +- Final decoding took place in individual processes that received only symbol matrices. +- All shuffled-message controls remained at or below 1.0%, with approximately 0.09% mean exact reconstruction. +- Consistent renaming of the sixteen symbols retained all predictions in all seeds. +- Each seed contains 16,384 schema-validated episodes; together these are 81,920 episodes. +- All 309 pre-hashed artifacts matched the post-run analysis byte for byte. + +## Decision for ECP-2 + +Adding more agents is not the logical next step. ECP-1 shows that partner swap creates compatibility, but doesn't automatically create compositionality. ECp-2 should therefore introduce a learning pressure that makes memorization more difficult without programming semantics in symbols in advance. + +The recommended confirmatory comparison is: + +1. maintain the independent population and 16-bit channel; +2. train iteratively across generations, where new receivers receive only messages and a limited number of examples from the previous generation; +3. systematically make the training world incomplete with varying combinations per generation; +4. select only for validation generalization and the speed at which a new receiver learns; +5. compare this method against an exact equal ECP-1 check without generation replacement; +6. re-use a completely new sealed test set; +7. define the primary group comparison and uncertainty margin in advance. + +Compression to 12 or 10 bits remains delayed. First, a robust reusable protocol needs to be created; only after that maximum efficiency is a meaningful key question. + +## Local Evidence Files + +The untracked source run is located locally `runs/20260718T001805Z-ecp1-experiment/`. It contains `report.md`, `summary.json`, `posthoc-analysis.json` and the per-seed metrics, 81,920 episodes, checkpoints and isolated process input. diff --git a/docs/results-ecp2.md b/docs/results-ecp2.md new file mode 100644 index 0000000..4437184 --- /dev/null +++ b/docs/results-ecp2.md @@ -0,0 +1,60 @@ +# Results ECP-2 + +Confirmatory intervention: `ecp2-confirmatory/intervention/20260718T013310Z-ecp2-experiment`
+Paired control: `ecp2-confirmatory/control/20260718T013310Z-ecp2-experiment`
+Split-SHA-256: `7a227e22d86f00d8ab5078690de37de794774cdab636e7db374c5adbd0985126`
+Formal primary classification: **mixed evidence** + +## Conclusion + +ECP-2 delivers the first clearly compositional protocol in this series, but not yet a robust final model. The intervention gives each factor a separate slot, allows the senders to choose a one-to-one factor-slot permutation, and applies consensus only to that free choice. All intervention channels converge on the same slot binding within each seed. + +Mean exact reconstruction of entirely new color-shape combinations increases from 58.2% to 66.1% relative to the paired control. Four of five seeds improve, but the exact one-sided paired sign-flip test is not significant with five pairs (`p = 0.15625`). Universal-translator accuracy rises from 66.2% to 77.6%, improves in all five seeds, and has `p = 0.03125`. + +Yet only two of five intervention seeds reach every preset threshold. The weak seeds still contain collisions among the freely learned symbols for factor values. Slot structure alone does not guarantee that each value receives a unique atomic code. + +## Primary results + +| Seed | Known | Worst known pair | Compositional validation | New test pairs | Worst test pair | Universal translator | Classification | +|---:|---:|---:|---:|---:|---:|---:|---| +| 11 | 100.0% | 100.0% | 97.0% | 86.4% | 76.6% | 98.2% | strong | +| 23 | 100.0% | 100.0% | 100.0% | 100.0% | 100.0% | 100.0% | strong | +| 37 | 89.6% | 89.6% | 55.5% | 35.4% | 21.9% | 75.0% | Mixed | +| 53 | 91.7% | 91.7% | 72.7% | 55.3% | 49.2% | 51.6% | Mixed | +| 71 | 100.0% | 100.0% | 40.1% | 53.2% | 34.4% | 63.3% | Mixed | +| **Average** | **96.3%** | **96.3%** | **73.0%** | **66.1%** | **56.4%** | **77.6%** | **mixed** | + +## Paired comparison + +| Metric | Without binding consensus | With binding consensus | Difference | Seeds better | Exact one-sided `p` | +|---|---:|---:|---:|---:|---:| +| New test pairs | 58.2% | 66.1% | +7.9 percentage points | 4/5 | 0.15625 | +| Universal translator | 66.2% | 77.6% | +11.4 percentage points | 5/5 | 0.03125 | +| Strong seeds | 1/5 | 2/5 | +1 seed | — | — | + +The final architecture itself is powerful: also the control without consensus achieves on average much more compositional generalization than ECP-1. The combined comparison only isolates the extra effect of binding consensus, not the effect of the structural slot bias. + +## Interpretation + +ECP-2 operates beyond words and alphabets: a message is a sequence of four discrete symbols, and both symbol usage and slot order are arbitrary. In successful seeds the code is perfectly injective, has topographic similarity 1.0, and composes new combinations exactly. + +However, this success is not entirely spontaneous linguistic emergence. The architecture prescribes that the four meaning factors must be expressed in four separate slots. It does not determine what those slots mean, but it does impose the grammatical form “one factor per position.” This experiment therefore shows that an efficient non-human convention can be learned within a compositional channel, not that neural agents discover that channel structure without an inductive bias. + +## Validity and integrity + +- Intervention and control use exactly the same split, five seeds, architecture and training budget; only binding consensus differs. +- ECP-0 and ECP-1 test pairs are excluded. The ECP-2 test split remained sealed during development and model selection. +- All final senders and receivers turned into isolated processes; receivers only received the four hard symbols. +- Shuffled-message controls remained below the defined threshold, and consistent symbol renaming preserved all predictions. +- 81,920 episodes and 309 artifacts were checked per arm; all hashes matched byte for byte. +- The twenty channel seed combinations were above all hundred permutations for topographic similarity. + +## Decision for ECP-3 + +ECP-3 retains the freely learned final permutation but makes the atomic code within each factor injective: different factor values must use different symbols. The symbols themselves remain meaningless and freely chosen. Population consensus is extended from slot binding to atomic code. A completely new validation and test split excludes both previous test pairs and the ECP-2 validation pairs already used. + +The goal is not a higher peak score—ECP-2 already has a seed with 100% accuracy—but stability across seeds. Only if at least four of five seeds are classified as strong, preferably all five, does this become a candidate for the first usable base model. + +## Local Evidence Files + +The untracked source runs are stored locally under `runs/ecp2-confirmatory/intervention/20260718T013310Z-ecp2-experiment/` and `runs/ecp2-confirmatory/control/20260718T013310Z-ecp2-experiment/`. They contain the paired comparisons, post-hoc analyses, and all per-seed artifacts. diff --git a/docs/results-ecp3.md b/docs/results-ecp3.md new file mode 100644 index 0000000..657a5e0 --- /dev/null +++ b/docs/results-ecp3.md @@ -0,0 +1,98 @@ +# Results ECP-3 — First Robust Base Model + +Confirmatory intervention: `ecp3-confirmatory/intervention/20260718T020939Z-ecp3-experiment`
+Paired control: `ecp3-confirmatory/control/20260718T020939Z-ecp3-experiment`
+Split-SHA-256: `91d6439fada82b1384a8d03f7cc1f5602091f794477be31c179c5a26e1b0464b`
+Formal primary classification: **strong evidence** + +## Outcome + +ECP-3 meets the predefined definition of a usable base model. Four of five independent seeds reach every threshold; in those four seeds, the population and the universal translator reconstruct every entirely new test meaning without error. Across all five seeds, mean test exact-match accuracy is 89.0% and mean translation accuracy is 95.0%. + +The protocol does not use words, letters or predefined symbols. A message consists of four whole symbol IDs between 0 and 15. The senders themselves learn which factor is in which position and which symbol represents a factor value. The only prescribed grammatical conditions are one factor at a time and a unique code for different values within the same factor. + +## Primary results + +| Seed | Known | Worst known pair | Compositional validation | New test pairs | Worst test pair | Universal translator | Classification | +|---:|---:|---:|---:|---:|---:|---:|---| +| 11 | 100.0% | 100.0% | 100.0% | 100.0% | 100.0% | 100.0% | strong | +| 23 | 100.0% | 100.0% | 100.0% | 100.0% | 100.0% | 100.0% | strong | +| 37 | 100.0% | 100.0% | 99.6% | 100.0% | 100.0% | 100.0% | strong | +| 53 | 100.0% | 100.0% | 51.8% | 45.0% | 38.3% | 75.0% | negative | +| 71 | 100.0% | 100.0% | 100.0% | 100.0% | 100.0% | 100.0% | strong | +| **Average** | **100.0%** | **100.0%** | **90.3%** | **89.0%** | **87.7%** | **95.0%** | **strong** | + +The median is 100% for both test exact-match and translation exact-match accuracy. The lower mean score is entirely caused by one outlier, not by small errors across all runs. + +## Paired control: what does consensus do? + +The control uses the same injective sender architecture but without consensus on slot bindings or atomic codes. + +| Metric | Without consensus | With consensus | Difference | Intervention better | Exact one-sided `p` | +|---|---:|---:|---:|---:|---:| +| New test pairs | 79.0% | 89.0% | +10.0 percentage points | 5/5 seeds | 0.03125 | +| Universal translator | 79.2% | 95.0% | +15.8 percentage points | 3 better, 1 equal, 1 lower | 0.125 | +| Strong seeds | 3/5 | 4/5 | +1 seed | — | — | + +The intervention increases the exact message agreement between channels from 27.2% on average to 77.0%. Consensus is not a semantic dictionary, but a mechanism through which independent agents often choose the same arbitrary dialect. + +## What the new form of communication looks like + +Seed 11 chose the slot order for all four channels: + +`[shape, texture, size, color]` + +Sender 0 chose, among other things, the free atomic codes: + +- colors `c0..c7` → `[1,12,2,6,10,5,8,11]`; +- shapes `s0..s7` → `[10,13,11,2,12,3,9,14]`; +- sizes `z0..z3` → `[3,15,7,4]`; +- textures `t0..t3` → `[0,2,7,15]`. + +This makes the never-trained combination `(c0,s0,z0,t0)` sent as: + +`⟦10 · 0 · 3 · 1⟧` + +The four receivers and the individually trained universal translator exactly reconstruct this. The numbers have no fixed human meaning outside of this one learned protocol; consistent renaming of all sixteen symbols does not change any prediction. + +## Efficiency + +| Representation for this synthetic task | Bits per message | Relative to ECP-3 | +|---|---:|---:| +| Dutch template in UTF-8 | 328 | 20.5× larger | +| Canonical JSON in UTF-8 | 432 | 27× larger | +| **ECP-3** | **16** | **1×** | +| Hand-crafted compositional reference | 12 | 25% less than ECP-3 | +| Theoretical lower bound | 10 | 37.5% less than ECP-3 | + +ECP-3 uses 16 channel bits for 10 bits of source entropy: 62.5% of the capacity carries theoretically necessary information. It is therefore much more compact than human text for this precisely defined meaning space, but is not yet bit-optimal. The comparison says nothing about the general expressivity of Dutch; it is only a task-specific representation comparison. + +Each sender uses 1,024 unique messages across all 1,024 meanings and has zero message collisions. The protocol is therefore unambiguous. Message topology is exactly factorized: changing one factor changes exactly one symbol position on average, and topographic Spearman correlation is 1.0. + +## What seed 53 teaches us + +Seed 53 also has injective channels, a shared hard slot binding, and 100% known communication. However, the generic GRU receivers learned color and shape partly as a joint contextual rule. On new combinations, color remains 90.7% correct but shape only 48.2%, causing exact accuracy to fall to 45.0%. + +This is not a collision or ambiguity in the transmitted protocol; the universal translator reaches 75.0% on the same messages. It is a decoder-local optimum. Under the preselected 4/5 rule, ECP-3 is therefore robust enough as a base model, but is not guaranteed to be error-free for every initialization. A subsequent model version can also make the receiver factor-isolated. + +## Validity and integrity + +- The configurations and decision rules are frozen before test access. +- All 48 pairs previously used in ECP-0, ECP-1, or ECP-2 were excluded from the new validation and test splits. +- The test split is not used for training, early stopping, or model selection. +- Four senders and four receivers are independently parametrized. +- Final evaluation was conducted in separate processes that received only the permitted matrices. +- All hub and symbol permutation controls have been successful. +- Each arm contains 81,920 schema-validated episodes. +- All 309 artifacts per arm matched their hashes at recalculation byte for byte. +- All twenty sender seed combinations were above all hundred permutations for topographic similarity. + +## Scientific conclusion + +Within this synthetic world, it has now been demonstrated that independent AI agents can learn a meaningful, non-alphabetic and task-efficient convention that systematically composes new combinations from reusable atoms and can be read by an independent translator. + +It has not been shown that such grammar emerges spontaneously without architectural bias, that it is better than human language for open communication, or that it reaches the theoretical bit lower bound. ECP-3 is therefore the **first working base model**, not the endpoint of the research program. + +## Local Evidence Files + +The untracked source run is stored locally at `runs/ecp3-confirmatory/intervention/20260718T020939Z-ecp3-experiment/`. It contains the report, summary, post-hoc analysis, paired comparison, and all per-seed artifacts. diff --git a/docs/results-ecp4.md b/docs/results-ecp4.md new file mode 100644 index 0000000..86626ef --- /dev/null +++ b/docs/results-ecp4.md @@ -0,0 +1,44 @@ +# Results ECP-4 — Perfect 10-Bit Population, Unstable Translator + +Confirmatory intervention: `ecp4-confirmatory/intervention/20260718T061339Z-ecp4-experiment`
+Paired 16-bit control: `ecp4-confirmatory/control/20260718T061339Z-ecp4-experiment`
+Formal primary classification: **mixed evidence** + +## Outcome + +ECP-4 reaches the theoretical 10-bit lower bound without any loss in primary agent communication. All five seeds, all sixteen sender-receiver pairs, and all 2,048 test episodes per seed are exactly correct. The 16-bit control also reaches 100%; the paired compression difference is exactly zero. + +However, the independently trained universal translator reaches the threshold only in seed 11. In the remaining four seeds, it chooses the wrong hard factor-slot permutation. The formal overall classification therefore remains mixed despite flawless primary communication. + +## Primary results + +| Seed | Known | New test pairs | Worst test pair | Universal translator | Classification | +|---:|---:|---:|---:|---:|---| +| 11 | 100% | 100% | 100% | 100.0% | strong | +| 23 | 100% | 100% | 100% | 9.4% | Mixed | +| 37 | 100% | 100% | 100% | 9.4% | Mixed | +| 53 | 100% | 100% | 100% | 9.4% | Mixed | +| 71 | 100% | 100% | 100% | 12.5% | Mixed | +| **Average** | **100%** | **100%** | **100%** | **28.1%** | **mixed** | + +The 16-bit control also achieves 100% mean population exact-match accuracy and 65.9% translation exact-match accuracy. Two translator seeds fail there as well. The problem therefore does not arise from information lost through compression, but from learning one discrete choice among 24 possible final permutations. + +## Efficiency + +The four local factor alphabets use `3+3+2+2 = 10` bits. This exactly equals `log2(1024)` and cannot be reduced further for a uniform, unambiguous code. Each sender uses 1,024 unique messages for 1,024 meanings without collisions. ECP-4 therefore has 100% theoretical channel efficiency. + +## Integrity + +- All five populations reach exactly 100% on training, validation, and test data. +- All 20 senders have topographic similarity 1.0. +- Each arm contains 81,920 schema-validated episodes. +- All 309 artifacts per arm and their hashes are fully valid. +- Shuffled-message and consistent symbol-permutation controls passed. + +## Decision for ECP-5 + +The 10-bit code and factor-isolated population remain unchanged. ECP-5 replaces only the error-sensitive gradient-based selection of the translator binding with exact calibration across the 24 possible permutations. Calibration uses only the labeled training messages already available to each universal translator. + +## Local Evidence Files + +The untracked post-hoc analysis and associated comparison are locally below `runs/ecp4-confirmatory/intervention/20260718T061339Z-ecp4-experiment/`. diff --git a/docs/results-ecp5.md b/docs/results-ecp5.md new file mode 100644 index 0000000..40728d0 --- /dev/null +++ b/docs/results-ecp5.md @@ -0,0 +1,121 @@ +# Results ECP-5 — Fully Efficient 10-Bit Model + +Confirmatory intervention: `ecp5-confirmatory/intervention/20260718T062848Z-ecp5-experiment`
+Paired control: `ecp5-confirmatory/control/20260718T062848Z-ecp5-experiment`
+Split-SHA-256: `cc487fd9042c5190bee93278c4be5180363f46a46d0e8af2f9d7d75a4f173140`
+Formal primary classification: **strong evidence** + +## End result + +ECP-5 is a fully efficient and robust communication protocol within the defined synthetic world: + +- 5/5 seeds strong; +- 100% known communication; +- 100% on completely new size-texture combinations; +- 100% for the worst sender-receiver pair; +- 100% universal translation; +- exactly 10 bits per message, equal to the theoretical lower limit; +- 1,024 unique messages for 1,024 meanings, without collisions. + +## Confirmatory results + +| Seed | Known | New test combinations | Worst agent pair | Universal translator | Classification | +|---:|---:|---:|---:|---:|---| +| 11 | 100% | 100% | 100% | 100% | strong | +| 23 | 100% | 100% | 100% | 100% | strong | +| 37 | 100% | 100% | 100% | 100% | strong | +| 53 | 100% | 100% | 100% | 100% | strong | +| 71 | 100% | 100% | 100% | 100% | strong | +| **Average** | **100%** | **100%** | **100%** | **100%** | **strong** | + +All compositional validation scores are 100%. The four channels within each seed produce exactly the same message for the same meaning. + +## Effect of binding calibration + +Uncalibrated control also retains 100% primary population communication, but only two of five universal translators find the right slot grammar. + +| Seed | Uncalibrated translator | Calibrated translator | Difference | +|---:|---:|---:|---:| +| 11 | 100.0% | 100.0% | 0.0 pp | +| 23 | 12.5% | 100.0% | +87.5 pp | +| 37 | 100.0% | 100.0% | 0.0 pp | +| 53 | 9.4% | 100.0% | +90.6 pp | +| 71 | 9.4% | 100.0% | +90.6 pp | +| **Average** | **46.3%** | **100.0%** | **+53.8 pp** | + +The intervention is better in all three seeds where improvement was possible and remains at 100% in the other two. The exact paired sign-flip test gives `p=0.125`, because only three differences are nonzero and therefore only eight effective sign combinations exist. The effect size and failure mode are unambiguous: calibration corrects every wrong control binding. + +In all five interventions the chosen final permutation scores exactly 10.0 bits of mutual information compared to 8.0 bits for the number two. + +## Transferability + +| Labeled meanings | Exact match on new test combinations | +|---:|---:| +| 32 | 97.5% average; median 100% | +| 128 | 100% | +| 256 | 100% | +| 512 | 100% | + +A new reader does not need to see a complete codebook of 1024 meanings. From 128 examples the factor grammar is transferred error-free in all seeds. + +## Actually 10 bits + +The source entropy is `log2(1024)=10` bits. ECP-5 uses local alphabets of 8, 8, 4, and 4 symbols, so `3+3+2+2=10` bits. The post-run analysis rechecked all 81,920 episode messages against the per-slot factor binding: + +- controlled messages: 81,920; +- incorrect bit lengths: 0; +- symbols outside local alphabets: 0; +- channel efficiency: 100% of the theoretically necessary capacity. + +| Representation for this task | Bits | Larger than ECP-5 | +|---|---:|---:| +| Canonical JSON in UTF-8 | 432 | 43.2× | +| Dutch template in UTF-8 | 328 | 32.8× | +| ECP-3 | 16 | 1.6× | +| Hand-crafted compositional reference | 12 | 1.2× | +| **ECP-5** | **10** | **1×; theoretically minimal** | + +This only compares the representation of the same defined meaning space, not the general expressivity of human language. + +## Example of the machine convention + +Seed 11 chose the slot order `[size, texture, color, shape]`. The never-trained combination `(c0,s0,z0,t1)` is sent as: + +`⟦0 · 3 · 5 · 4⟧` + +In the local alphabets, the wire representation is: + +`00 | 11 | 101 | 100` → `0011101100` + +The slot order and all value symbol permutations have been selected by the agents. The bits have no fixed human meaning without the learned protocol. + +## What has and has not been demonstrated with this + +Demonstrated: + +- independent agents can share an arbitrary non-alphabetic convention; +- the convention combines known atoms flawlessly into new meanings; +- an independent reader can reliably induce grammar; +- for this world, the channel reaches the information-theoretic lower bound. + +Not shown: + +- that the factor classification without architectural bias occurs spontaneously; +- that this protocol can replace open human language; +- that the same method adds dynamically unknown factors without new agreements; +- that efficiency in this uniform laboratory world transfers directly to natural multimodal data. + +ECP-5 is therefore the **fully efficient final model of this research case**, not a general universal AI language. + +## Integrity + +- All 309 artifacts and hashes are valid. +- All 81,920 episodes are present and schema-validated. +- All 20 senders beat their hundred topographic permutations. +- Shuffled-message controls remain below 1%. +- Consistent symbol renaming preserves all predictions. +- The final receivers and translators turned into isolated processes. + +## Local Evidence Files + +The untracked intervention and control artifacts are stored locally under `runs/ecp5-confirmatory/`. They include reports, summaries, post-hoc analyses, the paired comparison, and all per-seed artifacts. diff --git a/docs/results-ecp6.md b/docs/results-ecp6.md new file mode 100644 index 0000000..f677064 --- /dev/null +++ b/docs/results-ecp6.md @@ -0,0 +1,116 @@ +# Results ECP-6 — Scale Replication at 14 Bits + +Confirmatory run: `runs/20260718T070018Z-ecp6-experiment`
+Configuration SHA-256: `994ca086e1542e4608fec935ec5b72471b2e2cf73c2193f99ab6997044c40133`
+Split-SHA-256: `da751db7853ddbb84f000464c2627d4880eb154aef2158fb958d9a3779117d33`
+Formal primary classification: **strong evidence** + +## End result + +ECP-6 replicates the fully efficient ECP-5 protocol on a sixteen times larger meaning space: + +- 5/5 seeds strong; +- 100% communication on all known meanings; +- 100% on the explicitly sealed new color-shape combinations; +- 100% for the worst sender-receiver pair; +- 100% universal translation; +- 16,384 unique messages for 16,384 meanings, without collisions; +- exactly 14 bits per message, equal to the theoretical lower limit. + +## Primary confirmatory results + +| Seed | Known | New test combinations | Worst agent pair | Universal translator | Classification | +|---:|---:|---:|---:|---:|---| +| 11 | 100% | 100% | 100% | 100% | strong | +| 23 | 100% | 100% | 100% | 100% | strong | +| 37 | 100% | 100% | 100% | 100% | strong | +| 53 | 100% | 100% | 100% | 100% | strong | +| 71 | 100% | 100% | 100% | 100% | strong | +| **Average** | **100%** | **100%** | **100%** | **100%** | **strong** | + +All compositional validation scores are also 100%. Within each seed, the four independently initialized senders produce exactly the same message for the same meaning. + +## Efficiency and scale + +Source entropy is `log2(16,384)=14` bits. The factor-local alphabets require `4+4+3+3=14` bits. Each sender achieves: + +- message entropy: 14.0 bits; +- fraction of source entropy: 1.0; +- collisions: 0; +- mean message distance for a one-factor change: 1.0 slot; +- factor-position concentration: 1.0; +- topographic Spearman correlation: 1.0. + +| Representation for the same defined task | Mean bits | Larger than ECP-6 | +|---|---:|---:| +| Canonical JSON in UTF-8 | 438 | 31.3× | +| Dutch template in UTF-8 | 334 | 23.9× | +| ECP-5-payload | 10 | smaller world; not directly sufficient | +| Hand-crafted factor-local reference | 14 | 1× | +| **ECP-6** | **14** | **1×; theoretically minimal** | + +The text comparison covers only representation size within the same pre-shared schema. It does not compare the open-ended expressivity, robustness, or social function of human language. + +## Universal readability + +The universal translator finds the exact slot grammar in every seed. The chosen permutation scores 14.0 bits of empirical mutual information; the best alternative permutation scores 8.0 bits. The 6-bit margin makes the choice unambiguous. + +| Labeled meanings for a new reader | Test exact match, mean | Median | +|---:|---:|---:| +| 32 | 76.25% | 75% | +| 128 | 100% | 100% | +| 512 | 100% | 100% | +| 2,048 | 100% | 100% | + +The required transfer set therefore grows much more slowly than the complete codebook of 16,384 meanings. The shortfall with 32 examples comes from unseen color and shape atoms; size and texture are already flawless. + +## Example outside an alphabet + +Seed 11 used the slot order `[shape, color, texture, size]`. The sealed test meaning `(c0,s9,z0,t0)` is sent as: + +`⟦15 · 1 · 3 · 1⟧` + +and on the wire: + +`1111 | 0001 | 011 | 001` → `11110001011001`. + +This is not a shortened Dutch alphabet; it is a learned product code. Position carries factor type, the local symbol carries factor value, and the codebooks are meaningless permutations outside the shared convention. + +## Integrity and controls + +- All 309 captured artifact hashes match. +- All 163,840 episodes are present and schema-validated. +- All 163,840 messages use exactly 14 bits. +- Symbols outside their factor-local alphabet: 0. +- All twenty senders exceed 100 topographic permutation nulls (`p=0.00990099`). +- Shuffled-message control: mean exact match is `0.0092%`, well below the 1% threshold. +- Consistent symbol renaming preserves all predictions. +- Receivers and translators have been evaluated with only symbol matrices in isolated processes. + +## What has been demonstrated + +Within this synthetic, uniform and pre-factorised world, it has been demonstrated that independently initialised agents: + +1. share a non-lingual and non-alphabetic code convention; +2. generalize that convention reliably to completely new factor combinations; +3. transfer it to an independent new reader; +4. scale it from 1,024 to 16,384 meanings without loss of efficiency; +5. use exactly the information-theoretically necessary payload. + +## What has not been demonstrated + +- The factor classification does not arise spontaneously; the architecture imposes four factor slots as inductive bias. +- The experiment does not cover natural images, sound, uncertainty, or continuous meaning. +- The code does not negotiate on its own about new factors or protocol versions. +- The 14 bits do not include transport headers, error correction or pre-learning costs of the convention. +- The result shows no replacement of general human language. + +The sharpest conclusion is therefore: **a fully efficient, universally inductable machine convention can scale error-free on this product world**, not that a general autonomous AI language has already been realized. + +## Evidence files + +- [`report.md`](../evidence/ecp6/report.md) +- [`manifest.json`](../evidence/ecp6/manifest.json) +- [`baselines.json`](../evidence/ecp6/baselines.json) + +The complete local run also includes checkpoints, isolated process matrices and 163,840 episodes. These large generated artifacts are not included in Git; the frozen configuration and reproduction command are in [`evidence/ecp6/README.md`](../evidence/ecp6/README.md). diff --git a/pyproject.toml b/pyproject.toml index d0738c3..c46ca9e 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta" [project] name = "ai-taal-ecp" version = "0.1.0" -description = "Reproduceerbare experimenten met emergente AI-communicatie" +description = "Reproducible experiments in emergent AI communication" readme = "README.md" license = "MIT" authors = [{name = "Fatih Ligtvoet"}] diff --git a/runs/README.md b/runs/README.md index 4e183f6..3945c3d 100644 --- a/runs/README.md +++ b/runs/README.md @@ -1,12 +1,12 @@ # Runs -De simulator schrijft hier onveranderlijke uitvoerbestanden van ECP-experimenten. Iedere run krijgt een eigen map met minimaal: +The simulator writes here immutable output files from ECP experiments. Each run gets its own directory containing at minimum: -- de effectieve configuratie en hash; -- datasetmanifest en hashes; -- model- en softwareversies; -- ruwe berichten en reconstructies; -- metrics en controles; -- een ingevuld experimentrapport. +- the effective configuration and hash; +- dataset manifest and hashes; +- model and software versions; +- raw messages and reconstructions; +- metrics and controls; +- a filled-in experiment report. -Runmappen kunnen honderden megabytes groot worden en staan daarom in `.gitignore`. Commit geen checkpoints, geïsoleerde matrices of episodebestanden. Publiceer een compacte, gecontroleerde resultatensnapshot onder `evidence/` en leg de reproductieopdracht vast. +Run directories can grow hundreds of megabytes in size and are therefore listed in `.gitignore`. Do not commit checkpoints, isolated matrices, or episode files. Publish a compact, controlled results snapshot under `evidence/` and record the reproduction instruction. diff --git a/schemas/episode.schema.json b/schemas/episode.schema.json index 0d2aea8..7e98ab9 100644 --- a/schemas/episode.schema.json +++ b/schemas/episode.schema.json @@ -2,7 +2,7 @@ "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://local.ai-taal/schemas/episode.schema.json", "title": "ECP evaluated episode", - "description": "Eén discrete evaluatie met bronbetekenis, bericht en reconstructie.", + "description": "One discrete evaluation with source meaning, message, and reconstruction.", "type": "object", "additionalProperties": false, "required": [ diff --git a/schemas/meaning.schema.json b/schemas/meaning.schema.json index 1465ea8..62dccd2 100644 --- a/schemas/meaning.schema.json +++ b/schemas/meaning.schema.json @@ -2,7 +2,7 @@ "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://local.ai-taal/schemas/meaning.schema.json", "title": "ECP meaning", - "description": "Canonieke betekenis zonder natuurlijke-taallabels.", + "description": "Canonical meaning without natural-language labels.", "type": "object", "additionalProperties": false, "required": ["meaning_id", "color", "shape", "size", "texture"], diff --git a/schemas/message.schema.json b/schemas/message.schema.json index ad2adba..1a28482 100644 --- a/schemas/message.schema.json +++ b/schemas/message.schema.json @@ -2,7 +2,7 @@ "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://local.ai-taal/schemas/message.schema.json", "title": "ECP message", - "description": "Volledig gelogd discreet bericht tussen twee agents.", + "description": "Fully logged discrete message between two agents.", "type": "object", "additionalProperties": false, "required": [ diff --git a/src/ai_taal/__init__.py b/src/ai_taal/__init__.py index 7ded542..942c4b9 100644 --- a/src/ai_taal/__init__.py +++ b/src/ai_taal/__init__.py @@ -1,4 +1,3 @@ -"""Experimenten voor emergente AI-communicatie.""" +"""Experiments in emergent AI communication.""" __version__ = "0.1.0" - diff --git a/src/ai_taal/analysis.py b/src/ai_taal/analysis.py index 379f975..43bdcc0 100644 --- a/src/ai_taal/analysis.py +++ b/src/ai_taal/analysis.py @@ -1,4 +1,4 @@ -"""Reproduceerbare post-runanalyse van een voltooid ECP-0-experiment.""" +"""Reproducible post-run analysis of a completed ECP experiment.""" from __future__ import annotations @@ -25,7 +25,7 @@ def analyze_run( metrics_paths = sorted(run_directory.glob("seed-*/metrics.json")) if not metrics_paths: - raise ValueError(f"Geen seedmetrics gevonden in {run_directory}.") + raise ValueError(f"No seed metrics found in {run_directory}.") first_metrics = _read_json(metrics_paths[0]) if "population" in first_metrics: return _analyze_population_run( @@ -126,7 +126,7 @@ def compare_population_runs( intervention_split = _read_json(intervention_directory / "split_manifest.json") control_split = _read_json(control_directory / "split_manifest.json") if intervention_split["sha256"] != control_split["sha256"]: - raise ValueError("Interventie en controle gebruiken niet dezelfde datasplit.") + raise ValueError("Intervention and control do not use the same data split.") intervention_metrics = { int(metrics["seed"]): metrics @@ -139,7 +139,7 @@ def compare_population_runs( for metrics in [_read_json(path)] } if intervention_metrics.keys() != control_metrics.keys(): - raise ValueError("Interventie en controle bevatten niet dezelfde seeds.") + raise ValueError("Intervention and control do not contain the same seeds.") rows = [] for seed in sorted(intervention_metrics): @@ -235,7 +235,7 @@ def compare_population_runs( def _paired_sign_flip_test(differences: list[float]) -> dict[str, Any]: if not differences: - raise ValueError("Minstens één gepaard verschil is vereist.") + raise ValueError("At least one paired difference is required.") observed = statistics.mean(differences) null_values = [ statistics.mean( diff --git a/src/ai_taal/baselines.py b/src/ai_taal/baselines.py index 7578751..739079a 100644 --- a/src/ai_taal/baselines.py +++ b/src/ai_taal/baselines.py @@ -1,4 +1,4 @@ -"""Expliciete menselijke, technische en niet-compositionele vergelijkingen.""" +"""Explicit human, technical, and non-compositional comparisons.""" from __future__ import annotations @@ -17,6 +17,7 @@ def compute_baselines(meanings: Iterable[Meaning]) -> dict[str, Any]: json_bits = [] for meaning in meanings: labels = meaning.to_schema_dict() + # This Dutch text is experimental baseline data, not repository UI copy. dutch = ( f"kleur {labels['color']}, vorm {labels['shape']}, " f"grootte {labels['size']}, textuur {labels['texture']}" @@ -59,20 +60,20 @@ def compute_baselines(meanings: Iterable[Meaning]) -> dict[str, Any]: "bits_per_message": source_bits, "known_exact_match": 1.0, "compositional_exact_match": 1.0, - "note": "Ontworpen technische referentie en bronondergrens.", + "note": "Designed technical reference and source lower bound.", }, "random_lookup_code": { "bits_per_message": source_bits, "known_exact_match": 1.0, "compositional_exact_match": 0.0, - "note": "Onbekende betekenissen hebben per definitie geen geleerd codeboekitem.", + "note": "Unknown meanings have no learned codebook entry by definition.", }, "factor_local_compositional_code": { "bits_per_message": local_factor_bits, "known_exact_match": 1.0, "compositional_exact_match": 1.0, "unique_message_count": int(len(np.unique(handcrafted_messages, axis=0))), - "note": "Handmatig factor-lokaal referentieprotocol.", + "note": "Hand-crafted factor-local reference protocol.", }, } if factor_sizes == (8, 8, 4, 4): @@ -84,7 +85,7 @@ def compute_baselines(meanings: Iterable[Meaning]) -> dict[str, Any]: "known_exact_match": 1.0, "compositional_exact_match": 1.0, "unique_message_count": int(len(np.unique(handcrafted_messages, axis=0))), - "note": "Positie 1=kleur, positie 2=vorm, positie 3=grootte-textuur.", + "note": "Position 1=color, position 2=shape, position 3=size-texture.", } return result @@ -95,5 +96,5 @@ def _size_summary(values: list[int]) -> dict[str, float | str]: "mean_bits_per_message": float(array.mean()), "minimum_bits_per_message": float(array.min()), "maximum_bits_per_message": float(array.max()), - "note": "Representatiegrootte; geen vergelijking van algemene expressiviteit.", + "note": "Representation size; not a comparison of general expressivity.", } diff --git a/src/ai_taal/cli.py b/src/ai_taal/cli.py index 67e3745..94ff978 100644 --- a/src/ai_taal/cli.py +++ b/src/ai_taal/cli.py @@ -1,4 +1,4 @@ -"""Commandoregelinterface voor ECP-0.""" +"""Command-line interface for ECP experiments.""" from __future__ import annotations @@ -19,30 +19,30 @@ def build_parser() -> argparse.ArgumentParser: parser.add_argument("--config", type=Path, default=Path("config/ecp0.yaml")) subparsers = parser.add_subparsers(dest="command", required=True) - subparsers.add_parser("validate", help="Valideer configuratie en JSON-schema's.") - subparsers.add_parser("split", help="Toon de deterministische datasplitsing.") + subparsers.add_parser("validate", help="Validate the configuration and JSON Schemas.") + subparsers.add_parser("split", help="Show the deterministic data split.") analyze = subparsers.add_parser( - "analyze", help="Controleer en analyseer een voltooide confirmatieve run." + "analyze", help="Verify and analyze a completed confirmatory run." ) analyze.add_argument("run_directory", type=Path) analyze.add_argument("--permutations", type=int, default=100) compare = subparsers.add_parser( - "compare", help="Vergelijk gepaarde confirmatieve populatiearmen." + "compare", help="Compare paired confirmatory population arms." ) compare.add_argument("intervention_directory", type=Path) compare.add_argument("control_directory", type=Path) smoke = subparsers.add_parser( - "smoke", help="Draai 25 stappen zonder de compositionele testset te openen." + "smoke", help="Run 25 steps without opening the compositional test set." ) smoke.add_argument("--output-root", type=Path, default=Path("runs")) smoke.add_argument("--seed", type=int) development = subparsers.add_parser( "develop", - help="Train volledig op train/validatie en houd de compositionele testset gesloten.", + help="Train fully on train/validation while keeping the compositional test set sealed.", ) development.add_argument("--output-root", type=Path, default=Path("runs")) development.add_argument("--seed", action="append", type=int) @@ -50,24 +50,24 @@ def build_parser() -> argparse.ArgumentParser: "--algebraic-weight", type=float, help=( - "Alleen voor ontwikkeling: overschrijf het gewicht van de " - "algebraïsche consistentiedruk; 0 schakelt haar uit." + "Development only: override the algebraic-consistency weight; " + "0 disables it." ), ) development.add_argument( "--replacement-interval", type=int, help=( - "Alleen voor ontwikkeling: vervang na dit aantal stappen één zender " - "en ontvanger; 0 schakelt culturele transmissie uit." + "Development only: replace one sender and receiver after this many " + "steps; 0 disables cultural transmission." ), ) development.add_argument( "--maximum-replacements", type=int, help=( - "Alleen voor ontwikkeling: stop culturele vervanging na dit aantal " - "agents; 0 betekent doorgaan tot het einde." + "Development only: stop cultural replacement after this many " + "agents; 0 continues to the end." ), ) development.add_argument( @@ -78,31 +78,31 @@ def build_parser() -> argparse.ArgumentParser: "injective_permutation_slot_sender", "minimal_permutation_slot_sender", ), - help="Alleen voor ontwikkeling: overschrijf de zenderarchitectuur.", + help="Development only: override the sender architecture.", ) development.add_argument( "--slot-consensus-weight", type=float, help=( - "Alleen voor ontwikkeling: gebruik de permutationslotzender met " - "dit gewicht voor betekenisvrije bindingsconsensus." + "Development only: use the permutation-slot sender with this " + "weight for meaning-free binding consensus." ), ) experiment = subparsers.add_parser( - "experiment", help="Draai de vooraf vastgelegde confirmatieve runs." + "experiment", help="Run the preregistered confirmatory experiments." ) experiment.add_argument("--output-root", type=Path, default=Path("runs")) experiment.add_argument( "--unseal-test", action="store_true", - help="Bevestig expliciet dat de compositionele testset eenmalig mag worden gebruikt.", + help="Explicitly confirm one-time use of the compositional test set.", ) experiment.add_argument( "--seed", action="append", type=int, - help="Beperk tot één of meer seeds; zonder deze vlag worden alle vijf gebruikt.", + help="Limit execution to one or more seeds; without this flag all five are used.", ) return parser @@ -119,7 +119,7 @@ def main(argv: list[str] | None = None) -> int: validate_schemas(Path(config["artifacts"]["meaning_schema"]).parent) split = build_splits(config) print( - "Configuratie, schema's en splitsing geldig: " + "Configuration, schemas, and split are valid: " f"{len(split.train)}/{len(split.validation)}/{len(split.compositional_test)}" ) return 0 @@ -157,21 +157,21 @@ def main(argv: list[str] | None = None) -> int: and args.replacement_interval > 0 ): raise ValueError( - "Ontwikkel één interventie tegelijk: algebraïsch of generationeel." + "Develop one intervention at a time: algebraic or generational." ) if args.sender_family is not None and ( (args.algebraic_weight or 0) > 0 or (args.replacement_interval or 0) > 0 ): raise ValueError( - "Test een nieuwe zenderarchitectuur eerst zonder tweede interventie." + "Test a new sender architecture without a second intervention first." ) if args.slot_consensus_weight is not None and ( (args.algebraic_weight or 0) > 0 or (args.replacement_interval or 0) > 0 ): raise ValueError( - "Bindingsconsensus wordt zonder tweede interventie ontwikkeld." + "Develop binding consensus without a second intervention." ) if ( args.algebraic_weight is not None @@ -183,7 +183,7 @@ def main(argv: list[str] | None = None) -> int: config = copy.deepcopy(config) if args.algebraic_weight is not None: if args.algebraic_weight < 0: - raise ValueError("Algebraïsch gewicht mag niet negatief zijn.") + raise ValueError("Algebraic weight cannot be negative.") regularizer = config["training"]["algebraic_consistency"] regularizer["enabled"] = args.algebraic_weight > 0 regularizer["weight"] = args.algebraic_weight @@ -192,7 +192,7 @@ def main(argv: list[str] | None = None) -> int: } if args.replacement_interval is not None: if args.replacement_interval < 0: - raise ValueError("Vervangingsinterval mag niet negatief zijn.") + raise ValueError("Replacement interval cannot be negative.") config["training"]["algebraic_consistency"]["enabled"] = False transmission = config["training"]["cultural_transmission"] transmission["enabled"] = args.replacement_interval > 0 @@ -202,10 +202,10 @@ def main(argv: list[str] | None = None) -> int: } if args.maximum_replacements is not None: if args.maximum_replacements < 0: - raise ValueError("Maximum aantal vervangingen mag niet negatief zijn.") + raise ValueError("Maximum replacements cannot be negative.") if args.replacement_interval is None: raise ValueError( - "--maximum-replacements vereist --replacement-interval." + "--maximum-replacements requires --replacement-interval." ) transmission["maximum_replacements"] = args.maximum_replacements config["experiment"]["development_variant"][ @@ -220,7 +220,7 @@ def main(argv: list[str] | None = None) -> int: } if args.slot_consensus_weight is not None: if args.slot_consensus_weight < 0: - raise ValueError("Bindingsconsensusgewicht mag niet negatief zijn.") + raise ValueError("Binding-consensus weight cannot be negative.") config["agents"]["sender"]["family"] = ( "learned_permutation_slot_sender" ) @@ -256,7 +256,7 @@ def main(argv: list[str] | None = None) -> int: ) print(run_dir) return 0 - raise AssertionError(f"Onbekend commando: {args.command}") + raise AssertionError(f"Unknown command: {args.command}") if __name__ == "__main__": diff --git a/src/ai_taal/config.py b/src/ai_taal/config.py index c4e8aa7..e0d9a86 100644 --- a/src/ai_taal/config.py +++ b/src/ai_taal/config.py @@ -1,4 +1,4 @@ -"""Configuratie laden en de preregistratie-invarianten bewaken.""" +"""Load configurations and enforce preregistration invariants.""" from __future__ import annotations @@ -11,7 +11,7 @@ class ConfigError(ValueError): - """De experimentconfiguratie is intern tegenstrijdig.""" + """The experiment configuration is internally inconsistent.""" def load_config(path: str | Path) -> dict[str, Any]: @@ -22,12 +22,12 @@ def load_config(path: str | Path) -> dict[str, Any]: def _load_config(config_path: Path, *, seen: set[Path]) -> dict[str, Any]: if config_path in seen: - raise ConfigError(f"Cyclische configuratie-erfenis via {config_path}.") + raise ConfigError(f"Cyclic configuration inheritance through {config_path}.") seen.add(config_path) with config_path.open("r", encoding="utf-8") as handle: config = yaml.safe_load(handle) if not isinstance(config, dict): - raise ConfigError("De configuratie moet een YAML-object zijn.") + raise ConfigError("The configuration must be a YAML object.") parent = config.pop("extends", None) if parent is not None: parent_path = (config_path.parent / str(parent)).resolve() @@ -55,12 +55,12 @@ def validate_config(config: dict[str, Any]) -> None: split = config["dataset"] channel = config["channel"] except (KeyError, TypeError) as exc: - raise ConfigError(f"Verplicht configuratieveld ontbreekt: {exc}") from exc + raise ConfigError(f"Required configuration field is missing: {exc}") from exc calculated_meanings = math.prod(factor_sizes) if calculated_meanings != meaning_count: raise ConfigError( - f"Wereld bevat {calculated_meanings} combinaties, niet {meaning_count}." + f"World contains {calculated_meanings} combinations, not {meaning_count}." ) split_total = sum( @@ -72,37 +72,37 @@ def validate_config(config: dict[str, Any]) -> None: ) ) if split_total != meaning_count: - raise ConfigError(f"Datasplitsingen tellen op tot {split_total}, niet {meaning_count}.") + raise ConfigError(f"Data splits total {split_total}, not {meaning_count}.") if channel["type"] == "factor_local_discrete_fixed_length": alphabet_sizes = channel["factor_alphabet_sizes"] if alphabet_sizes != factor_sizes: - raise ConfigError("Lokale factoralfabetten passen niet bij de wereld.") + raise ConfigError("Factor-local alphabets do not match the world.") expected_message_bits = sum( math.ceil(math.log2(size)) for size in alphabet_sizes ) if channel["vocabulary_size"] != max(alphabet_sizes): - raise ConfigError("Globale tokenruimte past niet bij lokale alfabetten.") + raise ConfigError("Global token space does not match the local alphabets.") else: expected_bits_per_symbol = math.ceil(math.log2(channel["vocabulary_size"])) if expected_bits_per_symbol != channel["bits_per_symbol"]: - raise ConfigError("bits_per_symbol past niet bij vocabulary_size.") + raise ConfigError("bits_per_symbol does not match vocabulary_size.") expected_message_bits = channel["message_length"] * channel["bits_per_symbol"] if expected_message_bits != channel["bits_per_message"]: - raise ConfigError("bits_per_message past niet bij lengte en symboolkosten.") + raise ConfigError("bits_per_message does not match message length and symbol cost.") entropy = math.log2(meaning_count) if not math.isclose(entropy, config["world"]["source_entropy_bits"]): - raise ConfigError("source_entropy_bits past niet bij de uniforme wereld.") + raise ConfigError("source_entropy_bits does not match the uniform world.") seeds = config["reproducibility"]["training_seeds"] if len(seeds) != len(set(seeds)): - raise ConfigError("Iedere trainingsrun moet een unieke seed hebben.") + raise ConfigError("Every training run must use a unique seed.") if config["training"]["selection_never_uses_test"] is not True: - raise ConfigError("Testdata mag niet voor modelselectie worden gebruikt.") + raise ConfigError("Test data must not be used for model selection.") if config["training"]["evaluation_uses_hard_symbols_only"] is not True: - raise ConfigError("Evaluatie moet uitsluitend harde symbolen gebruiken.") + raise ConfigError("Evaluation must use hard symbols only.") def file_sha256(path: str | Path) -> str: diff --git a/src/ai_taal/experiment.py b/src/ai_taal/experiment.py index ed132d7..29e2800 100644 --- a/src/ai_taal/experiment.py +++ b/src/ai_taal/experiment.py @@ -1,4 +1,4 @@ -"""Orkestratie, isolatie, artefacten en classificatie van ECP-0-runs.""" +"""Orchestration, isolation, artifacts, and classification for ECP runs.""" from __future__ import annotations @@ -56,11 +56,11 @@ def run_experiment( seeds: list[int] | None = None, ) -> Path: if smoke and development: - raise ValueError("Een run kan niet tegelijk smoke en development zijn.") + raise ValueError("A run cannot be both smoke and development.") if not smoke and not development and not unseal_test: - raise ValueError("Een volledige run vereist de expliciete vlag --unseal-test.") + raise ValueError("A full run requires the explicit --unseal-test flag.") if (smoke or development) and unseal_test: - raise ValueError("Een niet-confirmatieve run mag de testset niet openen.") + raise ValueError("A non-confirmatory run must not open the test set.") split = build_splits(config) mode = "smoke" if smoke else "development" if development else "experiment" @@ -417,7 +417,7 @@ def validate_schemas(schema_directory: str | Path) -> None: registry = registry.with_resource(schema["$id"], Resource.from_contents(schema)) schemas.append(schema) if not schemas: - raise ValueError("Geen JSON-schema's gevonden.") + raise ValueError("No JSON Schemas found.") def _validate_episodes(episodes: list[dict[str, Any]], config: dict[str, Any]) -> None: @@ -449,23 +449,23 @@ def _validate_episodes(episodes: list[dict[str, Any]], config: dict[str, Any]) - ): value = int(meaning[factor_name][len(prefix) :]) if value < 0 or value >= len(factor_specs[factor_name]["values"]): - raise ValueError("Episode bevat een factorwaarde buiten de wereld.") + raise ValueError("Episode contains a factor value outside the world.") factors.append(value) expected_meaning = meaning_from_factors(factors, config) if expected_meaning.meaning_id != meaning["meaning_id"]: - raise ValueError("Episode bevat een inconsistente meaning_id.") + raise ValueError("Episode contains an inconsistent meaning_id.") message = episode["message"] if message["channel_bits"] != config["channel"]["bits_per_message"]: - raise ValueError("Episode bevat een onjuiste kanaalbitlengte.") + raise ValueError("Episode contains an incorrect channel bit length.") symbols = message["symbols"] if len(symbols) != config["channel"]["message_length"]: - raise ValueError("Episode bevat een onjuiste berichtlengte.") + raise ValueError("Episode contains an incorrect message length.") if any( symbol < config["channel"]["symbol_min"] or symbol > config["channel"]["symbol_max"] for symbol in symbols ): - raise ValueError("Episode bevat een symbool buiten het kanaalalfabet.") + raise ValueError("Episode contains a symbol outside the channel alphabet.") def _classify_seed( @@ -539,7 +539,7 @@ def _render_report( development: bool, ) -> str: title = ( - "ECP-0 technische proefrun" + "ECP-0 technical smoke run" if smoke else "ECP-0 ontwikkelrun" if development @@ -548,9 +548,9 @@ def _render_report( lines = [ f"# {title}", "", - f"Classificatie: **{summary['overall_classification']}**", + f"Classification: **{summary['overall_classification']}**", "", - "| Seed | Bekend exact | Validatie exact | Compositie exact | Vertaler compositie | Classificatie |", + "| Seed | Known exact | Validation exact | Compositional exact | Translator compositional | Classification |", "|---:|---:|---:|---:|---:|---|", ] for result in results: @@ -574,24 +574,24 @@ def _render_report( lines.extend( [ "", - "## Methodologische status", + "## Methodological status", "", - "De zender en ontvanger zijn voor iedere gerapporteerde evaluatie als afzonderlijke " - "processen uitgevoerd. De ontvanger ontving uitsluitend de discrete symboolmatrix.", + "The sender and receiver ran as separate processes for every reported evaluation. " + "The receiver received only the discrete symbol matrix.", "", ] ) if smoke: lines.append( - "Deze korte run controleert uitsluitend de technische keten en heeft de compositionele testset niet geopend." + "This short run checks only the technical pipeline and did not open the compositional test set." ) elif development: lines.append( - "Deze ontwikkelrun gebruikte alleen train en validatie. De compositionele testset bleef verzegeld." + "This development run used training and validation only. The compositional test set remained sealed." ) else: lines.append( - "De compositionele testset is voor deze confirmatieve run expliciet ontzegeld en niet voor modelselectie gebruikt." + "The compositional test set was explicitly unsealed for this confirmatory run and was not used for model selection." ) lines.append("") return "\n".join(lines) diff --git a/src/ai_taal/metrics.py b/src/ai_taal/metrics.py index 95f077d..12898bb 100644 --- a/src/ai_taal/metrics.py +++ b/src/ai_taal/metrics.py @@ -1,4 +1,4 @@ -"""Protocolmetingen die verder gaan dan alleen taaknauwkeurigheid.""" +"""Protocol measurements that go beyond task accuracy alone.""" from __future__ import annotations @@ -21,7 +21,7 @@ def prediction_metrics( targets = np.asarray([meaning.factors for meaning in meanings], dtype=np.int64) predictions = np.asarray(predictions, dtype=np.int64) if predictions.shape != targets.shape: - raise ValueError(f"Voorspellingen hebben vorm {predictions.shape}, verwacht {targets.shape}.") + raise ValueError(f"Predictions have shape {predictions.shape}; expected {targets.shape}.") correct = predictions == targets return { "exact_match": float(np.mean(np.all(correct, axis=1))), @@ -36,7 +36,7 @@ def protocol_statistics( semantic = np.asarray([meaning.factors for meaning in meanings], dtype=np.int16) messages = np.asarray(messages, dtype=np.int16) if messages.ndim != 2 or messages.shape[0] != semantic.shape[0]: - raise ValueError("Berichten en betekenissen hebben incompatibele vormen.") + raise ValueError("Messages and meanings have incompatible shapes.") message_tuples = [tuple(int(value) for value in row) for row in messages] counts = Counter(message_tuples) @@ -80,13 +80,13 @@ def topographic_permutation_test( repetitions: int, seed: int, ) -> dict[str, Any]: - """Vergelijk de waargenomen semantische geometrie met willekeurige koppelingen.""" + """Compare observed semantic geometry with random assignments.""" if repetitions < 1: - raise ValueError("Minstens één permutatie is vereist.") + raise ValueError("At least one permutation is required.") semantic = np.asarray(semantic, dtype=np.int16) messages = np.asarray(messages, dtype=np.int16) if semantic.shape[0] != messages.shape[0]: - raise ValueError("Betekenissen en berichten moeten evenveel rijen hebben.") + raise ValueError("Meanings and messages must have the same number of rows.") left_indices, right_indices, sampling = _topographic_pair_indices( len(semantic), max_pairs=MAX_TOPOGRAPHIC_PAIRS, seed=seed + 31 @@ -147,11 +147,11 @@ def _topographic_similarity( def _topographic_pair_indices( row_count: int, *, max_pairs: int, seed: int ) -> tuple[np.ndarray, np.ndarray, str]: - """Geef alle paren of een reproduceerbare uniforme steekproef zonder teruglegging.""" + """Return all pairs or a reproducible uniform sample without replacement.""" if row_count < 2: - raise ValueError("Topografische gelijkenis vereist minstens twee rijen.") + raise ValueError("Topographic similarity requires at least two rows.") if max_pairs < 1: - raise ValueError("max_pairs moet positief zijn.") + raise ValueError("max_pairs must be positive.") total_pairs = row_count * (row_count - 1) // 2 if total_pairs <= max_pairs: diff --git a/src/ai_taal/models.py b/src/ai_taal/models.py index daddc7a..fc9df83 100644 --- a/src/ai_taal/models.py +++ b/src/ai_taal/models.py @@ -1,4 +1,4 @@ -"""Zender, ontvanger en veilige afzonderlijke checkpoints voor ECP-0.""" +"""Sender, receiver, and safe independent checkpoints for ECP.""" from __future__ import annotations @@ -62,7 +62,7 @@ def from_dict(cls, value: dict[str, Any]) -> "ModelSpec": class Sender(nn.Module): - """Autoregressieve zender die factorcategorieën naar discrete symbolen omzet.""" + """Autoregressive sender that maps factor categories to discrete symbols.""" def __init__(self, spec: ModelSpec) -> None: super().__init__() @@ -115,14 +115,14 @@ def forward( return torch.stack(one_hot_messages, dim=1), torch.stack(tokens, dim=1) def relaxed_message(self, meanings: Tensor, *, temperature: float = 1.0) -> Tensor: - """Deterministische symboolverdelingen voor structurele trainingsdruk. + """Return deterministic symbol distributions for structural training pressure. - Dit pad verzendt niets tijdens evaluatie. Het maakt uitsluitend zichtbaar - hoe de zender zijn waarschijnlijkheidsmassa over het bestaande discrete - kanaal verdeelt, zonder Gumbelruis of vooraf toegewezen symboolbetekenis. + This path transmits nothing during evaluation. It only exposes how the + sender distributes probability mass over the existing discrete channel, + without Gumbel noise or preassigned symbol semantics. """ if temperature <= 0: - raise ValueError("Temperatuur moet positief zijn.") + raise ValueError("Temperature must be positive.") embedded_factors = [ embedding(meanings[:, index]) for index, embedding in enumerate(self.factor_embeddings) @@ -142,13 +142,13 @@ def relaxed_message(self, meanings: Tensor, *, temperature: float = 1.0) -> Tens class LearnedPermutationSlotSender(nn.Module): - """Compositionele slots waarvan de factor-slotkoppeling intern wordt gekozen.""" + """Compositional slots whose factor-slot binding is selected internally.""" def __init__(self, spec: ModelSpec) -> None: super().__init__() if spec.message_length != len(spec.factor_sizes): raise ValueError( - "Een permutationslotzender vereist één slot per betekenisfactor." + "A permutation-slot sender requires one slot per meaning factor." ) self.spec = spec self.factor_embeddings = nn.ModuleList( @@ -190,7 +190,7 @@ def forward( def relaxed_message(self, meanings: Tensor, *, temperature: float = 1.0) -> Tensor: if temperature <= 0: - raise ValueError("Temperatuur moet positief zijn.") + raise ValueError("Temperature must be positive.") return torch.softmax(self._message_logits(meanings) / temperature, dim=-1) def binding_matrix(self, *, straight_through: bool = True) -> Tensor: @@ -236,30 +236,30 @@ def _message_logits(self, meanings: Tensor) -> Tensor: class InjectivePermutationSlotSender(nn.Module): - """Vrij geleerde slots en injectieve atoomcodes zonder semantische labels. + """Freely learned slots and injective atomic codes without semantic labels. - Iedere factor kiest exact één slot. Binnen een factor krijgt iedere waarde - exact één ander symbool. De harde toewijzingen worden alleen structureel - begrensd; geen slot of symbool krijgt vooraf een menselijke betekenis. + Every factor selects exactly one slot. Within a factor, every value receives + a distinct symbol. The hard assignments are constrained structurally only; + no slot or symbol receives a human meaning in advance. """ def __init__(self, spec: ModelSpec) -> None: super().__init__() if spec.message_length != len(spec.factor_sizes): raise ValueError( - "Een injectieve permutationslotzender vereist één slot per factor." + "An injective permutation-slot sender requires one slot per factor." ) if any(size > spec.vocabulary_size for size in spec.factor_sizes): raise ValueError( - "Injectieve atoomcodes vereisen minstens zoveel symbolen als waarden." + "Injective atomic codes require at least as many symbols as values." ) self.spec = spec self.binding_logits = nn.Parameter( torch.empty(spec.message_length, len(spec.factor_sizes)) ) - # Vierkante matrices bevatten naast echte factorwaarden ook dummy-rijen. - # Daardoor kan Sinkhorn een volledige permutatie leren, terwijl alleen de - # eerste `factor_size` rijen daadwerkelijk worden uitgezonden. + # Square matrices contain dummy rows in addition to real factor values. + # This lets Sinkhorn learn a complete permutation while only the first + # `factor_size` rows are actually transmitted. self.codebook_logits = nn.ParameterList( [ nn.Parameter( @@ -301,7 +301,7 @@ def forward( def relaxed_message(self, meanings: Tensor, *, temperature: float = 1.0) -> Tensor: if temperature <= 0: - raise ValueError("Temperatuur moet positief zijn.") + raise ValueError("Temperature must be positive.") factor_codes = torch.stack( [ self.soft_codebook_matrix(index, temperature=temperature)[ @@ -331,7 +331,7 @@ def soft_binding_matrix(self) -> Tensor: def codebook_matrix( self, factor_index: int, *, straight_through: bool = True ) -> Tensor: - """Geef de echte waarderijen van een harde één-op-één-symboolcode.""" + """Return the real value rows of a hard one-to-one symbol code.""" soft_full = self.soft_codebook_matrix(factor_index) hard_full = self._greedy_permutation(soft_full.detach()) factor_size = self.spec.factor_sizes[factor_index] @@ -345,7 +345,7 @@ def soft_codebook_matrix( self, factor_index: int, *, temperature: float = 1.0 ) -> Tensor: if temperature <= 0: - raise ValueError("Temperatuur moet positief zijn.") + raise ValueError("Temperature must be positive.") return self._sinkhorn(self.codebook_logits[factor_index] / temperature) def soft_codebook_matrices(self) -> tuple[Tensor, ...]: @@ -365,7 +365,7 @@ def _sinkhorn(logits: Tensor) -> Tensor: @staticmethod def _greedy_permutation(scores: Tensor) -> Tensor: - """Deterministische harde permutatie; gradiënten lopen via Sinkhorn.""" + """Deterministic hard permutation; gradients flow through Sinkhorn.""" size = scores.shape[0] hard = torch.zeros_like(scores) used_rows: set[int] = set() @@ -380,21 +380,21 @@ def _greedy_permutation(scores: Tensor) -> Tensor: if len(used_rows) == size: break if len(used_rows) != size: - raise RuntimeError("Kon geen volledige injectieve symboolcode construeren.") + raise RuntimeError("Could not construct a complete injective symbol code.") return hard class MinimalPermutationSlotSender(InjectivePermutationSlotSender): - """Injectieve lokale factoralfabetten op de exacte bronondergrens.""" + """Injective factor-local alphabets at the exact source lower bound.""" def __init__(self, spec: ModelSpec) -> None: nn.Module.__init__(self) if spec.message_length != len(spec.factor_sizes): raise ValueError( - "Een minimale permutationslotzender vereist één slot per factor." + "A minimal permutation-slot sender requires one slot per factor." ) if spec.vocabulary_size < max(spec.factor_sizes): - raise ValueError("Globale tokenruimte is kleiner dan een factoralfabet.") + raise ValueError("Global token space is smaller than a factor alphabet.") self.spec = spec self.binding_logits = nn.Parameter( torch.empty(spec.message_length, len(spec.factor_sizes)) @@ -428,7 +428,7 @@ def forward( def relaxed_message(self, meanings: Tensor, *, temperature: float = 1.0) -> Tensor: if temperature <= 0: - raise ValueError("Temperatuur moet positief zijn.") + raise ValueError("Temperature must be positive.") factor_codes = self._padded_factor_codes( meanings, relaxed=True, temperature=temperature ) @@ -485,7 +485,7 @@ def make_sender(spec: ModelSpec) -> SenderModel: class Receiver(nn.Module): - """Ontvanger die uitsluitend een discrete symboolreeks naar factoren decodeert.""" + """Receiver that decodes only a discrete symbol sequence into factors.""" def __init__(self, spec: ModelSpec) -> None: super().__init__() @@ -508,20 +508,20 @@ def forward(self, message: Tensor) -> tuple[Tensor, ...]: elif message.ndim == 3: embedded = message @ self.symbol_embedding.weight else: - raise ValueError("Bericht moet [batch,lengte] of [batch,lengte,vocab] zijn.") + raise ValueError("Message must have shape [batch,length] or [batch,length,vocab].") _, hidden = self.recurrent(embedded) representation = hidden[-1] return tuple(head(representation) for head in self.factor_heads) class FactorizedPermutationSlotReceiver(nn.Module): - """Decodeert iedere factor uit exact één vrij gekozen berichtslot.""" + """Decode each factor from exactly one freely selected message slot.""" def __init__(self, spec: ModelSpec) -> None: super().__init__() if spec.message_length != len(spec.factor_sizes): raise ValueError( - "Een factorontvanger vereist één berichtslot per factor." + "A factorized receiver requires one message slot per factor." ) self.spec = spec self.symbol_embedding = nn.Embedding( @@ -548,7 +548,7 @@ def forward(self, message: Tensor) -> tuple[Tensor, ...]: elif message.ndim == 3: embedded = message @ self.symbol_embedding.weight else: - raise ValueError("Bericht moet [batch,lengte] of [batch,lengte,vocab] zijn.") + raise ValueError("Message must have shape [batch,length] or [batch,length,vocab].") factors = torch.einsum("fs,bse->bfe", self.binding_matrix(), embedded) return tuple( head(factors[:, index]) @@ -594,12 +594,12 @@ def forward( class PopulationSystem(nn.Module): - """Volledig onafhankelijke zenders en ontvangers met één gedeeld kanaal.""" + """Fully independent senders and receivers with one shared channel.""" def __init__(self, spec: ModelSpec, *, sender_count: int, receiver_count: int) -> None: super().__init__() if sender_count < 2 or receiver_count < 2: - raise ValueError("Een populatie vereist minstens twee zenders en ontvangers.") + raise ValueError("A population requires at least two senders and two receivers.") self.spec = spec self.senders = nn.ModuleList(make_sender(spec) for _ in range(sender_count)) self.receivers = nn.ModuleList( @@ -627,7 +627,7 @@ def save_agent_checkpoint( kind: str, ) -> None: if kind not in {"sender", "receiver", "translator"}: - raise ValueError(f"Onbekend agenttype: {kind}") + raise ValueError(f"Unknown agent type: {kind}") payload = { "format_version": 1, "kind": kind, @@ -643,7 +643,7 @@ def load_agent_checkpoint( payload = torch.load(Path(path), map_location=device, weights_only=True) kind = payload["kind"] if expected_kind is not None and kind != expected_kind: - raise ValueError(f"Checkpoint bevat {kind}, verwacht {expected_kind}.") + raise ValueError(f"Checkpoint contains {kind}; expected {expected_kind}.") spec = ModelSpec.from_dict(payload["model_spec"]) agent: SenderModel | ReceiverModel if kind == "sender": @@ -651,7 +651,7 @@ def load_agent_checkpoint( elif kind in {"receiver", "translator"}: agent = make_receiver(spec) else: - raise ValueError(f"Checkpoint bevat onbekend agenttype: {kind}") + raise ValueError(f"Checkpoint contains unknown agent type: {kind}") agent.load_state_dict(payload["state_dict"]) agent.to(device) agent.eval() diff --git a/src/ai_taal/population_experiment.py b/src/ai_taal/population_experiment.py index 9f0f4fe..4ca5e99 100644 --- a/src/ai_taal/population_experiment.py +++ b/src/ai_taal/population_experiment.py @@ -1,4 +1,4 @@ -"""Populatie-experimenten met universele vertaling en overdraagbaarheid.""" +"""Population experiments with universal translation and transferability.""" from __future__ import annotations @@ -50,14 +50,14 @@ def run_population_experiment( ) -> Path: experiment_id = config["experiment"]["id"].upper() if smoke and development: - raise ValueError("Een run kan niet tegelijk smoke en development zijn.") + raise ValueError("A run cannot be both smoke and development.") if not smoke and not development and not unseal_test: raise ValueError( - f"Een confirmatieve {experiment_id}-run vereist --unseal-test." + f"A confirmatory {experiment_id} run requires --unseal-test." ) if (smoke or development) and unseal_test: raise ValueError( - f"Een niet-confirmatieve {experiment_id}-run mag de testset niet openen." + f"A non-confirmatory {experiment_id} run must not open the test set." ) split = build_splits(config) @@ -284,7 +284,7 @@ def run_population_seed( "train", "validation", "compositional_test" } if unknown_logged_splits: - raise ValueError(f"Onbekende episode-logsplits: {unknown_logged_splits}") + raise ValueError(f"Unknown episode-log splits: {unknown_logged_splits}") logged_splits = [ (name, meanings) for name, meanings in evaluated_splits @@ -829,7 +829,7 @@ def _render_report( ) -> str: experiment_id = summary["experiment_id"].upper() title = ( - f"{experiment_id} technische proefrun" + f"{experiment_id} technical smoke run" if smoke else f"{experiment_id} ontwikkelrun" if development @@ -838,9 +838,9 @@ def _render_report( lines = [ f"# {title}", "", - f"Classificatie: **{summary['overall_classification']}**", + f"Classification: **{summary['overall_classification']}**", "", - "| Seed | Bekend gemiddeld | Bekend slechtste paar | Validatie gemiddeld | Test gemiddeld | Universele vertaler test | Classificatie |", + "| Seed | Known mean | Known worst pair | Validation mean | Test mean | Universal translator test | Classification |", "|---:|---:|---:|---:|---:|---:|---|", ] for result in results: @@ -863,23 +863,23 @@ def _render_report( lines.extend( [ "", - "## Methodologische status", + "## Methodological status", "", - "Alle zenders en ontvangers hebben onafhankelijke parameters. Tijdens de definitieve evaluatie ontvingen afzonderlijke ontvangerprocessen uitsluitend symboolmatrices van alle zenders.", + "All senders and receivers have independent parameters. During final evaluation, separate receiver processes received only symbol matrices from all senders.", "", ] ) if smoke: lines.append( - f"Technische ketencontrole; de {experiment_id}-testset bleef gesloten." + f"Technical pipeline check; the {experiment_id} test set remained sealed." ) elif development: lines.append( - f"Volledige ontwikkeltraining; de {experiment_id}-testset bleef gesloten." + f"Full development training; the {experiment_id} test set remained sealed." ) else: lines.append( - f"Confirmatieve run met de vooraf bevroren {experiment_id}-configuratie en eenmalige testontzegeling." + f"Confirmatory run with the prefrozen {experiment_id} configuration and one-time test unsealing." ) lines.append("") return "\n".join(lines) diff --git a/src/ai_taal/training.py b/src/ai_taal/training.py index 40cfa5f..6128955 100644 --- a/src/ai_taal/training.py +++ b/src/ai_taal/training.py @@ -1,4 +1,4 @@ -"""Trainingslussen die de compositionele testset nooit voor selectie gebruiken.""" +"""Training loops that never use the compositional test set for selection.""" from __future__ import annotations @@ -138,7 +138,7 @@ def train_communication_system( break if best_state is None: - raise RuntimeError("Training leverde geen selecteerbaar model op.") + raise RuntimeError("Training produced no selectable model.") system.load_state_dict(best_state) system.eval() return system, TrainingResult( @@ -189,7 +189,7 @@ def train_population_system( atom_consensus_enabled = bool(atom_consensus_config.get("enabled", False)) if population_config["pairing"] != "all_senders_all_receivers": raise ValueError( - "Populatietraining ondersteunt alleen all_senders_all_receivers." + "Population training supports all_senders_all_receivers only." ) transmission_config = training.get("cultural_transmission", {}) transmission_enabled = bool(transmission_config.get("enabled", False)) @@ -197,7 +197,7 @@ def train_population_system( maximum_replacements = int(transmission_config.get("maximum_replacements", 0)) if transmission_enabled and replacement_interval < evaluation_interval: raise ValueError( - "Vervangingsinterval moet minstens één evaluatie-interval beslaan." + "Replacement interval must span at least one evaluation interval." ) required_replacements = ( max(len(population.senders), len(population.receivers)) @@ -387,7 +387,7 @@ def train_population_system( optimizer = _population_optimizer(population, training) if best_state is None: - raise RuntimeError("Populatietraining leverde geen selecteerbaar model op.") + raise RuntimeError("Population training produced no selectable model.") population.load_state_dict(best_state) population.eval() return population, PopulationTrainingResult( @@ -416,7 +416,7 @@ def _replace_population_members( receiver_index: int, device: str, ) -> None: - """Vervang één generatiepaar zonder toestand van overlevende agents te delen.""" + """Replace one generational pair without sharing surviving-agent state.""" population.senders[sender_index] = make_sender(population.spec).to(device) population.receivers[receiver_index] = make_receiver(population.spec).to(device) @@ -429,7 +429,7 @@ def slot_binding_consensus_loss( method = getattr(sender, "soft_binding_matrix", None) if method is None: raise ValueError( - "Bindingsconsensus vereist learned_permutation_slot_sender." + "Binding consensus requires learned_permutation_slot_sender." ) bindings.append(method()) stacked = torch.stack(bindings) @@ -441,13 +441,13 @@ def slot_binding_consensus_loss( def atom_code_consensus_loss( population: PopulationSystem, *, sharpness_weight: float ) -> Tensor: - """Lijn vrije, injectieve waardecodes tussen onafhankelijke zenders uit.""" + """Align free injective value codes across independent senders.""" codebooks_by_sender = [] for sender in population.senders: method = getattr(sender, "soft_codebook_matrices", None) if method is None: raise ValueError( - "Atoomcodeconsensus vereist injective_permutation_slot_sender." + "Atomic-code consensus requires injective_permutation_slot_sender." ) codebooks_by_sender.append(method()) losses = [] @@ -468,14 +468,14 @@ def build_algebraic_quadruples( sample_count: int, seed: int, ) -> Tensor: - """Bouw contextparen voor dezelfde atomaire betekenisverandering. + """Build contextual pairs for the same atomic meaning change. - Iedere rij bevat A, B, A' en B'. A→A' en B→B' veranderen exact - dezelfde factorwaarde, maar in verschillende contexten. Uitsluitend - betekenissen uit de trainingsset worden opgenomen. + Every row contains A, B, A', and B'. A→A' and B→B' change exactly + the same factor value, but in different contexts. Only meanings from + the training set are included. """ if sample_count < 1: - raise ValueError("Minstens één algebraïsch viertal is vereist.") + raise ValueError("At least one algebraic quadruple is required.") lookup = {meaning.factors: meaning.factors for meaning in train_meanings} transitions: dict[ tuple[int, int, int], list[tuple[tuple[int, ...], tuple[int, ...]]] @@ -495,7 +495,7 @@ def build_algebraic_quadruples( ).append((factors, changed_tuple)) valid = [(key, pairs) for key, pairs in transitions.items() if len(pairs) >= 2] if not valid: - raise ValueError("Trainingsset bevat geen herhaalde atomaire transities.") + raise ValueError("Training set contains no repeated atomic transitions.") rng = random.Random(seed) quadruples = [] @@ -511,9 +511,9 @@ def build_algebraic_quadruples( def algebraic_consistency_loss( sender: Sender, quadruples: Tensor, *, temperature: float ) -> Tensor: - """Maak dezelfde factoraanpassing contextinvariant in berichtverdeling.""" + """Make the same factor change context-invariant in message distribution.""" if quadruples.ndim != 3 or quadruples.shape[1:] != (4, 4): - raise ValueError("Algebraïsche viertallen moeten vorm [batch,4,4] hebben.") + raise ValueError("Algebraic quadruples must have shape [batch,4,4].") batch_size = quadruples.shape[0] distributions = sender.relaxed_message( quadruples.reshape(batch_size * 4, 4), temperature=temperature @@ -614,7 +614,7 @@ def train_translator( break if best_state is None: - raise RuntimeError("Vertalertraining leverde geen selecteerbaar model op.") + raise RuntimeError("Translator training produced no selectable model.") translator.load_state_dict(best_state) translator.eval() return translator, TrainingResult( @@ -635,13 +635,13 @@ def calibrate_receiver_binding( confidence: float, freeze: bool, ) -> dict[str, Any]: - """Kies exact de beste factor-slotpermutatie op empirische informatie.""" + """Select the exact best factor-slot permutation from empirical information.""" binding_logits = getattr(receiver, "binding_logits", None) permutation_matrices = getattr(receiver, "permutation_matrices", None) if binding_logits is None or permutation_matrices is None: - raise ValueError("Bindingskalibratie vereist een permutationslotontvanger.") + raise ValueError("Binding calibration requires a permutation-slot receiver.") if confidence <= 0: - raise ValueError("Kalibratieconfidence moet positief zijn.") + raise ValueError("Calibration confidence must be positive.") factor_count = meanings.shape[1] slot_count = messages.shape[1] vocabulary_size = receiver.spec.vocabulary_size @@ -755,6 +755,6 @@ def _factor_loss(logits: tuple[Tensor, ...], targets: Tensor) -> Tensor: def _geometric_schedule(start: float, end: float, progress: float) -> float: if start <= 0 or end <= 0: - raise ValueError("Temperaturen moeten positief zijn.") + raise ValueError("Temperatures must be positive.") return start * math.pow(end / start, progress) make_receiver, diff --git a/src/ai_taal/worker.py b/src/ai_taal/worker.py index 352b465..09d8805 100644 --- a/src/ai_taal/worker.py +++ b/src/ai_taal/worker.py @@ -1,4 +1,4 @@ -"""Geïsoleerde zender- en decoderprocessen voor de definitieve evaluatie.""" +"""Isolated sender and decoder processes for final evaluation.""" from __future__ import annotations @@ -24,7 +24,7 @@ def _read_matrix(path: Path) -> torch.Tensor: with path.open("r", encoding="utf-8") as handle: value = json.load(handle) if not isinstance(value, list) or any(not isinstance(row, list) for row in value): - raise ValueError("Workerinvoer moet een JSON-matrix zijn.") + raise ValueError("Worker input must be a JSON matrix.") return torch.tensor(value, dtype=torch.long) @@ -54,12 +54,12 @@ def main(argv: list[str] | None = None) -> int: MinimalPermutationSlotSender, ), ): - raise TypeError("Zendercheckpoint laadde geen zender.") + raise TypeError("Sender checkpoint did not load a sender.") output = encode_meanings(agent, matrix) else: agent = load_agent_checkpoint(args.checkpoint) if not isinstance(agent, (Receiver, FactorizedPermutationSlotReceiver)): - raise TypeError("Decodercheckpoint laadde geen ontvanger.") + raise TypeError("Decoder checkpoint did not load a receiver.") output = predict_receiver(agent, matrix) _write_matrix(args.output, output) return 0 diff --git a/src/ai_taal/world.py b/src/ai_taal/world.py index 820aed7..f23c5c1 100644 --- a/src/ai_taal/world.py +++ b/src/ai_taal/world.py @@ -1,4 +1,4 @@ -"""De volledig synthetische ECP-0-wereld en deterministische datasplitsing.""" +"""The fully synthetic ECP world and deterministic data splitting.""" from __future__ import annotations @@ -97,9 +97,9 @@ def build_splits(config: dict[str, Any]) -> WorldSplit: if len(held_out_factor_names) != 2 or any( name not in FACTOR_NAMES for name in held_out_factor_names ): - raise ValueError("holdout_factors moet twee geldige, verschillende factoren bevatten.") + raise ValueError("holdout_factors must contain two valid, distinct factors.") if held_out_factor_names[0] == held_out_factor_names[1]: - raise ValueError("holdout_factors moet twee verschillende factoren bevatten.") + raise ValueError("holdout_factors must contain two distinct factors.") left_name, right_name = held_out_factor_names left_index = FACTOR_NAMES.index(left_name) right_index = FACTOR_NAMES.index(right_name) @@ -110,7 +110,7 @@ def build_splits(config: dict[str, Any]) -> WorldSplit: ) if left_count != right_count or holdout_count != left_count: raise ValueError( - "Een held-out matching vereist gelijke factorgroottes en één paar per waarde." + "A held-out matching requires equal factor sizes and one pair per value." ) excluded_values = dataset.get( @@ -133,7 +133,7 @@ def build_splits(config: dict[str, Any]) -> WorldSplit: ) if (explicit_validation is None) != (explicit_test is None): raise ValueError( - "Expliciete validatie- en testmatchings moeten samen worden opgegeven." + "Explicit validation and test matchings must be provided together." ) if explicit_validation is not None: held_out_validation = _parse_explicit_matching( @@ -141,39 +141,39 @@ def build_splits(config: dict[str, Any]) -> WorldSplit: left_count, left_name=left_name, right_name=right_name, - purpose="validatiematching", + purpose="validation matching", ) held_out = _parse_explicit_matching( explicit_test, left_count, left_name=left_name, right_name=right_name, - purpose="testmatching", + purpose="test matching", ) if set(held_out_validation) & set(held_out): - raise ValueError("Expliciete validatie- en testmatchings overlappen.") + raise ValueError("Explicit validation and test matchings overlap.") if not (set(held_out_validation) | set(held_out)).isdisjoint(excluded_pairs): - raise ValueError("Expliciete matchings bevatten eerder uitgesloten paren.") + raise ValueError("Explicit matchings contain previously excluded pairs.") elif validation_holdout_count: if validation_holdout_count != left_count: raise ValueError( - "Een compositionele validatiematching vereist één paar per kleur." + "A compositional validation matching requires one pair per value." ) held_out_validation = _sample_matching( - rng, left_count, excluded_pairs, purpose="validatiematching" + rng, left_count, excluded_pairs, purpose="validation matching" ) held_out = _sample_matching( rng, left_count, excluded_pairs | set(held_out_validation), - purpose="testmatching", + purpose="test matching", ) else: held_out = _sample_matching( rng, left_count, excluded_pairs, - purpose="testmatching", + purpose="test matching", ) held_out_set = set(held_out) @@ -204,7 +204,7 @@ def build_splits(config: dict[str, Any]) -> WorldSplit: not in validation_set ] if len(validation) != validation_count: - raise RuntimeError("Compositionele validatiematching heeft onjuiste grootte.") + raise RuntimeError("Compositional validation matching has the wrong size.") else: validation = None train = None @@ -219,7 +219,7 @@ def build_splits(config: dict[str, Any]) -> WorldSplit: train = proposed_train break if validation is None or train is None: - raise RuntimeError("Kon geen gestratificeerde train/validatiesplitsing maken.") + raise RuntimeError("Could not create a stratified train/validation split.") result = WorldSplit( train=tuple(sorted(train, key=lambda item: item.meaning_id)), @@ -246,7 +246,7 @@ def _sample_matching( pairs = tuple((color, permutation[color]) for color in range(size)) if set(pairs).isdisjoint(excluded_pairs): return pairs - raise RuntimeError(f"Kon geen {purpose} maken buiten de uitgesloten paren.") + raise RuntimeError(f"Could not create a {purpose} outside the excluded pairs.") def _parse_explicit_matching( @@ -261,22 +261,22 @@ def _parse_explicit_matching( (int(value[left_name]), int(value[right_name])) for value in values ) if len(pairs) != size or len(set(pairs)) != size: - raise ValueError(f"Expliciete {purpose} moet {size} unieke paren bevatten.") + raise ValueError(f"Explicit {purpose} must contain {size} unique pairs.") if {color for color, _ in pairs} != set(range(size)): - raise ValueError(f"Expliciete {purpose} bevat niet iedere kleur exact één keer.") + raise ValueError(f"Explicit {purpose} does not contain every left value exactly once.") if {shape for _, shape in pairs} != set(range(size)): - raise ValueError(f"Expliciete {purpose} bevat niet iedere vorm exact één keer.") + raise ValueError(f"Explicit {purpose} does not contain every right value exactly once.") return tuple(sorted(pairs)) def meaning_from_factors(factors: Iterable[int], config: dict[str, Any]) -> Meaning: values = tuple(int(value) for value in factors) if len(values) != len(FACTOR_NAMES): - raise ValueError("Een ECP-0-betekenis heeft precies vier factoren.") + raise ValueError("An ECP meaning has exactly four factors.") sizes = [len(config["world"]["factors"][name]["values"]) for name in FACTOR_NAMES] for value, size in zip(values, sizes, strict=True): if value < 0 or value >= size: - raise ValueError(f"Factorwaarde {value} valt buiten 0..{size - 1}.") + raise ValueError(f"Factor value {value} is outside 0..{size - 1}.") meaning_id = 0 for value, size in zip(values, sizes, strict=True): meaning_id = meaning_id * size + value @@ -307,11 +307,11 @@ def _validate_split(split: WorldSplit, config: dict[str, Any]) -> None: "compositional_test": len(split.compositional_test), } if actual != expected: - raise AssertionError(f"Onjuiste splitsingsgroottes: {actual} versus {expected}.") + raise AssertionError(f"Incorrect split sizes: {actual} versus {expected}.") groups = [split.train, split.validation, split.compositional_test] id_sets = [{meaning.meaning_id for meaning in group} for group in groups] if any(id_sets[left] & id_sets[right] for left, right in ((0, 1), (0, 2), (1, 2))): - raise AssertionError("Datasplitsingen overlappen.") + raise AssertionError("Data splits overlap.") if len(set.union(*id_sets)) != config["world"]["meaning_count"]: - raise AssertionError("Datasplitsingen dekken de wereld niet volledig.") + raise AssertionError("Data splits do not cover the complete world.") diff --git a/tests/test_config.py b/tests/test_config.py index 22a9c32..b0ecfcf 100644 --- a/tests/test_config.py +++ b/tests/test_config.py @@ -15,7 +15,7 @@ def test_registered_invariants_are_consistent(config): def test_invalid_split_is_rejected(config): invalid = deepcopy(config) invalid["dataset"]["train_meanings"] -= 1 - with pytest.raises(ConfigError, match="Datasplitsingen"): + with pytest.raises(ConfigError, match="Data splits"): validate_config(invalid)