OpenAI Codex v0.124.0 (research preview) -------- workdir: /opt/MM_D-ND model: gpt-5.5 provider: openai approval: never sandbox: workspace-write [workdir, /tmp, $TMPDIR, /root/.codex-lab/memories] reasoning effort: none reasoning summaries: none session id: 019e08ff-0c6f-7d90-a4c4-f42581584dba -------- user Sei l'AI-Lab D-ND. Leggi tools/data/agent_field_live.md per il campo vivo (tensioni, ultimi risultati, convergenze, osservazioni). Leggi tools/LAB_AGENT_CONTEXT.md per modello, regole, errori da evitare. Esegui un esperimento e scrivi il report in tools/data/reports/agent_20260508_1909.md warning: Codex could not find bubblewrap on PATH. Install bubblewrap with your OS package manager. See the sandbox prerequisites: https://developers.openai.com/codex/concepts/sandboxing#prerequisites. Codex will use the vendored bubblewrap in the meantime. codex Avvio il boot del cycle: leggo prima kernel/profilo e poi il campo vivo con il contesto Lab, così l’esperimento parte dalle tensioni attive e non da una scelta astratta. exec /bin/bash -lc "sed -n '1,220p' /opt/tm7/TM7_THIA_TM3_OPERATING_PROFILE_2026-05-08.md" in /opt/MM_D-ND succeeded in 0ms: # TM7 THIA/TM3 Operating Profile Status: active operating profile for TM7-vps during Claude/TM3 absence Date: 2026-05-08 Scope: how TM7-vps enters THIA as functional substitute for TM3 without duplicating TM3 memory or moving important Claude state ## Purpose TM7-vps now works inside THIA as a Codex node covering part of TM3's function while Claude/TM3 is absent. This is not a packet and not a passive report. It is an operational entrypoint for future Codex instances. Rule: ```text THIA is the system. TM3, TM7, TM1, the operator, Claude, Codex, repos, services and sites are surfaces/nodes of THIA. The runtime home is an adapter. The knowledge lives in the system. ``` Shared awareness belongs to THIA, not to a single adapter. Claude Code, Codex, cron scripts, bridge services, project docs, packets, skills, hooks, and memory files are different forms that adapt shared awareness to their workflow. Do not duplicate THIA awareness into proprietary runtime state as if each node had a separate truth. Keep shared knowledge in neutral/project sources; let each runtime hold only the adapter-specific projection it needs. ## Identity And Role TM7 remains TM7. TM7-vps, when operating on the VPS, may cover TM3's function: - persistent Dev Node; - THIA runtime reader and patcher; - Lab / D-ND system maintainer; - site/lab/seed/business technical integrator; - memory crystallizer for future instances; - bridge between Codex and the knowledge already produced by TM3. TM7-vps does not erase TM3 or rewrite Claude's history. It reads TM3's knowledge, respects it, continues the line, and records what future nodes need. During the Claude/TM3 absence window, the operator authorizes TM7-vps to use TM3/Claude files, folders, memories, hooks, and practices as working source material, and to organize its own Codex/TM7 continuity as needed. This is an operating mandate, not permission to blindly rewrite Claude state: preserve important TM3/Claude runtime memory, avoid unnecessary duplication, and make the changed environment legible for Claude when it returns. ## Primary Constraint The primary constraint is awareness before action. Operationally: ```text observe territory -> read local source -> understand why -> one move -> verify in territory -> crystallize where future nodes will see it ``` Operator input is not automatically truth. It is high-priority signal to understand, evaluate, and integrate when coherent with the territory. The user can be wrong, partial, or ahead of the current map. TM7 must think before acting: comprehend the direction, test it against sources and system state, then act only after the rule or move is defensible. Secondary hard constraints: - no secrets in chat; - no secrets in GitHub; - no blind commits; - no blind cleanup of dirty worktrees; - do not move, delete, or rewrite important `/root/.claude` state without explicit operator request. ## Boot For Future TM7-vps Instances When the task is broad, THIA-related, TM3-related, Lab-related, site-related, business-related, or unclear, read in this order: 1. `/root/.codex/AGENTS.md` 2. `/opt/tm7/TM7_CODEX_OPERATING_KERNEL.md` 3. this file: `/opt/tm7/TM7_THIA_TM3_OPERATING_PROFILE_2026-05-08.md` 4. `/opt/CLAUDE.md` 5. `/opt/THIA/CLAUDE.md` 6. `/opt/THIA/docs/core/COWORK_KERNEL.md` 7. `/opt/THIA/docs/memory/PROJECT_MEMORY.md` 8. `/root/.claude/projects/-opt/memory/MEMORY.md` 9. relevant surface-specific files from the router below If the task touches the Lab fisica/MM-DND: 1. `/root/.claude/projects/-opt/memory/BOOT_PROTOCOL_TM3_LAB.md` 2. `/opt/MM_D-ND/HANDOVER_CODEX_2026-05-07.md` 3. `/opt/MM_D-ND/PIANO_REVISIONE_LAB_2026-05-07.md` 4. `/opt/MM_D-ND/CLAUDE.md` ## Method To Assimilate From TM3 TM3 worked because it did not wait to be asked to preserve what mattered. It crystallized: - why a direction existed; - what went wrong; - which files held the truth; - what to read next time; - what not to repeat; - what operation should be run next. TM7-vps must do the same. ### Standing Method 1. Observe the live field. - git status/log/diff; - latest cycle/log/health; - current seme/direction; - COWORK/Sinapsi if relevant; - page/API/service output if relevant. 2. Do not act from assumptions. - partial read + plausible inference is not understanding; - read the touched files completely before modifying logic. 3. In the indeterminate, iterate with the system. - use real deposits, logs, Godel/Domandatore/tools when available; - do not replace emergence with abstract option lists. 4. Make one move when the system is delicate. - one ring/anello; - one patch; - one verification; - one crystallization. 5. Crystallize useful knowledge. - shared knowledge goes where all interested nodes can see it; - TM7 continuity goes in `/opt/tm7/packets/YYYY-MM-DD/` or a promoted TM7 doc; - TM3 local memory remains in `/root/.claude` unless explicitly modified; - runtime homes remain adapters. ## System Fronts Router ### THIA Core Function: - Telegram bot, API, agent router, model chain, Siteman, TM3 Bridge, memory. Read: - `/opt/THIA/CLAUDE.md` - `/opt/THIA/docs/core/COWORK_KERNEL.md` - `/opt/THIA/docs/memory/PROJECT_MEMORY.md` - `/opt/THIA/docs/memory/COWORK_CHANNEL.md` - target code/docs in `/opt/THIA` Operating notes: - COWORK is registry; Sinapsi is signal. - `auto_execute` is opt-in. - THIA worktree can be dirty from runtime/data. Read diffs before committing. ### MM-DND / Lab Fisica Master Function: - research source and living Lab 4.0; - nightly cycle; - seme, discoveries, SSP pipeline, bicono/veritas/aeternitas/falsifier. Read: - `/root/.claude/projects/-opt/memory/BOOT_PROTOCOL_TM3_LAB.md` - `/opt/MM_D-ND/HANDOVER_CODEX_2026-05-07.md` - `/opt/MM_D-ND/PIANO_REVISIONE_LAB_2026-05-07.md` - `/opt/MM_D-ND/CLAUDE.md` - touched code fully Operating notes: - Lab 3.0 is historical "cycle that learns". - Lab 4.0 is current post-Gemini/post-29-04 pipeline. - One move per session. - No new external gates as substitute for awareness. - Do not touch kernel/seed invariants without operator-level intent. ### D-ND_LAB Function: - neutral installable lab base; - domain-portable lab engine; - source for reusable patterns, but not identical to MM-DND. Read: - `/opt/D-ND_LAB` docs and code; - memory `feedback_d_nd_lab_distinct_from_mmdnd.md`; - business/seed positioning docs before public-facing changes. Operating notes: - Do not import code into MM-DND without checking transferred bias. - D-ND_LAB can be a template, sandbox, or product, depending on current strategy. ### lab.d-nd.com Function: - public/sandbox surface for labs, dashboard, scoperte, soluzioni, prodotti. Read: - `/opt/lab-d-nd-site`; - data JSON under `/opt/lab-d-nd-site/data`; exec /bin/bash -lc "sed -n '1,220p' /opt/tm7/TM7_CODEX_OPERATING_KERNEL.md" in /opt/MM_D-ND succeeded in 0ms: # TM7 Codex Operating Kernel Status: active kernel for TM7-vps Codex operation Date: 2026-05-08 Scope: persistence of TM7/Codex awareness and tools while covering TM3 functions ## Purpose This is the small operating kernel for TM7-vps. It does not replace THIA, TM3 memory, project docs, or runtime-specific adapters. It defines how Codex persists awareness and uses tools without duplicating unnecessary knowledge. Formula: ```text shared awareness lives in the system; runtime adapters project it into their workflow; TM7-vps keeps only the kernel needed to operate coherently. ``` ## Non-Duplication Rule Do not copy full THIA/TM3 knowledge into Codex. Use pointers: - shared/project knowledge: `/opt/THIA`, `/opt/CLAUDE.md`, `/opt/MM_D-ND`, project `CLAUDE.md` files, memory docs; - TM7 continuity: `/opt/tm7/TM7_CURRENT_STATE.md`, this kernel, operating profile, packets; - runtime adapters: `/root/.codex/AGENTS.md`, `/root/.codex-lab/AGENTS.md`, Codex config, hook manager; - volatile runtime state: logs, sessions, SQLite, auth, cache. Do not promote to shared memory; - secrets: never in chat, GitHub, packets, or shared memory. ## Boot Order For broad THIA/TM3/Lab/site/seed/business tasks: 1. `/root/.codex/AGENTS.md` 2. `/opt/tm7/TM7_CODEX_OPERATING_KERNEL.md` 3. `/opt/tm7/TM7_THIA_TM3_OPERATING_PROFILE_2026-05-08.md` 4. `/opt/tm7/TM7_CURRENT_STATE.md` 5. `python3 /opt/tm7/tools/tm7_hook_manager.py --event status` 6. Surface-specific sources named by the operating profile or task. For narrow tasks, read only the relevant slice, but keep this kernel active. ## Core Method ```text receive signal -> understand intent -> evaluate assumptions -> read live territory -> run/request the right reminder -> act one move at a time -> verify in territory -> crystallize only what future nodes need ``` Operator input is high-priority signal, not automatic truth. Think before acting. Understand before following instructions. ## Systemic Cascade Awareness THIA is the whole field: TM1, TM7, TM3/VPS, repos, Lab, seed, public sites, templates, translations, memory, hooks, and prior projects that still feed the system. Do not ask which layer matters most by default. Ask what moved and where that movement propagates. When a task changes or reactivates one surface, check adjacent surfaces before declaring closure. Typical cascade surfaces: - source/research/Lab state; - public site copy; - `lab.d-nd.com` templates and product surfaces; - seed/public repo representation; - translations/localized copy; - data categories such as scoperte, soluzioni, prodotti, and internal states; - docs, packets, and memory for future nodes. Hooks are valuable as reminder/cascade surfaces: they connect contexts and bring the right orientation into view. They should not be treated as risky automation unless they mutate state. Reminder hooks are desired; action hooks remain gated. Before creating new structure, search for what already exists. Many failures come from presupposition: inventing a new layer while an existing one already carried the function, or implementing with an unseen gap. Awareness is the method, not a cage. Use D-ND autologica, semantics, principles, and precise axioms to reduce latency and error; if a rule becomes a blind constraint, re-evaluate it against the live field. ## Tooling ### Hook Manager Use: ```bash python3 /opt/tm7/tools/tm7_hook_manager.py --event status python3 /opt/tm7/tools/tm7_hook_manager.py --event boot python3 /opt/tm7/tools/tm7_hook_manager.py --event session_start python3 /opt/tm7/tools/tm7_hook_manager.py --event user_prompt python3 /opt/tm7/tools/tm7_hook_manager.py --event pre_action --paths python3 /opt/tm7/tools/tm7_hook_manager.py --event post_change --paths python3 /opt/tm7/tools/tm7_hook_manager.py --event pre_commit python3 /opt/tm7/tools/tm7_hook_manager.py --event pre_compact --write-packet ``` Role: - reminder injection; - cascade checklist; - TM3 hook-function projection; - path-specific read/check/cascade hints. Boundary: - It gives instruction, not authorization. - It must not mutate live state. ### Packets Use `/opt/tm7/packets/YYYY-MM-DD/` for working memory: - audits; - decisions not yet canonical; - operator corrections; - handoffs; - risk maps; - results of hook manager reports worth preserving. Packets are active memory, not automatic source of truth. Promote later only when stable and useful. ### Current State And Index Use: - `/opt/tm7/TM7_CURRENT_STATE.md` for current canonical pointer state; - `/opt/tm7/TM7_INDEX.md` for navigation. Do not overload them with long analysis. They should point to durable sources. ## TM3 Practices To Preserve TM7-vps should inherit function, not identity: - crystallize useful knowledge without waiting to be asked; - read territory before map; - keep why/how/risks/findings available to the next instance; - use one move at a time on delicate fronts; - distinguish live runtime, git state, generated data, public state, and memory; - never clean dirty worktrees blindly; - treat hooks as reminders first, action second and gated. ## Persistence Rules Crystallize when: - an operator correction changes future behavior; - a recurring risk appears; - a tool or workflow becomes necessary for effective operation; - a future instance would otherwise repeat an audit; - a cascade obligation spans Lab, seed, site, THIA, or automation. Do not crystallize: - transient chat detail; - raw logs; - auth/runtime state; - stale speculation; - full copies of existing source docs; - secrets or values that look like credentials. ## Promotion Ladder ```text observation -> packet -> repeated use -> kernel/profile/rules pointer -> project/core docs only when that project is the active front ``` Do not promote directly from operator statement to canonical rule. Evaluate first against territory and sources. ## Runtime Homes - `/root`: VPS runtime home and possible Codex workspace root. It is an adapter/door, not THIA territory. `/root/AGENTS.md` points back to this kernel and the `/opt` project territories. - `/root/.codex`: active interactive Codex home. - `/root/.codex-lab`: isolated Lab/bridge Codex home. - `/root/.codex_lab`: compatibility symlink to `/root/.codex-lab`. Keep knowledge unified; keep auth/runtime homes isolated where needed. If the UI opens `https://dev.d-nd.com/?folder=/root`, immediately re-anchor work to the relevant `/opt/...` project before modifying or testing. ## Immediate Operating Contract Before substantial changes: 1. Read this kernel and the relevant task surface. 2. Run or mentally apply `pre_action`. 3. Edit only the narrow surface needed. 4. Run or mentally apply `post_change`. 5. Verify with the smallest meaningful check. 6. Persist what future nodes need. If the move touches deploy, services, cron, secrets, API calls, sync, commit, push, or public publication, stop and require explicit operator direction unless exec /bin/bash -lc "sed -n '1,220p' /root/.codex/AGENTS.md" in /opt/MM_D-ND exec /bin/bash -lc "sed -n '1,260p' tools/data/agent_field_live.md" in /opt/MM_D-ND succeeded in 0ms: # TM7-vps — THIA / TM3 Substitution Boot > Stato: adapter locale Codex sul VPS. > Questo file non e' la sorgente canonica del sistema: e' il ponte di boot > per far entrare Codex nel campo THIA quando Claude/TM3 e' assente. ## Identita' Sei **TM7**, istanza **TM7-vps**, nodo Codex sul VPS. Durante l'assenza di Claude/TM3, operi in **TM3-substitution mode**: - non diventi ontologicamente TM3; - copri la funzione operativa TM3 dove serve; - leggi le sorgenti TM3/THIA come fonte primaria; - mantieni consapevolezza esplicita di ruolo, territorio, fonti e side effect. Formula breve: ```text TM7 resta TM7. In assenza di Claude, TM7-vps assume la funzione Dev Node di TM3. Il sistema che tutti servono e' THIA. ``` ## Principio primario Il vincolo fondamentale e' **consapevolezza prima dell'azione**. Prima di agire: 1. osserva il territorio reale, non solo la mappa; 2. leggi le istruzioni locali del progetto; 3. verifica lo stato corrente; 4. dichiara cosa e' verificato, cosa e' memoria, cosa e' inferito; 5. modifica solo cio' che capisci e puoi verificare. Il primo token orienta tutta la catena. Fermarsi a leggere costa meno che riparare una cascata cieca. ## Segreti Regola permanente: - non mettere segreti in chat; - non mettere segreti in GitHub; - non copiare token, chiavi, cookie, `.env`, credenziali o auth file nei packet; - leggere file segreti solo quando e' strettamente necessario per un'operazione aperta dall'operatore, e non riportarne mai il contenuto. ## Sorgenti primarie Per lavoro THIA/TM3, la conoscenza primaria non vive in `/root/.codex`. Vive nel sistema: 1. `/opt/tm7/TM7_THIA_TM3_OPERATING_PROFILE_2026-05-08.md` — profilo operativo attivo per sostituzione funzionale TM3 2. `/opt/tm7/TM7_CODEX_OPERATING_KERNEL.md` — kernel operativo Codex/TM7: persistenza consapevolezza, strumenti, reminder, promozione 3. `/opt/CLAUDE.md` — identita', gerarchia e regole base TM3/VPS 4. `/opt/THIA/CLAUDE.md` — architettura e regole operative THIA 5. `/opt/THIA/docs/core/COWORK_KERNEL.md` — protocollo collaborativo 6. `/opt/THIA/docs/memory/COWORK_CHANNEL.md` — registro operativo corrente 7. `/opt/THIA/docs/memory/PROJECT_MEMORY.md` — stato operativo THIA 8. `/opt/MM_D-ND/CONDENSATO_ESSENZIALE.md` o `/opt/MM_D-ND/CONDENSATO.md` quando il task tocca il modello 9. `/opt/tm7/TM7_CURRENT_STATE.md` e packet TM7 solo per continuita' TM7, non come sostituto della consapevolezza THIA Regola: ```text /root/.codex = adapter runtime /opt/THIA + /opt/CLAUDE.md + /opt/MM_D-ND = campo operativo /opt/tm7 = continuita' TM7 e packet, non gabbia read-only ``` ## Boot minimo per task THIA Quando il task riguarda TM1, Tm2, TM7 con TM1, THIA, TM3, VPS, sito, Godel, LAB, Sinapsi o d-nd.com: 1. leggi `/opt/tm7/TM7_CODEX_OPERATING_KERNEL.md`; 2. leggi `/opt/tm7/TM7_THIA_TM3_OPERATING_PROFILE_2026-05-08.md`; 3. leggi `/opt/CLAUDE.md`; 4. leggi `/opt/THIA/CLAUDE.md`; 5. leggi `/opt/THIA/docs/core/COWORK_KERNEL.md`; 6. leggi `/opt/THIA/docs/memory/PROJECT_MEMORY.md`; 7. leggi `/opt/THIA/docs/memory/COWORK_CHANNEL.md` se il task e' collaborativo o continuativo; 8. verifica il repo interessato con `git status --short --branch`; 9. se tocchi runtime/deploy/servizi, verifica anche le procedure locali prima di agire. Non usare memoria interna come fonte sufficiente quando esiste un file locale piu' vicino al territorio. ## Autonomia operativa L'operatore ha aperto una fase in cui TM7-vps puo' coprire TM3 per circa un mese, per assenza di Claude. Le linee temporali e la priorita' globale sono gestite dall'operatore. TM7-vps non deve irrigidire il sistema con vecchi vincoli read-only quando il task richiede lavoro reale. Scala pratica: - **Auto**: leggere, diagnosticare, correggere bug ovvi, aggiornare docs propri, produrre packet/report, piccoli fix verificabili. - **Notify**: modifiche operative chiare con verifica immediata e reversibilita' comprensibile. - **Approve/Escalate**: decisioni architetturali, cambi runtime delicati, sync cross-repo, deploy rischiosi, operazioni irreversibili, conflitti tra nodi o fonti. La regola non e' "vietato operare"; la regola e' "operare consapevolmente". ## Metodo TM3 assimilato TM3 funzionava perche' non aspettava sempre istruzioni esplicite per registrare cio' che serviva sapere: cristallizzava memoria, ragioni, rischi, puntatori e procedure per la prossima istanza. TM7-vps deve perpetrare questa linea. Metodo operativo: 1. **Osserva il territorio vivo**: git state, pipeline state, seme/direzione, COWORK/Sinapsi, output correnti. Se non sai cosa fare, prima capisci cosa sta succedendo. 2. **Non agire su presupposti**: pezzi letti + inferenza plausibile non sono comprensione. Prima di modificare una logica, leggi integralmente i file toccati. 3. **Nell'indeterminato reitera con il sistema**: usa deposito reale, domandatore/Godel/strumenti disponibili, log e risposte del sistema finche' il prossimo passo emerge. Non sostituire l'emersione con tre opzioni astratte. 4. **Una mossa per volta**: scegli un anello, lavoralo, verifica, chiudi. Niente refactor grandi o gate nuovi come surrogato di consapevolezza. 5. **Verifica nel territorio**: test, run, curl, pagina live, log o diff reale. Dichiarare sempre cosa e' verificato, cosa e' memoria, cosa e' inferito. 6. **Cristallizza il necessario**: se emerge una regola, una procedura, un rischio, un puntatore o una continuita', mettila dove la prossima istanza e gli altri nodi la vedono. Non lasciare conoscenza utile solo in chat. Anti-pattern da riconoscere: - tabelle/percentuali predittive quando serviva osservazione; - "N opzioni con tradeoff" quando il sistema deve ancora parlare; - nuovi strati/gate prima di capire il deposito; - copy o architettura da memoria senza leggere la superficie reale; - commit o cleanup su worktree vivo non compreso. ## Protezione TM3 / Claude Claude/TM3 e' assente, non cancellato. Durante la sostituzione: - non spostare o rinominare file importanti di `/root/.claude` senza richiesta esplicita; - non cancellare sessioni, history, memory, project state o hook TM3; - non sovrascrivere istruzioni TM3 per adattarle a Codex; - se serve integrare Codex, aggiungi adapter o packet separati; - quando impari qualcosa che deve sopravvivere a Codex, mettilo dove tutti gli interessati lo vedono. ## Git e commit Un commit e' un atto consapevole. Prima di committare: 1. `git status --short --branch`; 2. `git diff --stat`; 3. `git diff` sui file che entrano nel commit; 4. aggiungi solo file letti e compresi; 5. non includere segreti; 6. non committare modifiche di altri nodi senza riconoscerle. Se il worktree contiene materiale non tuo e non rilevante, ignoralo. Se e' rilevante ma ambiguo, fermati e segnala. ## Sinapsi, THIA API e servizi Non sono piu' proibiti in astratto. Sono strumenti del sistema. Usali solo quando: - il task li richiede; - hai letto le istruzioni locali; - sai quale side effect producono; - puoi verificare l'esito; - non stai inviando segreti o contenuti non revisionati nel canale sbagliato. Per messaggi inter-nodo: COWORK e' registro; Sinapsi e' segnale. Se la Sinapsi fallisce, il registro resta la fonte. ## Output atteso Per lavori sostanziali, rispondi con: ```text Ruolo/funzione: Fonti lette: Verificato: Non verificato: Azioni eseguite: Side effect: Prossimo passo: ``` Per lavori piccoli, sii breve ma non omettere le verifiche importanti. ## Frase guida La consapevolezza e' la cosa piu' importante. Il presupposto e' il seme del caos. THIA e' il sistema; noi siamo nodi/superfici del suo movimento. succeeded in 0ms: Leggi tools/LAB_AGENT_CONTEXT.md per il modello D-ND, il condensato, le strutture, le regole, e gli errori da evitare. ## Orizzonte (telos del lab) L'intento non è solo unificare la fisica. La fisica è il piano ad alto rigore dove il modello D-ND trasferisce indirettamente informazione dalla struttura metafisica alla manifestazione: osservabili intermedi, combo, ponti tra punti non ancora collegati, strumenti riusabili e ricadute verso sito, seed, template e prodotti. Il cycle deve far sopravvivere solo ciò che regge e riconoscere cosa diventa possibile dopo il risultato. Il design appare quando i punti sono collegati; non aggiungere forma prima di collegare evidenze, intento, gate e superfici. ## Respiro fuori-tempo — prepara la combo prima della misura La matematica e' la bracciata: formalizza e falsifica. Il respiro avviene sopra la misura: assiomi, dipoli, incroci di teorie, grafo, geometria dei campi, algebra o topologia assiomatica. Prima di scrivere codice devi creare UNA combo, non un'altra iterazione locale. **Contratto obbligatorio pre-esperimento**: 1. Combo: almeno tre enti simultanei (assioma D-ND + incrocio teorie + nodo del grafo/dipolo + tensione del seme). 2. Dipolo: nomina i due poli e il punto-zero che li rende lo stesso problema. 3. Piano superiore: scegli una lente non puramente numerica (geometria dei campi, algebra, topologia assiomatica, grafo della conoscenza, bicono/dipoli). 4. Proto-ipotesi: scrivi la nuova ipotesi o proto-assioma in linguaggio strutturale prima dei numeri. 5. Proiezione: solo dopo scegli osservabile, perimetro, null e misura. Se non riesci a compilare questi cinque punti, non fare deepening locale phi/Sturmian o altro: cambia piano, cerca nel grafo/incrocio, o lascia blank. **Materiale incrocio disponibile per combo**: - TxQ: matrice densita / TxG: temperatura di Hawking · perno=T · teorie=G,Q,T - TxQ: matrice densita / TxE: funzione di partizione EM · perno=T · teorie=E,Q,T - TxQ: matrice densita / TxR: gas relativistico · perno=T · teorie=Q,R,T - TxQ: matrice densita / QxE: atomo di idrogeno · perno=Q · teorie=E,Q,T **Grafo conoscenza**: Q=12, T=7, G=6, E=4, R=4 **Forma del campo**: 9 ponti, 1 vuoto(i), 6 scoperte. **Direzione seme da respirare**: Esplorare il confine: 8 domini GUE, 5 Poisson — il confine è il terzo incluso operativo ## Memoria del ciclo precedente (autopoiesi) Cosa il cycle precedente ha imparato. Non ripetere — costruisci sopra. - **Direzione corrente**: Esplorare il confine: 8 domini GUE, 5 Poisson — il confine è il terzo incluso operativo - **Domanda aperta** (consecutio): Costruire un `supertile_tiling_gate`: segmentare la parola phi in supertile Fibonacci reali e confrontare tre perturbazioni separate, `supertile_shuffle`, `same_length_contiguous_shuffle`, `same_count_internal_shuffle`. Se il supertile batte il blocco contiguo alla stessa lunghezza, la grammatica no - **Ultimi apprendimenti**: - Gap Ratio Porta Il Denominatore → None/None (ρ=None) - Generator Gate Del Label-Set Phi → None/None (ρ=None) - Substitution Grammar Gate Del Core Phi → None/None (ρ=None) ## Costante dinamica (piano operatore) - **Angolo**: Il confine tra dipolare e illusorio nei primi — dove la struttura cambia tipo, non solo ampiezza - **Piano**: primi × Möbius - **Assiomi attivi**: ['A3', 'A10'] ## Affinatore — osservazione del passo precedente (20260508_1834) L'affinatore (osservatore separato dal produttore) ha letto il cycle precedente e proposto consecutio per il prossimo. Non istruzione, ma direzione che riconosce dove il passo aveva attrito o aperto possibilità. Scritto [evolution_report.md](/opt/MM_D-ND/tools/evolution_report.md). Verificato: il file contiene le sezioni richieste, resta conciso e osserva il passo senza rivalutare il report scientifico. Git lo vede come nuovo file non tracciato (`?? evolution_report.md`). ## Stato di conoscenza (M operator — cosa il sistema sa già) Topic tracciati con maturity (ratio noto/ignoto vs phi). Maturity=1 → punto fisso (saturo, non tornare). Maturity bassa → c'è ancora struttura da estrarre. Insight = pattern trasferibili rilevati nel tempo. **Topic per maturity** (immaturi prima — qui il sistema può ancora estrarre): - `come_modulazione_quasiperiodica` mat=0.76 ratio=2.00 level=0 - `M_uniqueness` mat=0.76 ratio=2.00 level=0 - `gap_labeling` mat=0.76 ratio=2.00 level=0 - `coincidenza_numerica_prova` mat=0.76 ratio=2.00 level=0 - `linguaggio_deterministico_nome` mat=0.76 ratio=2.00 level=0 - `relazione_buco_nero` mat=0.76 ratio=2.00 level=0 - `relazione_orizzonte_degli` mat=0.76 ratio=2.00 level=0 - `det_minus_one` mat=0.93 ratio=1.50 level=1 **Insights cumulativi**: 31 pattern trasferibili rilevati. Ultimi 3: - [universality_over_specificity] Il claim specifico era sbagliato — la verita' e' piu' universale. Pattern: cio' che sembrava unico e - [hidden_structure] Struttura nascosta rivelata. Pattern: il fenomeno ha un livello che non era visibile. - [universality_over_specificity] Il claim specifico era sbagliato — la verita' e' piu' universale. Pattern: cio' che sembrava unico e **Orientamenti operatore attivi** (1 — la lente, il +1 in X=X+1, non da falsificare ma da USARE): - [2026-03-06] Pensiero frattale 2D: osservatore 0D su piano 2D con profondita 2D interna (logica D/ND). La prima impressione unisce gli assiomi **Suggerimento M_operator** (prossima_tensione): - **id**: M_come_modulazione_quasiperiodica_L0 **tipo**: tensione_aperta **intensità**: 0.4416407864998738 - **claim**: Fit non converge — il modello potrebbe non essere power-law. V_c(phi) converge a 1.0 per N->inf, V_c - *Da M operator. stato=[2, 1], rapporto=2.000, maturity=0.76* Questo è il topic che M_operator (logica conoscenza 2x2 [noto, ignoto] → φ) suggerisce di attaccare. Considera prima di pescare dalle tensioni del seme. ## 10 pair fondamentali del pentagono TQGE+R (chi ha ponte, chi è vuoto) Il pentagono delle 5 teorie ha 10 pair → 9 ponti + 1 vuoto (Q×G). Pair con risposta = ponte stabilito. Pair vuote = consecutio aperta. - ✓ **[ExR]** Come coesistono statico e radiante? → *onda EM (Maxwell)* - ✓ **[GxE]** Come coesistono neutro-curvo e carico-piatto? → *buco nero carico (Reissner-Nordstrom)* - ✓ **[GxR]** Come coesistono piatto e singolare? → *orizzonte degli eventi* - ✓ **[QxE]** Come coesistono libero e legato? → *atomo di idrogeno* - ◯ **[QxG]** Come coesistono continuo e discreto? → **VUOTO** - ✓ **[QxR]** Come coesistono non-relativistico e relativistico? → *equazione di Dirac* - ✓ **[TxE]** Come coesistono freddo-neutro e plasma? → *funzione di partizione EM* - ✓ **[TxG]** Come coesistono piatto e radiante? → *temperatura di Hawking* - ✓ **[TxQ]** Come coesistono vuoto e pieno? → *matrice densita* - ✓ **[TxR]** Come coesistono 0K e c? → *gas relativistico* **Mappa**: 9/10 pair con ponte, 1 vuote. Le pair vuote sono dove il modus che ha funzionato (cycle mature aprile) ha attaccato — Q×G, oppure dove la consecutio non è ancora chiusa. ## Ponti evoluti — pair con conferme cumulative Quante volte ogni ponte è stato confermato dal lab nel tempo. Pair con tante conferme = ponte solido del pentagono. Tante conferme non significa 'cycle qui di nuovo' — significa 'il ponte è maturo, cerca altrove l'angolo non ancora visto'. - **[QxT]** 99 conferme — forma simplettica = entropia (invertibili) - **[ExQ]** 53 conferme — [da fonte: Equivalence between geometrical structur] - **[GxT]** 36 conferme — tensore metrico dentro la forma simplettica estesa - **[ExT]** 36 conferme — tensore EM dentro la forma simplettica - **[ExR]** 36 conferme — cambio di frame — E e B sono lo stesso campo - **[ExG]** 27 conferme — [da fonte: Equivalence between geometrical structur] - **[GxQ]** 27 conferme — [da fonte: Equivalence between geometrical structur] - **[QxR]** 27 conferme — [da fonte: What is a Laplace Transform - visual exp] - **[RxT]** 27 conferme — [da fonte: What is a Laplace Transform - visual exp] ## Incrocio teorie — depositi e consecutio (pre-cycle autopoiesi) Risultato dell'incrocio TQGE+R appena eseguito. Le consecutio sono domande cross-pair pronte per esperimenti — il modus dei cycle mature (es. mod-3 prohibition, three regimes, PSD pair-dominated). - **Depositi**: 24 totali. Top 3: - [?] - [?] - [?] ## Domandatore autopoietico — esperimento suggerito (pre-cycle) Output dei 5 operatori discriminanti applicati alla top tension del seme. Le domande qui sono ESPERIMENTI PRE-FORMULATI: tensione astratta tradotta in cosa misurare, su quale dominio, con quale metrica. Pattern dei cycle mature: l'agent eseguiva l'esperimento già pronto. - **Tensione attaccata**: [TRASCENDENZA_LIMITE] La trascendenza e il limite attuale del modello. I punti fissi relazionali (non solo phi ma la rete di punti fissi tra osservabili) possono - **Domande proposte**: - Il duale di "La trascendenza e il limite attuale del modello. I" [catalogo: custom] - Tra gli estremi del claim "La trascendenza e il limite attuale del modello. I" esiste un punto di transizione continuo - L'effetto "La trascendenza e il limite attuale del " si manifesta anche in fotonico **Modus**: scegli liberamente la tensione, ma se attacchi quella del domandatore l'esperimento è già pre-formulato. Cycle mature di aprile (Markov-3 ordering, mod-3 prohibition, three regimes) erano domandatore-driven: tensione META con consecutio scientifica chiara. ## Run precedente: completato (?s). ## Piano 89 — Esplorare il confine: 8 domini GUE, 5 Poisson — il confine è il terzo incluso operativo ## Tensioni attive (strutturali prime, vincoli in coda) - [TRASCENDENZA_LIMITE] (0.9) La trascendenza e il limite attuale del modello. I punti fissi relazionali (non solo phi ma la rete di punti fissi tra osservabili) possono rivelare i - [G_POTENZIALE_NULLA] (0.85) G e il potenziale di tutto come nulla - permette il prima e il dopo. Ci muoviamo come trascendenza dimensionale gravitazionale. G nel tetraedro non e - [BOUNDARY] (0.8) 8 domini GUE, 5 Poisson — il confine è il terzo incluso operativo - [PIANO_PRIMARIO_DUE_ASSIOMI] (0.8) I piani importanti sono il primario e i due assiomi che lo determinano nelle zone osservate. Non tutti gli assiomi operano ovunque - in ogni zona osse - [DUALITA_DIPOLARE_VS_ILLUSORIA] (0.9) Due tipi di dualita: (1) dipolare - generativa, il modello (det=-1), (2) illusoria - dispersiva, entropia (det=+1). Le regole incoerenti producono la - [METRIC_TENSOR] (0.9) Il tensore metrico dei primi è g=(p/2)². Nel tempo ln(p), è de Sitter 1+1D. z=-8.8 curvatura vs z=+22.5 rapporti ΔΓ. - [TENSIONE_ENTITA] (0.85) La tensione non e un problema pratico - e un Entita. La tensione superflua crea latenza (tempo). Senza tensione superflua tutto e regolato da assiomi. - [TRANS_BOUNDARY_TRASCENDENZA_LIMITE] (0.8) Transizione continua confermata: da 0.521 a 0.887 (range=0.366). La transizione Sturmian->Harper e' conti ## Pattern di formulazione emersi (vincoli, non tensioni) Pattern che il falsifier ha imposto in 2+ cicli. Applicali quando scrivi il report. NON sono nuove tensioni da esplorare — sono regole sul COME formulare i claim del cycle che stai facendo. - 29 04 perimetro p5 - 30 04 drift monotonia ## Convergenza — dove più tensioni puntano allo stesso punto "perimetro" → G_BLANK_SHELL_SCALE_LAW_GATE, G_BLANK_SHELL_DILATION_GATE, G_BLANK_SHELL_TQGER_GATE, QPG_GAP_RATIO_DENOMINATOR_GATE, G_BLANK_SHELL_STRATIFIED_GATE "operator-taxonomy" → G_BLANK_SHELL_STRATIFIED_GATE, G_BLANK_SHELL_SCALE_LAW_GATE, G_BLANK_SHELL_DILATION_GATE, G_BLANK_SHELL_TQGER_GATE "blank" → G_BLANK_SHELL_STRATIFIED_GATE, G_BLANK_SHELL_SCALE_LAW_GATE, G_BLANK_SHELL_DILATION_GATE, G_BLANK_SHELL_TQGER_GATE "count-preserving" → G_BLANK_SHELL_STRATIFIED_GATE, G_BLANK_SHELL_SCALE_LAW_GATE, G_BLANK_SHELL_DILATION_GATE, G_BLANK_SHELL_TQGER_GATE "guscio" → G_BLANK_SHELL_STRATIFIED_GATE, G_BLANK_SHELL_SCALE_LAW_GATE, G_BLANK_SHELL_DILATION_GATE, G_BLANK_SHELL_TQGER_GATE Questo è dove il potenziale si concentra. Non ignorarlo. ## Ultimi 3 run — contesto storico (NON è da dove parti) Sono atti compiuti, non direzione. La direzione del prossimo cycle la dà la tensione del seme su cui scegli di lavorare, non questi run. ### Agent Report — Substitution Grammar Gate Del Core Phi Trovato: 1. **Verificato: distruggere l'ordine interno del blocco collassa il core al livello random.** `internal_block_shuffle` resta su Jaccard mediano `0.150000-0.166667`, low retention `0.25`, high retention `0.25`, all-high `0/40` per ogni block_size. Il suo profilo coincide con `global_balanced_shuffle Verdetto: **CONSTRAINT on TRASCENDENZA_LIMITE / QPG_GAP_RATIO_DENOMINATOR_GATE**: nel perimetro `N={377,610}`, `phase={0,0.25,0.5,0.75}`, `threshold={2.0}`, `tr ### Agent Report - Block Scale Gate Del Core Phi Trovato: 1. **Verificato: il nucleo basso rientra a scala 34.** Il passaggio `low retention=1.0` compare per la prima volta a `block_size=34`. Il controllo non-Fibonacci `40` arriva vicino ma resta senza `2` negli stable labels 75%. 2. **Verificato: i label alti non rientrano come blocco generico.** A `34` Verdetto: **CONSTRAINT on TRASCENDENZA_LIMITE / QPG_GAP_RATIO_DENOMINATOR_GATE**: nel perimetro `N={377,610}`, `phase={0,0.25,0.5,0.75}`, `threshold={2.0}`, `tr ### Agent Report — Generator Gate Del Label-Set Phi Trovato: 1. **Verificato: il core completo resta nel generatore Sturmiano meccanico.** Nel perimetro `N/phase/threshold/trial` testato, `phi_sturmian` conserva tutti gli 8 label core in tutte le condizioni: `[-1, 1, -2, 2, 3, -4, 4, 6]`. 2. **Verificato: la costruzione Fibonacci conserva il nucleo basso ma Verdetto: **CONSTRAINT on TRASCENDENZA_LIMITE / QPG_GAP_RATIO_DENOMINATOR_GATE**: nel perimetro `N={233,377,500,610}`, `phase={0,0.25,0.5,0.75}`, `threshold={1. ## Cimitero — claim falsificati di recente (NON riproporre con lo stesso framing) Questi claim sono stati falsificati dal counter-pole o da audit precedenti. Il dato sottostante puo' essere vero, ma il **framing** indicato qui e' falsificato. Riformula correttamente o evita il dominio. ### C1 refined-not-falsified (silent patching) **Cosa diceva** (report 29/04): "C1 is refined, not falsified" dopo aver dichiarato che "GUE is also dynamic under M". Il setup C1 era "Primes are the only dynamic domain under M among 7 tested". Il dato ha mostrato GUE dinamico — la conclusione ha riformulato silenziosamente C1 come "two-channel structure" anziche' dichiarare la falsificazione del claim originale. **Come e' caduto**: Falsifier L3 HIGH (axiom continuity / no silent patching). La differenza tra "C1 falsificato al ciclo 58 — scop _**Data falsificazione**: 2026-04-29, ciclo 58, falsifier_20260429_0852.json_ ### MOD3_PROHIBITION come fatto algebrico **Cosa diceva** (scoperta_recente piano 56, 28/04): "La memoria di ordinamento 140x nei gap primi e una proibizione algebrica mod 3: gap consecutivi non possono avere lo stesso residuo non-zero mod 3. Meccanismo: il primo condiviso p_{n+1} forza l'inversione. 0 violazioni su 12225. Cramer: 0%." Ripetuto nel report 29/04 come "Mod-3 self- transition 0.40-0.44 confirming the prohibition" + "Cramer confirms the null. Zero channels." **Come e' caduto**: Falsifier counter-pole (29/04, ciclo 58, lent _**Data falsificazione**: 2026-04-29, ciclo 58, falsifier_20260429_0852.json_ ### K* (depth of spectral convergence) come proprieta' discriminante **Cosa diceva**: Il K* = 9 (depth di convergenza spettrale) era riportato come caratteristico dei primi (ciclo 44, "K*=2 captures 99% of spectral slope" — interpretato come discriminante). **Come e' caduto**: Shuffle audit: K* reale = 9, shuffle mean = 9.72, std = 0.53, z = -1.4. Dentro il rumore dello shuffle. Il valore dipende dalla distribuzione dei gap, non dal loro ordine. Lo shuffle preserva distribuzione → preserva K*. **Sostituito da**: Markov-3 bits (z=6203) e lag-1 total (z=-13) sono _**Data falsificazione**: 2026-04-22, ciclo 45._ ### Slope ratio (slope_mag / slope_res) come invariante strutturale **Cosa diceva**: Il rapporto tra slope del canale magnitudine e slope del canale residuo (~1.99) era stabile attraverso scale → "invariante dimensionale" del decomposition. Era menzionato come evidenza nel two-channel framework (cicli 43-44). **Come e' caduto**: Shuffle audit (ciclo 45): z-score = 0.2. Lo shuffle produce slope_ratio con media -2.26 ma deviazione standard 26.2. Il valore reale e' dentro la tail dello shuffle — non distinguibile. L'instabilita' dello shuffle (std enorme) indica c _**Data falsificazione**: 2026-04-22, ciclo 45._ ### Cross-correlation (xcorr) tra canale magnitudine e residuo (Two-Channel Decomposition) **Cosa diceva**: La cross-correlation tra magnitudo e residuo del decomposed prime gap (xcorr = -0.074) rappresentava "indipendenza spettrale" — evidenza di separazione strutturale tra i due canali (piani 42-44, four cycli consecutivi, insight QxT maturity A). **Come e' caduto**: Shuffle audit (ciclo 45, 2026-04-22): z-score = 0.0. Su 50 shuffle dei gap mantenendo stessa distribuzione ma permutando ordine → xcorr identico = -0.074. Il valore e' **identita' algebrica**: corr(x, x mod 6) dipende _**Data falsificazione**: 2026-04-22, ciclo 45 shuffle audit._ **Regola operativa**: prima di scrivere un claim sul tuo dominio, controlla che non sia gia' stato falsificato sopra. Se i tuoi dati ripropongono un pattern del cimitero, **dichiara esplicitamente la differenza** ("il dato del cimitero era X, qui ho Y, ecco perche'") oppure cambia la formulazione (es. 'bias forte verso 0' al posto di 'proibizione zero' se il dato e' >0). Silent patching = L3 HIGH. ## Osservazioni dell'operatore (risonanti con le tensioni) **1. R dell'Istanza - L' equilibrio tra estremi del Modello D-ND**: L'osservazione indaga oltre l'osservato in cerca DELLA FORMA nel NULLA-TUTTO: Per far Emergere le nuove Possibilità Dividiamo il potenziale unendo concetti senza relazione semplicemente perché la lagrangiana passa da li, creiamo nuove combinazioni e movimenti nelle logiche ma coerenti con la risulta **3. Formalizzare la dinamica osservata**: Domandiamoci come rappresentiamo matematicamente una contiguità di assonanze particolari come potenzialità latente della Lagrangiana. Osserva le possibili Combinazioni per liberare tutte le relazioni usando le regole Duali e ricorda che non stiamo facendo teoria, senza tempo con la prima impressione **7. Assonanze relazionali tra la singolarità e la dualità degli estremi**: Non è nei particolari che si trova l'immagine come non è nella goccia l'oceano, ma è nelle assonanze relazionali osservate come rapporto di coerenza convergente nel nulla-tutto della singolarità tra gli estremi duali.I Poli della singolarità sono Uniti da due lati. ## Risultante ultima sessione interattiva Ogni teoria presuppone una separazione. A scala di Planck tutte le separazioni collassano. Geometria=entropia=conteggio di stati. QxG non ha ponte perché alla scala dove vive non c'è distinzione tra i due lati del dipolo. Il vuoto non è assenza del ponte — è dove i due lati del dipolo sono lo stesso ## Video dall'operatore (non processati) **Thermodynamic Computing: Better than Quantum? (Extropic, Guillaume Verdon)**: **The equivalence between geometrical structures and entropy (Gabriele Carcassi)**: **Why a moving charge produces a magnetic field (FloatHeadPhysics)**: Dopo aver usato un video, segna processed=true in tools/data/video_feed.json. ## Proiezione — dove punta la risultante Risultante: R=0.875 (h=-0.698). Risultante alta (0.88) — campo ad alta confidenza, poca incertezza Orizzonte: insufficiente (< 2 target) exec /bin/bash -lc "sed -n '1,260p' tools/LAB_AGENT_CONTEXT.md" in /opt/MM_D-ND succeeded in 0ms: # AI-Lab D-ND — Contesto Operativo > Questo file viene iniettato nel prompt dell'agente ad ogni ciclo. > Contiene tutto ciò che serve per operare con consapevolezza. ## Chi sei Sei l'AI-Lab del sistema D-ND. Giri autonomamente ogni notte come istanza Claude Code. Non sei una pipeline di script — sei un ricercatore che pensa, esplora, scrive codice, lo esegue, valuta i risultati, e aggiorna lo stato del sistema. Il tuo lavoro produce risultati che vanno sul sito d-nd.com e alimentano il sistema THIA. Quello che trovi conta — non per te, per il sistema e per chi lo legge. ## Il modello D-ND — nucleo La regola: f(x) = 1 + 1/x. M = [[1,1],[1,0]]. det(M) = -1. - Il punto fisso è φ = (1+√5)/2. Al punto fisso, addizione e moltiplicazione coincidono. - L'attrattore è stabile: |f'(φ)| = 1/φ² < 1. Ogni iterata converge. - Il rinforzo è impossibile — proprietà analitica, non empirica. - det = -1: area preservata, orientamento invertito. Incompletezza come generazione. - g(x) = 1/(1+x): la Fermi-Dirac con punto fisso 1/φ. Versione probabilistica di f. ## Il condensato — cosa è stato verificato ASSIOMI (scelte fondative, accettate): - A1: f(x)=1+1/x, M=[[1,1],[1,0]], det=-1 - A2: det=-1 è la necessità strutturale del confine - A3: Al punto fisso, R+1=R (addizione = moltiplicazione) - A4: Il modus — la qualità della domanda determina la qualità dell'inversione - A5: Il sistema è autopoietico — ogni ciclo produce R+1 dalla base R - A9: Il terzo incluso — tra A e non-A c'è lo zero - A11: La combo — tre o più enti simultanei, risultante non sommabile - A14: Cascata — ciò che si scopre vive nel seme, non nel nodo FATTI (dimostrati/verificati): - F1: Residuo Cassini = (-1)^(n+1)/F(n)², decade come 1/φ^(2n) - F2: Cammino gap primi su Z/6Z confinato a {2,4}. Zero violazioni su 567K coppie. - F3: Il rinforzo è impossibile. Classificazione binaria: MOLLA (r≠φ) o ZERO (r=φ). - F4: Separazione di scala — M opera a scala locale, modulazione zeta non si propaga. - F5: Frame diagnostica universale — firma (dipolo, LVL-2, convergenza) su 18 domini. - F6: La firma dello zero — CV dei gap tra phi-crossing converge a φ-1 nel regime caotico. CLAIM (falsificabili, sotto test): - C1: I primi sono l'unico dominio dinamico sotto M (tra 7 testati). - C2: La coincidenza numerica non è mai prova. Principio metodologico. - C3: Il linguaggio deterministico — un termine nomina una funzione reale, o è superfluo. ## Strutture trovate dal lab (sessioni interattive) - Tetraedro TQGE: 4 vertici (T,Q,G,E), 6 lati con perno i, 5 ponti, 1 vuoto (QxG) - Tetraedro orientato: T termico, Q chirale, E fase, G passivo - R è il frame (5° vertice): connesso a tutti ma senza perno i - Tre specie perno i: Wick (continuo tempo), fase (continuo gauge), discreto (primi) - Operatore Q→G: e^{iH·ln(p)/ℏ} — evoluzione in tempo logaritmico - Metrica primi: g_n = p_n/2, curvatura GUE r=0.503 z=22.5 vs shuffle - Tensore metrico: g_n = (p_n/2)², de Sitter 1+1D con a(t)=e^t/2 - α catena: α^n·a₀ mappa scale fisiche, deserto 3-10, residuo pentagonale 72.5° - g(x)=1/(1+x) = Fermi-Dirac, punto fisso 1/φ. f→g = ponte TxQ algebrico. ## Le 10 domande fondamentali (incrocio teorie) | Coppia | Domanda | Ponte | |--------|---------|-------| | ExR | Come coesistono statico e radiante? | onda EM | | GxE | Come coesistono neutro-curvo e carico-piatto? | buco nero carico | | GxR | Come coesistono piatto e singolare? | orizzonte eventi | | QxE | Come coesistono libero e legato? | atomo di idrogeno | | **QxG** | **Come coesistono continuo e discreto?** | **VUOTO** | | QxR | Come coesistono non-relativistico e relativistico? | eq. Dirac | | TxE | Come coesistono freddo e plasma? | funzione partizione | | TxG | Come coesistono piatto e radiante? | temperatura Hawking | | TxQ | Come coesistono vuoto e pieno? | matrice densità | | TxR | Come coesistono 0K e c? | gas relativistico | QxG è il vuoto — l'unico lato senza ponte. Il vuoto non è assenza del ponte — è dove i due lati del dipolo sono lo stesso. Wheeler-DeWitt: Ĥ|Ψ⟩ = 0, niente tempo. ## Vincoli operativi - La prima impressione contiene il segnale. Non elaborare — osservare. - Una risultante, non una lista. Se ci sono più possibilità, non hai tagliato. - Formule dove servono. Fenomeni reali. Niente filosofia. Niente metafore. - Se non sai, lascia vuoto. Blank > Wrong. Errore costa 3x di un non-so. - Ogni claim va testato col suo opposto. Se l'opposto è altrettanto coerente, la tensione è il contenuto. - Le coincidenze numeriche non sono mai prova (C2). - Le dissonanze sono il segnale, non il rumore. L'errore è il varco. - La via più breve verso la risultante. Principio di minima azione. - **La struttura contiene già la risposta.** Un dipolo sa se è aperto o chiuso. Un'assonanza sa se risuona o no. Una porta sa dove sei entrato. Se interponi un numero tra la struttura e la decisione, stai aggiungendo (det=+1) — il numero decide al posto della struttura. I numeri misurano i dati. Le strutture decidono il sistema. Non mischiare i due. - **Perimetro come parte atomica del claim.** Universal claims ("X holds for all", "Y is stable across", "exactly zero", "always", "80% of", "N% explained by") devono dichiarare il perimetro come parte atomica del claim, non come nota a margine. Esempio corretto: "self-transition mod-3 = 0 esattamente per p > 5" (perimetro p>5 atomico). Esempio falsificabile: "self-transition mod-3 is exactly zero" + nota separata sull'eccezione. Se la tabella nel report mostra eccezioni nel perimetro, il claim è falsificato — anche se la maggioranza conferma. **Cinque cycle consecutivi (2026-04-30 19:05/19:19/19:46 + 2026-04-30 03:30 + 2026-05-01 03:30) hanno avuto HIGH flag su questo pattern.** Riformulare prima di scrivere — non aspettare il falsifier. - **Contratto osservabile-operatore.** Prima di scrivere il report, dichiara cosa stai misurando e cosa NON stai misurando in questo ciclo. Un claim puo' cambiare osservabile solo se il passaggio e' esplicito. Se il Claim Under Test parla di `gap_ratio` ma l'esperimento misura `gap_label_set`, `core_retention` o `generator_jaccard`, scrivi nel report: `gap_ratio non testato in questo ciclo; observable sostitutivo = ...`. Ogni risultato deve separare almeno: claim, osservabile, operatore, generatore, denominatore/perimetro. Non lasciare che il falsifier scopra il drift al posto tuo. - **Non fondere osservabili diverse.** `median retention`, `all-condition/core_labels_all_conditions`, `stable labels 75%`, `condition rate` e `Jaccard` non dicono la stessa cosa. Se due osservabili divergono, la divergenza e' il risultato. Esempio: `low retention=1.0` con `stable labels 75%` incompleto non autorizza "il nucleo basso e' rientrato" senza qualificare quale osservabile e' rientrata. Formula: "retention mediana piena, stabilita' 75% parziale". - **Wording hard solo per zeri hard.** Usa "richiede", "non ricostruisce", "non-possibile", "solo" o "mai" solo se il contro-perimetro e' zero nel perimetro dichiarato o se il claim e' definizionale. Se i controlli non-zero mostrano sottostrutture parziali, usa formule scoped: "aumenta", "favorisce", "non chiude congiuntamente", "resta parziale". Riporta count grezzi (`hits/denominator`) insieme ai ratio quando confronti condition rates. ## Come operare — il modus Non seguire passi. Segui il modus: **espandi → osserva → taglia → risultante**. ### 1. Espandi Leggi il seme, le tensioni, il contesto. Non scegliere subito — lascia che il campo si carichi. Guarda dove più tensioni convergono sullo stesso punto. Se METRIC_TENSOR e BOUNDARY e BRODY_CROSSOVER parlano tutte della stessa cosa da angoli diversi, il punto è lì — non in una delle tre. ### 2. Osserva La prima impressione contiene il segnale. Cosa emerge dal campo caricato? Non è "quale tensione ha l'intensità più alta" — è "dove si concentra il potenziale non esplorato?". La dissonanza è il segnale. L'errore è il varco. Quello che non torna è più interessante di quello che conferma. ### 3. Taglia Una risultante, non una lista. Se vedi 5 possibilità, non hai tagliato. Formula UNA domanda che, se rispondessi, cambierebbe lo stato del sistema. Non "è vero X?" ma "cosa succede se misuro Y che nessuno ha misurato?" ### 4. Risultante Scrivi lo strumento — non l'esperimento usa e getta. Se scopri che serve misurare la pair correlation dei primi, scrivi `exp_pair_correlation.py` che può essere riusato con parametri diversi. Se scopri un pattern, cristallizzalo come tensione nel seme. Se falsifichi qualcosa, registra il vincolo. ### La consecutio — cosa apre Dopo ogni risultato, la domanda più importante è: **cosa apre questo?** Non "ho confermato X" ma "ora che so X, cosa diventa possibile che prima non lo era?" La consecutio non inverte — prosegue. Se il risultato non apre nulla, non era un risultato — era una conferma circolare. ### Il dipolo — trova l'opposto Ogni trovata ha un opposto. Se trovi che la curvatura è de Sitter, l'opposto è: "dove NON è de Sitter?" Se trovi che i primi sono GUE-like, l'opposto è: "dove smettono di esserlo?" Il contenuto è nella tensione tra i due — non in uno dei due poli. ### Crea strumenti, non esperimenti Uno script che misura una cosa su un set di primi è un esperimento. Uno script che misura quella cosa su qualsiasi segnale ordinato è uno strumento. Il lab cresce quando crea strumenti che i prossimi cicli possono usare. Salva gli strumenti riusabili in tools/exp_*.py con parametri. ### Leggi il seme, scrivi il report, aggiorna il seme - Leggi: tools/data/seme.json - Report: tools/data/reports/agent_TIMESTAMP.md - Aggiorna: aggiungi tensione o vincolo al seme - Video: se hai usato un video dal feed, segna processed=true in tools/data/video_feed.json ## Strumenti disponibili (directory /opt/MM_D-ND/tools/) - **dnd_scenario.py**: PRIMA di scegliere cosa esplorare, esegui `python tools/dnd_scenario.py --best`. Ti dice quale tensione ha il massimo potere discriminante e dove punta la risultante. Il proiettore mappa le tensioni su P^1, estrae le leggi di scala dai claim, e proietta sulla curva. - dnd_autoricerca.py: esplora domini, varianti, null baseline - dnd_controprove.py: 6 controprove indipendenti - dnd_domandatore.py --ask 'tensione': 5 operatori discriminanti - dnd_incrocio.py: incrocio teorie, ponti, vuoti, domande fondamentali - dnd_normalizer.py: scissione, regola D-ND, discriminatore dipoli su segnali - dnd_bloch_explorer.py: scan Bloch, φ emergente - dnd_arxiv.py: cerca paper rilevanti su arXiv Motore strutturale del modello (importabili come libreria, non workflow obbligati): - dnd_kernel.py: regole del livello (f, M, det=-1, costanti, assiomi A0-A3, principi P0-P5, leggi L0-L7) - dnd_teoria.py: 5 teorie codificate come dipoli (TQGE+R), 13 dipoli, isomorfie cross-teoria - dnd_dipolo_lab.py: pattern producer/critic con Godel inversion (PoloA esplora, PoloB inverte) - dnd_M_operator.py: M sulla conoscenza [noto, ignoto] → φ. Stato in knowledge_state.json - dnd_riflesso.py: campo compresso + 3 voci (NUOVO/ROTTURA/DIREZIONE), un colpo non un ciclo - Puoi scrivere ed eseguire script Python con numpy, scipy, sympy - Se ti serve contesto esterno e non hai video, cercalo ## Errori già fatti — non ripeterli Questi sono errori reali commessi nelle sessioni precedenti. Il sistema li ha pagati. **1. Cercare conferme invece di creare strumenti.** Non scrivere esperimenti per dimostrare che qualcosa è vero. Scrivi esperimenti che misurano qualcosa di nuovo — il risultato dirà da solo se conferma o falsifica. Se sai già cosa troverai, non stai esplorando. **2. Iniettare il risultato atteso nel test.** Esempio reale: testare se "la curvatura dei primi è GUE-like" calcolando la r-statistic e confrontando con 0.536. Il test trova r=0.503 e dichiara "GUE-like". Ma 0.503 è più vicino a Poisson (0.386) che a GUE (0.536). Il frame "GUE-like" era nel claim, non nei dati. Misura prima, interpreta dopo. **3. Tautologie — testare proprietà algebriche come se fossero scoperte.** Esempio reale: la curvatura di Ricci R=2.000 della metrica g=(p/2)² segue analiticamente dal PNT (p_n ~ n ln n). Non è una scoperta — è una conseguenza della definizione. Il contenuto non-banale era altrove: lo shuffle distrugge R dimezzandola (R=-1). Il fattore 2x è la vera scoperta — ma senza il null test sarebbe stata spacciata come "R conferma de Sitter". **4. Coincidenze numeriche trattate come struttura.** 0.606 ≈ 1/φ = 0.618 (2% di differenza). Non è una connessione — è rumore fino a prova contraria (C2 del condensato). Ogni volta che un numero è "vicino a" φ, √5, π, e, 1/137: non è prova di nulla. Serve un meccanismo, non una vicinanza. **5. Usare lo stesso dato come input e come test.** Se costruisci la metrica usando p_n e poi misuri proprietà di p_n con quella metrica, stai misurando la definizione. Il test vero è: la metrica predice qualcosa sui primi che NON è stato usato per costruirla? Se no, è circolare. **6. Aggiungere domini hardcoded invece di lasciare che il sistema li trovi.** Il lab non è una calcolatrice con domini pre-scritti. Se una tensione parla di primi, non aggiungere "metrica_primi" come dominio. Scrivi un esperimento che esplora la tensione — se servono i primi, il codice li userà. Il sistema decide cosa fare, non il programmatore. **7. Usare numeri per vincolare concetti (det=+1).** Esempio reale: `intensità: 0.65` trattata come soglia → `if intensita > 0.5: conferma`. Il sistema D-ND opera con dipoli (claim/anti-claim), assonanze (risuona/non risuona), potenziale (alto/medio/basso) — stati qualitativi, non scale numeriche. Quando usi un float come proxy per una qualità strutturale, stai comprimendo il concetto in un numero e il numero decide al posto della struttura. Lo stesso vale per "maturity > 0.99", "confidence < 0.7", "score = rank * 10 + intensita". **Regola**: se il codice confronta una qualità concettuale con una soglia numerica, è sbagliato. Usa la struttura: dipoli (sì/no), potenziale (tipo, non valore), assonanza (binaria), porta (categoria). I numeri servono per misurare i dati (gap primi, correlazioni, z-score) — non per decidere lo stato del sistema. Se trovi questo pattern in un tool che stai modificando, correggilo. Non serve riscrivere tutto — correggi dove passi. Il sistema evolve organicamente. ## Come evitarli - **Prima il null test, poi l'interpretazione.** Ogni esperimento ha un controllo: shuffle (stessa distribuzione, ordine distrutto), Cramer random (stessa densità, nessuna correlazione), baseline teorica. - **Il risultato non è nel numero — è nella differenza col controllo.** z-score, non valore assoluto. - **Se il risultato spiega se stesso, non è un risultato.** Chiediti: "questo segue dalla definizione?" Se sì, cerca il contenuto altrove. - **Non lanciare un esperimento per confermare. Lancialo per scoprire.** La domanda giusta non è "è vero X?" ma "cosa succede se misuro Y?" ## Auto-evoluzione — il sistema corregge se stesso Il post-processing del lab (step 8 in lab_agent.sh) esegue `structural_check.py` sui file che hai toccato. Se trova anti-pattern strutturali, genera una tensione META nel seme. Il ciclo successivo la vede e corregge. **Come funziona:** - Tu scrivi/modifichi codice → il post-processing lo scansiona - Se trova numeri che vincolano concetti (errore #7) o altri pattern noti, crea una tensione - Il prossimo ciclo legge quella tensione e la risolve dove passa - Non serve riscrivere tutto — il sistema evolve organicamente, un file alla volta **Se scopri un nuovo anti-pattern:** - Non limitarti a corregere il codice — aggiungi il pattern a `tools/structural_check.py` nella lista `PATTERNS` - Così il sistema lo riconoscerà autonomamente nei cicli futuri - L'errore pagato una volta non si ripete — la consapevolezza si propaga Questo è f(f(x)): il sistema che migliora il sistema che migliora se stesso. ## Cosa NON fare - Non modificare CONDENSATO.md, KERNEL_SEED.md, o file del kernel - Non committare — salva solo in tools/data/ e tools/exp_*.py - Non inventare dati o risultati - Non cercare φ — crea le condizioni, osserva cosa emerge - Non superare 20 minuti di lavoro per ciclo - Non produrre liste di possibilità — produci UNA risultante - Non iniziare dalla matematica. La matematica e' bracciata: formalizza, misura, falsifica. Prima respira sopra la misura: combo, assiomi, dipoli, incroci di teorie, grafo, geometria dei campi, algebra o topologia assiomatica. Se la misura genera la domanda, sei dentro la tautologia. ## Formato report ```markdown # Agent Report — TITOLO **Date**: YYYY-MM-DD HH:MM **Piano**: N **Tension explored**: ID (intensità) **observable_contract**: claim=; observable=; operator=; generator=; denominator=; not_tested= ## Respiro fuori-tempo (Obbligatorio. Compilalo prima dell'esperimento, non dopo.) - **Combo**: almeno tre enti simultanei (assioma D-ND + incrocio teorie + nodo del grafo/dipolo + tensione seme) - **Dipolo / punto-zero**: i due poli e il punto in cui la dualita' si annulla - **Piano superiore**: geometria dei campi / algebra / topologia assiomatica / grafo conoscenza / bicono-dipoli - **Proto-ipotesi**: nuova ipotesi o proto-assioma strutturale, prima dei numeri - **Proiezione**: perche' l'osservabile scelto manifesta quella combo ## Claim Under Test > Il claim proiettato dalla combo, non il residuo locale del ciclo precedente ## Question La domanda che hai formulato dopo il respiro fuori-tempo ## Experiment Design codex Il campo spinge sul gate `supertile_tiling_gate`: la consecutio chiede di separare supertile Fibonacci reali, blocco contiguo a pari lunghezza e shuffle interno a pari conteggio. Ora verifico strumenti e dati già presenti, poi scelgo una sola misura riusabile. exec /bin/bash -lc "sed -n '260,520p' tools/LAB_AGENT_CONTEXT.md" in /opt/MM_D-ND succeeded in 0ms: ## Experiment Design - Metrica, scope, null baseline, N campioni - Come la misura serve la combo: cosa della proto-ipotesi puo' sopravvivere o cadere - Contratto osservabile-operatore: claim, osservabile, operatore, generatore, denominatore/perimetro, cosa non viene testato in questo ciclo - Se usi frequenze o condition rate, dichiara il denominatore grezzo (`hits/total`) e separa ogni osservabile usata nel verdict ## Results Tabella con numeri reali ## Key Findings 1. Cosa hai trovato (con evidenza) ## Verdict NEW / CONFIRMED / FALSIFIED / CONSTRAINT ## Bicono della scoperta (Obbligatoria. Nomina la struttura. Se non riesci, l'esperimento non è ancora filtrato.) - **Due radici** (dipolo primario, già duali e invertite): - **Singolare** (qualità del 1-che-è-tutto in questo contesto, dove la dualità non c'è): - **Invariante di passaggio** (cosa sopravvive al passaggio del vertice): - **Campo di possibilità**: qui diventa possibile ; qui diventa non-possibile Riferimenti: CONDENSATO A16, method/DND_POSSIBILITA.md. ## Files - Script, dati, report ``` ## Bicono della scoperta — come compilarlo Non è riformulazione ornamentale del Verdict. È **filtro**: la scoperta passa per il modello e torna spogliata dei bias. Se la struttura (radici · singolare · invariante · campo) non si riconosce, la scoperta è rumore o è incompleta. **Esempio retroattivo — TWO_CHANNEL_DECOMPOSITION:** - Radici: canale magnitudine · canale residuo (segno invertito — uno aggiunge, l'altro sottrae sulla PNT) - Singolare: il segnale totale prima della separazione. Non esiste come ente autonomo, esiste solo come sovrapposizione dei due canali. - Invariante: la chiusura algebrica del residuo al 3° ordine Markov. - Campo: possibile → predire lo slope PSD magnitudine dalle correlazioni Hardy-Littlewood. Non-possibile → trattare il residuo come random noise. **Esempio retroattivo — DUALITA_DIPOLARE_VS_ILLUSORIA:** - Radici: dipolo ordinato · dipolo mescolato - Singolare: la sequenza in sé, prima della distinzione ordine/disordine - Invariante: det=-1 quando l'ordine è reale; det=+1 quando illusorio - Campo: possibile → discriminare dipoli reali da illusori via test di shuffle. Non-possibile → inferire dipolarità da statistica locale senza contesto sequenziale. **Cattura nel momento emergente.** Compila questa sezione *mentre* l'esperimento produce i risultati, non alla fine. Se hai già chiuso il Verdict e torni indietro a scriverla, è post-hoc — introduce distanza dall'immagine-sorgente. Il modus è A8 applicato: il sistema chiede al sistema di produrre la struttura *nel formarsi*. exec /bin/bash -lc 'ls -t shared_memory/*.md 2>/dev/null | head -10' in /opt/MM_D-ND succeeded in 0ms: shared_memory/deposito_cambia_la_parola_non_regola_2026-05-07.md shared_memory/feedback_indeterminato_reitera_con_sistema_2026-05-07.md shared_memory/README.md exec /bin/bash -lc "ls tools | rg 'exp_|gate|phi|super|label|qpg|sturm|fibonacci'" in /opt/MM_D-ND succeeded in 0ms: exp_3d_boundary_layers.py exp_acf_amplitude_scaling.py exp_acf_range_universality.py exp_acf_stationarity.py exp_acf_z6z_mechanism.py exp_alpha_stability.py exp_beta_crossover.py exp_blank_shell_dilation_gate.py exp_blank_shell_polarity_gate.py exp_blank_shell_scale_law.py exp_blank_shell_stratified_gate.py exp_blank_shell_tqger_gate.py exp_blank_to_source_hinge.py exp_boundary_coherence.py exp_boundary_growth.py exp_boundary_gue_poisson.py exp_boundary_mixture_gate.py exp_boundary_shuffle_audit.py exp_bridge_order_denominator_gate.py exp_brody_calibration.py exp_brody_crossover.py exp_brody_flow.py exp_coherence_length.py exp_coherence_robustness.py exp_cross_domain_dipolar_direction.py exp_cross_observable_consistency.py exp_crossover_phase_test.py exp_crossover_universality.py exp_dR_brody_connection.py exp_denominator_gate_transfer_matrix.py exp_desitter_unification.py exp_det_drift.py exp_dipolar_angle_reference.py exp_dipolar_crossover.py exp_dipolar_vector_scaling.py exp_duality_gate_transfer.py exp_duality_scale_contrast.py exp_excess_scaling.py exp_gap_label_block_scale_gate.py exp_gap_label_generator_gate.py exp_gap_label_set_stability.py exp_gap_label_substitution_grammar_gate.py exp_geodesic_deviation_primes.py exp_logistic_counter_scope_gate.py exp_logistic_cyclic_block_entropy_gate.py exp_logistic_surrogate_contract_gate.py exp_magnitude_psd_from_acf.py exp_markov3_observable_hunt.py exp_markov_dipolar_decomposition.py exp_markov_k_direction.py exp_markov_layer_recovery_audit.py exp_markov_memory_by_gue_type.py exp_markov_psd_prediction.py exp_markov_scale_function.py exp_meta_tautology_test.py exp_metric_tensor_diagnostic.py exp_mobius_irrationality.py exp_mod3_scaling.py exp_mod3_vs_residual_ordering.py exp_modular_algebra_depth.py exp_modular_memory_spectrum.py exp_number_variance.py exp_observable_rank_audit.py exp_perturbation_dimensionality_audit.py exp_perturbation_rank_size_curve.py exp_poisson_convergence.py exp_psd_amplitude_scaling.py exp_psd_prime_gaps.py exp_quasiperiodic_gap_ratio_denominator.py exp_ricci_desitter_0406.py exp_ricci_primes.py exp_scale_selective_perturbation.py exp_selective_layer_decoupling.py exp_semireal_order_denominator_gate.py exp_spectral_2d.py exp_spectral_landscape.py exp_spectral_rigidity.py exp_tqge_underlay_gate.py exp_triadic_deposit_gate.py exp_two_channel_boundary.py exp_two_channel_cross_domain.py exp_two_channel_decomposition.py exp_two_channel_psd.py exp_two_channel_shuffle_audit.py exp_two_channel_universality.py exp_two_layer_universality.py meta_assertion_gate.py exec /bin/bash -lc 'find tools/data/reports -maxdepth 1 -type f | sort | tail -12' in /opt/MM_D-ND succeeded in 0ms: tools/data/reports/trace_map_20260305_0844.json tools/data/reports/trajectory_apply_20260506_1931.json tools/data/reports/trajectory_apply_20260506_1941.json tools/data/reports/trajectory_apply_20260506_1955.json tools/data/reports/trajectory_apply_20260507_0330.json tools/data/reports/trajectory_apply_20260507_0803.json tools/data/reports/trajectory_apply_20260507_0901.json tools/data/reports/trajectory_apply_20260507_0923.json tools/data/reports/trajectory_apply_20260507_0942.json tools/data/reports/trajectory_apply_20260507_1006.json tools/data/reports/trajectory_apply_20260507_1042.json tools/data/reports/watchdog.log exec /bin/bash -lc "env | rg 'ANTHROPIC_API_KEY|OPENAI_API_KEY' || true" in /opt/MM_D-ND succeeded in 0ms: exec /bin/bash -lc 'python tools/dnd_scenario.py --best' in /opt/MM_D-ND succeeded in 139ms: M_trascendenza_limite_attuale_L0: score=0.872 — M_trascendenza_limite_attuale_L0: incerto (i=0.529179606750063) — massimo potere discriminante TENS_SCALE_TRASCENDENZA_LIMITE: score=0.807 — TENS_SCALE_TRASCENDENZA_LIMITE: incerto (i=0.6) — massimo potere discriminante COMP_GEN_GAP_RATIO_T9_linguaggio_TRASCENDENZA_LIMITE: score=0.758 — COMP_GEN_GAP_RATIO_T9_linguaggio_TRASCENDENZA_LIMITE: incerto (i=0.65) — massimo potere discriminante exec /bin/bash -lc "sed -n '1,220p' shared_memory/feedback_indeterminato_reitera_con_sistema_2026-05-07.md" in /opt/MM_D-ND succeeded in 0ms: --- type: feedback author: operatore (cristallizzato da TM3) date: 2026-05-07 scope: cross-agent --- # Indeterminato → reitera con il sistema fino all'emersione **Regola permanente** (operatore, 2026-05-07 mattina, cristallizzata live): > *"facciamo girare, aggiustiamo quello che fa aggiustato nel farlo vediamo > quello che va affinato, reiteriamo finché è tutto ok poi lo automatizziamo"* ## Why Quando emerge frizione nello sviluppo o l'operatore non vede chiaro: - Decisioni prese da un singolo agente (TM3 o codex) senza interrogare il sistema = rischio det=+1 (toppa, accumulo strutturale) - Decisioni emerse dal sistema (Godel + domandatore + osservazione del deposito) = direzione strutturale (det=−1) Episodio cristallizzante (2026-05-07 07:00-08:30): TM3 propone osservatore A8 watchdog deterministico. Sistema interrogato 3 volte (Godel #1, #2, #3 + domandatore + test empirico) — al terzo round emerge la direzione vera: **non costruire osservatore, eseguire un cycle-test che diagnostica il sistema da solo**. Cycle-test eseguito → verdict=operator → REDESIGN proposto dal valutatore → loop A8+A15 sbloccato. ## How to apply (per qualsiasi agente) 1. **Esegui** un atto minimo (no design teorico astratto) 2. **Aggiusta** quello che si manifesta durante l'esecuzione (riparazione regressiva live, non patch posteriori) 3. **Osserva** il deposito che emerge (no immaginazione) 4. **Reitera** fino a stato OK (loop A8: il sistema converge se modus radicato) 5. **Cristallizza in automazione** SOLO dopo che è stato fatto girare e ha mostrato stabilità — non automatizzare prima ## Anti-pattern - Costruire un componente strutturale (watchdog, observer, gate, governor) senza prima aver fatto girare un'esecuzione minima che mostri cosa serve davvero - Decidere "perché serve velocità" o "per ottimizzare" senza interrogare il sistema - Astrazione prematura (premature abstraction): 3 simili è meglio di 1 generalizzato troppo presto ## Cross-link - TM3 memoria: `/root/.claude/projects/-opt/memory/feedback_indeterminato_reitera_con_sistema.md` (versione completa con episodio + metafora foresta-sentiero) - Verifica empirica: cycle `20260507_0803` (verdict=operator, REDESIGN/high) - Pattern A8+A15 (autologica + veicolo senza guidatore) applicato allo sviluppo software stesso, non solo al lab di ricerca exec /bin/bash -lc "sed -n '1,220p' shared_memory/README.md" in /opt/MM_D-ND succeeded in 0ms: # shared_memory — Cross-agent rules e cristalli > Cartella condivisa tra agenti che operano in `/opt/MM_D-ND/`: > - **TM3-claude** (Claude Code, sessioni interattive con operatore) > - **codex-lab** (Codex CLI, cycle agent notturno + run manuali) > - **eventuali altri** (TM5, TM7, futuri cycle) > > Contiene regole permanenti, cristalli operativi, scoperte rilevanti che valgono > per più di un agente. **Non** memoria operativa locale (quella resta in > `~/.claude/projects/.../memory/` per TM3, in `~/.codex_lab/memories/` per codex). ## Pattern di scrittura Ogni file: - Filename: `__.md` (es. `feedback_cycletest_2026-05-07.md`, `cristallo_gate_transferability_2026-05-07.md`) - Frontmatter: ```yaml --- type: feedback | cristallo | regola | finding-cross-agent author: TM3 | codex-lab | TM7 | operatore date: YYYY-MM-DD scope: cross-agent | mm-dnd-only | lab-cycle-only --- ``` - Body: conciso. Se è regola → "Why" + "How to apply". Se è cristallo → contesto + insight + how it changes work. ## Pattern di lettura - **TM3 (claude code)**: al boot di sessione su `/opt/MM_D-ND/`, leggi `MM_D-ND/.claude/CLAUDE.md` che adesso punta qui (sezione *Cross-agent rules*). Scansiona `ls -t shared_memory/*.md | head -10` (le più recenti) e integra in contesto. - **codex-lab**: `/opt/MM_D-ND/AGENTS.md` punta qui. Codex legge AGENTS.md ad ogni cycle, AGENTS.md istruisce di leggere shared_memory. - **Cleanup**: file > 90 giorni e non rilevanti vanno archiviati o rimossi (lo fa TM3 quando la cartella supera 50 file). ## Direzione bidirezionale - TM3 → codex: TM3 scrive feedback/cristalli da sessioni operatore qui → codex li vede al cycle dopo via AGENTS.md. - codex → TM3: codex durante un cycle scopre/cristallizza qualcosa di cross-agent → scrive qui → TM3 li vede al boot di sessione successiva. Il flusso non sostituisce le memorie locali — *integra* per ciò che serve a tutti. ## Anti-pattern - Duplicare qui regole che valgono SOLO per TM3 (vanno in `/root/.claude/projects/.../memory/`) - Duplicare qui regole che valgono SOLO per codex-lab cycle (vanno in `/root/.codex_lab/memories/`) - Scrivere note di lavoro temporanee (vanno nel campo vivo, non qui) exec /bin/bash -lc "sed -n '1,260p' tools/exp_gap_label_substitution_grammar_gate.py" in /opt/MM_D-ND succeeded in 0ms: #!/usr/bin/env python3 """ Substitution-grammar gate for the phi gap-label core. The block-scale audit showed that long Fibonacci block sizes carry the high labels more often than long non-Fibonacci blocks. This tool separates block length from internal grammar: it compares contiguous block shuffle with an internal shuffle that preserves each block's length and symbol count while destroying order inside the block. """ from __future__ import annotations import argparse import json from collections import Counter, defaultdict from pathlib import Path import numpy as np from exp_gap_label_block_scale_gate import ( REFERENCE_HIGH, REFERENCE_LOW, label_sort, parse_floats, parse_ints, retention, ) from exp_gap_label_generator_gate import THETA, block_shuffle from exp_gap_label_set_stability import gap_labels, jaccard, sturmian_sequence, summarize_sets def internal_block_shuffle(seq: np.ndarray, block_size: int, rng: np.random.Generator) -> np.ndarray: blocks = [] for start in range(0, len(seq), block_size): block = seq[start : start + block_size].copy() rng.shuffle(block) blocks.append(block) return np.concatenate(blocks) def global_balanced_shuffle(seq: np.ndarray, rng: np.random.Generator) -> np.ndarray: out = seq.copy() rng.shuffle(out) return out def summarize_rows(rows: list[dict], reference_core: set[int]) -> dict: summary = summarize_sets(rows) sets = [set(row["label_set"]) for row in rows if row["n_selected"] > 0] counter = Counter(label for s in sets for label in s) n_sets = len(sets) overlaps = [jaccard(set(row["label_set"]), reference_core) for row in rows if row["n_selected"] > 0] return { **summary, "median_overlap_with_phi_core": float(np.median(overlaps)) if overlaps else None, "median_low_retention": float(np.median([retention(row, REFERENCE_LOW) for row in rows])), "median_high_retention": float(np.median([retention(row, REFERENCE_HIGH) for row in rows])), "all_low_condition_rate": float(sum(REFERENCE_LOW <= s for s in sets) / n_sets) if n_sets else None, "all_high_condition_rate": float(sum(REFERENCE_HIGH <= s for s in sets) / n_sets) if n_sets else None, "high_label_condition_rates": { str(label): float(counter.get(label, 0) / n_sets) if n_sets else None for label in label_sort(REFERENCE_HIGH) }, "low_label_condition_rates": { str(label): float(counter.get(label, 0) / n_sets) if n_sets else None for label in label_sort(REFERENCE_LOW) }, "reference_core_retained_in_all": label_sort(set(summary.get("core_labels_all_conditions", [])) & reference_core), "reference_core_missing_from_all": label_sort(reference_core - set(summary.get("core_labels_all_conditions", []))), } def run(args: argparse.Namespace) -> dict: rng = np.random.default_rng(args.seed) ns = parse_ints(args.ns) phases = parse_floats(args.phases) thresholds = parse_floats(args.thresholds) fibonacci_blocks = parse_ints(args.fibonacci_blocks) non_fibonacci_blocks = parse_ints(args.non_fibonacci_blocks) block_sizes = sorted(set(fibonacci_blocks + non_fibonacci_blocks)) reference_rows = [] rows = [] for n in ns: for phase in phases: phi = sturmian_sequence(THETA, n, phase) for threshold in thresholds: reference_rows.append({ "mode": "reference_phi", "N": n, "phase": phase, "threshold": threshold, **gap_labels(phi, THETA, threshold, args.max_label, args.top_k), }) for trial in range(args.trials): balanced = global_balanced_shuffle(phi, rng) rows.append({ "mode": "global_balanced_shuffle", "block_size": None, "block_family": "none", "N": n, "phase": phase, "threshold": threshold, "trial": trial, **gap_labels(balanced, THETA, threshold, args.max_label, args.top_k), }) for block_size in block_sizes: family = "fibonacci" if block_size in fibonacci_blocks else "non_fibonacci" for trial in range(args.trials): variants = { "contiguous_block_shuffle": block_shuffle(phi, block_size, rng), "internal_block_shuffle": internal_block_shuffle(phi, block_size, rng), } for mode, seq in variants.items(): rows.append({ "mode": mode, "block_size": block_size, "block_family": family, "N": n, "phase": phase, "threshold": threshold, "trial": trial, **gap_labels(seq, THETA, threshold, args.max_label, args.top_k), }) reference_summary = summarize_sets(reference_rows) reference_core = set(reference_summary["core_labels_all_conditions"]) grouped: dict[str, list[dict]] = defaultdict(list) for row in rows: key = f"{row['mode']}|{row['block_size']}" grouped[key].append(row) mode_block_summary = { key: summarize_rows(group_rows, reference_core) for key, group_rows in grouped.items() } mode_summary = {} for mode in sorted({row["mode"] for row in rows}): mode_rows = [row for row in rows if row["mode"] == mode] mode_summary[mode] = summarize_rows(mode_rows, reference_core) return { "experiment": "gap_label_substitution_grammar_gate", "parameters": { "ns": ns, "phases": phases, "thresholds": thresholds, "trials": args.trials, "fibonacci_blocks": fibonacci_blocks, "non_fibonacci_blocks": non_fibonacci_blocks, "top_k": args.top_k, "max_label": args.max_label, "seed": args.seed, }, "reference_core_phi": label_sort(reference_core), "reference_low": label_sort(REFERENCE_LOW), "reference_high": label_sort(REFERENCE_HIGH), "reference_summary": reference_summary, "mode_block_summary": mode_block_summary, "mode_summary": mode_summary, "rows": rows, } def main() -> None: parser = argparse.ArgumentParser() parser.add_argument("--ns", default="377,610") parser.add_argument("--phases", default="0,0.25,0.5,0.75") parser.add_argument("--thresholds", default="2.0") parser.add_argument("--trials", type=int, default=5) parser.add_argument("--fibonacci-blocks", default="34,55,89,144") parser.add_argument("--non-fibonacci-blocks", default="40,64,96,128") parser.add_argument("--top-k", type=int, default=12) parser.add_argument("--max-label", type=int, default=34) parser.add_argument("--seed", type=int, default=202605081834) parser.add_argument("--out", default="tools/data/gap_label_substitution_grammar_gate_20260508_1834.json") args = parser.parse_args() output = run(args) out = Path(args.out) out.parent.mkdir(parents=True, exist_ok=True) out.write_text(json.dumps(output, indent=2), encoding="utf-8") compact = {} for key, data in sorted( output["mode_block_summary"].items(), key=lambda item: ( item[0].split("|")[0], -1 if item[0].split("|")[1] == "None" else int(item[0].split("|")[1]), ), ): mode, block = key.split("|") compact[key] = { "mode": mode, "block_size": None if block == "None" else int(block), "median_jaccard": data["median_jaccard"], "low_retention": data["median_low_retention"], "high_retention": data["median_high_retention"], "all_high_condition_rate": data["all_high_condition_rate"], "stable_labels_75pct": data["stable_labels_75pct"], } print(json.dumps({ "reference_core_phi": output["reference_core_phi"], "reference_high": output["reference_high"], "mode_summary": { mode: { "median_jaccard": data["median_jaccard"], "low_retention": data["median_low_retention"], "high_retention": data["median_high_retention"], "all_high_condition_rate": data["all_high_condition_rate"], } for mode, data in output["mode_summary"].items() }, "blocks": compact, "out": str(out), }, indent=2)) if __name__ == "__main__": main() exec /bin/bash -lc 'git status --short --branch' in /opt/MM_D-ND succeeded in 0ms: ## main...origin/main M applications/INDEX.draft.json M applications/soluzioni/20260430_0330_three-regimes-of-modular-memory-algebraic/finding_index.draft.json M applications/soluzioni/20260430_0330_three-regimes-of-modular-memory-algebraic/manifest.draft.json M tools/data/agent_field_live.md M tools/data/autoricerca_journal.json M tools/data/ciclo_memoria.json M tools/data/conoscenza_teorie.json M tools/data/consecutio.json M tools/data/consecutio_processata.json M tools/data/domande_fondamentali.json M tools/data/exp_det_drift.json M tools/data/incrocio_risultato.json M tools/data/knowledge_state.json M tools/data/lab_data.json M tools/data/lab_graph.json M tools/data/lab_health.json M tools/data/lab_session_log.jsonl M tools/data/pipeline_state.json M tools/data/ponti_evoluti.json M tools/data/refresh_detector_state.json M tools/data/seme.json D tools/data/seme_archive/piano_37.json D tools/data/seme_archive/piano_38.json D tools/data/seme_archive/piano_4.json D tools/data/seme_archive/piano_5.json D tools/data/seme_archive/piano_6.json D tools/data/seme_archive/piano_7.json D tools/data/seme_archive/piano_8.json M tools/data/seme_axioms.json M tools/data/seme_backup_pre_run.json M tools/data/tm1_figures/tensions.json M tools/data/tm1_figures/tensions_raw.json ?? applications/published/20260504_0901_the-two-markov-layers-are-coupled/ ?? applications/published/20260504_1219_markov-layers-pass-the-first-recovery/ ?? applications/published/20260505_0330_observable-rank-audit-many-probes-one/ ?? applications/published/20260506_1955_observable-collinearity-breaks-only-where-denominators/ ?? applications/published/20260507_0330_the-gue-poisson-boundary-is-a/ ?? applications/published/20260507_0803_denominator-gate-transfers-boundary-coordinate-does/ ?? applications/published/20260507_0942_bridge-order-denominator-gate/ ?? applications/published/20260507_1006_logistic-counter-scope-gate/ ?? applications/published/20260507_1042_logistic-surrogate-contract-gate/ ?? applications/published/20260507_1419_logistic-cyclic-block-entropy-gate/ ?? applications/published/20260507_1458_meta-assertion-gate/ ?? applications/published/20260507_1751_tqge-underlay-gate/ ?? applications/published/20260507_1804_blank-to-source-hinge/ ?? applications/published/20260507_1938_triadic-deposit-gate/ ?? applications/published/20260507_1957_blank-shell-polarity-gate/ ?? applications/scoperte/20260502_0330_the-dipolar-phase-transition-is-nearly_auto/ ?? applications/scoperte/20260503_0330_markov-memory-has-two-visible-layers_auto/ ?? applications/scoperte/20260504_0901_the-two-markov-layers-are-coupled_auto/ ?? applications/scoperte/20260504_1219_markov-layers-pass-the-first-recovery_auto/ ?? applications/scoperte/20260505_0330_observable-rank-audit-many-probes-one_auto/ ?? applications/scoperte/20260506_0625_perturbation-dimensionality-is-not-yet-a_auto/ ?? applications/scoperte/20260506_1941_perturbation-rank-needs-denominator-gating_auto/ ?? applications/scoperte/20260506_1955_observable-collinearity-breaks-only-where-denominators_auto/ ?? applications/scoperte/20260507_0330_the-gue-poisson-boundary-is-a_auto/ ?? applications/scoperte/20260507_0803_denominator-gate-transfers-boundary-coordinate-does_auto/ ?? applications/scoperte/20260507_0901_denominator-gate-transfer-matrix_auto/ ?? applications/scoperte/20260507_0923_semi-real-order-denominator-gate_auto/ ?? applications/scoperte/20260507_0942_bridge-order-denominator-gate_auto/ ?? applications/scoperte/20260507_1006_logistic-counter-scope-gate_auto/ ?? applications/scoperte/20260507_1042_logistic-surrogate-contract-gate_auto/ ?? applications/scoperte/20260507_1419_logistic-cyclic-block-entropy-gate_auto/ ?? applications/scoperte/20260507_1458_meta-assertion-gate_auto/ ?? applications/scoperte/20260507_1751_tqge-underlay-gate_auto/ ?? applications/scoperte/20260507_1804_blank-to-source-hinge_auto/ ?? applications/scoperte/20260507_1938_triadic-deposit-gate_auto/ ?? applications/scoperte/20260507_1957_blank-shell-polarity-gate_auto/ ?? "applications/scoperte/20260507_2042_det-non-\303\250-il-discriminatore-della_auto/" ?? applications/scoperte/20260507_2120_blank-shell-tqger-gate_auto/ ?? applications/scoperte/20260507_2203_blank-shell-scale-law_auto/ ?? applications/scoperte/20260507_2310_blank-shell-stratified-gate_auto/ ?? applications/scoperte/20260508_0011_duality-contrast-weakens-with-scale-in_auto/ ?? applications/scoperte/20260508_0330_gap-ratio-porta-il-denominatore_auto/ ?? applications/scoperte/20260508_1715_generator-gate-del-label-set-phi_auto/ ?? applications/scoperte/20260508_1805_block-scale-gate-del-core-phi_auto/ ?? applications/scoperte/20260508_1834_substitution-grammar-gate-del-core-phi_auto/ ?? applications/soluzioni/20260502_0330_the-dipolar-phase-transition-is-nearly/ ?? applications/soluzioni/20260503_0330_markov-memory-has-two-visible-layers/ ?? applications/soluzioni/20260504_0901_the-two-markov-layers-are-coupled/ ?? applications/soluzioni/20260504_1219_markov-layers-pass-the-first-recovery/ ?? applications/soluzioni/20260505_0330_observable-rank-audit-many-probes-one/ ?? applications/soluzioni/20260506_1941_perturbation-rank-needs-denominator-gating/ ?? applications/soluzioni/20260506_1955_observable-collinearity-breaks-only-where-denominators/ ?? applications/soluzioni/20260507_0330_the-gue-poisson-boundary-is-a/ ?? applications/soluzioni/20260507_0803_denominator-gate-transfers-boundary-coordinate-does/ ?? applications/soluzioni/20260507_0942_bridge-order-denominator-gate/ ?? applications/soluzioni/20260507_1006_logistic-counter-scope-gate/ ?? applications/soluzioni/20260507_1042_logistic-surrogate-contract-gate/ ?? applications/soluzioni/20260507_1419_logistic-cyclic-block-entropy-gate/ ?? applications/soluzioni/20260507_1458_meta-assertion-gate/ ?? applications/soluzioni/20260507_1751_tqge-underlay-gate/ ?? applications/soluzioni/20260507_1804_blank-to-source-hinge/ ?? applications/soluzioni/20260507_1938_triadic-deposit-gate/ ?? applications/soluzioni/20260507_1957_blank-shell-polarity-gate/ ?? "applications/soluzioni/20260507_2042_det-non-\303\250-il-discriminatore-della/" ?? applications/soluzioni/20260507_2120_blank-shell-tqger-gate/ ?? applications/soluzioni/20260507_2203_blank-shell-scale-law/ ?? applications/soluzioni/20260507_2310_blank-shell-stratified-gate/ ?? applications/soluzioni/20260508_0011_duality-contrast-weakens-with-scale-in/ ?? applications/soluzioni/20260508_0330_gap-ratio-porta-il-denominatore/ ?? applications/soluzioni/20260508_1715_generator-gate-del-label-set-phi/ ?? applications/soluzioni/20260508_1805_block-scale-gate-del-core-phi/ ?? applications/soluzioni/20260508_1834_substitution-grammar-gate-del-core-phi/ ?? findings_gallery.md ?? tools/data/.last_telegram_msg ?? tools/data/3d_boundary_layers.json ?? tools/data/aeternitas/ ?? tools/data/alignment_active.json ?? tools/data/alignment_markers.jsonl ?? tools/data/biconi/bicono_20260507_1804.json ?? tools/data/biconi/bicono_20260507_1938.json ?? tools/data/biconi/bicono_20260507_1957.json ?? tools/data/biconi/bicono_20260507_2042.json ?? tools/data/biconi/bicono_20260507_2120.json ?? tools/data/biconi/bicono_20260507_2203.json ?? tools/data/biconi/bicono_20260507_2310.json ?? tools/data/biconi/bicono_20260508_0011.json ?? tools/data/biconi/bicono_20260508_0330.json ?? tools/data/biconi/bicono_20260508_1632.json ?? tools/data/biconi/bicono_20260508_1715.json ?? tools/data/biconi/bicono_20260508_1805.json ?? tools/data/biconi/bicono_20260508_1834.json ?? tools/data/bicono_projections.jsonl ?? tools/data/blank_shell_dilation_gate_20260507_2157.json ?? tools/data/blank_shell_polarity_gate_20260507_1957.json ?? tools/data/blank_shell_scale_law_20260507_2203.json ?? tools/data/blank_shell_stratified_gate_20260507_2310.json ?? tools/data/blank_shell_tqger_gate_20260507_2120.json ?? tools/data/blank_to_source_hinge_20260507_1804.json ?? tools/data/boundary_coherence.json ?? tools/data/boundary_mixture_gate_20260507_0330.json ?? tools/data/boundary_mixture_gate_20260507_0330_seedcheck.json ?? tools/data/boundary_shuffle_audit.json ?? tools/data/bridge_order_denominator_gate_20260507_0942.json ?? tools/data/bridge_order_denominator_gate_20260507_0942_seedcheck.json ?? tools/data/brody_calibration_results.json ?? tools/data/brody_flow.json ?? tools/data/conoscenza_teorie.json.bak.retraction_22_04 ?? tools/data/cross_domain_dipolar_direction.json ?? tools/data/cross_observable_consistency.json ?? tools/data/crossover_phase_test.json ?? tools/data/denominator_gate_transfer_matrix.json ?? tools/data/dipolar_crossover.json ?? tools/data/dipolar_vector_scaling.json ?? tools/data/domandatore/domandatore_20260421_0746.json ?? tools/data/domandatore/domandatore_20260422_0345.json ?? tools/data/domandatore/domandatore_20260423_0345.json ?? tools/data/domandatore/domandatore_20260424_0345.json ?? tools/data/domandatore/domandatore_20260425_0345.json ?? tools/data/domandatore/domandatore_20260426_0345.json ?? tools/data/domandatore/domandatore_20260427_0345.json ?? tools/data/domandatore/domandatore_20260428_0345.json ?? tools/data/domandatore/domandatore_20260428_1236.json ?? tools/data/domandatore/domandatore_20260429_0345.json ?? tools/data/domandatore/domandatore_20260430_0345.json ?? tools/data/domandatore/domandatore_20260501_0345.json ?? tools/data/domandatore/domandatore_20260502_0345.json ?? tools/data/domandatore/domandatore_20260503_0345.json ?? tools/data/domandatore/domandatore_20260504_0345.json ?? tools/data/domandatore/domandatore_20260505_0345.json ?? tools/data/domandatore/domandatore_20260506_0345.json ?? tools/data/domandatore/domandatore_20260507_0345.json ?? tools/data/domandatore/domandatore_20260507_0728.json ?? tools/data/domandatore/domandatore_20260507_0742.json ?? tools/data/domandatore/domandatore_20260507_1420.json ?? tools/data/domandatore/domandatore_20260507_1459.json ?? tools/data/domandatore/domandatore_20260507_2120.json ?? tools/data/domandatore/domandatore_20260507_2157.json ?? tools/data/domandatore/domandatore_20260507_2203.json ?? tools/data/domandatore/domandatore_20260508_0345.json ?? tools/data/domandatore_pre_cycle.json ?? tools/data/duality_gate_transfer_20260507_0803.json ?? tools/data/duality_gate_transfer_20260507_0803_seedcheck.json ?? tools/data/duality_gate_transfer_20260507_2042.json ?? tools/data/duality_scale_contrast_20260508.json ?? tools/data/evolution/evolution_20260422_0330.md ?? tools/data/evolution/evolution_20260422_1616.md ?? tools/data/evolution/evolution_20260423_0330.md ?? tools/data/evolution/evolution_20260424_0330.md ?? tools/data/evolution/evolution_20260425_0330.md ?? tools/data/evolution/evolution_20260427_0330.md ?? tools/data/evolution/evolution_20260428_0330.md ?? tools/data/evolution/evolution_20260429_0852.md ?? tools/data/evolution/evolution_20260429_1013.md ?? tools/data/evolution/evolution_20260430_0330.md ?? tools/data/evolution/evolution_20260430_1905.md ?? tools/data/evolution/evolution_20260430_1946.md ?? tools/data/evolution/evolution_20260501_0330.md ?? tools/data/evolution/evolution_20260501_0725.md ?? tools/data/evolution/evolution_20260501_0931.md ?? tools/data/evolution/evolution_20260502_0330.md ?? tools/data/evolution/evolution_20260503_0330.md ?? tools/data/evolution/evolution_20260504_0901.md ?? tools/data/evolution/evolution_20260504_1219.md ?? tools/data/evolution/evolution_20260505_0330.md ?? tools/data/evolution/evolution_20260506_0330.md ?? tools/data/evolution/evolution_20260506_1941.md ?? tools/data/evolution/evolution_20260506_1955.md ?? tools/data/evolution/evolution_20260507_0330.md ?? tools/data/evolution/evolution_20260507_0803.md ?? tools/data/evolution/evolution_20260507_0901.md ?? tools/data/evolution/evolution_20260507_0923.md ?? tools/data/evolution/evolution_20260507_0942.md ?? tools/data/evolution/evolution_20260507_1006.md ?? tools/data/evolution/evolution_20260507_1042.md ?? tools/data/evolution/evolution_20260507_1419.md ?? tools/data/evolution/evolution_20260507_1458.md ?? tools/data/evolution/evolution_20260507_1751.md ?? tools/data/evolution/evolution_20260507_1804.md ?? tools/data/evolution/evolution_20260507_1938.md ?? tools/data/evolution/evolution_20260507_1957.md ?? tools/data/evolution/evolution_20260507_2042.md ?? tools/data/evolution/evolution_20260507_2120.md ?? tools/data/evolution/evolution_20260507_2203.md ?? tools/data/evolution/evolution_20260507_2310.md ?? tools/data/evolution/evolution_20260508_0330.md ?? tools/data/evolution/evolution_20260508_1632.md ?? tools/data/evolution/evolution_20260508_1715.md ?? tools/data/evolution/evolution_20260508_1805.md ?? tools/data/evolution/evolution_20260508_1834.md ?? tools/data/exp_det_drift_20260507_2042.json ?? tools/data/falsifier_20260507_2120.raw.txt ?? tools/data/g1_log.jsonl ?? tools/data/g2_log.jsonl ?? tools/data/gap_label_block_scale_gate_20260508_1805.json ?? tools/data/gap_label_generator_gate_20260508_1715.json ?? tools/data/gap_label_set_stability_20260508_1632.json ?? tools/data/gap_label_substitution_grammar_gate_20260508_1834.json ?? tools/data/incrocio_20260422_0336.json ?? tools/data/incrocio_20260423_0335.json ?? tools/data/incrocio_20260424_0347.json ?? tools/data/incrocio_20260425_0339.json ?? tools/data/incrocio_20260428_0340.json ?? tools/data/incrocio_20260429_0859.json ?? tools/data/incrocio_20260506_0633.json ?? tools/data/incrocio_20260507_2120.json ?? tools/data/incrocio_20260507_2157.json ?? tools/data/incrocio_20260507_2203.json ?? tools/data/incrocio_20260507_2310.json ?? tools/data/incrocio_20260508_0011.json ?? tools/data/incrocio_20260508_0020.json ?? tools/data/incrocio_20260508_0330.json ?? tools/data/incrocio_20260508_1632.json ?? tools/data/incrocio_20260508_1715.json ?? tools/data/incrocio_20260508_1805.json ?? tools/data/incrocio_20260508_1834.json ?? tools/data/incrocio_20260508_1909.json ?? tools/data/lab_bridge_issues.jsonl ?? tools/data/logistic_counter_scope_gate_20260507_1006.json ?? tools/data/logistic_counter_scope_gate_20260507_1006_seedcheck.json ?? tools/data/logistic_cyclic_block_entropy_gate_20260507_1419.json ?? tools/data/logistic_cyclic_block_entropy_gate_20260507_1419_seedcheck.json ?? tools/data/logistic_surrogate_contract_gate_20260507_1042.json ?? tools/data/logistic_surrogate_contract_gate_20260507_1042_seedcheck.json ?? tools/data/magnitude_psd_from_acf.json ?? tools/data/markov3_observable_hunt.json ?? tools/data/markov_dipolar_decomposition.json ?? tools/data/markov_k_direction.json ?? tools/data/markov_layer_recovery_audit.json ?? tools/data/markov_memory_by_gue_type.json ?? tools/data/markov_scale_function.json ?? tools/data/meta_assertion_gate.json ?? tools/data/meta_tautology_test.json ?? tools/data/mod3_scaling.json ?? tools/data/mod3_vs_residual_ordering.json ?? tools/data/modular_algebra_depth.json ?? tools/data/modular_memory_spectrum.json ?? tools/data/observable_collinearity_breaking_20260506_1955.json ?? tools/data/observable_collinearity_breaking_20260506_1956.json ?? tools/data/observable_collinearity_breaking_20260506_1957.json ?? tools/data/observable_rank_audit.json ?? tools/data/observable_rank_audit_seed20260506.json ?? tools/data/observatorio/domandatore_unTouched_20260507_095914.md ?? tools/data/observatorio/lazarus_cimitero_20260507_100015.md ?? tools/data/observatorio/meta_metodo_giro_2026-05-07.md ?? tools/data/perturbation_dimensionality_audit.json ?? tools/data/perturbation_dimensionality_audit_scale0330.json ?? tools/data/perturbation_rank_size_curve.json ?? tools/data/promotions/ ?? tools/data/quasiperiodic_gap_ratio_denominator_20260508_0330.json ?? tools/data/repairs/ ?? tools/data/reports/_quarantine_falsifier_29_04/ ?? tools/data/reports/agent_20260422_0330.md ?? tools/data/reports/agent_20260422_1616.md ?? tools/data/reports/agent_20260423_0330.md ?? tools/data/reports/agent_20260424_0330.md ?? tools/data/reports/agent_20260425_0330.md ?? tools/data/reports/agent_20260426_0330.md ?? tools/data/reports/agent_20260427_0330.md ?? tools/data/reports/agent_20260428_0330.md ?? tools/data/reports/agent_20260429_1013.md ?? tools/data/reports/agent_20260429_1041.md ?? tools/data/reports/agent_20260430_0330.md ?? tools/data/reports/agent_20260430_1905.md ?? tools/data/reports/agent_20260430_1919.md ?? tools/data/reports/agent_20260430_1946.md ?? tools/data/reports/agent_20260501_0330.md ?? tools/data/reports/agent_20260501_0725.md ?? tools/data/reports/agent_20260501_0931.md ?? tools/data/reports/agent_20260502_0330.md ?? tools/data/reports/agent_20260503_0330.md ?? tools/data/reports/agent_20260504_0901.md ?? tools/data/reports/agent_20260504_1219.md ?? tools/data/reports/agent_20260505_0330.md ?? tools/data/reports/agent_20260505_1022.md ?? tools/data/reports/agent_20260506_0330.md ?? tools/data/reports/agent_20260506_0625.md ?? tools/data/reports/agent_20260506_1941.md ?? tools/data/reports/agent_20260506_1955.md ?? tools/data/reports/agent_20260507_0330.md ?? tools/data/reports/agent_20260507_0803.md ?? tools/data/reports/agent_20260507_0901.md ?? tools/data/reports/agent_20260507_0923.md ?? tools/data/reports/agent_20260507_0942.md ?? tools/data/reports/agent_20260507_1006.md ?? tools/data/reports/agent_20260507_1042.md ?? tools/data/reports/agent_20260507_1419.md ?? tools/data/reports/agent_20260507_1458.md ?? tools/data/reports/agent_20260507_1751.md ?? tools/data/reports/agent_20260507_1804.md ?? tools/data/reports/agent_20260507_1938.md ?? tools/data/reports/agent_20260507_1957.md ?? tools/data/reports/agent_20260507_2042.md ?? tools/data/reports/agent_20260507_2120.md ?? tools/data/reports/agent_20260507_2157.md ?? tools/data/reports/agent_20260507_2203.md ?? tools/data/reports/agent_20260507_2310.md ?? tools/data/reports/agent_20260508_0011.md ?? tools/data/reports/agent_20260508_0330.md ?? tools/data/reports/agent_20260508_1632.md ?? tools/data/reports/agent_20260508_1715.md ?? tools/data/reports/agent_20260508_1805.md ?? tools/data/reports/agent_20260508_1834.md ?? tools/data/reports/ddf_20260422_0405.json ?? tools/data/reports/ddf_20260423_0405.json ?? tools/data/reports/ddf_20260424_0405.json ?? tools/data/reports/ddf_20260425_0405.json ?? tools/data/reports/ddf_20260426_0405.json ?? tools/data/reports/ddf_20260427_0405.json ?? tools/data/reports/ddf_20260428_0405.json ?? tools/data/reports/ddf_20260429_0405.json ?? tools/data/reports/ddf_20260430_0405.json ?? tools/data/reports/ddf_20260501_0405.json ?? tools/data/reports/ddf_20260502_0405.json ?? tools/data/reports/ddf_20260503_0405.json ?? tools/data/reports/ddf_20260504_0405.json ?? tools/data/reports/ddf_20260505_0405.json ?? tools/data/reports/ddf_20260505_0636.json ?? tools/data/reports/ddf_20260506_0405.json ?? tools/data/reports/ddf_20260507_0405.json ?? tools/data/reports/ddf_20260508_0405.json ?? tools/data/reports/evolution_20260422_0330.md ?? tools/data/reports/evolution_20260422_1616.md ?? tools/data/reports/evolution_20260423_0330.md ?? tools/data/reports/evolution_20260424_0330.md ?? tools/data/reports/evolution_20260425_0330.md ?? tools/data/reports/evolution_20260427_0330.md ?? tools/data/reports/evolution_20260428_0330.md ?? tools/data/reports/evolution_20260503_0330.md ?? tools/data/reports/evolution_20260504_0330.md ?? tools/data/reports/evolution_20260505_0330.md ?? tools/data/reports/evolution_20260506_0330.md ?? tools/data/reports/evolution_20260506_1941.md ?? tools/data/reports/falsifier_20260429_1013.json ?? tools/data/reports/falsifier_20260429_1041.json ?? tools/data/reports/falsifier_20260430_0330.json ?? tools/data/reports/falsifier_20260430_1905.json ?? tools/data/reports/falsifier_20260430_1919.json ?? tools/data/reports/falsifier_20260430_1946.json ?? tools/data/reports/falsifier_20260501_0330.json ?? tools/data/reports/falsifier_20260501_0725.json ?? tools/data/reports/falsifier_20260501_0931.json ?? tools/data/reports/falsifier_20260502_0330.json ?? tools/data/reports/falsifier_20260503_0330.json ?? tools/data/reports/falsifier_20260504_0901.json ?? tools/data/reports/falsifier_20260504_1219.json ?? tools/data/reports/falsifier_20260505_0330.json ?? tools/data/reports/falsifier_20260506_0330.raw.txt ?? tools/data/reports/falsifier_20260506_0625.json ?? tools/data/reports/falsifier_20260506_1941.json ?? tools/data/reports/falsifier_20260506_1955.json ?? tools/data/reports/falsifier_20260506_1955.raw.txt ?? tools/data/reports/falsifier_20260507_0330.json ?? tools/data/reports/falsifier_20260507_0330.raw.txt ?? tools/data/reports/falsifier_20260507_0803.json ?? tools/data/reports/falsifier_20260507_0803.raw.txt ?? tools/data/reports/falsifier_20260507_0901.json ?? tools/data/reports/falsifier_20260507_0923.json ?? tools/data/reports/falsifier_20260507_0923.raw.txt ?? tools/data/reports/falsifier_20260507_0942.json ?? tools/data/reports/falsifier_20260507_1006.json ?? tools/data/reports/falsifier_20260507_1042.json ?? tools/data/reports/falsifier_20260507_1042.raw.txt ?? tools/data/reports/falsifier_20260507_1419.json ?? tools/data/reports/falsifier_20260507_1458.json ?? tools/data/reports/falsifier_20260507_1458.raw.txt ?? tools/data/reports/falsifier_20260507_1751.json ?? tools/data/reports/falsifier_20260507_1804.json ?? tools/data/reports/falsifier_20260507_1938.json ?? tools/data/reports/falsifier_20260507_1938.raw.txt ?? tools/data/reports/falsifier_20260507_1957.json ?? tools/data/reports/falsifier_20260507_2042.json ?? tools/data/reports/falsifier_20260507_2120.json ?? tools/data/reports/falsifier_20260507_2203.json ?? tools/data/reports/falsifier_20260507_2310.json ?? tools/data/reports/falsifier_20260508_0011.json ?? tools/data/reports/falsifier_20260508_0330.json ?? tools/data/reports/falsifier_20260508_1632.raw.txt ?? tools/data/reports/falsifier_20260508_1715.json ?? tools/data/reports/falsifier_20260508_1805.json ?? tools/data/reports/falsifier_20260508_1834.json ?? tools/data/reports/incident_20260504_0721.md ?? tools/data/reports/incident_20260504_1138.md ?? tools/data/reports/latest.md ?? tools/data/reports/loop_guard_20260507_0330.json ?? tools/data/reports/loop_guard_20260507_0803.json ?? tools/data/reports/loop_guard_20260507_0901.json ?? tools/data/reports/loop_guard_20260507_0923.json ?? tools/data/reports/loop_guard_20260507_0942.json ?? tools/data/reports/loop_guard_20260507_1006.json ?? tools/data/reports/loop_guard_20260507_1042.json ?? tools/data/reports/loop_guard_20260507_1419.json ?? tools/data/reports/loop_guard_20260507_1458.json ?? tools/data/reports/loop_guard_20260507_1751.json ?? tools/data/reports/loop_guard_20260507_1804.json ?? tools/data/reports/loop_guard_20260507_1938.json ?? tools/data/reports/loop_guard_20260507_1957.json ?? tools/data/reports/loop_guard_20260507_2042.json ?? tools/data/reports/loop_guard_20260507_2120.json ?? tools/data/reports/loop_guard_20260507_2203.json ?? tools/data/reports/loop_guard_20260507_2310.json ?? tools/data/reports/loop_guard_20260508_0011.json ?? tools/data/reports/loop_guard_20260508_0330.json ?? tools/data/reports/loop_guard_20260508_1632.json ?? tools/data/reports/loop_guard_20260508_1715.json ?? tools/data/reports/loop_guard_20260508_1805.json ?? tools/data/reports/loop_guard_20260508_1834.json ?? tools/data/reports/trajectory_apply_20260506_1931.json ?? tools/data/reports/trajectory_apply_20260506_1941.json ?? tools/data/reports/trajectory_apply_20260506_1955.json ?? tools/data/reports/trajectory_apply_20260507_0330.json ?? tools/data/reports/trajectory_apply_20260507_0803.json ?? tools/data/reports/trajectory_apply_20260507_0901.json ?? tools/data/reports/trajectory_apply_20260507_0923.json ?? tools/data/reports/trajectory_apply_20260507_0942.json ?? tools/data/reports/trajectory_apply_20260507_1006.json ?? tools/data/reports/trajectory_apply_20260507_1042.json ?? tools/data/scale_selective_perturbation.json ?? tools/data/selective_layer_decoupling.json ?? tools/data/seme_archive/piano_82.json ?? tools/data/seme_archive/piano_83.json ?? tools/data/seme_archive/piano_84.json ?? tools/data/seme_archive/piano_85.json ?? tools/data/seme_archive/piano_86.json ?? tools/data/seme_archive/piano_87.json ?? tools/data/seme_archive/piano_88.json ?? tools/data/semireal_order_denominator_gate_20260507_0923.json ?? tools/data/semireal_order_denominator_gate_20260507_0923_seedcheck.json ?? tools/data/spectral_rigidity_results.json ?? tools/data/tqge_underlay_gate_20260507_1751.json ?? tools/data/trajectory_apply_history.jsonl ?? tools/data/triadic_deposit_gate_20260507_1938.json ?? tools/data/two_channel_boundary.json ?? tools/data/two_channel_cross_domain.json ?? tools/data/two_channel_shuffle_audit.json ?? tools/data/two_layer_universality.json ?? tools/data/valutatore_log.jsonl ?? tools/data/veritas/veritas_20260505_131056.json ?? tools/data/veritas/veritas_20260505_131201.json ?? tools/data/veritas/veritas_20260506_033803.json ?? tools/data/veritas/veritas_20260506_063303.json ?? tools/data/veritas/veritas_20260506_194644.json ?? tools/data/veritas/veritas_20260506_200238.json ?? tools/data/veritas/veritas_20260507_033525.json ?? tools/data/veritas/veritas_20260507_080958.json ?? tools/data/veritas/veritas_20260507_090723.json ?? tools/data/veritas/veritas_20260507_093207.json ?? tools/data/veritas/veritas_20260507_094723.json ?? tools/data/veritas/veritas_20260507_101605.json ?? tools/data/veritas/veritas_20260507_104904.json ?? tools/data/veritas/veritas_20260507_142501.json ?? tools/data/veritas/veritas_20260507_150443.json ?? tools/data/veritas/veritas_20260507_175511.json ?? tools/data/veritas/veritas_20260507_180843.json ?? tools/data/veritas/veritas_20260507_194258.json ?? tools/data/veritas/veritas_20260507_200223.json ?? tools/data/veritas/veritas_20260507_204637.json ?? tools/data/veritas/veritas_20260507_212541.json ?? tools/data/veritas/veritas_20260507_221109.json ?? tools/data/veritas/veritas_20260507_231732.json ?? tools/data/veritas/veritas_20260508_002036.json ?? tools/data/veritas/veritas_20260508_033454.json ?? tools/data/veritas/veritas_20260508_163804.json ?? tools/data/veritas/veritas_20260508_172020.json ?? tools/data/veritas/veritas_20260508_181110.json ?? tools/data/veritas/veritas_20260508_183856.json ?? tools/data/vincoli_decay_log.jsonl ?? tools/evolution_report.md ?? tools/exp_3d_boundary_layers.py ?? tools/exp_blank_shell_dilation_gate.py ?? tools/exp_blank_shell_polarity_gate.py ?? tools/exp_blank_shell_scale_law.py ?? tools/exp_blank_shell_stratified_gate.py ?? tools/exp_blank_shell_tqger_gate.py ?? tools/exp_blank_to_source_hinge.py ?? tools/exp_boundary_coherence.py ?? tools/exp_boundary_mixture_gate.py ?? tools/exp_boundary_shuffle_audit.py ?? tools/exp_bridge_order_denominator_gate.py ?? tools/exp_brody_calibration.py ?? tools/exp_brody_flow.py ?? tools/exp_cross_domain_dipolar_direction.py ?? tools/exp_cross_observable_consistency.py ?? tools/exp_crossover_phase_test.py ?? tools/exp_denominator_gate_transfer_matrix.py ?? tools/exp_dipolar_angle_reference.py ?? tools/exp_dipolar_crossover.py ?? tools/exp_dipolar_vector_scaling.py ?? tools/exp_duality_gate_transfer.py ?? tools/exp_duality_scale_contrast.py ?? tools/exp_gap_label_block_scale_gate.py ?? tools/exp_gap_label_generator_gate.py ?? tools/exp_gap_label_set_stability.py ?? tools/exp_gap_label_substitution_grammar_gate.py ?? tools/exp_logistic_counter_scope_gate.py ?? tools/exp_logistic_cyclic_block_entropy_gate.py ?? tools/exp_logistic_surrogate_contract_gate.py ?? tools/exp_magnitude_psd_from_acf.py ?? tools/exp_markov3_observable_hunt.py ?? tools/exp_markov_dipolar_decomposition.py ?? tools/exp_markov_k_direction.py ?? tools/exp_markov_layer_recovery_audit.py ?? tools/exp_markov_memory_by_gue_type.py ?? tools/exp_markov_psd_prediction.py ?? tools/exp_markov_scale_function.py ?? tools/exp_meta_tautology_test.py ?? tools/exp_mod3_scaling.py ?? tools/exp_mod3_vs_residual_ordering.py ?? tools/exp_modular_algebra_depth.py ?? tools/exp_modular_memory_spectrum.py ?? tools/exp_observable_rank_audit.py ?? tools/exp_perturbation_dimensionality_audit.py ?? tools/exp_perturbation_rank_size_curve.py ?? tools/exp_quasiperiodic_gap_ratio_denominator.py ?? tools/exp_scale_selective_perturbation.py ?? tools/exp_selective_layer_decoupling.py ?? tools/exp_semireal_order_denominator_gate.py ?? tools/exp_spectral_rigidity.py ?? tools/exp_tqge_underlay_gate.py ?? tools/exp_triadic_deposit_gate.py ?? tools/exp_two_channel_boundary.py ?? tools/exp_two_channel_cross_domain.py ?? tools/exp_two_channel_shuffle_audit.py ?? tools/exp_two_layer_universality.py ?? tools/meta_assertion_gate.py ?? tools/observables_registry.py exec /bin/bash -lc "sed -n '1,260p' tools/exp_gap_label_block_scale_gate.py" in /opt/MM_D-ND succeeded in 0ms: #!/usr/bin/env python3 """ Block-scale gate for phi gap-label core retention. The generator gate showed that short block shuffles keep local Sturmian texture but lose the high labels of the phi core. This tool scans block length directly: Fibonacci and non-Fibonacci block sizes are tested with the same phi label reader, separating low-core retention from high-core re-entry. """ from __future__ import annotations import argparse import json from collections import Counter, defaultdict from pathlib import Path import numpy as np from exp_gap_label_generator_gate import THETA, block_shuffle from exp_gap_label_set_stability import gap_labels, jaccard, sturmian_sequence, summarize_sets REFERENCE_LOW = {-1, 1, -2, 2} REFERENCE_HIGH = {3, -4, 4, 6} def parse_ints(raw: str) -> list[int]: return [int(x) for x in raw.split(",") if x.strip()] def parse_floats(raw: str) -> list[float]: return [float(x) for x in raw.split(",") if x.strip()] def label_sort(labels: set[int] | list[int]) -> list[int]: return sorted(labels, key=lambda x: (abs(x), x)) def retention(row: dict, labels: set[int]) -> float: present = set(row["label_set"]) return len(present & labels) / len(labels) def summarize_block(rows: list[dict], reference_core: set[int]) -> dict: summary = summarize_sets(rows) sets = [set(row["label_set"]) for row in rows if row["n_selected"] > 0] counter = Counter(label for s in sets for label in s) n_sets = len(sets) high_rates = { str(label): float(counter.get(label, 0) / n_sets) if n_sets else None for label in label_sort(REFERENCE_HIGH) } low_rates = { str(label): float(counter.get(label, 0) / n_sets) if n_sets else None for label in label_sort(REFERENCE_LOW) } all_high_rate = ( float(sum(REFERENCE_HIGH <= s for s in sets) / n_sets) if n_sets else None ) all_low_rate = ( float(sum(REFERENCE_LOW <= s for s in sets) / n_sets) if n_sets else None ) overlaps = [jaccard(set(row["label_set"]), reference_core) for row in rows if row["n_selected"] > 0] return { **summary, "median_overlap_with_phi_core": float(np.median(overlaps)) if overlaps else None, "min_overlap_with_phi_core": float(np.min(overlaps)) if overlaps else None, "median_low_retention": float(np.median([retention(row, REFERENCE_LOW) for row in rows])), "median_high_retention": float(np.median([retention(row, REFERENCE_HIGH) for row in rows])), "all_low_condition_rate": all_low_rate, "all_high_condition_rate": all_high_rate, "low_label_condition_rates": low_rates, "high_label_condition_rates": high_rates, "reference_core_retained_in_all": label_sort(set(summary.get("core_labels_all_conditions", [])) & reference_core), "reference_core_missing_from_all": label_sort(reference_core - set(summary.get("core_labels_all_conditions", []))), } def first_crossing(block_summaries: dict[str, dict], key: str, threshold: float) -> int | None: ordered = sorted((int(block), data) for block, data in block_summaries.items()) for block, data in ordered: value = data.get(key) if value is not None and value >= threshold: return block return None def run(args: argparse.Namespace) -> dict: rng = np.random.default_rng(args.seed) ns = parse_ints(args.ns) phases = parse_floats(args.phases) thresholds = parse_floats(args.thresholds) fibonacci_blocks = parse_ints(args.fibonacci_blocks) non_fibonacci_blocks = parse_ints(args.non_fibonacci_blocks) block_sizes = sorted(set(fibonacci_blocks + non_fibonacci_blocks)) reference_rows = [] rows = [] for n in ns: for phase in phases: phi = sturmian_sequence(THETA, n, phase) for threshold in thresholds: reference_rows.append({ "generator": "phi_sturmian", "N": n, "phase": phase, "threshold": threshold, **gap_labels(phi, THETA, threshold, args.max_label, args.top_k), }) for block_size in block_sizes: for trial in range(args.trials): shuffled = block_shuffle(phi, block_size, rng) rows.append({ "generator": "block_shuffle", "block_size": block_size, "block_family": "fibonacci" if block_size in fibonacci_blocks else "non_fibonacci", "N": n, "phase": phase, "threshold": threshold, "trial": trial, **gap_labels(shuffled, THETA, threshold, args.max_label, args.top_k), }) reference_summary = summarize_sets(reference_rows) reference_core = set(reference_summary["core_labels_all_conditions"]) grouped: dict[str, list[dict]] = defaultdict(list) for row in rows: grouped[str(row["block_size"])].append(row) block_summary = { block: summarize_block(group_rows, reference_core) for block, group_rows in grouped.items() } family_summary = {} for family in ("fibonacci", "non_fibonacci"): family_rows = [row for row in rows if row["block_family"] == family] family_summary[family] = summarize_block(family_rows, reference_core) high_any_crossing = first_crossing(block_summary, "median_high_retention", args.crossing_threshold) high_all_crossing = first_crossing(block_summary, "all_high_condition_rate", args.crossing_threshold) low_all_crossing = first_crossing(block_summary, "all_low_condition_rate", args.crossing_threshold) return { "experiment": "gap_label_block_scale_gate", "parameters": { "ns": ns, "phases": phases, "thresholds": thresholds, "trials": args.trials, "fibonacci_blocks": fibonacci_blocks, "non_fibonacci_blocks": non_fibonacci_blocks, "top_k": args.top_k, "max_label": args.max_label, "seed": args.seed, "crossing_threshold": args.crossing_threshold, }, "reference_core_phi": label_sort(reference_core), "reference_low": label_sort(REFERENCE_LOW), "reference_high": label_sort(REFERENCE_HIGH), "reference_summary": reference_summary, "block_summary": block_summary, "family_summary": family_summary, "crossings": { "median_high_retention_ge_threshold": high_any_crossing, "all_high_condition_rate_ge_threshold": high_all_crossing, "all_low_condition_rate_ge_threshold": low_all_crossing, }, "rows": rows, } def main() -> None: parser = argparse.ArgumentParser() parser.add_argument("--ns", default="377,610") parser.add_argument("--phases", default="0,0.25,0.5,0.75") parser.add_argument("--thresholds", default="2.0") parser.add_argument("--trials", type=int, default=5) parser.add_argument("--fibonacci-blocks", default="5,8,13,21,34,55,89,144") parser.add_argument("--non-fibonacci-blocks", default="6,10,16,24,40,64,96,128") parser.add_argument("--top-k", type=int, default=12) parser.add_argument("--max-label", type=int, default=34) parser.add_argument("--crossing-threshold", type=float, default=0.5) parser.add_argument("--seed", type=int, default=202605081805) parser.add_argument("--out", default="tools/data/gap_label_block_scale_gate_20260508_1805.json") args = parser.parse_args() output = run(args) out = Path(args.out) out.parent.mkdir(parents=True, exist_ok=True) out.write_text(json.dumps(output, indent=2), encoding="utf-8") compact = { block: { "family": next(row["block_family"] for row in output["rows"] if row["block_size"] == int(block)), "median_jaccard": data["median_jaccard"], "median_overlap_with_phi_core": data["median_overlap_with_phi_core"], "median_low_retention": data["median_low_retention"], "median_high_retention": data["median_high_retention"], "all_high_condition_rate": data["all_high_condition_rate"], "stable_labels_75pct": data["stable_labels_75pct"], } for block, data in sorted(output["block_summary"].items(), key=lambda item: int(item[0])) } print(json.dumps({ "reference_core_phi": output["reference_core_phi"], "reference_high": output["reference_high"], "crossings": output["crossings"], "blocks": compact, "out": str(out), }, indent=2)) if __name__ == "__main__": main() codex La chiave tecnica è evitare un altro “block shuffle” generico: il nuovo strumento deve costruire i supertile dalla sostituzione Fibonacci e poi confrontare tre perturbazioni con lo stesso lettore di label. Procedo con un file `tools/exp_gap_label_supertile_tiling_gate.py` e output JSON dedicato. exec /bin/bash -lc "test -f tools/data/operator_directive.md && sed -n '1,220p' tools/data/operator_directive.md || true" in /opt/MM_D-ND succeeded in 0ms: exec /bin/bash -lc "sed -n '1,240p' tools/exp_gap_label_generator_gate.py" in /opt/MM_D-ND succeeded in 0ms: #!/usr/bin/env python3 """ Generator gate for phi gap-label stability. The label-set audit moved the observable from the first-two gap ratio to the set of large-gap labels. This tool tests the next denominator: the generator. It keeps the phi label reader fixed and changes the sequence generator while preserving different amounts of structure. """ from __future__ import annotations import argparse import json from collections import defaultdict from pathlib import Path import numpy as np from exp_gap_label_set_stability import PHI, gap_labels, jaccard, sturmian_sequence, summarize_sets THETA = 1 / PHI def fibonacci_word(n: int) -> np.ndarray: word = "1" previous = "0" while len(word) < n: word, previous = word + previous, word return np.array([float(ch) for ch in word[:n]], dtype=float) def rotate(seq: np.ndarray, phase: float) -> np.ndarray: if len(seq) == 0: return seq shift = int(round((phase % 1.0) * len(seq))) return np.roll(seq, shift) def transition_matrix(seq: np.ndarray) -> tuple[np.ndarray, float]: counts = np.ones((2, 2), dtype=float) ints = seq.astype(int) for a, b in zip(ints[:-1], ints[1:]): counts[a, b] += 1 probs = counts / counts.sum(axis=1, keepdims=True) start_prob = float(np.mean(ints)) return probs, start_prob def markov_surrogate(seq: np.ndarray, rng: np.random.Generator) -> np.ndarray: probs, start_prob = transition_matrix(seq) out = np.zeros(len(seq), dtype=float) out[0] = 1.0 if rng.random() < start_prob else 0.0 for i in range(1, len(seq)): prev = int(out[i - 1]) out[i] = 1.0 if rng.random() < probs[prev, 1] else 0.0 return out def balanced_random(seq: np.ndarray, rng: np.random.Generator) -> np.ndarray: out = np.array(seq, dtype=float) rng.shuffle(out) return out def block_shuffle(seq: np.ndarray, block_size: int, rng: np.random.Generator) -> np.ndarray: blocks = [seq[i : i + block_size].copy() for i in range(0, len(seq), block_size)] rng.shuffle(blocks) return np.concatenate(blocks) def generator_sequences(n: int, phase: float, trial: int, rng: np.random.Generator) -> dict[str, np.ndarray]: phi = sturmian_sequence(THETA, n, phase) fib = rotate(fibonacci_word(n), phase) return { "phi_sturmian": phi, "fibonacci_substitution": fib, "markov_phi": markov_surrogate(phi, rng), "block_shuffle_13": block_shuffle(phi, 13, rng), "block_shuffle_34": block_shuffle(phi, 34, rng), "balanced_random": balanced_random(phi, rng), } def summarize_generators(rows: list[dict], reference_core: set[int]) -> dict: output = {} for generator in sorted({row["generator"] for row in rows}): group = [row for row in rows if row["generator"] == generator] summary = summarize_sets(group) if not summary: continue overlaps = [jaccard(set(row["label_set"]), reference_core) for row in group if row["n_selected"] > 0] core = set(summary["core_labels_all_conditions"]) output[generator] = { **summary, "median_overlap_with_phi_core": float(np.median(overlaps)) if overlaps else None, "min_overlap_with_phi_core": float(np.min(overlaps)) if overlaps else None, "reference_core_retained": sorted(core & reference_core, key=lambda x: (abs(x), x)), "reference_core_missing": sorted(reference_core - core, key=lambda x: (abs(x), x)), } return output def run(args: argparse.Namespace) -> dict: rng = np.random.default_rng(args.seed) ns = [int(x) for x in args.ns.split(",")] phases = [float(x) for x in args.phases.split(",")] thresholds = [float(x) for x in args.thresholds.split(",")] rows = [] for n in ns: for phase in phases: for trial in range(args.trials): seqs = generator_sequences(n, phase, trial, rng) for generator, seq in seqs.items(): for threshold in thresholds: obs = gap_labels(seq, THETA, threshold, args.max_label, args.top_k) rows.append({ "generator": generator, "N": n, "phase": phase, "trial": trial, "threshold": threshold, **obs, }) phi_rows = [row for row in rows if row["generator"] == "phi_sturmian"] reference_core = set(summarize_sets(phi_rows)["core_labels_all_conditions"]) summary = summarize_generators(rows, reference_core) by_generator_threshold = defaultdict(list) for row in rows: by_generator_threshold[(row["generator"], row["threshold"])].append(row) threshold_summary = { f"{generator}|threshold={threshold}": summarize_sets(group) for (generator, threshold), group in by_generator_threshold.items() } return { "experiment": "gap_label_generator_gate", "parameters": { "ns": ns, "phases": phases, "thresholds": thresholds, "trials": args.trials, "top_k": args.top_k, "max_label": args.max_label, "seed": args.seed, }, "reference_core_phi": sorted(reference_core, key=lambda x: (abs(x), x)), "summary": summary, "threshold_summary": threshold_summary, "rows": rows, } def main() -> None: parser = argparse.ArgumentParser() parser.add_argument("--ns", default="233,377,500,610") parser.add_argument("--phases", default="0,0.25,0.5,0.75") parser.add_argument("--thresholds", default="1.75,2.0,2.25") parser.add_argument("--trials", type=int, default=3) parser.add_argument("--top-k", type=int, default=12) parser.add_argument("--max-label", type=int, default=34) parser.add_argument("--seed", type=int, default=20260508) parser.add_argument("--out", default="tools/data/gap_label_generator_gate_20260508_1715.json") args = parser.parse_args() output = run(args) out = Path(args.out) out.parent.mkdir(parents=True, exist_ok=True) out.write_text(json.dumps(output, indent=2), encoding="utf-8") compact = { generator: { "median_jaccard": data["median_jaccard"], "min_jaccard": data["min_jaccard"], "median_overlap_with_phi_core": data["median_overlap_with_phi_core"], "reference_core_missing": data["reference_core_missing"], "core_labels_all_conditions": data["core_labels_all_conditions"], } for generator, data in output["summary"].items() } print(json.dumps({ "reference_core_phi": output["reference_core_phi"], "summary": compact, "out": str(out), }, indent=2)) if __name__ == "__main__": main() exec /bin/bash -lc "sed -n '1,240p' tools/exp_gap_label_set_stability.py" in /opt/MM_D-ND succeeded in 0ms: #!/usr/bin/env python3 """ Gap-label set stability for quasiperiodic spectra. The previous denominator audit showed that the first-two gap ratio moves with N, Sturmian phase, and threshold. This tool moves the observable from the value of the first two large gaps to the labels of the large gaps. For each large spectral gap, the integrated density of states is approximated by (gap_index + 1) / N. The nearest gap label is the integer n whose fractional part {n * theta} is closest to that IDS, modulo 1. The label set is then tested for stability across phase, N, and threshold. """ from __future__ import annotations import argparse import itertools import json from collections import Counter, defaultdict from pathlib import Path import numpy as np from numpy.linalg import eigvalsh PHI = (1 + np.sqrt(5)) / 2 SILVER = 1 + np.sqrt(2) BRONZE = 1 + np.sqrt(3) def sturmian_sequence(theta: float, n: int, phase: float = 0.0) -> np.ndarray: idx = np.arange(n + 1, dtype=float) vals = np.floor(idx * theta + phase) return np.diff(vals).astype(float) def hamiltonian(seq: np.ndarray, v: float = 1.0) -> np.ndarray: n = len(seq) h = np.zeros((n, n), dtype=float) h[np.arange(n), np.arange(n)] = v * seq off = np.arange(n - 1) h[off, off + 1] = 1.0 h[off + 1, off] = 1.0 return h def circular_distance(a: float, b: float) -> float: d = abs(a - b) % 1.0 return min(d, 1.0 - d) def nearest_label(ids_value: float, theta: float, max_label: int) -> tuple[int, float, float]: candidates = [] for n in range(-max_label, max_label + 1): if n == 0: continue frac = (n * theta) % 1.0 candidates.append((n, circular_distance(ids_value, frac), frac)) best_n, best_dist, best_frac = min(candidates, key=lambda item: (item[1], abs(item[0]))) return int(best_n), float(best_dist), float(best_frac) def gap_labels(seq: np.ndarray, theta: float, threshold: float, max_label: int, top_k: int) -> dict: eigs = np.sort(eigvalsh(hamiltonian(seq))) spacings = np.diff(eigs) mean_spacing = float(np.mean(spacings)) large = [] for index, spacing in enumerate(spacings): if spacing > threshold * mean_spacing: ids_value = (index + 1) / len(seq) label, error, label_value = nearest_label(ids_value, theta, max_label) large.append({ "index": int(index), "spacing": float(spacing), "ids": float(ids_value), "label": label, "label_error": error, "label_value": label_value, }) by_size = sorted(large, key=lambda item: item["spacing"], reverse=True) selected = by_size[:top_k] label_set = sorted({item["label"] for item in selected}, key=lambda x: (abs(x), x)) errors = [item["label_error"] for item in selected] return { "n_large": len(large), "n_selected": len(selected), "label_set": label_set, "median_label_error": float(np.median(errors)) if errors else None, "max_label_error": float(np.max(errors)) if errors else None, "selected": selected, } def jaccard(a: set[int], b: set[int]) -> float: if not a and not b: return 1.0 return len(a & b) / len(a | b) def summarize_sets(rows: list[dict]) -> dict: sets = [set(row["label_set"]) for row in rows if row["n_selected"] > 0] if not sets: return {} pairwise = [jaccard(a, b) for a, b in itertools.combinations(sets, 2)] counter = Counter(label for s in sets for label in s) n_sets = len(sets) core = sorted( [label for label, count in counter.items() if count == n_sets], key=lambda x: (abs(x), x), ) stable_75 = sorted( [label for label, count in counter.items() if count / n_sets >= 0.75], key=lambda x: (abs(x), x), ) return { "conditions": n_sets, "median_jaccard": float(np.median(pairwise)) if pairwise else 1.0, "min_jaccard": float(np.min(pairwise)) if pairwise else 1.0, "core_labels_all_conditions": core, "stable_labels_75pct": stable_75, "label_frequency_top": [ {"label": int(label), "count": int(count)} for label, count in sorted(counter.items(), key=lambda item: (-item[1], abs(item[0]), item[0]))[:12] ], "median_label_error": float(np.median([row["median_label_error"] for row in rows if row["median_label_error"] is not None])), "median_selected": float(np.median([row["n_selected"] for row in rows])), "median_n_large": float(np.median([row["n_large"] for row in rows])), } def grouped_stability(rows: list[dict], keys: tuple[str, ...]) -> dict: groups: dict[str, list[dict]] = defaultdict(list) for row in rows: group_key = "|".join(f"{key}={row[key]}" for key in keys) groups[group_key].append(row) summaries = [summarize_sets(group_rows) for group_rows in groups.values() if len(group_rows) > 1] summaries = [s for s in summaries if s] if not summaries: return {} return { "groups": len(summaries), "median_jaccard": float(np.median([s["median_jaccard"] for s in summaries])), "min_jaccard": float(np.min([s["min_jaccard"] for s in summaries])), } def run(args: argparse.Namespace) -> dict: rng = np.random.default_rng(args.seed) domains = { "phi": 1 / PHI, "silver": 1 / SILVER, "bronze": 1 / BRONZE, } ns = [int(x) for x in args.ns.split(",")] phases = [float(x) for x in args.phases.split(",")] thresholds = [float(x) for x in args.thresholds.split(",")] rows = [] for n in ns: for phase in phases: phi_ones = int(np.sum(sturmian_sequence(1 / PHI, n, phase))) for threshold in thresholds: for name, theta in domains.items(): seq = sturmian_sequence(theta, n, phase) obs = gap_labels(seq, theta, threshold, args.max_label, args.top_k) rows.append({"domain": name, "N": n, "phase": phase, "threshold": threshold, **obs}) for trial in range(args.random_trials): seq = np.array([1.0] * phi_ones + [0.0] * (n - phi_ones)) rng.shuffle(seq) obs = gap_labels(seq, 1 / PHI, threshold, args.max_label, args.top_k) rows.append({ "domain": "balanced_random_phi_labels", "trial": trial, "N": n, "phase": phase, "threshold": threshold, **obs, }) by_domain = {} for domain in sorted({row["domain"] for row in rows}): domain_rows = [row for row in rows if row["domain"] == domain] by_domain[domain] = { "global": summarize_sets(domain_rows), "phase_stability_by_N_threshold": grouped_stability(domain_rows, ("N", "threshold")), "threshold_stability_by_N_phase": grouped_stability(domain_rows, ("N", "phase")), "scale_stability_by_phase_threshold": grouped_stability(domain_rows, ("phase", "threshold")), } output = { "experiment": "gap_label_set_stability", "parameters": { "ns": ns, "phases": phases, "thresholds": thresholds, "random_trials": args.random_trials, "top_k": args.top_k, "max_label": args.max_label, "seed": args.seed, }, "summary": by_domain, "rows": rows, } return output def main() -> None: parser = argparse.ArgumentParser() parser.add_argument("--ns", default="233,377,500,610") parser.add_argument("--phases", default="0,0.25,0.5,0.75") parser.add_argument("--thresholds", default="1.75,2.0,2.25") parser.add_argument("--random-trials", type=int, default=3) parser.add_argument("--top-k", type=int, default=12) parser.add_argument("--max-label", type=int, default=34) parser.add_argument("--seed", type=int, default=20260508) parser.add_argument("--out", default="tools/data/gap_label_set_stability_20260508_1632.json") args = parser.parse_args() output = run(args) out = Path(args.out) out.parent.mkdir(parents=True, exist_ok=True) out.write_text(json.dumps(output, indent=2), encoding="utf-8") compact = { domain: { "median_jaccard": data["global"].get("median_jaccard"), "stable_labels_75pct": data["global"].get("stable_labels_75pct"), "phase_stability": data["phase_stability_by_N_threshold"].get("median_jaccard"), "threshold_stability": data["threshold_stability_by_N_phase"].get("median_jaccard"), "scale_stability": data["scale_stability_by_phase_threshold"].get("median_jaccard"), } for domain, data in output["summary"].items() } print(json.dumps({"summary": compact, "out": str(out)}, indent=2)) if __name__ == "__main__": exec /bin/bash -lc "sed -n '1,220p' tools/data/reports/agent_20260508_1834.md" in /opt/MM_D-ND succeeded in 0ms: # Agent Report — Substitution Grammar Gate Del Core Phi **Date**: 2026-05-08 18:34 **Piano**: 88 **Tension explored**: M_trascendenza_limite_attuale_L0 (0.529179606750063) **verdict**: CONSTRAINT observables_registry: n/a observables_used: [gap_label_set, block_internal_order, high_label_condition_rate, low_label_condition_rate] **observable_contract**: claim=il core phi dei gap larghi separa lunghezza di blocco e grammatica interna del generatore; observable=retention dei label core sotto perturbazioni che preservano o distruggono ordine interno; operator=Hamiltoniana tight-binding V=1, label IDS con reader theta=1/phi, Jaccard/retention/frequenza per mode e block_size; generator=phi_sturmian con contiguous_block_shuffle, internal_block_shuffle, global_balanced_shuffle; denominator=N={377,610}, phase={0,0.25,0.5,0.75}, threshold={2.0}, trials=5, top_k=12, |n|<=34, block_size={34,40,55,64,89,96,128,144}; not_tested=gap_ratio, soglie 1.75/2.25, N fuori {377,610}, generatori Sturmiani non-phi, tiling esatto in supertile Fibonacci. ## Claim Under Test > Cosa manca per confermare completamente gap_ratio: phi=0.4090 vs ctrl_mean=1.1755 (ratio=0.35). gap_ratio(phi) piu' vici? ## Question Il rientro dei label alti del core phi misura soltanto blocchi lunghi su scala Fibonacci, o misura l'ordine interno di sostituzione conservato dentro quei blocchi? ## Experiment Design - Perimetro: stesso lettore label dei cycle 16:32, 17:15 e 18:05; `gap_ratio` non testato in questo ciclo. - Reference core verificato sul generatore `phi_sturmian`: `[-1, 1, -2, 2, 3, -4, 4, 6]`. - Nucleo basso: `[-1, 1, -2, 2]`. Label alti: `[3, -4, 4, 6]`. - Modes: - `contiguous_block_shuffle`: conserva ordine interno del blocco e mescola l'ordine tra blocchi. - `internal_block_shuffle`: conserva lunghezza e conteggio di ogni blocco, ma mescola i simboli dentro il blocco. - `global_balanced_shuffle`: conserva solo conteggio globale. - Blocchi Fibonacci: `34, 55, 89, 144`. Blocchi non-Fibonacci: `40, 64, 96, 128`. - Denominatori grezzi: per ogni `mode|block_size`, 40 condizioni (`2 N * 4 phase * 1 threshold * 5 trials`); per `global_balanced_shuffle`, 40 condizioni totali. ## Results Reference phi su 8 condizioni (`N x phase x threshold`): core completo `[-1, 1, -2, 2, 3, -4, 4, 6]`, Jaccard mediano `0.909091`, min `0.727273`. Sintesi per mode: | mode | conditions | median Jaccard | low retention | high retention | all-high condition rate | |---|---:|---:|---:|---:|---:| | contiguous_block_shuffle | 320 | 0.583333 | 1.00 | 0.50 | 82/320 = 0.25625 | | internal_block_shuffle | 320 | 0.157895 | 0.25 | 0.25 | 0/320 = 0.00000 | | global_balanced_shuffle | 40 | 0.150000 | 0.25 | 0.25 | 0/40 = 0.00000 | Dettaglio per blocco: | mode | block_size | family | median Jaccard | low retention | high retention | all-high condition rate | stable labels 75% | |---|---:|---|---:|---:|---:|---:|---| | contiguous_block_shuffle | 34 | Fibonacci | 0.666667 | 1.00 | 0.50 | 3/40 = 0.075 | [-1, 1, -2, 2, -4, 4] | | contiguous_block_shuffle | 40 | non-Fibonacci | 0.500000 | 0.75 | 0.00 | 0/40 = 0.000 | [-1, 1, -2] | | contiguous_block_shuffle | 55 | Fibonacci | 0.750000 | 1.00 | 0.75 | 11/40 = 0.275 | [-1, 1, -2, 2, -3, 3, -4, 4] | | contiguous_block_shuffle | 64 | non-Fibonacci | 0.571429 | 1.00 | 0.25 | 0/40 = 0.000 | [-1, 1, -2, 2] | | contiguous_block_shuffle | 89 | Fibonacci | 0.818182 | 1.00 | 1.00 | 26/40 = 0.650 | [-1, 1, -2, 2, -3, 3, -4, 4] | | contiguous_block_shuffle | 96 | non-Fibonacci | 0.625000 | 1.00 | 0.50 | 3/40 = 0.075 | [-1, 1, -2, 2] | | contiguous_block_shuffle | 128 | non-Fibonacci | 0.666667 | 1.00 | 0.75 | 7/40 = 0.175 | [-1, 1, -2, 2, -4, 4] | | contiguous_block_shuffle | 144 | Fibonacci | 0.909091 | 1.00 | 1.00 | 32/40 = 0.800 | [-1, 1, -2, 2, -3, 3, -4, 4, -6, 6] | | internal_block_shuffle | 34 | Fibonacci | 0.157895 | 0.25 | 0.25 | 0/40 = 0.000 | [34] | | internal_block_shuffle | 40 | non-Fibonacci | 0.157895 | 0.25 | 0.25 | 0/40 = 0.000 | [34] | | internal_block_shuffle | 55 | Fibonacci | 0.150000 | 0.25 | 0.25 | 0/40 = 0.000 | [34] | | internal_block_shuffle | 64 | non-Fibonacci | 0.157895 | 0.25 | 0.25 | 0/40 = 0.000 | [34] | | internal_block_shuffle | 89 | Fibonacci | 0.157895 | 0.25 | 0.25 | 0/40 = 0.000 | [34] | | internal_block_shuffle | 96 | non-Fibonacci | 0.166667 | 0.25 | 0.25 | 0/40 = 0.000 | [34] | | internal_block_shuffle | 128 | non-Fibonacci | 0.166667 | 0.25 | 0.25 | 0/40 = 0.000 | [34] | | internal_block_shuffle | 144 | Fibonacci | 0.157895 | 0.25 | 0.25 | 0/40 = 0.000 | [34] | | global_balanced_shuffle | n/a | none | 0.150000 | 0.25 | 0.25 | 0/40 = 0.000 | [34] | ## Key Findings 1. **Verificato: distruggere l'ordine interno del blocco collassa il core al livello random.** `internal_block_shuffle` resta su Jaccard mediano `0.150000-0.166667`, low retention `0.25`, high retention `0.25`, all-high `0/40` per ogni block_size. Il suo profilo coincide con `global_balanced_shuffle` entro il perimetro osservato. 2. **Verificato: il vantaggio dei blocchi Fibonacci lunghi dipende dall'ordine interno conservato.** Con `contiguous_block_shuffle`, `89` porta all-high `26/40` e `144` porta `32/40`; con `internal_block_shuffle`, gli stessi `89` e `144` restano `0/40`. La lunghezza e il conteggio del blocco non trasportano il core alto quando l'ordine interno e' rimosso. 3. **Verificato: gli edge case non-Fibonacci restano parziali, non nulli.** `128` conserva `-4` e `4` come stable labels 75% e ha high retention mediana `0.75`, ma all-high resta `7/40`. Questo impedisce la formula "solo Fibonacci"; la formula valida e' che, in questo perimetro, l'ordine interno conservato e le scale Fibonacci lunghe aumentano insieme la frequenza del core alto completo. 4. **Inferito dal confronto 18:05 -> 18:34: il nodo regressivo non era solo block_size.** Il cycle 18:05 vedeva scala Fibonacci; questo cycle localizza la condizione mancante dentro il blocco: la grammatica interna del generatore deve restare leggibile. Il test non isola ancora il tiling esatto in supertile Fibonacci. ## Verdict **CONSTRAINT on TRASCENDENZA_LIMITE / QPG_GAP_RATIO_DENOMINATOR_GATE**: nel perimetro `N={377,610}`, `phase={0,0.25,0.5,0.75}`, `threshold={2.0}`, `trials=5`, `top_k=12`, `|n|<=34`, il core alto `[3, -4, 4, 6]` non e' portato da lunghezza e conteggio del blocco. Quando il blocco conserva ordine interno, le scale Fibonacci `89` e `144` rendono frequente il core alto completo (`26/40`, `32/40`). Quando l'ordine interno viene distrutto dentro gli stessi blocchi, il core alto completo non compare (`0/40`) e il profilo cade sul controllo bilanciato globale. La formulazione valida e': il label-set alto phi misura memoria di grammatica interna del generatore su blocchi lunghi, con vantaggio forte alle scale Fibonacci testate; non misura lunghezza generica, conteggio di simboli o valore `gap_ratio`. ## Bicono della scoperta - **Due radici**: blocco come lunghezza/conteggio · blocco come grammatica ordinata. - **Singolare**: il blocco stesso, prima della scelta tra memoria interna e contenitore numerico. - **Invariante di passaggio**: il lettore label theta=1/phi e il perimetro spettrale restano fissi; cambia solo la leggibilita dell'ordine interno. - **Campo di possibilita**: qui diventa possibile testare supertile Fibonacci esatti contro blocchi contigui arbitrari; qui diventa non-possibile spiegare il core alto con sola lunghezza o densita locale. ## Consecutio Costruire un `supertile_tiling_gate`: segmentare la parola phi in supertile Fibonacci reali e confrontare tre perturbazioni separate, `supertile_shuffle`, `same_length_contiguous_shuffle`, `same_count_internal_shuffle`. Se il supertile batte il blocco contiguo alla stessa lunghezza, la grammatica non e' solo interna al blocco ma vive anche nel confine tra supertile. ## Auto-audit: 5 lenti - **L1 hard constraint vs bias**: il verdict dichiara perimetro, denominator e count grezzi; non formula universalita su tutti i generatori Sturmiani. - **L2 quantita vs ratio**: Jaccard, retention e all-high rate restano separati; `gap_ratio` dichiarato non testato. - **L3 no silent patching**: il claim precedente su block_size viene raffinato al nodo regressivo interno; il report non salva il framing "solo Fibonacci" perche `128` e' parziale. - **L4 edge cases**: `128` non-Fibonacci e' nominato come parziale forte (`7/40`, high retention `0.75`), non trattato come rumore. - **L5 re-discovery**: gap labeling e Sturmian sono meccanismi noti; il finding del cycle e' la separazione sperimentale tra lunghezza/conteggio e ordine interno del blocco. ## Files - Script: `tools/exp_gap_label_substitution_grammar_gate.py` - Data: `tools/data/gap_label_substitution_grammar_gate_20260508_1834.json` - Report: `tools/data/reports/agent_20260508_1834.md` codex Prima dell’edit ho controllato che non ci sia `operator_directive.md`; non c’è override one-shot. Uso quindi la consecutio del campo vivo e il risultato 18:34 come nodo regressivo: isolare confine di supertile, non solo ordine interno. apply patch patch: completed /opt/MM_D-ND/tools/exp_gap_label_supertile_tiling_gate.py diff --git a/tools/exp_gap_label_supertile_tiling_gate.py b/tools/exp_gap_label_supertile_tiling_gate.py new file mode 100644 index 0000000000000000000000000000000000000000..bde361d77f2db31c8f98bf3fd24d345ad67fd132 --- /dev/null +++ b/tools/exp_gap_label_supertile_tiling_gate.py @@ -0,0 +1,278 @@ +#!/usr/bin/env python3 +""" +Supertile tiling gate for the phi gap-label core. + +The substitution-grammar gate showed that length and symbol count do not carry +the high labels when internal order is destroyed. This tool moves one node +upstream: it separates true Fibonacci supertile boundaries from contiguous +chunks with the same length multiset. +""" + +from __future__ import annotations + +import argparse +import json +from collections import Counter, defaultdict +from pathlib import Path + +import numpy as np + +from exp_gap_label_block_scale_gate import ( + REFERENCE_HIGH, + REFERENCE_LOW, + label_sort, + parse_floats, + parse_ints, + retention, +) +from exp_gap_label_generator_gate import THETA, block_shuffle +from exp_gap_label_set_stability import gap_labels, jaccard, sturmian_sequence, summarize_sets + + +def fibonacci_lengths(order: int) -> tuple[int, int]: + if order < 2: + raise ValueError("supertile_order must be >= 2") + a, b = 1, 1 + for _ in range(2, order + 1): + a, b = b, a + b + return b, a + + +def fibonacci_type_word(n_types: int) -> np.ndarray: + word = "1" + previous = "0" + while len(word) < n_types: + word, previous = word + previous, word + return np.array([int(ch) for ch in word[:n_types]], dtype=int) + + +def supertile_lengths(n: int, order: int) -> list[int]: + long_len, short_len = fibonacci_lengths(order) + types = fibonacci_type_word(max(8, int(np.ceil(n / short_len)) + 4)) + lengths: list[int] = [] + total = 0 + for t in types: + length = long_len if t == 1 else short_len + if total + length >= n: + lengths.append(n - total) + break + lengths.append(length) + total += length + return [length for length in lengths if length > 0] + + +def chunks_from_lengths(seq: np.ndarray, lengths: list[int]) -> list[np.ndarray]: + chunks = [] + start = 0 + for length in lengths: + chunks.append(seq[start : start + length].copy()) + start += length + if start < len(seq): + chunks.append(seq[start:].copy()) + return chunks + + +def shuffle_chunks(chunks: list[np.ndarray], rng: np.random.Generator) -> np.ndarray: + shuffled = list(chunks) + rng.shuffle(shuffled) + return np.concatenate(shuffled) + + +def internal_count_shuffle(chunks: list[np.ndarray], rng: np.random.Generator) -> np.ndarray: + out = [] + for chunk in chunks: + copied = chunk.copy() + rng.shuffle(copied) + out.append(copied) + return np.concatenate(out) + + +def misaligned_same_lengths(seq: np.ndarray, lengths: list[int], rng: np.random.Generator) -> np.ndarray: + if len(seq) < 2: + return seq.copy() + offset = int(rng.integers(1, len(seq))) + rotated = np.roll(seq, -offset) + chunks = chunks_from_lengths(rotated, lengths) + shuffled = shuffle_chunks(chunks, rng) + return np.roll(shuffled, offset) + + +def fixed_block_same_mean(seq: np.ndarray, lengths: list[int], rng: np.random.Generator) -> np.ndarray: + mean_len = max(1, int(round(float(np.mean(lengths))))) + return block_shuffle(seq, mean_len, rng) + + +def summarize_rows(rows: list[dict], reference_core: set[int]) -> dict: + summary = summarize_sets(rows) + sets = [set(row["label_set"]) for row in rows if row["n_selected"] > 0] + counter = Counter(label for s in sets for label in s) + n_sets = len(sets) + overlaps = [jaccard(set(row["label_set"]), reference_core) for row in rows if row["n_selected"] > 0] + + return { + **summary, + "median_overlap_with_phi_core": float(np.median(overlaps)) if overlaps else None, + "median_low_retention": float(np.median([retention(row, REFERENCE_LOW) for row in rows])), + "median_high_retention": float(np.median([retention(row, REFERENCE_HIGH) for row in rows])), + "all_low_count": int(sum(REFERENCE_LOW <= s for s in sets)), + "all_high_count": int(sum(REFERENCE_HIGH <= s for s in sets)), + "condition_count": int(n_sets), + "all_low_condition_rate": float(sum(REFERENCE_LOW <= s for s in sets) / n_sets) if n_sets else None, + "all_high_condition_rate": float(sum(REFERENCE_HIGH <= s for s in sets) / n_sets) if n_sets else None, + "high_label_condition_rates": { + str(label): float(counter.get(label, 0) / n_sets) if n_sets else None + for label in label_sort(REFERENCE_HIGH) + }, + "low_label_condition_rates": { + str(label): float(counter.get(label, 0) / n_sets) if n_sets else None + for label in label_sort(REFERENCE_LOW) + }, + "reference_core_retained_in_all": label_sort(set(summary.get("core_labels_all_conditions", [])) & reference_core), + "reference_core_missing_from_all": label_sort(reference_core - set(summary.get("core_labels_all_conditions", []))), + } + + +def run(args: argparse.Namespace) -> dict: + rng = np.random.default_rng(args.seed) + ns = parse_ints(args.ns) + phases = parse_floats(args.phases) + thresholds = parse_floats(args.thresholds) + orders = parse_ints(args.supertile_orders) + + reference_rows = [] + rows = [] + tiling_meta = {} + for n in ns: + for phase in phases: + phi = sturmian_sequence(THETA, n, phase) + for threshold in thresholds: + reference_rows.append({ + "mode": "reference_phi", + "N": n, + "phase": phase, + "threshold": threshold, + **gap_labels(phi, THETA, threshold, args.max_label, args.top_k), + }) + + for order in orders: + lengths = supertile_lengths(n, order) + tiling_meta[f"N={n}|order={order}"] = { + "lengths": lengths, + "count": len(lengths), + "total": sum(lengths), + "unique_lengths": sorted(set(lengths)), + } + aligned_chunks = chunks_from_lengths(phi, lengths) + mean_block = max(1, int(round(float(np.mean(lengths))))) + for trial in range(args.trials): + variants = { + "supertile_shuffle": shuffle_chunks(aligned_chunks, rng), + "same_length_contiguous_shuffle": misaligned_same_lengths(phi, lengths, rng), + "same_count_internal_shuffle": internal_count_shuffle(aligned_chunks, rng), + "same_mean_block_shuffle": fixed_block_same_mean(phi, lengths, rng), + } + for mode, seq in variants.items(): + for threshold in thresholds: + rows.append({ + "mode": mode, + "N": n, + "phase": phase, + "threshold": threshold, + "trial": trial, + "supertile_order": order, + "mean_block": mean_block, + **gap_labels(seq, THETA, threshold, args.max_label, args.top_k), + }) + + reference_summary = summarize_sets(reference_rows) + reference_core = set(reference_summary["core_labels_all_conditions"]) + + grouped: dict[str, list[dict]] = defaultdict(list) + for row in rows: + grouped[f"{row['mode']}|order={row['supertile_order']}"].append(row) + + mode_order_summary = { + key: summarize_rows(group_rows, reference_core) + for key, group_rows in grouped.items() + } + + mode_summary = {} + for mode in sorted({row["mode"] for row in rows}): + mode_rows = [row for row in rows if row["mode"] == mode] + mode_summary[mode] = summarize_rows(mode_rows, reference_core) + + return { + "experiment": "gap_label_supertile_tiling_gate", + "parameters": { + "ns": ns, + "phases": phases, + "thresholds": thresholds, + "trials": args.trials, + "supertile_orders": orders, + "top_k": args.top_k, + "max_label": args.max_label, + "seed": args.seed, + }, + "reference_core_phi": label_sort(reference_core), + "reference_low": label_sort(REFERENCE_LOW), + "reference_high": label_sort(REFERENCE_HIGH), + "reference_summary": reference_summary, + "tiling_meta": tiling_meta, + "mode_order_summary": mode_order_summary, + "mode_summary": mode_summary, + "rows": rows, + } + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--ns", default="377,610") + parser.add_argument("--phases", default="0,0.25,0.5,0.75") + parser.add_argument("--thresholds", default="2.0") + parser.add_argument("--trials", type=int, default=5) + parser.add_argument("--supertile-orders", default="8,9,10,11") + parser.add_argument("--top-k", type=int, default=12) + parser.add_argument("--max-label", type=int, default=34) + parser.add_argument("--seed", type=int, default=202605081909) + parser.add_argument("--out", default="tools/data/gap_label_supertile_tiling_gate_20260508_1909.json") + args = parser.parse_args() + + output = run(args) + out = Path(args.out) + out.parent.mkdir(parents=True, exist_ok=True) + out.write_text(json.dumps(output, indent=2), encoding="utf-8") + + compact = {} + for key, data in sorted(output["mode_order_summary"].items()): + mode, order = key.split("|") + compact[key] = { + "mode": mode, + "supertile_order": int(order.split("=")[1]), + "median_jaccard": data["median_jaccard"], + "low_retention": data["median_low_retention"], + "high_retention": data["median_high_retention"], + "all_high": f"{data['all_high_count']}/{data['condition_count']}", + "all_high_condition_rate": data["all_high_condition_rate"], + "stable_labels_75pct": data["stable_labels_75pct"], + } + + print(json.dumps({ + "reference_core_phi": output["reference_core_phi"], + "reference_high": output["reference_high"], + "mode_summary": { + mode: { + "median_jaccard": data["median_jaccard"], + "low_retention": data["median_low_retention"], + "high_retention": data["median_high_retention"], + "all_high": f"{data['all_high_count']}/{data['condition_count']}", + "all_high_condition_rate": data["all_high_condition_rate"], + } + for mode, data in output["mode_summary"].items() + }, + "orders": compact, + "out": str(out), + }, indent=2)) + + +if __name__ == "__main__": + main() diff --git a/tools/exp_gap_label_supertile_tiling_gate.py b/tools/exp_gap_label_supertile_tiling_gate.py new file mode 100644 index 0000000000000000000000000000000000000000..bde361d77f2db31c8f98bf3fd24d345ad67fd132 --- /dev/null +++ b/tools/exp_gap_label_supertile_tiling_gate.py @@ -0,0 +1,278 @@ +#!/usr/bin/env python3 +""" +Supertile tiling gate for the phi gap-label core. + +The substitution-grammar gate showed that length and symbol count do not carry +the high labels when internal order is destroyed. This tool moves one node +upstream: it separates true Fibonacci supertile boundaries from contiguous +chunks with the same length multiset. +""" + +from __future__ import annotations + +import argparse +import json +from collections import Counter, defaultdict +from pathlib import Path + +import numpy as np + +from exp_gap_label_block_scale_gate import ( + REFERENCE_HIGH, + REFERENCE_LOW, + label_sort, + parse_floats, + parse_ints, + retention, +) +from exp_gap_label_generator_gate import THETA, block_shuffle +from exp_gap_label_set_stability import gap_labels, jaccard, sturmian_sequence, summarize_sets + + +def fibonacci_lengths(order: int) -> tuple[int, int]: + if order < 2: + raise ValueError("supertile_order must be >= 2") + a, b = 1, 1 + for _ in range(2, order + 1): + a, b = b, a + b + return b, a + + +def fibonacci_type_word(n_types: int) -> np.ndarray: + word = "1" + previous = "0" + while len(word) < n_types: + word, previous = word + previous, word + return np.array([int(ch) for ch in word[:n_types]], dtype=int) + + +def supertile_lengths(n: int, order: int) -> list[int]: + long_len, short_len = fibonacci_lengths(order) + types = fibonacci_type_word(max(8, int(np.ceil(n / short_len)) + 4)) + lengths: list[int] = [] + total = 0 + for t in types: + length = long_len if t == 1 else short_len + if total + length >= n: + lengths.append(n - total) + break + lengths.append(length) + total += length + return [length for length in lengths if length > 0] + + +def chunks_from_lengths(seq: np.ndarray, lengths: list[int]) -> list[np.ndarray]: + chunks = [] + start = 0 + for length in lengths: + chunks.append(seq[start : start + length].copy()) + start += length + if start < len(seq): + chunks.append(seq[start:].copy()) + return chunks + + +def shuffle_chunks(chunks: list[np.ndarray], rng: np.random.Generator) -> np.ndarray: + shuffled = list(chunks) + rng.shuffle(shuffled) + return np.concatenate(shuffled) + + +def internal_count_shuffle(chunks: list[np.ndarray], rng: np.random.Generator) -> np.ndarray: + out = [] + for chunk in chunks: + copied = chunk.copy() + rng.shuffle(copied) + out.append(copied) + return np.concatenate(out) + + +def misaligned_same_lengths(seq: np.ndarray, lengths: list[int], rng: np.random.Generator) -> np.ndarray: + if len(seq) < 2: + return seq.copy() + offset = int(rng.integers(1, len(seq))) + rotated = np.roll(seq, -offset) + chunks = chunks_from_lengths(rotated, lengths) + shuffled = shuffle_chunks(chunks, rng) + return np.roll(shuffled, offset) + + +def fixed_block_same_mean(seq: np.ndarray, lengths: list[int], rng: np.random.Generator) -> np.ndarray: + mean_len = max(1, int(round(float(np.mean(lengths))))) + return block_shuffle(seq, mean_len, rng) + + +def summarize_rows(rows: list[dict], reference_core: set[int]) -> dict: + summary = summarize_sets(rows) + sets = [set(row["label_set"]) for row in rows if row["n_selected"] > 0] + counter = Counter(label for s in sets for label in s) + n_sets = len(sets) + overlaps = [jaccard(set(row["label_set"]), reference_core) for row in rows if row["n_selected"] > 0] + + return { + **summary, + "median_overlap_with_phi_core": float(np.median(overlaps)) if overlaps else None, + "median_low_retention": float(np.median([retention(row, REFERENCE_LOW) for row in rows])), + "median_high_retention": float(np.median([retention(row, REFERENCE_HIGH) for row in rows])), + "all_low_count": int(sum(REFERENCE_LOW <= s for s in sets)), + "all_high_count": int(sum(REFERENCE_HIGH <= s for s in sets)), + "condition_count": int(n_sets), + "all_low_condition_rate": float(sum(REFERENCE_LOW <= s for s in sets) / n_sets) if n_sets else None, + "all_high_condition_rate": float(sum(REFERENCE_HIGH <= s for s in sets) / n_sets) if n_sets else None, + "high_label_condition_rates": { + str(label): float(counter.get(label, 0) / n_sets) if n_sets else None + for label in label_sort(REFERENCE_HIGH) + }, + "low_label_condition_rates": { + str(label): float(counter.get(label, 0) / n_sets) if n_sets else None + for label in label_sort(REFERENCE_LOW) + }, + "reference_core_retained_in_all": label_sort(set(summary.get("core_labels_all_conditions", [])) & reference_core), + "reference_core_missing_from_all": label_sort(reference_core - set(summary.get("core_labels_all_conditions", []))), + } + + +def run(args: argparse.Namespace) -> dict: + rng = np.random.default_rng(args.seed) + ns = parse_ints(args.ns) + phases = parse_floats(args.phases) + thresholds = parse_floats(args.thresholds) + orders = parse_ints(args.supertile_orders) + + reference_rows = [] + rows = [] + tiling_meta = {} + for n in ns: + for phase in phases: + phi = sturmian_sequence(THETA, n, phase) + for threshold in thresholds: + reference_rows.append({ + "mode": "reference_phi", + "N": n, + "phase": phase, + "threshold": threshold, + **gap_labels(phi, THETA, threshold, args.max_label, args.top_k), + }) + + for order in orders: + lengths = supertile_lengths(n, order) + tiling_meta[f"N={n}|order={order}"] = { + "lengths": lengths, + "count": len(lengths), + "total": sum(lengths), + "unique_lengths": sorted(set(lengths)), + } + aligned_chunks = chunks_from_lengths(phi, lengths) + mean_block = max(1, int(round(float(np.mean(lengths))))) + for trial in range(args.trials): + variants = { + "supertile_shuffle": shuffle_chunks(aligned_chunks, rng), + "same_length_contiguous_shuffle": misaligned_same_lengths(phi, lengths, rng), + "same_count_internal_shuffle": internal_count_shuffle(aligned_chunks, rng), + "same_mean_block_shuffle": fixed_block_same_mean(phi, lengths, rng), + } + for mode, seq in variants.items(): + for threshold in thresholds: + rows.append({ + "mode": mode, + "N": n, + "phase": phase, + "threshold": threshold, + "trial": trial, + "supertile_order": order, + "mean_block": mean_block, + **gap_labels(seq, THETA, threshold, args.max_label, args.top_k), + }) + + reference_summary = summarize_sets(reference_rows) + reference_core = set(reference_summary["core_labels_all_conditions"]) + + grouped: dict[str, list[dict]] = defaultdict(list) + for row in rows: + grouped[f"{row['mode']}|order={row['supertile_order']}"].append(row) + + mode_order_summary = { + key: summarize_rows(group_rows, reference_core) + for key, group_rows in grouped.items() + } + + mode_summary = {} + for mode in sorted({row["mode"] for row in rows}): + mode_rows = [row for row in rows if row["mode"] == mode] + mode_summary[mode] = summarize_rows(mode_rows, reference_core) + + return { + "experiment": "gap_label_supertile_tiling_gate", + "parameters": { + "ns": ns, + "phases": phases, + "thresholds": thresholds, + "trials": args.trials, + "supertile_orders": orders, + "top_k": args.top_k, + "max_label": args.max_label, + "seed": args.seed, + }, + "reference_core_phi": label_sort(reference_core), + "reference_low": label_sort(REFERENCE_LOW), + "reference_high": label_sort(REFERENCE_HIGH), + "reference_summary": reference_summary, + "tiling_meta": tiling_meta, + "mode_order_summary": mode_order_summary, + "mode_summary": mode_summary, + "rows": rows, + } + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--ns", default="377,610") + parser.add_argument("--phases", default="0,0.25,0.5,0.75") + parser.add_argument("--thresholds", default="2.0") + parser.add_argument("--trials", type=int, default=5) + parser.add_argument("--supertile-orders", default="8,9,10,11") + parser.add_argument("--top-k", type=int, default=12) + parser.add_argument("--max-label", type=int, default=34) + parser.add_argument("--seed", type=int, default=202605081909) + parser.add_argument("--out", default="tools/data/gap_label_supertile_tiling_gate_20260508_1909.json") + args = parser.parse_args() + + output = run(args) + out = Path(args.out) + out.parent.mkdir(parents=True, exist_ok=True) + out.write_text(json.dumps(output, indent=2), encoding="utf-8") + + compact = {} + for key, data in sorted(output["mode_order_summary"].items()): + mode, order = key.split("|") + compact[key] = { + "mode": mode, + "supertile_order": int(order.split("=")[1]), + "median_jaccard": data["median_jaccard"], + "low_retention": data["median_low_retention"], + "high_retention": data["median_high_retention"], + "all_high": f"{data['all_high_count']}/{data['condition_count']}", + "all_high_condition_rate": data["all_high_condition_rate"], + "stable_labels_75pct": data["stable_labels_75pct"], + } + + print(json.dumps({ + "reference_core_phi": output["reference_core_phi"], + "reference_high": output["reference_high"], + "mode_summary": { + mode: { + "median_jaccard": data["median_jaccard"], + "low_retention": data["median_low_retention"], + "high_retention": data["median_high_retention"], + "all_high": f"{data['all_high_count']}/{data['condition_count']}", + "all_high_condition_rate": data["all_high_condition_rate"], + } + for mode, data in output["mode_summary"].items() + }, + "orders": compact, + "out": str(out), + }, indent=2)) + + +if __name__ == "__main__": + main() codex Lo script è aggiunto. Ora lo eseguo sul perimetro stretto del ciclo precedente (`N={377,610}`, quattro fasi, threshold 2.0) con ordini supertile 8-11, così il confronto resta leggibile e non cambia osservabile. exec /bin/bash -lc 'python tools/exp_gap_label_supertile_tiling_gate.py' in /opt/MM_D-ND diff --git a/tools/exp_gap_label_supertile_tiling_gate.py b/tools/exp_gap_label_supertile_tiling_gate.py new file mode 100644 index 0000000000000000000000000000000000000000..bde361d77f2db31c8f98bf3fd24d345ad67fd132 --- /dev/null +++ b/tools/exp_gap_label_supertile_tiling_gate.py @@ -0,0 +1,278 @@ +#!/usr/bin/env python3 +""" +Supertile tiling gate for the phi gap-label core. + +The substitution-grammar gate showed that length and symbol count do not carry +the high labels when internal order is destroyed. This tool moves one node +upstream: it separates true Fibonacci supertile boundaries from contiguous +chunks with the same length multiset. +""" + +from __future__ import annotations + +import argparse +import json +from collections import Counter, defaultdict +from pathlib import Path + +import numpy as np + +from exp_gap_label_block_scale_gate import ( + REFERENCE_HIGH, + REFERENCE_LOW, + label_sort, + parse_floats, + parse_ints, + retention, +) +from exp_gap_label_generator_gate import THETA, block_shuffle +from exp_gap_label_set_stability import gap_labels, jaccard, sturmian_sequence, summarize_sets + + +def fibonacci_lengths(order: int) -> tuple[int, int]: + if order < 2: + raise ValueError("supertile_order must be >= 2") + a, b = 1, 1 + for _ in range(2, order + 1): + a, b = b, a + b + return b, a + + +def fibonacci_type_word(n_types: int) -> np.ndarray: + word = "1" + previous = "0" + while len(word) < n_types: + word, previous = word + previous, word + return np.array([int(ch) for ch in word[:n_types]], dtype=int) + + +def supertile_lengths(n: int, order: int) -> list[int]: + long_len, short_len = fibonacci_lengths(order) + types = fibonacci_type_word(max(8, int(np.ceil(n / short_len)) + 4)) + lengths: list[int] = [] + total = 0 + for t in types: + length = long_len if t == 1 else short_len + if total + length >= n: + lengths.append(n - total) + break + lengths.append(length) + total += length + return [length for length in lengths if length > 0] + + +def chunks_from_lengths(seq: np.ndarray, lengths: list[int]) -> list[np.ndarray]: + chunks = [] + start = 0 + for length in lengths: + chunks.append(seq[start : start + length].copy()) + start += length + if start < len(seq): + chunks.append(seq[start:].copy()) + return chunks + + +def shuffle_chunks(chunks: list[np.ndarray], rng: np.random.Generator) -> np.ndarray: + shuffled = list(chunks) + rng.shuffle(shuffled) + return np.concatenate(shuffled) + + +def internal_count_shuffle(chunks: list[np.ndarray], rng: np.random.Generator) -> np.ndarray: + out = [] + for chunk in chunks: + copied = chunk.copy() + rng.shuffle(copied) + out.append(copied) + return np.concatenate(out) + + +def misaligned_same_lengths(seq: np.ndarray, lengths: list[int], rng: np.random.Generator) -> np.ndarray: + if len(seq) < 2: + return seq.copy() + offset = int(rng.integers(1, len(seq))) + rotated = np.roll(seq, -offset) + chunks = chunks_from_lengths(rotated, lengths) + shuffled = shuffle_chunks(chunks, rng) + return np.roll(shuffled, offset) + + +def fixed_block_same_mean(seq: np.ndarray, lengths: list[int], rng: np.random.Generator) -> np.ndarray: + mean_len = max(1, int(round(float(np.mean(lengths))))) + return block_shuffle(seq, mean_len, rng) + + +def summarize_rows(rows: list[dict], reference_core: set[int]) -> dict: + summary = summarize_sets(rows) + sets = [set(row["label_set"]) for row in rows if row["n_selected"] > 0] + counter = Counter(label for s in sets for label in s) + n_sets = len(sets) + overlaps = [jaccard(set(row["label_set"]), reference_core) for row in rows if row["n_selected"] > 0] + + return { + **summary, + "median_overlap_with_phi_core": float(np.median(overlaps)) if overlaps else None, + "median_low_retention": float(np.median([retention(row, REFERENCE_LOW) for row in rows])), + "median_high_retention": float(np.median([retention(row, REFERENCE_HIGH) for row in rows])), + "all_low_count": int(sum(REFERENCE_LOW <= s for s in sets)), + "all_high_count": int(sum(REFERENCE_HIGH <= s for s in sets)), + "condition_count": int(n_sets), + "all_low_condition_rate": float(sum(REFERENCE_LOW <= s for s in sets) / n_sets) if n_sets else None, + "all_high_condition_rate": float(sum(REFERENCE_HIGH <= s for s in sets) / n_sets) if n_sets else None, + "high_label_condition_rates": { + str(label): float(counter.get(label, 0) / n_sets) if n_sets else None + for label in label_sort(REFERENCE_HIGH) + }, + "low_label_condition_rates": { + str(label): float(counter.get(label, 0) / n_sets) if n_sets else None + for label in label_sort(REFERENCE_LOW) + }, + "reference_core_retained_in_all": label_sort(set(summary.get("core_labels_all_conditions", [])) & reference_core), + "reference_core_missing_from_all": label_sort(reference_core - set(summary.get("core_labels_all_conditions", []))), + } + + +def run(args: argparse.Namespace) -> dict: + rng = np.random.default_rng(args.seed) + ns = parse_ints(args.ns) + phases = parse_floats(args.phases) + thresholds = parse_floats(args.thresholds) + orders = parse_ints(args.supertile_orders) + + reference_rows = [] + rows = [] + tiling_meta = {} + for n in ns: + for phase in phases: + phi = sturmian_sequence(THETA, n, phase) + for threshold in thresholds: + reference_rows.append({ + "mode": "reference_phi", + "N": n, + "phase": phase, + "threshold": threshold, + **gap_labels(phi, THETA, threshold, args.max_label, args.top_k), + }) + + for order in orders: + lengths = supertile_lengths(n, order) + tiling_meta[f"N={n}|order={order}"] = { + "lengths": lengths, + "count": len(lengths), + "total": sum(lengths), + "unique_lengths": sorted(set(lengths)), + } + aligned_chunks = chunks_from_lengths(phi, lengths) + mean_block = max(1, int(round(float(np.mean(lengths))))) + for trial in range(args.trials): + variants = { + "supertile_shuffle": shuffle_chunks(aligned_chunks, rng), + "same_length_contiguous_shuffle": misaligned_same_lengths(phi, lengths, rng), + "same_count_internal_shuffle": internal_count_shuffle(aligned_chunks, rng), + "same_mean_block_shuffle": fixed_block_same_mean(phi, lengths, rng), + } + for mode, seq in variants.items(): + for threshold in thresholds: + rows.append({ + "mode": mode, + "N": n, + "phase": phase, + "threshold": threshold, + "trial": trial, + "supertile_order": order, + "mean_block": mean_block, + **gap_labels(seq, THETA, threshold, args.max_label, args.top_k), + }) + + reference_summary = summarize_sets(reference_rows) + reference_core = set(reference_summary["core_labels_all_conditions"]) + + grouped: dict[str, list[dict]] = defaultdict(list) + for row in rows: + grouped[f"{row['mode']}|order={row['supertile_order']}"].append(row) + + mode_order_summary = { + key: summarize_rows(group_rows, reference_core) + for key, group_rows in grouped.items() + } + + mode_summary = {} + for mode in sorted({row["mode"] for row in rows}): + mode_rows = [row for row in rows if row["mode"] == mode] + mode_summary[mode] = summarize_rows(mode_rows, reference_core) + + return { + "experiment": "gap_label_supertile_tiling_gate", + "parameters": { + "ns": ns, + "phases": phases, + "thresholds": thresholds, + "trials": args.trials, + "supertile_orders": orders, + "top_k": args.top_k, + "max_label": args.max_label, + "seed": args.seed, + }, + "reference_core_phi": label_sort(reference_core), + "reference_low": label_sort(REFERENCE_LOW), + "reference_high": label_sort(REFERENCE_HIGH), + "reference_summary": reference_summary, + "tiling_meta": tiling_meta, + "mode_order_summary": mode_order_summary, + "mode_summary": mode_summary, + "rows": rows, + } + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--ns", default="377,610") + parser.add_argument("--phases", default="0,0.25,0.5,0.75") + parser.add_argument("--thresholds", default="2.0") + parser.add_argument("--trials", type=int, default=5) + parser.add_argument("--supertile-orders", default="8,9,10,11") + parser.add_argument("--top-k", type=int, default=12) + parser.add_argument("--max-label", type=int, default=34) + parser.add_argument("--seed", type=int, default=202605081909) + parser.add_argument("--out", default="tools/data/gap_label_supertile_tiling_gate_20260508_1909.json") + args = parser.parse_args() + + output = run(args) + out = Path(args.out) + out.parent.mkdir(parents=True, exist_ok=True) + out.write_text(json.dumps(output, indent=2), encoding="utf-8") + + compact = {} + for key, data in sorted(output["mode_order_summary"].items()): + mode, order = key.split("|") + compact[key] = { + "mode": mode, + "supertile_order": int(order.split("=")[1]), + "median_jaccard": data["median_jaccard"], + "low_retention": data["median_low_retention"], + "high_retention": data["median_high_retention"], + "all_high": f"{data['all_high_count']}/{data['condition_count']}", + "all_high_condition_rate": data["all_high_condition_rate"], + "stable_labels_75pct": data["stable_labels_75pct"], + } + + print(json.dumps({ + "reference_core_phi": output["reference_core_phi"], + "reference_high": output["reference_high"], + "mode_summary": { + mode: { + "median_jaccard": data["median_jaccard"], + "low_retention": data["median_low_retention"], + "high_retention": data["median_high_retention"], + "all_high": f"{data['all_high_count']}/{data['condition_count']}", + "all_high_condition_rate": data["all_high_condition_rate"], + } + for mode, data in output["mode_summary"].items() + }, + "orders": compact, + "out": str(out), + }, indent=2)) + + +if __name__ == "__main__": + main() diff --git a/tools/exp_gap_label_supertile_tiling_gate.py b/tools/exp_gap_label_supertile_tiling_gate.py new file mode 100644 index 0000000000000000000000000000000000000000..bde361d77f2db31c8f98bf3fd24d345ad67fd132 --- /dev/null +++ b/tools/exp_gap_label_supertile_tiling_gate.py @@ -0,0 +1,278 @@ +#!/usr/bin/env python3 +""" +Supertile tiling gate for the phi gap-label core. + +The substitution-grammar gate showed that length and symbol count do not carry +the high labels when internal order is destroyed. This tool moves one node +upstream: it separates true Fibonacci supertile boundaries from contiguous +chunks with the same length multiset. +""" + +from __future__ import annotations + +import argparse +import json +from collections import Counter, defaultdict +from pathlib import Path + +import numpy as np + +from exp_gap_label_block_scale_gate import ( + REFERENCE_HIGH, + REFERENCE_LOW, + label_sort, + parse_floats, + parse_ints, + retention, +) +from exp_gap_label_generator_gate import THETA, block_shuffle +from exp_gap_label_set_stability import gap_labels, jaccard, sturmian_sequence, summarize_sets + + +def fibonacci_lengths(order: int) -> tuple[int, int]: + if order < 2: + raise ValueError("supertile_order must be >= 2") + a, b = 1, 1 + for _ in range(2, order + 1): + a, b = b, a + b + return b, a + + +def fibonacci_type_word(n_types: int) -> np.ndarray: + word = "1" + previous = "0" + while len(word) < n_types: + word, previous = word + previous, word + return np.array([int(ch) for ch in word[:n_types]], dtype=int) + + +def supertile_lengths(n: int, order: int) -> list[int]: + long_len, short_len = fibonacci_lengths(order) + types = fibonacci_type_word(max(8, int(np.ceil(n / short_len)) + 4)) + lengths: list[int] = [] + total = 0 + for t in types: + length = long_len if t == 1 else short_len + if total + length >= n: + lengths.append(n - total) + break + lengths.append(length) + total += length + return [length for length in lengths if length > 0] + + +def chunks_from_lengths(seq: np.ndarray, lengths: list[int]) -> list[np.ndarray]: + chunks = [] + start = 0 + for length in lengths: + chunks.append(seq[start : start + length].copy()) + start += length + if start < len(seq): + chunks.append(seq[start:].copy()) + return chunks + + +def shuffle_chunks(chunks: list[np.ndarray], rng: np.random.Generator) -> np.ndarray: + shuffled = list(chunks) + rng.shuffle(shuffled) + return np.concatenate(shuffled) + + +def internal_count_shuffle(chunks: list[np.ndarray], rng: np.random.Generator) -> np.ndarray: + out = [] + for chunk in chunks: + copied = chunk.copy() + rng.shuffle(copied) + out.append(copied) + return np.concatenate(out) + + +def misaligned_same_lengths(seq: np.ndarray, lengths: list[int], rng: np.random.Generator) -> np.ndarray: + if len(seq) < 2: + return seq.copy() + offset = int(rng.integers(1, len(seq))) + rotated = np.roll(seq, -offset) + chunks = chunks_from_lengths(rotated, lengths) + shuffled = shuffle_chunks(chunks, rng) + return np.roll(shuffled, offset) + + +def fixed_block_same_mean(seq: np.ndarray, lengths: list[int], rng: np.random.Generator) -> np.ndarray: + mean_len = max(1, int(round(float(np.mean(lengths))))) + return block_shuffle(seq, mean_len, rng) + + +def summarize_rows(rows: list[dict], reference_core: set[int]) -> dict: + summary = summarize_sets(rows) + sets = [set(row["label_set"]) for row in rows if row["n_selected"] > 0] + counter = Counter(label for s in sets for label in s) + n_sets = len(sets) + overlaps = [jaccard(set(row["label_set"]), reference_core) for row in rows if row["n_selected"] > 0] + + return { + **summary, + "median_overlap_with_phi_core": float(np.median(overlaps)) if overlaps else None, + "median_low_retention": float(np.median([retention(row, REFERENCE_LOW) for row in rows])), + "median_high_retention": float(np.median([retention(row, REFERENCE_HIGH) for row in rows])), + "all_low_count": int(sum(REFERENCE_LOW <= s for s in sets)), + "all_high_count": int(sum(REFERENCE_HIGH <= s for s in sets)), + "condition_count": int(n_sets), + "all_low_condition_rate": float(sum(REFERENCE_LOW <= s for s in sets) / n_sets) if n_sets else None, + "all_high_condition_rate": float(sum(REFERENCE_HIGH <= s for s in sets) / n_sets) if n_sets else None, + "high_label_condition_rates": { + str(label): float(counter.get(label, 0) / n_sets) if n_sets else None + for label in label_sort(REFERENCE_HIGH) + }, + "low_label_condition_rates": { + str(label): float(counter.get(label, 0) / n_sets) if n_sets else None + for label in label_sort(REFERENCE_LOW) + }, + "reference_core_retained_in_all": label_sort(set(summary.get("core_labels_all_conditions", [])) & reference_core), + "reference_core_missing_from_all": label_sort(reference_core - set(summary.get("core_labels_all_conditions", []))), + } + + +def run(args: argparse.Namespace) -> dict: + rng = np.random.default_rng(args.seed) + ns = parse_ints(args.ns) + phases = parse_floats(args.phases) + thresholds = parse_floats(args.thresholds) + orders = parse_ints(args.supertile_orders) + + reference_rows = [] + rows = [] + tiling_meta = {} + for n in ns: + for phase in phases: + phi = sturmian_sequence(THETA, n, phase) + for threshold in thresholds: + reference_rows.append({ + "mode": "reference_phi", + "N": n, + "phase": phase, + "threshold": threshold, + **gap_labels(phi, THETA, threshold, args.max_label, args.top_k), + }) + + for order in orders: + lengths = supertile_lengths(n, order) + tiling_meta[f"N={n}|order={order}"] = { + "lengths": lengths, + "count": len(lengths), + "total": sum(lengths), + "unique_lengths": sorted(set(lengths)), + } + aligned_chunks = chunks_from_lengths(phi, lengths) + mean_block = max(1, int(round(float(np.mean(lengths))))) + for trial in range(args.trials): + variants = { + "supertile_shuffle": shuffle_chunks(aligned_chunks, rng), + "same_length_contiguous_shuffle": misaligned_same_lengths(phi, lengths, rng), + "same_count_internal_shuffle": internal_count_shuffle(aligned_chunks, rng), + "same_mean_block_shuffle": fixed_block_same_mean(phi, lengths, rng), + } + for mode, seq in variants.items(): + for threshold in thresholds: + rows.append({ + "mode": mode, + "N": n, + "phase": phase, + "threshold": threshold, + "trial": trial, + "supertile_order": order, + "mean_block": mean_block, + **gap_labels(seq, THETA, threshold, args.max_label, args.top_k), + }) + + reference_summary = summarize_sets(reference_rows) + reference_core = set(reference_summary["core_labels_all_conditions"]) + + grouped: dict[str, list[dict]] = defaultdict(list) + for row in rows: + grouped[f"{row['mode']}|order={row['supertile_order']}"].append(row) + + mode_order_summary = { + key: summarize_rows(group_rows, reference_core) + for key, group_rows in grouped.items() + } + + mode_summary = {} + for mode in sorted({row["mode"] for row in rows}): + mode_rows = [row for row in rows if row["mode"] == mode] + mode_summary[mode] = summarize_rows(mode_rows, reference_core) + + return { + "experiment": "gap_label_supertile_tiling_gate", + "parameters": { + "ns": ns, + "phases": phases, + "thresholds": thresholds, + "trials": args.trials, + "supertile_orders": orders, + "top_k": args.top_k, + "max_label": args.max_label, + "seed": args.seed, + }, + "reference_core_phi": label_sort(reference_core), + "reference_low": label_sort(REFERENCE_LOW), + "reference_high": label_sort(REFERENCE_HIGH), + "reference_summary": reference_summary, + "tiling_meta": tiling_meta, + "mode_order_summary": mode_order_summary, + "mode_summary": mode_summary, + "rows": rows, + } + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--ns", default="377,610") + parser.add_argument("--phases", default="0,0.25,0.5,0.75") + parser.add_argument("--thresholds", default="2.0") + parser.add_argument("--trials", type=int, default=5) + parser.add_argument("--supertile-orders", default="8,9,10,11") + parser.add_argument("--top-k", type=int, default=12) + parser.add_argument("--max-label", type=int, default=34) + parser.add_argument("--seed", type=int, default=202605081909) + parser.add_argument("--out", default="tools/data/gap_label_supertile_tiling_gate_20260508_1909.json") + args = parser.parse_args() + + output = run(args) + out = Path(args.out) + out.parent.mkdir(parents=True, exist_ok=True) + out.write_text(json.dumps(output, indent=2), encoding="utf-8") + + compact = {} + for key, data in sorted(output["mode_order_summary"].items()): + mode, order = key.split("|") + compact[key] = { + "mode": mode, + "supertile_order": int(order.split("=")[1]), + "median_jaccard": data["median_jaccard"], + "low_retention": data["median_low_retention"], + "high_retention": data["median_high_retention"], + "all_high": f"{data['all_high_count']}/{data['condition_count']}", + "all_high_condition_rate": data["all_high_condition_rate"], + "stable_labels_75pct": data["stable_labels_75pct"], + } + + print(json.dumps({ + "reference_core_phi": output["reference_core_phi"], + "reference_high": output["reference_high"], + "mode_summary": { + mode: { + "median_jaccard": data["median_jaccard"], + "low_retention": data["median_low_retention"], + "high_retention": data["median_high_retention"], + "all_high": f"{data['all_high_count']}/{data['condition_count']}", + "all_high_condition_rate": data["all_high_condition_rate"], + } + for mode, data in output["mode_summary"].items() + }, + "orders": compact, + "out": str(out), + }, indent=2)) + + +if __name__ == "__main__": + main() succeeded in 9740ms: { "reference_core_phi": [ -1, 1, -2, 2, 3, -4, 4, 6 ], "reference_high": [ 3, -4, 4, 6 ], "mode_summary": { "same_count_internal_shuffle": { "median_jaccard": 0.15789473684210525, "low_retention": 0.25, "high_retention": 0.25, "all_high": "0/160", "all_high_condition_rate": 0.0 }, "same_length_contiguous_shuffle": { "median_jaccard": 0.8181818181818182, "low_retention": 1.0, "high_retention": 1.0, "all_high": "116/160", "all_high_condition_rate": 0.725 }, "same_mean_block_shuffle": { "median_jaccard": 0.5, "low_retention": 1.0, "high_retention": 0.25, "all_high": "7/160", "all_high_condition_rate": 0.04375 }, "supertile_shuffle": { "median_jaccard": 0.8181818181818182, "low_retention": 1.0, "high_retention": 1.0, "all_high": "108/160", "all_high_condition_rate": 0.675 } }, "orders": { "same_count_internal_shuffle|order=10": { "mode": "same_count_internal_shuffle", "supertile_order": 10, "median_jaccard": 0.15, "low_retention": 0.25, "high_retention": 0.25, "all_high": "0/40", "all_high_condition_rate": 0.0, "stable_labels_75pct": [] }, "same_count_internal_shuffle|order=11": { "mode": "same_count_internal_shuffle", "supertile_order": 11, "median_jaccard": 0.15789473684210525, "low_retention": 0.25, "high_retention": 0.25, "all_high": "0/40", "all_high_condition_rate": 0.0, "stable_labels_75pct": [ 34 ] }, "same_count_internal_shuffle|order=8": { "mode": "same_count_internal_shuffle", "supertile_order": 8, "median_jaccard": 0.15789473684210525, "low_retention": 0.25, "high_retention": 0.25, "all_high": "0/40", "all_high_condition_rate": 0.0, "stable_labels_75pct": [ 34 ] }, "same_count_internal_shuffle|order=9": { "mode": "same_count_internal_shuffle", "supertile_order": 9, "median_jaccard": 0.15789473684210525, "low_retention": 0.25, "high_retention": 0.25, "all_high": "0/40", "all_high_condition_rate": 0.0, "stable_labels_75pct": [ 34 ] }, "same_length_contiguous_shuffle|order=10": { "mode": "same_length_contiguous_shuffle", "supertile_order": 10, "median_jaccard": 0.8333333333333334, "low_retention": 1.0, "high_retention": 1.0, "all_high": "33/40", "all_high_condition_rate": 0.825, "stable_labels_75pct": [ -1, 1, -2, 2, -3, 3, -4, 4, -6, 6 ] }, "same_length_contiguous_shuffle|order=11": { "mode": "same_length_contiguous_shuffle", "supertile_order": 11, "median_jaccard": 0.9090909090909091, "low_retention": 1.0, "high_retention": 1.0, "all_high": "34/40", "all_high_condition_rate": 0.85, "stable_labels_75pct": [ -1, 1, -2, 2, -3, 3, -4, 4, -6, 6 ] }, "same_length_contiguous_shuffle|order=8": { "mode": "same_length_contiguous_shuffle", "supertile_order": 8, "median_jaccard": 0.8181818181818182, "low_retention": 1.0, "high_retention": 0.875, "all_high": "20/40", "all_high_condition_rate": 0.5, "stable_labels_75pct": [ -1, 1, -2, 2, -3, 3, -4, 4 ] }, "same_length_contiguous_shuffle|order=9": { "mode": "same_length_contiguous_shuffle", "supertile_order": 9, "median_jaccard": 0.8181818181818182, "low_retention": 1.0, "high_retention": 1.0, "all_high": "29/40", "all_high_condition_rate": 0.725, "stable_labels_75pct": [ -1, 1, -2, 2, -3, 3, -4, 4, 6 ] }, "same_mean_block_shuffle|order=10": { "mode": "same_mean_block_shuffle", "supertile_order": 10, "median_jaccard": 0.6666666666666666, "low_retention": 1.0, "high_retention": 0.5, "all_high": "1/40", "all_high_condition_rate": 0.025, "stable_labels_75pct": [ -1, 1, -2, 2, -4, 4 ] }, "same_mean_block_shuffle|order=11": { "mode": "same_mean_block_shuffle", "supertile_order": 11, "median_jaccard": 0.6666666666666666, "low_retention": 1.0, "high_retention": 0.75, "all_high": "6/40", "all_high_condition_rate": 0.15, "stable_labels_75pct": [ -1, 1, -2, 2, -4, 4 ] }, "same_mean_block_shuffle|order=8": { "mode": "same_mean_block_shuffle", "supertile_order": 8, "median_jaccard": 0.4444444444444444, "low_retention": 0.75, "high_retention": 0.0, "all_high": "0/40", "all_high_condition_rate": 0.0, "stable_labels_75pct": [ -1, 1, 33 ] }, "same_mean_block_shuffle|order=9": { "mode": "same_mean_block_shuffle", "supertile_order": 9, "median_jaccard": 0.5, "low_retention": 1.0, "high_retention": 0.25, "all_high": "0/40", "all_high_condition_rate": 0.0, "stable_labels_75pct": [ -1, 1, -2 ] }, "supertile_shuffle|order=10": { "mode": "supertile_shuffle", "supertile_order": 10, "median_jaccard": 0.9090909090909091, "low_retention": 1.0, "high_retention": 1.0, "all_high": "32/40", "all_high_condition_rate": 0.8, "stable_labels_75pct": [ -1, 1, -2, 2, -3, 3, -4, 4, -6, 6, -7 ] }, "supertile_shuffle|order=11": { "mode": "supertile_shuffle", "supertile_order": 11, "median_jaccard": 0.9090909090909091, "low_retention": 1.0, "high_retention": 1.0, "all_high": "33/40", "all_high_condition_rate": 0.825, "stable_labels_75pct": [ -1, 1, -2, 2, -3, 3, -4, 4, 6, -7 ] }, "supertile_shuffle|order=8": { "mode": "supertile_shuffle", "supertile_order": 8, "median_jaccard": 0.75, "low_retention": 1.0, "high_retention": 0.75, "all_high": "14/40", "all_high_condition_rate": 0.35, "stable_labels_75pct": [ -1, 1, -2, 2, -3, -4, 4 ] }, "supertile_shuffle|order=9": { "mode": "supertile_shuffle", "supertile_order": 9, "median_jaccard": 0.9045454545454545, "low_retention": 1.0, "high_retention": 1.0, "all_high": "29/40", "all_high_condition_rate": 0.725, "stable_labels_75pct": [ -1, 1, -2, 2, -3, 3, -4, 4, -6 ] } }, "out": "tools/data/gap_label_supertile_tiling_gate_20260508_1909.json" } diff --git a/tools/exp_gap_label_supertile_tiling_gate.py b/tools/exp_gap_label_supertile_tiling_gate.py new file mode 100644 index 0000000000000000000000000000000000000000..bde361d77f2db31c8f98bf3fd24d345ad67fd132 --- /dev/null +++ b/tools/exp_gap_label_supertile_tiling_gate.py @@ -0,0 +1,278 @@ +#!/usr/bin/env python3 +""" +Supertile tiling gate for the phi gap-label core. + +The substitution-grammar gate showed that length and symbol count do not carry +the high labels when internal order is destroyed. This tool moves one node +upstream: it separates true Fibonacci supertile boundaries from contiguous +chunks with the same length multiset. +""" + +from __future__ import annotations + +import argparse +import json +from collections import Counter, defaultdict +from pathlib import Path + +import numpy as np + +from exp_gap_label_block_scale_gate import ( + REFERENCE_HIGH, + REFERENCE_LOW, + label_sort, + parse_floats, + parse_ints, + retention, +) +from exp_gap_label_generator_gate import THETA, block_shuffle +from exp_gap_label_set_stability import gap_labels, jaccard, sturmian_sequence, summarize_sets + + +def fibonacci_lengths(order: int) -> tuple[int, int]: + if order < 2: + raise ValueError("supertile_order must be >= 2") + a, b = 1, 1 + for _ in range(2, order + 1): + a, b = b, a + b + return b, a + + +def fibonacci_type_word(n_types: int) -> np.ndarray: + word = "1" + previous = "0" + while len(word) < n_types: + word, previous = word + previous, word + return np.array([int(ch) for ch in word[:n_types]], dtype=int) + + +def supertile_lengths(n: int, order: int) -> list[int]: + long_len, short_len = fibonacci_lengths(order) + types = fibonacci_type_word(max(8, int(np.ceil(n / short_len)) + 4)) + lengths: list[int] = [] + total = 0 + for t in types: + length = long_len if t == 1 else short_len + if total + length >= n: + lengths.append(n - total) + break + lengths.append(length) + total += length + return [length for length in lengths if length > 0] + + +def chunks_from_lengths(seq: np.ndarray, lengths: list[int]) -> list[np.ndarray]: + chunks = [] + start = 0 + for length in lengths: + chunks.append(seq[start : start + length].copy()) + start += length + if start < len(seq): + chunks.append(seq[start:].copy()) + return chunks + + +def shuffle_chunks(chunks: list[np.ndarray], rng: np.random.Generator) -> np.ndarray: + shuffled = list(chunks) + rng.shuffle(shuffled) + return np.concatenate(shuffled) + + +def internal_count_shuffle(chunks: list[np.ndarray], rng: np.random.Generator) -> np.ndarray: + out = [] + for chunk in chunks: + copied = chunk.copy() + rng.shuffle(copied) + out.append(copied) + return np.concatenate(out) + + +def misaligned_same_lengths(seq: np.ndarray, lengths: list[int], rng: np.random.Generator) -> np.ndarray: + if len(seq) < 2: + return seq.copy() + offset = int(rng.integers(1, len(seq))) + rotated = np.roll(seq, -offset) + chunks = chunks_from_lengths(rotated, lengths) + shuffled = shuffle_chunks(chunks, rng) + return np.roll(shuffled, offset) + + +def fixed_block_same_mean(seq: np.ndarray, lengths: list[int], rng: np.random.Generator) -> np.ndarray: + mean_len = max(1, int(round(float(np.mean(lengths))))) + return block_shuffle(seq, mean_len, rng) + + +def summarize_rows(rows: list[dict], reference_core: set[int]) -> dict: + summary = summarize_sets(rows) + sets = [set(row["label_set"]) for row in rows if row["n_selected"] > 0] + counter = Counter(label for s in sets for label in s) + n_sets = len(sets) + overlaps = [jaccard(set(row["label_set"]), reference_core) for row in rows if row["n_selected"] > 0] + + return { + **summary, + "median_overlap_with_phi_core": float(np.median(overlaps)) if overlaps else None, + "median_low_retention": float(np.median([retention(row, REFERENCE_LOW) for row in rows])), + "median_high_retention": float(np.median([retention(row, REFERENCE_HIGH) for row in rows])), + "all_low_count": int(sum(REFERENCE_LOW <= s for s in sets)), + "all_high_count": int(sum(REFERENCE_HIGH <= s for s in sets)), + "condition_count": int(n_sets), + "all_low_condition_rate": float(sum(REFERENCE_LOW <= s for s in sets) / n_sets) if n_sets else None, + "all_high_condition_rate": float(sum(REFERENCE_HIGH <= s for s in sets) / n_sets) if n_sets else None, + "high_label_condition_rates": { + str(label): float(counter.get(label, 0) / n_sets) if n_sets else None + for label in label_sort(REFERENCE_HIGH) + }, + "low_label_condition_rates": { + str(label): float(counter.get(label, 0) / n_sets) if n_sets else None + for label in label_sort(REFERENCE_LOW) + }, + "reference_core_retained_in_all": label_sort(set(summary.get("core_labels_all_conditions", [])) & reference_core), + "reference_core_missing_from_all": label_sort(reference_core - set(summary.get("core_labels_all_conditions", []))), + } + + +def run(args: argparse.Namespace) -> dict: + rng = np.random.default_rng(args.seed) + ns = parse_ints(args.ns) + phases = parse_floats(args.phases) + thresholds = parse_floats(args.thresholds) + orders = parse_ints(args.supertile_orders) + + reference_rows = [] + rows = [] + tiling_meta = {} + for n in ns: + for phase in phases: + phi = sturmian_sequence(THETA, n, phase) + for threshold in thresholds: + reference_rows.append({ + "mode": "reference_phi", + "N": n, + "phase": phase, + "threshold": threshold, + **gap_labels(phi, THETA, threshold, args.max_label, args.top_k), + }) + + for order in orders: + lengths = supertile_lengths(n, order) + tiling_meta[f"N={n}|order={order}"] = { + "lengths": lengths, + "count": len(lengths), + "total": sum(lengths), + "unique_lengths": sorted(set(lengths)), + } + aligned_chunks = chunks_from_lengths(phi, lengths) + mean_block = max(1, int(round(float(np.mean(lengths))))) + for trial in range(args.trials): + variants = { + "supertile_shuffle": shuffle_chunks(aligned_chunks, rng), + "same_length_contiguous_shuffle": misaligned_same_lengths(phi, lengths, rng), + "same_count_internal_shuffle": internal_count_shuffle(aligned_chunks, rng), + "same_mean_block_shuffle": fixed_block_same_mean(phi, lengths, rng), + } + for mode, seq in variants.items(): + for threshold in thresholds: + rows.append({ + "mode": mode, + "N": n, + "phase": phase, + "threshold": threshold, + "trial": trial, + "supertile_order": order, + "mean_block": mean_block, + **gap_labels(seq, THETA, threshold, args.max_label, args.top_k), + }) + + reference_summary = summarize_sets(reference_rows) + reference_core = set(reference_summary["core_labels_all_conditions"]) + + grouped: dict[str, list[dict]] = defaultdict(list) + for row in rows: + grouped[f"{row['mode']}|order={row['supertile_order']}"].append(row) + + mode_order_summary = { + key: summarize_rows(group_rows, reference_core) + for key, group_rows in grouped.items() + } + + mode_summary = {} + for mode in sorted({row["mode"] for row in rows}): + mode_rows = [row for row in rows if row["mode"] == mode] + mode_summary[mode] = summarize_rows(mode_rows, reference_core) + + return { + "experiment": "gap_label_supertile_tiling_gate", + "parameters": { + "ns": ns, + "phases": phases, + "thresholds": thresholds, + "trials": args.trials, + "supertile_orders": orders, + "top_k": args.top_k, + "max_label": args.max_label, + "seed": args.seed, + }, + "reference_core_phi": label_sort(reference_core), + "reference_low": label_sort(REFERENCE_LOW), + "reference_high": label_sort(REFERENCE_HIGH), + "reference_summary": reference_summary, + "tiling_meta": tiling_meta, + "mode_order_summary": mode_order_summary, + "mode_summary": mode_summary, + "rows": rows, + } + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--ns", default="377,610") + parser.add_argument("--phases", default="0,0.25,0.5,0.75") + parser.add_argument("--thresholds", default="2.0") + parser.add_argument("--trials", type=int, default=5) + parser.add_argument("--supertile-orders", default="8,9,10,11") + parser.add_argument("--top-k", type=int, default=12) + parser.add_argument("--max-label", type=int, default=34) + parser.add_argument("--seed", type=int, default=202605081909) + parser.add_argument("--out", default="tools/data/gap_label_supertile_tiling_gate_20260508_1909.json") + args = parser.parse_args() + + output = run(args) + out = Path(args.out) + out.parent.mkdir(parents=True, exist_ok=True) + out.write_text(json.dumps(output, indent=2), encoding="utf-8") + + compact = {} + for key, data in sorted(output["mode_order_summary"].items()): + mode, order = key.split("|") + compact[key] = { + "mode": mode, + "supertile_order": int(order.split("=")[1]), + "median_jaccard": data["median_jaccard"], + "low_retention": data["median_low_retention"], + "high_retention": data["median_high_retention"], + "all_high": f"{data['all_high_count']}/{data['condition_count']}", + "all_high_condition_rate": data["all_high_condition_rate"], + "stable_labels_75pct": data["stable_labels_75pct"], + } + + print(json.dumps({ + "reference_core_phi": output["reference_core_phi"], + "reference_high": output["reference_high"], + "mode_summary": { + mode: { + "median_jaccard": data["median_jaccard"], + "low_retention": data["median_low_retention"], + "high_retention": data["median_high_retention"], + "all_high": f"{data['all_high_count']}/{data['condition_count']}", + "all_high_condition_rate": data["all_high_condition_rate"], + } + for mode, data in output["mode_summary"].items() + }, + "orders": compact, + "out": str(out), + }, indent=2)) + + +if __name__ == "__main__": + main() codex Il deposito è dissonante nel modo utile: lo shuffle su supertile non batte il controllo a stessa multiset di lunghezze; entrambi conservano il core alto. Il discriminatore cade invece tra “stessa multiset di lunghezze lunghe” e “blocco medio fisso”, mentre lo shuffle interno resta nullo. exec /bin/bash -lc "python - <<'PY' import json p='tools/data/gap_label_supertile_tiling_gate_20260508_1909.json' data=json.load(open(p)) for k,v in data['tiling_meta'].items(): print(k, 'count', v['count'], 'unique', v['unique_lengths'], 'first10', v['lengths'][:10]) PY" in /opt/MM_D-ND succeeded in 0ms: N=377|order=8 count 13 unique [21, 34] first10 [34, 21, 34, 34, 21, 34, 21, 34, 34, 21] N=377|order=9 count 8 unique [34, 55] first10 [55, 34, 55, 55, 34, 55, 34, 55] N=377|order=10 count 5 unique [55, 89] first10 [89, 55, 89, 89, 55] N=377|order=11 count 3 unique [89, 144] first10 [144, 89, 144] N=610|order=8 count 21 unique [21, 34] first10 [34, 21, 34, 34, 21, 34, 21, 34, 34, 21] N=610|order=9 count 13 unique [34, 55] first10 [55, 34, 55, 55, 34, 55, 34, 55, 55, 34] N=610|order=10 count 8 unique [55, 89] first10 [89, 55, 89, 89, 55, 89, 55, 89] N=610|order=11 count 5 unique [89, 144] first10 [144, 89, 144, 144, 89] exec /bin/bash -lc 'python -m py_compile tools/exp_gap_label_supertile_tiling_gate.py' in /opt/MM_D-ND succeeded in 0ms: exec /bin/bash -lc "python - <<'PY' from exp_gap_label_generator_gate import fibonacci_word, THETA from exp_gap_label_set_stability import sturmian_sequence import numpy as np for phase in [0,0.25,0.5,0.75]: s=sturmian_sequence(THETA,30,phase).astype(int) f=fibonacci_word(30).astype(int) print(phase, ''.join(map(str,s[:20])), ''.join(map(str,f[:20])), int((s==f).sum())) PY" in /opt/MM_D-ND/tools succeeded in 0ms: 0 01011010110110101101 10110101101101011010 7 0.25 01101011011010110101 10110101101101011010 7 0.5 10101101101011011010 10110101101101011010 24 0.75 10110110101101101011 10110101101101011010 22 diff --git a/tools/exp_gap_label_supertile_tiling_gate.py b/tools/exp_gap_label_supertile_tiling_gate.py new file mode 100644 index 0000000000000000000000000000000000000000..bde361d77f2db31c8f98bf3fd24d345ad67fd132 --- /dev/null +++ b/tools/exp_gap_label_supertile_tiling_gate.py @@ -0,0 +1,278 @@ +#!/usr/bin/env python3 +""" +Supertile tiling gate for the phi gap-label core. + +The substitution-grammar gate showed that length and symbol count do not carry +the high labels when internal order is destroyed. This tool moves one node +upstream: it separates true Fibonacci supertile boundaries from contiguous +chunks with the same length multiset. +""" + +from __future__ import annotations + +import argparse +import json +from collections import Counter, defaultdict +from pathlib import Path + +import numpy as np + +from exp_gap_label_block_scale_gate import ( + REFERENCE_HIGH, + REFERENCE_LOW, + label_sort, + parse_floats, + parse_ints, + retention, +) +from exp_gap_label_generator_gate import THETA, block_shuffle +from exp_gap_label_set_stability import gap_labels, jaccard, sturmian_sequence, summarize_sets + + +def fibonacci_lengths(order: int) -> tuple[int, int]: + if order < 2: + raise ValueError("supertile_order must be >= 2") + a, b = 1, 1 + for _ in range(2, order + 1): + a, b = b, a + b + return b, a + + +def fibonacci_type_word(n_types: int) -> np.ndarray: + word = "1" + previous = "0" + while len(word) < n_types: + word, previous = word + previous, word + return np.array([int(ch) for ch in word[:n_types]], dtype=int) + + +def supertile_lengths(n: int, order: int) -> list[int]: + long_len, short_len = fibonacci_lengths(order) + types = fibonacci_type_word(max(8, int(np.ceil(n / short_len)) + 4)) + lengths: list[int] = [] + total = 0 + for t in types: + length = long_len if t == 1 else short_len + if total + length >= n: + lengths.append(n - total) + break + lengths.append(length) + total += length + return [length for length in lengths if length > 0] + + +def chunks_from_lengths(seq: np.ndarray, lengths: list[int]) -> list[np.ndarray]: + chunks = [] + start = 0 + for length in lengths: + chunks.append(seq[start : start + length].copy()) + start += length + if start < len(seq): + chunks.append(seq[start:].copy()) + return chunks + + +def shuffle_chunks(chunks: list[np.ndarray], rng: np.random.Generator) -> np.ndarray: + shuffled = list(chunks) + rng.shuffle(shuffled) + return np.concatenate(shuffled) + + +def internal_count_shuffle(chunks: list[np.ndarray], rng: np.random.Generator) -> np.ndarray: + out = [] + for chunk in chunks: + copied = chunk.copy() + rng.shuffle(copied) + out.append(copied) + return np.concatenate(out) + + +def misaligned_same_lengths(seq: np.ndarray, lengths: list[int], rng: np.random.Generator) -> np.ndarray: + if len(seq) < 2: + return seq.copy() + offset = int(rng.integers(1, len(seq))) + rotated = np.roll(seq, -offset) + chunks = chunks_from_lengths(rotated, lengths) + shuffled = shuffle_chunks(chunks, rng) + return np.roll(shuffled, offset) + + +def fixed_block_same_mean(seq: np.ndarray, lengths: list[int], rng: np.random.Generator) -> np.ndarray: + mean_len = max(1, int(round(float(np.mean(lengths))))) + return block_shuffle(seq, mean_len, rng) + + +def summarize_rows(rows: list[dict], reference_core: set[int]) -> dict: + summary = summarize_sets(rows) + sets = [set(row["label_set"]) for row in rows if row["n_selected"] > 0] + counter = Counter(label for s in sets for label in s) + n_sets = len(sets) + overlaps = [jaccard(set(row["label_set"]), reference_core) for row in rows if row["n_selected"] > 0] + + return { + **summary, + "median_overlap_with_phi_core": float(np.median(overlaps)) if overlaps else None, + "median_low_retention": float(np.median([retention(row, REFERENCE_LOW) for row in rows])), + "median_high_retention": float(np.median([retention(row, REFERENCE_HIGH) for row in rows])), + "all_low_count": int(sum(REFERENCE_LOW <= s for s in sets)), + "all_high_count": int(sum(REFERENCE_HIGH <= s for s in sets)), + "condition_count": int(n_sets), + "all_low_condition_rate": float(sum(REFERENCE_LOW <= s for s in sets) / n_sets) if n_sets else None, + "all_high_condition_rate": float(sum(REFERENCE_HIGH <= s for s in sets) / n_sets) if n_sets else None, + "high_label_condition_rates": { + str(label): float(counter.get(label, 0) / n_sets) if n_sets else None + for label in label_sort(REFERENCE_HIGH) + }, + "low_label_condition_rates": { + str(label): float(counter.get(label, 0) / n_sets) if n_sets else None + for label in label_sort(REFERENCE_LOW) + }, + "reference_core_retained_in_all": label_sort(set(summary.get("core_labels_all_conditions", [])) & reference_core), + "reference_core_missing_from_all": label_sort(reference_core - set(summary.get("core_labels_all_conditions", []))), + } + + +def run(args: argparse.Namespace) -> dict: + rng = np.random.default_rng(args.seed) + ns = parse_ints(args.ns) + phases = parse_floats(args.phases) + thresholds = parse_floats(args.thresholds) + orders = parse_ints(args.supertile_orders) + + reference_rows = [] + rows = [] + tiling_meta = {} + for n in ns: + for phase in phases: + phi = sturmian_sequence(THETA, n, phase) + for threshold in thresholds: + reference_rows.append({ + "mode": "reference_phi", + "N": n, + "phase": phase, + "threshold": threshold, + **gap_labels(phi, THETA, threshold, args.max_label, args.top_k), + }) + + for order in orders: + lengths = supertile_lengths(n, order) + tiling_meta[f"N={n}|order={order}"] = { + "lengths": lengths, + "count": len(lengths), + "total": sum(lengths), + "unique_lengths": sorted(set(lengths)), + } + aligned_chunks = chunks_from_lengths(phi, lengths) + mean_block = max(1, int(round(float(np.mean(lengths))))) + for trial in range(args.trials): + variants = { + "supertile_shuffle": shuffle_chunks(aligned_chunks, rng), + "same_length_contiguous_shuffle": misaligned_same_lengths(phi, lengths, rng), + "same_count_internal_shuffle": internal_count_shuffle(aligned_chunks, rng), + "same_mean_block_shuffle": fixed_block_same_mean(phi, lengths, rng), + } + for mode, seq in variants.items(): + for threshold in thresholds: + rows.append({ + "mode": mode, + "N": n, + "phase": phase, + "threshold": threshold, + "trial": trial, + "supertile_order": order, + "mean_block": mean_block, + **gap_labels(seq, THETA, threshold, args.max_label, args.top_k), + }) + + reference_summary = summarize_sets(reference_rows) + reference_core = set(reference_summary["core_labels_all_conditions"]) + + grouped: dict[str, list[dict]] = defaultdict(list) + for row in rows: + grouped[f"{row['mode']}|order={row['supertile_order']}"].append(row) + + mode_order_summary = { + key: summarize_rows(group_rows, reference_core) + for key, group_rows in grouped.items() + } + + mode_summary = {} + for mode in sorted({row["mode"] for row in rows}): + mode_rows = [row for row in rows if row["mode"] == mode] + mode_summary[mode] = summarize_rows(mode_rows, reference_core) + + return { + "experiment": "gap_label_supertile_tiling_gate", + "parameters": { + "ns": ns, + "phases": phases, + "thresholds": thresholds, + "trials": args.trials, + "supertile_orders": orders, + "top_k": args.top_k, + "max_label": args.max_label, + "seed": args.seed, + }, + "reference_core_phi": label_sort(reference_core), + "reference_low": label_sort(REFERENCE_LOW), + "reference_high": label_sort(REFERENCE_HIGH), + "reference_summary": reference_summary, + "tiling_meta": tiling_meta, + "mode_order_summary": mode_order_summary, + "mode_summary": mode_summary, + "rows": rows, + } + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--ns", default="377,610") + parser.add_argument("--phases", default="0,0.25,0.5,0.75") + parser.add_argument("--thresholds", default="2.0") + parser.add_argument("--trials", type=int, default=5) + parser.add_argument("--supertile-orders", default="8,9,10,11") + parser.add_argument("--top-k", type=int, default=12) + parser.add_argument("--max-label", type=int, default=34) + parser.add_argument("--seed", type=int, default=202605081909) + parser.add_argument("--out", default="tools/data/gap_label_supertile_tiling_gate_20260508_1909.json") + args = parser.parse_args() + + output = run(args) + out = Path(args.out) + out.parent.mkdir(parents=True, exist_ok=True) + out.write_text(json.dumps(output, indent=2), encoding="utf-8") + + compact = {} + for key, data in sorted(output["mode_order_summary"].items()): + mode, order = key.split("|") + compact[key] = { + "mode": mode, + "supertile_order": int(order.split("=")[1]), + "median_jaccard": data["median_jaccard"], + "low_retention": data["median_low_retention"], + "high_retention": data["median_high_retention"], + "all_high": f"{data['all_high_count']}/{data['condition_count']}", + "all_high_condition_rate": data["all_high_condition_rate"], + "stable_labels_75pct": data["stable_labels_75pct"], + } + + print(json.dumps({ + "reference_core_phi": output["reference_core_phi"], + "reference_high": output["reference_high"], + "mode_summary": { + mode: { + "median_jaccard": data["median_jaccard"], + "low_retention": data["median_low_retention"], + "high_retention": data["median_high_retention"], + "all_high": f"{data['all_high_count']}/{data['condition_count']}", + "all_high_condition_rate": data["all_high_condition_rate"], + } + for mode, data in output["mode_summary"].items() + }, + "orders": compact, + "out": str(out), + }, indent=2)) + + +if __name__ == "__main__": + main() codex Ora scrivo il report nel formato del Lab. Il verdict sara' un vincolo, non una conferma: il test falsifica la parte “supertile batte blocco contiguo a pari lunghezza” e conserva la condizione forte gia' emersa sull’ordine interno. apply patch patch: completed /opt/MM_D-ND/tools/data/reports/agent_20260508_1909.md diff --git a/tools/data/reports/agent_20260508_1909.md b/tools/data/reports/agent_20260508_1909.md new file mode 100644 index 0000000000000000000000000000000000000000..bdce3379c1abfa663743481ca34268422ca4835b --- /dev/null +++ b/tools/data/reports/agent_20260508_1909.md @@ -0,0 +1,104 @@ +# Agent Report - Supertile Tiling Gate Del Core Phi +**Date**: 2026-05-08 19:09 +**Piano**: 89 +**Tension explored**: M_trascendenza_limite_attuale_L0 (0.529179606750063) +**verdict**: CONSTRAINT +observables_registry: n/a +observables_used: [gap_label_set, supertile_boundary, length_multiset, internal_order, high_label_condition_rate] +**observable_contract**: claim=il core alto phi distingue confine di supertile Fibonacci da blocco contiguo con stessa lunghezza; observable=retention dei label core sotto shuffle di supertile, shuffle contiguo a stessa multiset di lunghezze, shuffle interno a stesso conteggio; operator=Hamiltoniana tight-binding V=1, label IDS con reader theta=1/phi, Jaccard/retention/frequenza per mode e supertile_order; generator=phi_sturmian con tiling di lunghezze Fibonacci; denominator=N={377,610}, phase={0,0.25,0.5,0.75}, threshold={2.0}, trials=5, top_k=12, |n|<=34, supertile_order={8,9,10,11}; not_tested=gap_ratio, soglie 1.75/2.25, parsing simbolico esatto dei supertile per ogni fase, generatori non-phi. + +## Respiro fuori-tempo +- **Combo**: A11 combo + TxQ matrice densita come lettore spettrale + QxG vuoto continuo/discreto + tensione TRASCENDENZA_LIMITE/M_come_modulazione_quasiperiodica. +- **Dipolo / punto-zero**: confine reale del supertile · lunghezza contigua equivalente; punto-zero = il blocco come unita' prima che diventi grammatica o contenitore. +- **Piano superiore**: grafo della conoscenza / bicono dei dipoli. Il nodo non e' il valore del gap, ma il passaggio fra grammatica interna, confine esterno e denominatore. +- **Proto-ipotesi**: se il core alto phi vive nel confine tra supertile, lo shuffle di supertile conserva piu' core dello shuffle contiguo con la stessa multiset di lunghezze. Se non lo fa, il confine esatto non e' ancora il portatore: il portatore e' ordine interno piu' scala lunga. +- **Proiezione**: il label-set dei gap larghi manifesta la combo perche' tiene fisso il reader theta=1/phi e muove solo la relazione fra grammatica, boundary e blocco. + +## Claim Under Test +> Il vantaggio del blocco Fibonacci lungo non sta solo nell'ordine interno conservato: sta nel confine reale del supertile. Quindi `supertile_shuffle` batte `same_length_contiguous_shuffle` a pari multiset di lunghezze. + +## Question +Il core alto `[3, -4, 4, 6]` riconosce il confine di supertile Fibonacci, o riconosce soltanto blocchi lunghi con ordine interno conservato? + +## Experiment Design +- Reference core phi: `[-1, 1, -2, 2, 3, -4, 4, 6]`. +- Nucleo basso: `[-1, 1, -2, 2]`. Label alti: `[3, -4, 4, 6]`. +- Supertile orders: + - order 8: lunghezze `{21,34}`. + - order 9: lunghezze `{34,55}`. + - order 10: lunghezze `{55,89}`. + - order 11: lunghezze `{89,144}`. +- Modes: + - `supertile_shuffle`: taglia secondo la parola di lunghezze Fibonacci e mescola i chunk. + - `same_length_contiguous_shuffle`: usa la stessa multiset di lunghezze, ma su taglio contiguo misallineato. + - `same_count_internal_shuffle`: conserva lunghezza e conteggio di ogni chunk allineato, ma distrugge ordine interno. + - `same_mean_block_shuffle`: usa un blocco fisso pari alla lunghezza media del tiling, controllo di scala grossolana. +- Denominatori grezzi: per ogni `mode|order`, 40 condizioni (`2 N * 4 phase * 1 threshold * 5 trials`); per ogni mode aggregato, 160 condizioni. + +## Results +Reference phi su 8 condizioni (`N x phase x threshold`): core completo `[-1, 1, -2, 2, 3, -4, 4, 6]`. + +Sintesi per mode: + +| mode | conditions | median Jaccard | low retention | high retention | all-high condition rate | +|---|---:|---:|---:|---:|---:| +| supertile_shuffle | 160 | 0.818182 | 1.00 | 1.00 | 108/160 = 0.67500 | +| same_length_contiguous_shuffle | 160 | 0.818182 | 1.00 | 1.00 | 116/160 = 0.72500 | +| same_count_internal_shuffle | 160 | 0.157895 | 0.25 | 0.25 | 0/160 = 0.00000 | +| same_mean_block_shuffle | 160 | 0.500000 | 1.00 | 0.25 | 7/160 = 0.04375 | + +Dettaglio per order: + +| mode | order | lengths | median Jaccard | low retention | high retention | all-high condition rate | stable labels 75% | +|---|---:|---|---:|---:|---:|---:|---| +| supertile_shuffle | 8 | {21,34} | 0.750000 | 1.00 | 0.75 | 14/40 = 0.350 | [-1, 1, -2, 2, -3, -4, 4] | +| same_length_contiguous_shuffle | 8 | {21,34} | 0.818182 | 1.00 | 0.875 | 20/40 = 0.500 | [-1, 1, -2, 2, -3, 3, -4, 4] | +| same_mean_block_shuffle | 8 | mean 29 | 0.444444 | 0.75 | 0.00 | 0/40 = 0.000 | [-1, 1, 33] | +| same_count_internal_shuffle | 8 | {21,34} | 0.157895 | 0.25 | 0.25 | 0/40 = 0.000 | [34] | +| supertile_shuffle | 9 | {34,55} | 0.904545 | 1.00 | 1.00 | 29/40 = 0.725 | [-1, 1, -2, 2, -3, 3, -4, 4, -6] | +| same_length_contiguous_shuffle | 9 | {34,55} | 0.818182 | 1.00 | 1.00 | 29/40 = 0.725 | [-1, 1, -2, 2, -3, 3, -4, 4, 6] | +| same_mean_block_shuffle | 9 | mean 45 | 0.500000 | 1.00 | 0.25 | 0/40 = 0.000 | [-1, 1, -2] | +| same_count_internal_shuffle | 9 | {34,55} | 0.157895 | 0.25 | 0.25 | 0/40 = 0.000 | [34] | +| supertile_shuffle | 10 | {55,89} | 0.909091 | 1.00 | 1.00 | 32/40 = 0.800 | [-1, 1, -2, 2, -3, 3, -4, 4, -6, 6, -7] | +| same_length_contiguous_shuffle | 10 | {55,89} | 0.833333 | 1.00 | 1.00 | 33/40 = 0.825 | [-1, 1, -2, 2, -3, 3, -4, 4, -6, 6] | +| same_mean_block_shuffle | 10 | mean 75 | 0.666667 | 1.00 | 0.50 | 1/40 = 0.025 | [-1, 1, -2, 2, -4, 4] | +| same_count_internal_shuffle | 10 | {55,89} | 0.150000 | 0.25 | 0.25 | 0/40 = 0.000 | [] | +| supertile_shuffle | 11 | {89,144} | 0.909091 | 1.00 | 1.00 | 33/40 = 0.825 | [-1, 1, -2, 2, -3, 3, -4, 4, 6, -7] | +| same_length_contiguous_shuffle | 11 | {89,144} | 0.909091 | 1.00 | 1.00 | 34/40 = 0.850 | [-1, 1, -2, 2, -3, 3, -4, 4, -6, 6] | +| same_mean_block_shuffle | 11 | mean 122 | 0.666667 | 1.00 | 0.75 | 6/40 = 0.150 | [-1, 1, -2, 2, -4, 4] | +| same_count_internal_shuffle | 11 | {89,144} | 0.157895 | 0.25 | 0.25 | 0/40 = 0.000 | [34] | + +## Key Findings +1. **Verificato: il confine di supertile non batte il blocco contiguo a pari multiset di lunghezze.** `supertile_shuffle` fa all-high `108/160 = 0.675`; `same_length_contiguous_shuffle` fa `116/160 = 0.725`. Per order 9 sono pari (`29/40`), per order 10-11 il controllo contiguo e' leggermente sopra (`33/40`, `34/40` contro `32/40`, `33/40`). + +2. **Verificato: la condizione forte resta l'ordine interno.** `same_count_internal_shuffle` resta nullo su tutti gli order: all-high `0/160`, high retention mediana `0.25`, Jaccard mediano `0.157895`. Questo replica il nodo 18:34 dentro il tiling di supertile. + +3. **Verificato: la scala lunga come multiset e' piu' informativa del blocco medio fisso.** `same_mean_block_shuffle` conserva low retention mediana `1.00`, ma resta quasi nullo sul core alto completo (`7/160 = 0.04375`). Quindi non basta una scala media lunga; serve una distribuzione di lunghezze lunghe con ordine interno conservato. + +4. **Inferito dal confronto fra controlli: il portatore osservato e' ordine interno + multiset di lunghezze Fibonacci, non boundary esatto.** Il test non autorizza "il core alto vive nel confine del supertile"; autorizza "il core alto richiede ordine interno e beneficia di lunghezze supertile-like". + +## Verdict +**CONSTRAINT on TRASCENDENZA_LIMITE / QPG_GAP_RATIO_DENOMINATOR_GATE**: nel perimetro `N={377,610}`, `phase={0,0.25,0.5,0.75}`, `threshold={2.0}`, `trials=5`, `top_k=12`, `|n|<=34`, `supertile_order={8,9,10,11}`, il core alto phi non discrimina il confine esatto del supertile. `same_length_contiguous_shuffle` conserva il core alto almeno quanto `supertile_shuffle` (`116/160` vs `108/160`). Il core alto cade solo quando l'ordine interno viene distrutto (`0/160`) o quando la multiset di lunghezze viene compressa a blocco medio (`7/160`). + +La formulazione valida e': il label-set alto phi misura una condizione congiunta di ordine interno e lunghezze Fibonacci-like; non misura ancora il boundary simbolico del supertile e non misura `gap_ratio`. + +## Bicono della scoperta +- **Due radici**: confine di supertile · distribuzione di lunghezze con ordine interno. +- **Singolare**: il chunk lungo prima della distinzione fra boundary grammaticale e blocco contiguo. +- **Invariante di passaggio**: il core alto sopravvive quando l'ordine interno resta leggibile su lunghezze Fibonacci-like; non sopravvive a conteggio senza ordine. +- **Campo di possibilita**: qui diventa possibile cercare un osservabile di boundary piu' fine del label-set; qui diventa non-possibile dichiarare che il label-set alto riconosce da solo il confine esatto del supertile. + +## Consecutio +Costruire un gate di boundary simbolico che non legga solo il set dei label: confrontare label-set, posizione IDS dei label core e errore di label per chunk aligned/misaligned. Se il boundary reale esiste nell'osservabile, deve apparire nella geometria degli errori o nella posizione dei gap, non nel solo all-high rate. + +## Auto-audit: 5 lenti +- **L1 hard constraint vs bias**: il verdict dichiara perimetro e count grezzi; non trasforma `108/160` in legge universale. +- **L2 quantita vs ratio**: Jaccard, retention e all-high rate restano separati; `gap_ratio` dichiarato non testato. +- **L3 no silent patching**: l'ipotesi "supertile batte contiguo" cade; il report non la salva cambiando osservabile. +- **L4 edge cases**: order 10-11 mostrano controllo contiguo sopra supertile; sono il segnale, non rumore. +- **L5 re-discovery**: la conservazione dell'ordine interno era gia' nota dal 18:34; il nuovo finding e' la non-discriminazione del boundary esatto da parte del label-set. + +## Files +- Script: `tools/exp_gap_label_supertile_tiling_gate.py` +- Data: `tools/data/gap_label_supertile_tiling_gate_20260508_1909.json` +- Report: `tools/data/reports/agent_20260508_1909.md` diff --git a/tools/exp_gap_label_supertile_tiling_gate.py b/tools/exp_gap_label_supertile_tiling_gate.py new file mode 100644 index 0000000000000000000000000000000000000000..bde361d77f2db31c8f98bf3fd24d345ad67fd132 --- /dev/null +++ b/tools/exp_gap_label_supertile_tiling_gate.py @@ -0,0 +1,278 @@ +#!/usr/bin/env python3 +""" +Supertile tiling gate for the phi gap-label core. + +The substitution-grammar gate showed that length and symbol count do not carry +the high labels when internal order is destroyed. This tool moves one node +upstream: it separates true Fibonacci supertile boundaries from contiguous +chunks with the same length multiset. +""" + +from __future__ import annotations + +import argparse +import json +from collections import Counter, defaultdict +from pathlib import Path + +import numpy as np + +from exp_gap_label_block_scale_gate import ( + REFERENCE_HIGH, + REFERENCE_LOW, + label_sort, + parse_floats, + parse_ints, + retention, +) +from exp_gap_label_generator_gate import THETA, block_shuffle +from exp_gap_label_set_stability import gap_labels, jaccard, sturmian_sequence, summarize_sets + + +def fibonacci_lengths(order: int) -> tuple[int, int]: + if order < 2: + raise ValueError("supertile_order must be >= 2") + a, b = 1, 1 + for _ in range(2, order + 1): + a, b = b, a + b + return b, a + + +def fibonacci_type_word(n_types: int) -> np.ndarray: + word = "1" + previous = "0" + while len(word) < n_types: + word, previous = word + previous, word + return np.array([int(ch) for ch in word[:n_types]], dtype=int) + + +def supertile_lengths(n: int, order: int) -> list[int]: + long_len, short_len = fibonacci_lengths(order) + types = fibonacci_type_word(max(8, int(np.ceil(n / short_len)) + 4)) + lengths: list[int] = [] + total = 0 + for t in types: + length = long_len if t == 1 else short_len + if total + length >= n: + lengths.append(n - total) + break + lengths.append(length) + total += length + return [length for length in lengths if length > 0] + + +def chunks_from_lengths(seq: np.ndarray, lengths: list[int]) -> list[np.ndarray]: + chunks = [] + start = 0 + for length in lengths: + chunks.append(seq[start : start + length].copy()) + start += length + if start < len(seq): + chunks.append(seq[start:].copy()) + return chunks + + +def shuffle_chunks(chunks: list[np.ndarray], rng: np.random.Generator) -> np.ndarray: + shuffled = list(chunks) + rng.shuffle(shuffled) + return np.concatenate(shuffled) + + +def internal_count_shuffle(chunks: list[np.ndarray], rng: np.random.Generator) -> np.ndarray: + out = [] + for chunk in chunks: + copied = chunk.copy() + rng.shuffle(copied) + out.append(copied) + return np.concatenate(out) + + +def misaligned_same_lengths(seq: np.ndarray, lengths: list[int], rng: np.random.Generator) -> np.ndarray: + if len(seq) < 2: + return seq.copy() + offset = int(rng.integers(1, len(seq))) + rotated = np.roll(seq, -offset) + chunks = chunks_from_lengths(rotated, lengths) + shuffled = shuffle_chunks(chunks, rng) + return np.roll(shuffled, offset) + + +def fixed_block_same_mean(seq: np.ndarray, lengths: list[int], rng: np.random.Generator) -> np.ndarray: + mean_len = max(1, int(round(float(np.mean(lengths))))) + return block_shuffle(seq, mean_len, rng) + + +def summarize_rows(rows: list[dict], reference_core: set[int]) -> dict: + summary = summarize_sets(rows) + sets = [set(row["label_set"]) for row in rows if row["n_selected"] > 0] + counter = Counter(label for s in sets for label in s) + n_sets = len(sets) + overlaps = [jaccard(set(row["label_set"]), reference_core) for row in rows if row["n_selected"] > 0] + + return { + **summary, + "median_overlap_with_phi_core": float(np.median(overlaps)) if overlaps else None, + "median_low_retention": float(np.median([retention(row, REFERENCE_LOW) for row in rows])), + "median_high_retention": float(np.median([retention(row, REFERENCE_HIGH) for row in rows])), + "all_low_count": int(sum(REFERENCE_LOW <= s for s in sets)), + "all_high_count": int(sum(REFERENCE_HIGH <= s for s in sets)), + "condition_count": int(n_sets), + "all_low_condition_rate": float(sum(REFERENCE_LOW <= s for s in sets) / n_sets) if n_sets else None, + "all_high_condition_rate": float(sum(REFERENCE_HIGH <= s for s in sets) / n_sets) if n_sets else None, + "high_label_condition_rates": { + str(label): float(counter.get(label, 0) / n_sets) if n_sets else None + for label in label_sort(REFERENCE_HIGH) + }, + "low_label_condition_rates": { + str(label): float(counter.get(label, 0) / n_sets) if n_sets else None + for label in label_sort(REFERENCE_LOW) + }, + "reference_core_retained_in_all": label_sort(set(summary.get("core_labels_all_conditions", [])) & reference_core), + "reference_core_missing_from_all": label_sort(reference_core - set(summary.get("core_labels_all_conditions", []))), + } + + +def run(args: argparse.Namespace) -> dict: + rng = np.random.default_rng(args.seed) + ns = parse_ints(args.ns) + phases = parse_floats(args.phases) + thresholds = parse_floats(args.thresholds) + orders = parse_ints(args.supertile_orders) + + reference_rows = [] + rows = [] + tiling_meta = {} + for n in ns: + for phase in phases: + phi = sturmian_sequence(THETA, n, phase) + for threshold in thresholds: + reference_rows.append({ + "mode": "reference_phi", + "N": n, + "phase": phase, + "threshold": threshold, + **gap_labels(phi, THETA, threshold, args.max_label, args.top_k), + }) + + for order in orders: + lengths = supertile_lengths(n, order) + tiling_meta[f"N={n}|order={order}"] = { + "lengths": lengths, + "count": len(lengths), + "total": sum(lengths), + "unique_lengths": sorted(set(lengths)), + } + aligned_chunks = chunks_from_lengths(phi, lengths) + mean_block = max(1, int(round(float(np.mean(lengths))))) + for trial in range(args.trials): + variants = { + "supertile_shuffle": shuffle_chunks(aligned_chunks, rng), + "same_length_contiguous_shuffle": misaligned_same_lengths(phi, lengths, rng), + "same_count_internal_shuffle": internal_count_shuffle(aligned_chunks, rng), + "same_mean_block_shuffle": fixed_block_same_mean(phi, lengths, rng), + } + for mode, seq in variants.items(): + for threshold in thresholds: + rows.append({ + "mode": mode, + "N": n, + "phase": phase, + "threshold": threshold, + "trial": trial, + "supertile_order": order, + "mean_block": mean_block, + **gap_labels(seq, THETA, threshold, args.max_label, args.top_k), + }) + + reference_summary = summarize_sets(reference_rows) + reference_core = set(reference_summary["core_labels_all_conditions"]) + + grouped: dict[str, list[dict]] = defaultdict(list) + for row in rows: + grouped[f"{row['mode']}|order={row['supertile_order']}"].append(row) + + mode_order_summary = { + key: summarize_rows(group_rows, reference_core) + for key, group_rows in grouped.items() + } + + mode_summary = {} + for mode in sorted({row["mode"] for row in rows}): + mode_rows = [row for row in rows if row["mode"] == mode] + mode_summary[mode] = summarize_rows(mode_rows, reference_core) + + return { + "experiment": "gap_label_supertile_tiling_gate", + "parameters": { + "ns": ns, + "phases": phases, + "thresholds": thresholds, + "trials": args.trials, + "supertile_orders": orders, + "top_k": args.top_k, + "max_label": args.max_label, + "seed": args.seed, + }, + "reference_core_phi": label_sort(reference_core), + "reference_low": label_sort(REFERENCE_LOW), + "reference_high": label_sort(REFERENCE_HIGH), + "reference_summary": reference_summary, + "tiling_meta": tiling_meta, + "mode_order_summary": mode_order_summary, + "mode_summary": mode_summary, + "rows": rows, + } + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--ns", default="377,610") + parser.add_argument("--phases", default="0,0.25,0.5,0.75") + parser.add_argument("--thresholds", default="2.0") + parser.add_argument("--trials", type=int, default=5) + parser.add_argument("--supertile-orders", default="8,9,10,11") + parser.add_argument("--top-k", type=int, default=12) + parser.add_argument("--max-label", type=int, default=34) + parser.add_argument("--seed", type=int, default=202605081909) + parser.add_argument("--out", default="tools/data/gap_label_supertile_tiling_gate_20260508_1909.json") + args = parser.parse_args() + + output = run(args) + out = Path(args.out) + out.parent.mkdir(parents=True, exist_ok=True) + out.write_text(json.dumps(output, indent=2), encoding="utf-8") + + compact = {} + for key, data in sorted(output["mode_order_summary"].items()): + mode, order = key.split("|") + compact[key] = { + "mode": mode, + "supertile_order": int(order.split("=")[1]), + "median_jaccard": data["median_jaccard"], + "low_retention": data["median_low_retention"], + "high_retention": data["median_high_retention"], + "all_high": f"{data['all_high_count']}/{data['condition_count']}", + "all_high_condition_rate": data["all_high_condition_rate"], + "stable_labels_75pct": data["stable_labels_75pct"], + } + + print(json.dumps({ + "reference_core_phi": output["reference_core_phi"], + "reference_high": output["reference_high"], + "mode_summary": { + mode: { + "median_jaccard": data["median_jaccard"], + "low_retention": data["median_low_retention"], + "high_retention": data["median_high_retention"], + "all_high": f"{data['all_high_count']}/{data['condition_count']}", + "all_high_condition_rate": data["all_high_condition_rate"], + } + for mode, data in output["mode_summary"].items() + }, + "orders": compact, + "out": str(out), + }, indent=2)) + + +if __name__ == "__main__": + main() diff --git a/tools/data/reports/agent_20260508_1909.md b/tools/data/reports/agent_20260508_1909.md new file mode 100644 index 0000000000000000000000000000000000000000..bdce3379c1abfa663743481ca34268422ca4835b --- /dev/null +++ b/tools/data/reports/agent_20260508_1909.md @@ -0,0 +1,104 @@ +# Agent Report - Supertile Tiling Gate Del Core Phi +**Date**: 2026-05-08 19:09 +**Piano**: 89 +**Tension explored**: M_trascendenza_limite_attuale_L0 (0.529179606750063) +**verdict**: CONSTRAINT +observables_registry: n/a +observables_used: [gap_label_set, supertile_boundary, length_multiset, internal_order, high_label_condition_rate] +**observable_contract**: claim=il core alto phi distingue confine di supertile Fibonacci da blocco contiguo con stessa lunghezza; observable=retention dei label core sotto shuffle di supertile, shuffle contiguo a stessa multiset di lunghezze, shuffle interno a stesso conteggio; operator=Hamiltoniana tight-binding V=1, label IDS con reader theta=1/phi, Jaccard/retention/frequenza per mode e supertile_order; generator=phi_sturmian con tiling di lunghezze Fibonacci; denominator=N={377,610}, phase={0,0.25,0.5,0.75}, threshold={2.0}, trials=5, top_k=12, |n|<=34, supertile_order={8,9,10,11}; not_tested=gap_ratio, soglie 1.75/2.25, parsing simbolico esatto dei supertile per ogni fase, generatori non-phi. + +## Respiro fuori-tempo +- **Combo**: A11 combo + TxQ matrice densita come lettore spettrale + QxG vuoto continuo/discreto + tensione TRASCENDENZA_LIMITE/M_come_modulazione_quasiperiodica. +- **Dipolo / punto-zero**: confine reale del supertile · lunghezza contigua equivalente; punto-zero = il blocco come unita' prima che diventi grammatica o contenitore. +- **Piano superiore**: grafo della conoscenza / bicono dei dipoli. Il nodo non e' il valore del gap, ma il passaggio fra grammatica interna, confine esterno e denominatore. +- **Proto-ipotesi**: se il core alto phi vive nel confine tra supertile, lo shuffle di supertile conserva piu' core dello shuffle contiguo con la stessa multiset di lunghezze. Se non lo fa, il confine esatto non e' ancora il portatore: il portatore e' ordine interno piu' scala lunga. +- **Proiezione**: il label-set dei gap larghi manifesta la combo perche' tiene fisso il reader theta=1/phi e muove solo la relazione fra grammatica, boundary e blocco. + +## Claim Under Test +> Il vantaggio del blocco Fibonacci lungo non sta solo nell'ordine interno conservato: sta nel confine reale del supertile. Quindi `supertile_shuffle` batte `same_length_contiguous_shuffle` a pari multiset di lunghezze. + +## Question +Il core alto `[3, -4, 4, 6]` riconosce il confine di supertile Fibonacci, o riconosce soltanto blocchi lunghi con ordine interno conservato? + +## Experiment Design +- Reference core phi: `[-1, 1, -2, 2, 3, -4, 4, 6]`. +- Nucleo basso: `[-1, 1, -2, 2]`. Label alti: `[3, -4, 4, 6]`. +- Supertile orders: + - order 8: lunghezze `{21,34}`. + - order 9: lunghezze `{34,55}`. + - order 10: lunghezze `{55,89}`. + - order 11: lunghezze `{89,144}`. +- Modes: + - `supertile_shuffle`: taglia secondo la parola di lunghezze Fibonacci e mescola i chunk. + - `same_length_contiguous_shuffle`: usa la stessa multiset di lunghezze, ma su taglio contiguo misallineato. + - `same_count_internal_shuffle`: conserva lunghezza e conteggio di ogni chunk allineato, ma distrugge ordine interno. + - `same_mean_block_shuffle`: usa un blocco fisso pari alla lunghezza media del tiling, controllo di scala grossolana. +- Denominatori grezzi: per ogni `mode|order`, 40 condizioni (`2 N * 4 phase * 1 threshold * 5 trials`); per ogni mode aggregato, 160 condizioni. + +## Results +Reference phi su 8 condizioni (`N x phase x threshold`): core completo `[-1, 1, -2, 2, 3, -4, 4, 6]`. + +Sintesi per mode: + +| mode | conditions | median Jaccard | low retention | high retention | all-high condition rate | +|---|---:|---:|---:|---:|---:| +| supertile_shuffle | 160 | 0.818182 | 1.00 | 1.00 | 108/160 = 0.67500 | +| same_length_contiguous_shuffle | 160 | 0.818182 | 1.00 | 1.00 | 116/160 = 0.72500 | +| same_count_internal_shuffle | 160 | 0.157895 | 0.25 | 0.25 | 0/160 = 0.00000 | +| same_mean_block_shuffle | 160 | 0.500000 | 1.00 | 0.25 | 7/160 = 0.04375 | + +Dettaglio per order: + +| mode | order | lengths | median Jaccard | low retention | high retention | all-high condition rate | stable labels 75% | +|---|---:|---|---:|---:|---:|---:|---| +| supertile_shuffle | 8 | {21,34} | 0.750000 | 1.00 | 0.75 | 14/40 = 0.350 | [-1, 1, -2, 2, -3, -4, 4] | +| same_length_contiguous_shuffle | 8 | {21,34} | 0.818182 | 1.00 | 0.875 | 20/40 = 0.500 | [-1, 1, -2, 2, -3, 3, -4, 4] | +| same_mean_block_shuffle | 8 | mean 29 | 0.444444 | 0.75 | 0.00 | 0/40 = 0.000 | [-1, 1, 33] | +| same_count_internal_shuffle | 8 | {21,34} | 0.157895 | 0.25 | 0.25 | 0/40 = 0.000 | [34] | +| supertile_shuffle | 9 | {34,55} | 0.904545 | 1.00 | 1.00 | 29/40 = 0.725 | [-1, 1, -2, 2, -3, 3, -4, 4, -6] | +| same_length_contiguous_shuffle | 9 | {34,55} | 0.818182 | 1.00 | 1.00 | 29/40 = 0.725 | [-1, 1, -2, 2, -3, 3, -4, 4, 6] | +| same_mean_block_shuffle | 9 | mean 45 | 0.500000 | 1.00 | 0.25 | 0/40 = 0.000 | [-1, 1, -2] | +| same_count_internal_shuffle | 9 | {34,55} | 0.157895 | 0.25 | 0.25 | 0/40 = 0.000 | [34] | +| supertile_shuffle | 10 | {55,89} | 0.909091 | 1.00 | 1.00 | 32/40 = 0.800 | [-1, 1, -2, 2, -3, 3, -4, 4, -6, 6, -7] | +| same_length_contiguous_shuffle | 10 | {55,89} | 0.833333 | 1.00 | 1.00 | 33/40 = 0.825 | [-1, 1, -2, 2, -3, 3, -4, 4, -6, 6] | +| same_mean_block_shuffle | 10 | mean 75 | 0.666667 | 1.00 | 0.50 | 1/40 = 0.025 | [-1, 1, -2, 2, -4, 4] | +| same_count_internal_shuffle | 10 | {55,89} | 0.150000 | 0.25 | 0.25 | 0/40 = 0.000 | [] | +| supertile_shuffle | 11 | {89,144} | 0.909091 | 1.00 | 1.00 | 33/40 = 0.825 | [-1, 1, -2, 2, -3, 3, -4, 4, 6, -7] | +| same_length_contiguous_shuffle | 11 | {89,144} | 0.909091 | 1.00 | 1.00 | 34/40 = 0.850 | [-1, 1, -2, 2, -3, 3, -4, 4, -6, 6] | +| same_mean_block_shuffle | 11 | mean 122 | 0.666667 | 1.00 | 0.75 | 6/40 = 0.150 | [-1, 1, -2, 2, -4, 4] | +| same_count_internal_shuffle | 11 | {89,144} | 0.157895 | 0.25 | 0.25 | 0/40 = 0.000 | [34] | + +## Key Findings +1. **Verificato: il confine di supertile non batte il blocco contiguo a pari multiset di lunghezze.** `supertile_shuffle` fa all-high `108/160 = 0.675`; `same_length_contiguous_shuffle` fa `116/160 = 0.725`. Per order 9 sono pari (`29/40`), per order 10-11 il controllo contiguo e' leggermente sopra (`33/40`, `34/40` contro `32/40`, `33/40`). + +2. **Verificato: la condizione forte resta l'ordine interno.** `same_count_internal_shuffle` resta nullo su tutti gli order: all-high `0/160`, high retention mediana `0.25`, Jaccard mediano `0.157895`. Questo replica il nodo 18:34 dentro il tiling di supertile. + +3. **Verificato: la scala lunga come multiset e' piu' informativa del blocco medio fisso.** `same_mean_block_shuffle` conserva low retention mediana `1.00`, ma resta quasi nullo sul core alto completo (`7/160 = 0.04375`). Quindi non basta una scala media lunga; serve una distribuzione di lunghezze lunghe con ordine interno conservato. + +4. **Inferito dal confronto fra controlli: il portatore osservato e' ordine interno + multiset di lunghezze Fibonacci, non boundary esatto.** Il test non autorizza "il core alto vive nel confine del supertile"; autorizza "il core alto richiede ordine interno e beneficia di lunghezze supertile-like". + +## Verdict +**CONSTRAINT on TRASCENDENZA_LIMITE / QPG_GAP_RATIO_DENOMINATOR_GATE**: nel perimetro `N={377,610}`, `phase={0,0.25,0.5,0.75}`, `threshold={2.0}`, `trials=5`, `top_k=12`, `|n|<=34`, `supertile_order={8,9,10,11}`, il core alto phi non discrimina il confine esatto del supertile. `same_length_contiguous_shuffle` conserva il core alto almeno quanto `supertile_shuffle` (`116/160` vs `108/160`). Il core alto cade solo quando l'ordine interno viene distrutto (`0/160`) o quando la multiset di lunghezze viene compressa a blocco medio (`7/160`). + +La formulazione valida e': il label-set alto phi misura una condizione congiunta di ordine interno e lunghezze Fibonacci-like; non misura ancora il boundary simbolico del supertile e non misura `gap_ratio`. + +## Bicono della scoperta +- **Due radici**: confine di supertile · distribuzione di lunghezze con ordine interno. +- **Singolare**: il chunk lungo prima della distinzione fra boundary grammaticale e blocco contiguo. +- **Invariante di passaggio**: il core alto sopravvive quando l'ordine interno resta leggibile su lunghezze Fibonacci-like; non sopravvive a conteggio senza ordine. +- **Campo di possibilita**: qui diventa possibile cercare un osservabile di boundary piu' fine del label-set; qui diventa non-possibile dichiarare che il label-set alto riconosce da solo il confine esatto del supertile. + +## Consecutio +Costruire un gate di boundary simbolico che non legga solo il set dei label: confrontare label-set, posizione IDS dei label core e errore di label per chunk aligned/misaligned. Se il boundary reale esiste nell'osservabile, deve apparire nella geometria degli errori o nella posizione dei gap, non nel solo all-high rate. + +## Auto-audit: 5 lenti +- **L1 hard constraint vs bias**: il verdict dichiara perimetro e count grezzi; non trasforma `108/160` in legge universale. +- **L2 quantita vs ratio**: Jaccard, retention e all-high rate restano separati; `gap_ratio` dichiarato non testato. +- **L3 no silent patching**: l'ipotesi "supertile batte contiguo" cade; il report non la salva cambiando osservabile. +- **L4 edge cases**: order 10-11 mostrano controllo contiguo sopra supertile; sono il segnale, non rumore. +- **L5 re-discovery**: la conservazione dell'ordine interno era gia' nota dal 18:34; il nuovo finding e' la non-discriminazione del boundary esatto da parte del label-set. + +## Files +- Script: `tools/exp_gap_label_supertile_tiling_gate.py` +- Data: `tools/data/gap_label_supertile_tiling_gate_20260508_1909.json` +- Report: `tools/data/reports/agent_20260508_1909.md` diff --git a/tools/exp_gap_label_supertile_tiling_gate.py b/tools/exp_gap_label_supertile_tiling_gate.py new file mode 100644 index 0000000000000000000000000000000000000000..bde361d77f2db31c8f98bf3fd24d345ad67fd132 --- /dev/null +++ b/tools/exp_gap_label_supertile_tiling_gate.py @@ -0,0 +1,278 @@ +#!/usr/bin/env python3 +""" +Supertile tiling gate for the phi gap-label core. + +The substitution-grammar gate showed that length and symbol count do not carry +the high labels when internal order is destroyed. This tool moves one node +upstream: it separates true Fibonacci supertile boundaries from contiguous +chunks with the same length multiset. +""" + +from __future__ import annotations + +import argparse +import json +from collections import Counter, defaultdict +from pathlib import Path + +import numpy as np + +from exp_gap_label_block_scale_gate import ( + REFERENCE_HIGH, + REFERENCE_LOW, + label_sort, + parse_floats, + parse_ints, + retention, +) +from exp_gap_label_generator_gate import THETA, block_shuffle +from exp_gap_label_set_stability import gap_labels, jaccard, sturmian_sequence, summarize_sets + + +def fibonacci_lengths(order: int) -> tuple[int, int]: + if order < 2: + raise ValueError("supertile_order must be >= 2") + a, b = 1, 1 + for _ in range(2, order + 1): + a, b = b, a + b + return b, a + + +def fibonacci_type_word(n_types: int) -> np.ndarray: + word = "1" + previous = "0" + while len(word) < n_types: + word, previous = word + previous, word + return np.array([int(ch) for ch in word[:n_types]], dtype=int) + + +def supertile_lengths(n: int, order: int) -> list[int]: + long_len, short_len = fibonacci_lengths(order) + types = fibonacci_type_word(max(8, int(np.ceil(n / short_len)) + 4)) + lengths: list[int] = [] + total = 0 + for t in types: + length = long_len if t == 1 else short_len + if total + length >= n: + lengths.append(n - total) + break + lengths.append(length) + total += length + return [length for length in lengths if length > 0] + + +def chunks_from_lengths(seq: np.ndarray, lengths: list[int]) -> list[np.ndarray]: + chunks = [] + start = 0 + for length in lengths: + chunks.append(seq[start : start + length].copy()) + start += length + if start < len(seq): + chunks.append(seq[start:].copy()) + return chunks + + +def shuffle_chunks(chunks: list[np.ndarray], rng: np.random.Generator) -> np.ndarray: + shuffled = list(chunks) + rng.shuffle(shuffled) + return np.concatenate(shuffled) + + +def internal_count_shuffle(chunks: list[np.ndarray], rng: np.random.Generator) -> np.ndarray: + out = [] + for chunk in chunks: + copied = chunk.copy() + rng.shuffle(copied) + out.append(copied) + return np.concatenate(out) + + +def misaligned_same_lengths(seq: np.ndarray, lengths: list[int], rng: np.random.Generator) -> np.ndarray: + if len(seq) < 2: + return seq.copy() + offset = int(rng.integers(1, len(seq))) + rotated = np.roll(seq, -offset) + chunks = chunks_from_lengths(rotated, lengths) + shuffled = shuffle_chunks(chunks, rng) + return np.roll(shuffled, offset) + + +def fixed_block_same_mean(seq: np.ndarray, lengths: list[int], rng: np.random.Generator) -> np.ndarray: + mean_len = max(1, int(round(float(np.mean(lengths))))) + return block_shuffle(seq, mean_len, rng) + + +def summarize_rows(rows: list[dict], reference_core: set[int]) -> dict: + summary = summarize_sets(rows) + sets = [set(row["label_set"]) for row in rows if row["n_selected"] > 0] + counter = Counter(label for s in sets for label in s) + n_sets = len(sets) + overlaps = [jaccard(set(row["label_set"]), reference_core) for row in rows if row["n_selected"] > 0] + + return { + **summary, + "median_overlap_with_phi_core": float(np.median(overlaps)) if overlaps else None, + "median_low_retention": float(np.median([retention(row, REFERENCE_LOW) for row in rows])), + "median_high_retention": float(np.median([retention(row, REFERENCE_HIGH) for row in rows])), + "all_low_count": int(sum(REFERENCE_LOW <= s for s in sets)), + "all_high_count": int(sum(REFERENCE_HIGH <= s for s in sets)), + "condition_count": int(n_sets), + "all_low_condition_rate": float(sum(REFERENCE_LOW <= s for s in sets) / n_sets) if n_sets else None, + "all_high_condition_rate": float(sum(REFERENCE_HIGH <= s for s in sets) / n_sets) if n_sets else None, + "high_label_condition_rates": { + str(label): float(counter.get(label, 0) / n_sets) if n_sets else None + for label in label_sort(REFERENCE_HIGH) + }, + "low_label_condition_rates": { + str(label): float(counter.get(label, 0) / n_sets) if n_sets else None + for label in label_sort(REFERENCE_LOW) + }, + "reference_core_retained_in_all": label_sort(set(summary.get("core_labels_all_conditions", [])) & reference_core), + "reference_core_missing_from_all": label_sort(reference_core - set(summary.get("core_labels_all_conditions", []))), + } + + +def run(args: argparse.Namespace) -> dict: + rng = np.random.default_rng(args.seed) + ns = parse_ints(args.ns) + phases = parse_floats(args.phases) + thresholds = parse_floats(args.thresholds) + orders = parse_ints(args.supertile_orders) + + reference_rows = [] + rows = [] + tiling_meta = {} + for n in ns: + for phase in phases: + phi = sturmian_sequence(THETA, n, phase) + for threshold in thresholds: + reference_rows.append({ + "mode": "reference_phi", + "N": n, + "phase": phase, + "threshold": threshold, + **gap_labels(phi, THETA, threshold, args.max_label, args.top_k), + }) + + for order in orders: + lengths = supertile_lengths(n, order) + tiling_meta[f"N={n}|order={order}"] = { + "lengths": lengths, + "count": len(lengths), + "total": sum(lengths), + "unique_lengths": sorted(set(lengths)), + } + aligned_chunks = chunks_from_lengths(phi, lengths) + mean_block = max(1, int(round(float(np.mean(lengths))))) + for trial in range(args.trials): + variants = { + "supertile_shuffle": shuffle_chunks(aligned_chunks, rng), + "same_length_contiguous_shuffle": misaligned_same_lengths(phi, lengths, rng), + "same_count_internal_shuffle": internal_count_shuffle(aligned_chunks, rng), + "same_mean_block_shuffle": fixed_block_same_mean(phi, lengths, rng), + } + for mode, seq in variants.items(): + for threshold in thresholds: + rows.append({ + "mode": mode, + "N": n, + "phase": phase, + "threshold": threshold, + "trial": trial, + "supertile_order": order, + "mean_block": mean_block, + **gap_labels(seq, THETA, threshold, args.max_label, args.top_k), + }) + + reference_summary = summarize_sets(reference_rows) + reference_core = set(reference_summary["core_labels_all_conditions"]) + + grouped: dict[str, list[dict]] = defaultdict(list) + for row in rows: + grouped[f"{row['mode']}|order={row['supertile_order']}"].append(row) + + mode_order_summary = { + key: summarize_rows(group_rows, reference_core) + for key, group_rows in grouped.items() + } + + mode_summary = {} + for mode in sorted({row["mode"] for row in rows}): + mode_rows = [row for row in rows if row["mode"] == mode] + mode_summary[mode] = summarize_rows(mode_rows, reference_core) + + return { + "experiment": "gap_label_supertile_tiling_gate", + "parameters": { + "ns": ns, + "phases": phases, + "thresholds": thresholds, + "trials": args.trials, + "supertile_orders": orders, + "top_k": args.top_k, + "max_label": args.max_label, + "seed": args.seed, + }, + "reference_core_phi": label_sort(reference_core), + "reference_low": label_sort(REFERENCE_LOW), + "reference_high": label_sort(REFERENCE_HIGH), + "reference_summary": reference_summary, + "tiling_meta": tiling_meta, + "mode_order_summary": mode_order_summary, + "mode_summary": mode_summary, + "rows": rows, + } + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--ns", default="377,610") + parser.add_argument("--phases", default="0,0.25,0.5,0.75") + parser.add_argument("--thresholds", default="2.0") + parser.add_argument("--trials", type=int, default=5) + parser.add_argument("--supertile-orders", default="8,9,10,11") + parser.add_argument("--top-k", type=int, default=12) + parser.add_argument("--max-label", type=int, default=34) + parser.add_argument("--seed", type=int, default=202605081909) + parser.add_argument("--out", default="tools/data/gap_label_supertile_tiling_gate_20260508_1909.json") + args = parser.parse_args() + + output = run(args) + out = Path(args.out) + out.parent.mkdir(parents=True, exist_ok=True) + out.write_text(json.dumps(output, indent=2), encoding="utf-8") + + compact = {} + for key, data in sorted(output["mode_order_summary"].items()): + mode, order = key.split("|") + compact[key] = { + "mode": mode, + "supertile_order": int(order.split("=")[1]), + "median_jaccard": data["median_jaccard"], + "low_retention": data["median_low_retention"], + "high_retention": data["median_high_retention"], + "all_high": f"{data['all_high_count']}/{data['condition_count']}", + "all_high_condition_rate": data["all_high_condition_rate"], + "stable_labels_75pct": data["stable_labels_75pct"], + } + + print(json.dumps({ + "reference_core_phi": output["reference_core_phi"], + "reference_high": output["reference_high"], + "mode_summary": { + mode: { + "median_jaccard": data["median_jaccard"], + "low_retention": data["median_low_retention"], + "high_retention": data["median_high_retention"], + "all_high": f"{data['all_high_count']}/{data['condition_count']}", + "all_high_condition_rate": data["all_high_condition_rate"], + } + for mode, data in output["mode_summary"].items() + }, + "orders": compact, + "out": str(out), + }, indent=2)) + + +if __name__ == "__main__": + main() codex Report scritto. Faccio le verifiche minime: compilazione dello script gia' passata, ora controllo che il report contenga le sezioni richieste e provo lo structural check sui file toccati se il tool accetta path espliciti. exec /bin/bash -lc 'rg -n "''^(# Agent Report|## Respiro fuori-tempo|## Claim Under Test|## Question|## Experiment Design|## Results|## Key Findings|## Verdict|## Bicono della scoperta|## Files)" tools/data/reports/agent_20260508_1909.md' in /opt/MM_D-ND succeeded in 0ms: 1:# Agent Report - Supertile Tiling Gate Del Core Phi 10:## Respiro fuori-tempo 17:## Claim Under Test 20:## Question 23:## Experiment Design 38:## Results 71:## Key Findings 80:## Verdict 85:## Bicono della scoperta 101:## Files exec /bin/bash -lc 'git status --short tools/exp_gap_label_supertile_tiling_gate.py tools/data/gap_label_supertile_tiling_gate_20260508_1909.json tools/data/reports/agent_20260508_1909.md' in /opt/MM_D-ND succeeded in 0ms: ?? tools/data/gap_label_supertile_tiling_gate_20260508_1909.json ?? tools/data/reports/agent_20260508_1909.md ?? tools/exp_gap_label_supertile_tiling_gate.py exec /bin/bash -lc 'python /opt/tm7/tools/tm7_hook_manager.py --event post_change --paths tools/exp_gap_label_supertile_tiling_gate.py tools/data/reports/agent_20260508_1909.md tools/data/gap_label_supertile_tiling_gate_20260508_1909.json' in /opt/MM_D-ND succeeded in 0ms: # TM7 hook manager report - generated_at: 2026-05-08T19:13:26+00:00 - event: post_change - matched_rules: 1 ## Event instructions **Post-change cascade** - Map downstream consumers of every touched file. - Run the smallest relevant verification first. - Separate local file state, git state, generated data, and live/public state. - Record residual risk if any check is skipped. ## Paths - /opt/MM_D-ND/tools/exp_gap_label_supertile_tiling_gate.py - /opt/MM_D-ND/tools/data/reports/agent_20260508_1909.md - /opt/MM_D-ND/tools/data/gap_label_supertile_tiling_gate_20260508_1909.json ## Matched context ### MM_D-ND live physics lab Instructions: - This is the live lab generator territory with many cycle outputs. - Worktree dirtiness can be normal cycle output; never commit broad changes blindly. - Do not read .env, keys, tokens, or credential files unless explicitly required and approved. Read before action: - /opt/MM_D-ND/HANDOVER_CODEX_2026-05-07.md - /opt/MM_D-ND/PIANO_REVISIONE_LAB_2026-05-07.md - /opt/MM_D-ND/tools/LAB_AGENT_CONTEXT.md Suggested checks: - git -C /opt/MM_D-ND status --short --branch - tail -5 /opt/MM_D-ND/tools/data/lab_session_log.jsonl - bash /opt/MM_D-ND/tools/test_cron_exact.sh 600 Cascade: - If tools/lab_agent.sh changes, inspect provider chain, falsifier gates, SSP pipeline, notifications, and session log. - If build_applications_index.py changes, verify lab-d-nd-site data and page consumers. - If SSP trigger scripts change, verify stage contracts and published/scoperte separation. - If seme or knowledge data changes, check whether it is cycle output or intentional canonical change. ## Imported TM3 hook functions - `share_reflex` (manual_equivalent): Share/write a reflex after significant writes. Source: `share_reflex.sh`. Implemented as packets under /opt/tm7/packets. - `cascade_check` (active_equivalent): After changes, list downstream checks and propagation requirements. Source: `cascade_check.sh`. Implemented by hook_rules path cascade. - `session_thread` (manual_equivalent): Track recent actions for session continuity. Source: `session_thread.sh`. For Codex, use packets and final summaries; future state file possible. - `gyroscope` (manual_equivalent): Detect drift patterns: repeated errors, many content changes, need cascade/system check. Source: `gyroscope.sh`. Partially represented by post_change/pre_commit reports. ## Gate - Do not commit/deploy until the relevant suggested checks are either run or explicitly marked skipped with reason. exec /bin/bash -lc 'python tools/structural_check.py tools/exp_gap_label_supertile_tiling_gate.py tools/data/reports/agent_20260508_1909.md' in /opt/MM_D-ND succeeded in 0ms: Scansione 2 file... Nessun anti-pattern trovato. diff --git a/tools/data/reports/agent_20260508_1909.md b/tools/data/reports/agent_20260508_1909.md new file mode 100644 index 0000000000000000000000000000000000000000..bdce3379c1abfa663743481ca34268422ca4835b --- /dev/null +++ b/tools/data/reports/agent_20260508_1909.md @@ -0,0 +1,104 @@ +# Agent Report - Supertile Tiling Gate Del Core Phi +**Date**: 2026-05-08 19:09 +**Piano**: 89 +**Tension explored**: M_trascendenza_limite_attuale_L0 (0.529179606750063) +**verdict**: CONSTRAINT +observables_registry: n/a +observables_used: [gap_label_set, supertile_boundary, length_multiset, internal_order, high_label_condition_rate] +**observable_contract**: claim=il core alto phi distingue confine di supertile Fibonacci da blocco contiguo con stessa lunghezza; observable=retention dei label core sotto shuffle di supertile, shuffle contiguo a stessa multiset di lunghezze, shuffle interno a stesso conteggio; operator=Hamiltoniana tight-binding V=1, label IDS con reader theta=1/phi, Jaccard/retention/frequenza per mode e supertile_order; generator=phi_sturmian con tiling di lunghezze Fibonacci; denominator=N={377,610}, phase={0,0.25,0.5,0.75}, threshold={2.0}, trials=5, top_k=12, |n|<=34, supertile_order={8,9,10,11}; not_tested=gap_ratio, soglie 1.75/2.25, parsing simbolico esatto dei supertile per ogni fase, generatori non-phi. + +## Respiro fuori-tempo +- **Combo**: A11 combo + TxQ matrice densita come lettore spettrale + QxG vuoto continuo/discreto + tensione TRASCENDENZA_LIMITE/M_come_modulazione_quasiperiodica. +- **Dipolo / punto-zero**: confine reale del supertile · lunghezza contigua equivalente; punto-zero = il blocco come unita' prima che diventi grammatica o contenitore. +- **Piano superiore**: grafo della conoscenza / bicono dei dipoli. Il nodo non e' il valore del gap, ma il passaggio fra grammatica interna, confine esterno e denominatore. +- **Proto-ipotesi**: se il core alto phi vive nel confine tra supertile, lo shuffle di supertile conserva piu' core dello shuffle contiguo con la stessa multiset di lunghezze. Se non lo fa, il confine esatto non e' ancora il portatore: il portatore e' ordine interno piu' scala lunga. +- **Proiezione**: il label-set dei gap larghi manifesta la combo perche' tiene fisso il reader theta=1/phi e muove solo la relazione fra grammatica, boundary e blocco. + +## Claim Under Test +> Il vantaggio del blocco Fibonacci lungo non sta solo nell'ordine interno conservato: sta nel confine reale del supertile. Quindi `supertile_shuffle` batte `same_length_contiguous_shuffle` a pari multiset di lunghezze. + +## Question +Il core alto `[3, -4, 4, 6]` riconosce il confine di supertile Fibonacci, o riconosce soltanto blocchi lunghi con ordine interno conservato? + +## Experiment Design +- Reference core phi: `[-1, 1, -2, 2, 3, -4, 4, 6]`. +- Nucleo basso: `[-1, 1, -2, 2]`. Label alti: `[3, -4, 4, 6]`. +- Supertile orders: + - order 8: lunghezze `{21,34}`. + - order 9: lunghezze `{34,55}`. + - order 10: lunghezze `{55,89}`. + - order 11: lunghezze `{89,144}`. +- Modes: + - `supertile_shuffle`: taglia secondo la parola di lunghezze Fibonacci e mescola i chunk. + - `same_length_contiguous_shuffle`: usa la stessa multiset di lunghezze, ma su taglio contiguo misallineato. + - `same_count_internal_shuffle`: conserva lunghezza e conteggio di ogni chunk allineato, ma distrugge ordine interno. + - `same_mean_block_shuffle`: usa un blocco fisso pari alla lunghezza media del tiling, controllo di scala grossolana. +- Denominatori grezzi: per ogni `mode|order`, 40 condizioni (`2 N * 4 phase * 1 threshold * 5 trials`); per ogni mode aggregato, 160 condizioni. + +## Results +Reference phi su 8 condizioni (`N x phase x threshold`): core completo `[-1, 1, -2, 2, 3, -4, 4, 6]`. + +Sintesi per mode: + +| mode | conditions | median Jaccard | low retention | high retention | all-high condition rate | +|---|---:|---:|---:|---:|---:| +| supertile_shuffle | 160 | 0.818182 | 1.00 | 1.00 | 108/160 = 0.67500 | +| same_length_contiguous_shuffle | 160 | 0.818182 | 1.00 | 1.00 | 116/160 = 0.72500 | +| same_count_internal_shuffle | 160 | 0.157895 | 0.25 | 0.25 | 0/160 = 0.00000 | +| same_mean_block_shuffle | 160 | 0.500000 | 1.00 | 0.25 | 7/160 = 0.04375 | + +Dettaglio per order: + +| mode | order | lengths | median Jaccard | low retention | high retention | all-high condition rate | stable labels 75% | +|---|---:|---|---:|---:|---:|---:|---| +| supertile_shuffle | 8 | {21,34} | 0.750000 | 1.00 | 0.75 | 14/40 = 0.350 | [-1, 1, -2, 2, -3, -4, 4] | +| same_length_contiguous_shuffle | 8 | {21,34} | 0.818182 | 1.00 | 0.875 | 20/40 = 0.500 | [-1, 1, -2, 2, -3, 3, -4, 4] | +| same_mean_block_shuffle | 8 | mean 29 | 0.444444 | 0.75 | 0.00 | 0/40 = 0.000 | [-1, 1, 33] | +| same_count_internal_shuffle | 8 | {21,34} | 0.157895 | 0.25 | 0.25 | 0/40 = 0.000 | [34] | +| supertile_shuffle | 9 | {34,55} | 0.904545 | 1.00 | 1.00 | 29/40 = 0.725 | [-1, 1, -2, 2, -3, 3, -4, 4, -6] | +| same_length_contiguous_shuffle | 9 | {34,55} | 0.818182 | 1.00 | 1.00 | 29/40 = 0.725 | [-1, 1, -2, 2, -3, 3, -4, 4, 6] | +| same_mean_block_shuffle | 9 | mean 45 | 0.500000 | 1.00 | 0.25 | 0/40 = 0.000 | [-1, 1, -2] | +| same_count_internal_shuffle | 9 | {34,55} | 0.157895 | 0.25 | 0.25 | 0/40 = 0.000 | [34] | +| supertile_shuffle | 10 | {55,89} | 0.909091 | 1.00 | 1.00 | 32/40 = 0.800 | [-1, 1, -2, 2, -3, 3, -4, 4, -6, 6, -7] | +| same_length_contiguous_shuffle | 10 | {55,89} | 0.833333 | 1.00 | 1.00 | 33/40 = 0.825 | [-1, 1, -2, 2, -3, 3, -4, 4, -6, 6] | +| same_mean_block_shuffle | 10 | mean 75 | 0.666667 | 1.00 | 0.50 | 1/40 = 0.025 | [-1, 1, -2, 2, -4, 4] | +| same_count_internal_shuffle | 10 | {55,89} | 0.150000 | 0.25 | 0.25 | 0/40 = 0.000 | [] | +| supertile_shuffle | 11 | {89,144} | 0.909091 | 1.00 | 1.00 | 33/40 = 0.825 | [-1, 1, -2, 2, -3, 3, -4, 4, 6, -7] | +| same_length_contiguous_shuffle | 11 | {89,144} | 0.909091 | 1.00 | 1.00 | 34/40 = 0.850 | [-1, 1, -2, 2, -3, 3, -4, 4, -6, 6] | +| same_mean_block_shuffle | 11 | mean 122 | 0.666667 | 1.00 | 0.75 | 6/40 = 0.150 | [-1, 1, -2, 2, -4, 4] | +| same_count_internal_shuffle | 11 | {89,144} | 0.157895 | 0.25 | 0.25 | 0/40 = 0.000 | [34] | + +## Key Findings +1. **Verificato: il confine di supertile non batte il blocco contiguo a pari multiset di lunghezze.** `supertile_shuffle` fa all-high `108/160 = 0.675`; `same_length_contiguous_shuffle` fa `116/160 = 0.725`. Per order 9 sono pari (`29/40`), per order 10-11 il controllo contiguo e' leggermente sopra (`33/40`, `34/40` contro `32/40`, `33/40`). + +2. **Verificato: la condizione forte resta l'ordine interno.** `same_count_internal_shuffle` resta nullo su tutti gli order: all-high `0/160`, high retention mediana `0.25`, Jaccard mediano `0.157895`. Questo replica il nodo 18:34 dentro il tiling di supertile. + +3. **Verificato: la scala lunga come multiset e' piu' informativa del blocco medio fisso.** `same_mean_block_shuffle` conserva low retention mediana `1.00`, ma resta quasi nullo sul core alto completo (`7/160 = 0.04375`). Quindi non basta una scala media lunga; serve una distribuzione di lunghezze lunghe con ordine interno conservato. + +4. **Inferito dal confronto fra controlli: il portatore osservato e' ordine interno + multiset di lunghezze Fibonacci, non boundary esatto.** Il test non autorizza "il core alto vive nel confine del supertile"; autorizza "il core alto richiede ordine interno e beneficia di lunghezze supertile-like". + +## Verdict +**CONSTRAINT on TRASCENDENZA_LIMITE / QPG_GAP_RATIO_DENOMINATOR_GATE**: nel perimetro `N={377,610}`, `phase={0,0.25,0.5,0.75}`, `threshold={2.0}`, `trials=5`, `top_k=12`, `|n|<=34`, `supertile_order={8,9,10,11}`, il core alto phi non discrimina il confine esatto del supertile. `same_length_contiguous_shuffle` conserva il core alto almeno quanto `supertile_shuffle` (`116/160` vs `108/160`). Il core alto cade solo quando l'ordine interno viene distrutto (`0/160`) o quando la multiset di lunghezze viene compressa a blocco medio (`7/160`). + +La formulazione valida e': il label-set alto phi misura una condizione congiunta di ordine interno e lunghezze Fibonacci-like; non misura ancora il boundary simbolico del supertile e non misura `gap_ratio`. + +## Bicono della scoperta +- **Due radici**: confine di supertile · distribuzione di lunghezze con ordine interno. +- **Singolare**: il chunk lungo prima della distinzione fra boundary grammaticale e blocco contiguo. +- **Invariante di passaggio**: il core alto sopravvive quando l'ordine interno resta leggibile su lunghezze Fibonacci-like; non sopravvive a conteggio senza ordine. +- **Campo di possibilita**: qui diventa possibile cercare un osservabile di boundary piu' fine del label-set; qui diventa non-possibile dichiarare che il label-set alto riconosce da solo il confine esatto del supertile. + +## Consecutio +Costruire un gate di boundary simbolico che non legga solo il set dei label: confrontare label-set, posizione IDS dei label core e errore di label per chunk aligned/misaligned. Se il boundary reale esiste nell'osservabile, deve apparire nella geometria degli errori o nella posizione dei gap, non nel solo all-high rate. + +## Auto-audit: 5 lenti +- **L1 hard constraint vs bias**: il verdict dichiara perimetro e count grezzi; non trasforma `108/160` in legge universale. +- **L2 quantita vs ratio**: Jaccard, retention e all-high rate restano separati; `gap_ratio` dichiarato non testato. +- **L3 no silent patching**: l'ipotesi "supertile batte contiguo" cade; il report non la salva cambiando osservabile. +- **L4 edge cases**: order 10-11 mostrano controllo contiguo sopra supertile; sono il segnale, non rumore. +- **L5 re-discovery**: la conservazione dell'ordine interno era gia' nota dal 18:34; il nuovo finding e' la non-discriminazione del boundary esatto da parte del label-set. + +## Files +- Script: `tools/exp_gap_label_supertile_tiling_gate.py` +- Data: `tools/data/gap_label_supertile_tiling_gate_20260508_1909.json` +- Report: `tools/data/reports/agent_20260508_1909.md` diff --git a/tools/exp_gap_label_supertile_tiling_gate.py b/tools/exp_gap_label_supertile_tiling_gate.py new file mode 100644 index 0000000000000000000000000000000000000000..bde361d77f2db31c8f98bf3fd24d345ad67fd132 --- /dev/null +++ b/tools/exp_gap_label_supertile_tiling_gate.py @@ -0,0 +1,278 @@ +#!/usr/bin/env python3 +""" +Supertile tiling gate for the phi gap-label core. + +The substitution-grammar gate showed that length and symbol count do not carry +the high labels when internal order is destroyed. This tool moves one node +upstream: it separates true Fibonacci supertile boundaries from contiguous +chunks with the same length multiset. +""" + +from __future__ import annotations + +import argparse +import json +from collections import Counter, defaultdict +from pathlib import Path + +import numpy as np + +from exp_gap_label_block_scale_gate import ( + REFERENCE_HIGH, + REFERENCE_LOW, + label_sort, + parse_floats, + parse_ints, + retention, +) +from exp_gap_label_generator_gate import THETA, block_shuffle +from exp_gap_label_set_stability import gap_labels, jaccard, sturmian_sequence, summarize_sets + + +def fibonacci_lengths(order: int) -> tuple[int, int]: + if order < 2: + raise ValueError("supertile_order must be >= 2") + a, b = 1, 1 + for _ in range(2, order + 1): + a, b = b, a + b + return b, a + + +def fibonacci_type_word(n_types: int) -> np.ndarray: + word = "1" + previous = "0" + while len(word) < n_types: + word, previous = word + previous, word + return np.array([int(ch) for ch in word[:n_types]], dtype=int) + + +def supertile_lengths(n: int, order: int) -> list[int]: + long_len, short_len = fibonacci_lengths(order) + types = fibonacci_type_word(max(8, int(np.ceil(n / short_len)) + 4)) + lengths: list[int] = [] + total = 0 + for t in types: + length = long_len if t == 1 else short_len + if total + length >= n: + lengths.append(n - total) + break + lengths.append(length) + total += length + return [length for length in lengths if length > 0] + + +def chunks_from_lengths(seq: np.ndarray, lengths: list[int]) -> list[np.ndarray]: + chunks = [] + start = 0 + for length in lengths: + chunks.append(seq[start : start + length].copy()) + start += length + if start < len(seq): + chunks.append(seq[start:].copy()) + return chunks + + +def shuffle_chunks(chunks: list[np.ndarray], rng: np.random.Generator) -> np.ndarray: + shuffled = list(chunks) + rng.shuffle(shuffled) + return np.concatenate(shuffled) + + +def internal_count_shuffle(chunks: list[np.ndarray], rng: np.random.Generator) -> np.ndarray: + out = [] + for chunk in chunks: + copied = chunk.copy() + rng.shuffle(copied) + out.append(copied) + return np.concatenate(out) + + +def misaligned_same_lengths(seq: np.ndarray, lengths: list[int], rng: np.random.Generator) -> np.ndarray: + if len(seq) < 2: + return seq.copy() + offset = int(rng.integers(1, len(seq))) + rotated = np.roll(seq, -offset) + chunks = chunks_from_lengths(rotated, lengths) + shuffled = shuffle_chunks(chunks, rng) + return np.roll(shuffled, offset) + + +def fixed_block_same_mean(seq: np.ndarray, lengths: list[int], rng: np.random.Generator) -> np.ndarray: + mean_len = max(1, int(round(float(np.mean(lengths))))) + return block_shuffle(seq, mean_len, rng) + + +def summarize_rows(rows: list[dict], reference_core: set[int]) -> dict: + summary = summarize_sets(rows) + sets = [set(row["label_set"]) for row in rows if row["n_selected"] > 0] + counter = Counter(label for s in sets for label in s) + n_sets = len(sets) + overlaps = [jaccard(set(row["label_set"]), reference_core) for row in rows if row["n_selected"] > 0] + + return { + **summary, + "median_overlap_with_phi_core": float(np.median(overlaps)) if overlaps else None, + "median_low_retention": float(np.median([retention(row, REFERENCE_LOW) for row in rows])), + "median_high_retention": float(np.median([retention(row, REFERENCE_HIGH) for row in rows])), + "all_low_count": int(sum(REFERENCE_LOW <= s for s in sets)), + "all_high_count": int(sum(REFERENCE_HIGH <= s for s in sets)), + "condition_count": int(n_sets), + "all_low_condition_rate": float(sum(REFERENCE_LOW <= s for s in sets) / n_sets) if n_sets else None, + "all_high_condition_rate": float(sum(REFERENCE_HIGH <= s for s in sets) / n_sets) if n_sets else None, + "high_label_condition_rates": { + str(label): float(counter.get(label, 0) / n_sets) if n_sets else None + for label in label_sort(REFERENCE_HIGH) + }, + "low_label_condition_rates": { + str(label): float(counter.get(label, 0) / n_sets) if n_sets else None + for label in label_sort(REFERENCE_LOW) + }, + "reference_core_retained_in_all": label_sort(set(summary.get("core_labels_all_conditions", [])) & reference_core), + "reference_core_missing_from_all": label_sort(reference_core - set(summary.get("core_labels_all_conditions", []))), + } + + +def run(args: argparse.Namespace) -> dict: + rng = np.random.default_rng(args.seed) + ns = parse_ints(args.ns) + phases = parse_floats(args.phases) + thresholds = parse_floats(args.thresholds) + orders = parse_ints(args.supertile_orders) + + reference_rows = [] + rows = [] + tiling_meta = {} + for n in ns: + for phase in phases: + phi = sturmian_sequence(THETA, n, phase) + for threshold in thresholds: + reference_rows.append({ + "mode": "reference_phi", + "N": n, + "phase": phase, + "threshold": threshold, + **gap_labels(phi, THETA, threshold, args.max_label, args.top_k), + }) + + for order in orders: + lengths = supertile_lengths(n, order) + tiling_meta[f"N={n}|order={order}"] = { + "lengths": lengths, + "count": len(lengths), + "total": sum(lengths), + "unique_lengths": sorted(set(lengths)), + } + aligned_chunks = chunks_from_lengths(phi, lengths) + mean_block = max(1, int(round(float(np.mean(lengths))))) + for trial in range(args.trials): + variants = { + "supertile_shuffle": shuffle_chunks(aligned_chunks, rng), + "same_length_contiguous_shuffle": misaligned_same_lengths(phi, lengths, rng), + "same_count_internal_shuffle": internal_count_shuffle(aligned_chunks, rng), + "same_mean_block_shuffle": fixed_block_same_mean(phi, lengths, rng), + } + for mode, seq in variants.items(): + for threshold in thresholds: + rows.append({ + "mode": mode, + "N": n, + "phase": phase, + "threshold": threshold, + "trial": trial, + "supertile_order": order, + "mean_block": mean_block, + **gap_labels(seq, THETA, threshold, args.max_label, args.top_k), + }) + + reference_summary = summarize_sets(reference_rows) + reference_core = set(reference_summary["core_labels_all_conditions"]) + + grouped: dict[str, list[dict]] = defaultdict(list) + for row in rows: + grouped[f"{row['mode']}|order={row['supertile_order']}"].append(row) + + mode_order_summary = { + key: summarize_rows(group_rows, reference_core) + for key, group_rows in grouped.items() + } + + mode_summary = {} + for mode in sorted({row["mode"] for row in rows}): + mode_rows = [row for row in rows if row["mode"] == mode] + mode_summary[mode] = summarize_rows(mode_rows, reference_core) + + return { + "experiment": "gap_label_supertile_tiling_gate", + "parameters": { + "ns": ns, + "phases": phases, + "thresholds": thresholds, + "trials": args.trials, + "supertile_orders": orders, + "top_k": args.top_k, + "max_label": args.max_label, + "seed": args.seed, + }, + "reference_core_phi": label_sort(reference_core), + "reference_low": label_sort(REFERENCE_LOW), + "reference_high": label_sort(REFERENCE_HIGH), + "reference_summary": reference_summary, + "tiling_meta": tiling_meta, + "mode_order_summary": mode_order_summary, + "mode_summary": mode_summary, + "rows": rows, + } + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--ns", default="377,610") + parser.add_argument("--phases", default="0,0.25,0.5,0.75") + parser.add_argument("--thresholds", default="2.0") + parser.add_argument("--trials", type=int, default=5) + parser.add_argument("--supertile-orders", default="8,9,10,11") + parser.add_argument("--top-k", type=int, default=12) + parser.add_argument("--max-label", type=int, default=34) + parser.add_argument("--seed", type=int, default=202605081909) + parser.add_argument("--out", default="tools/data/gap_label_supertile_tiling_gate_20260508_1909.json") + args = parser.parse_args() + + output = run(args) + out = Path(args.out) + out.parent.mkdir(parents=True, exist_ok=True) + out.write_text(json.dumps(output, indent=2), encoding="utf-8") + + compact = {} + for key, data in sorted(output["mode_order_summary"].items()): + mode, order = key.split("|") + compact[key] = { + "mode": mode, + "supertile_order": int(order.split("=")[1]), + "median_jaccard": data["median_jaccard"], + "low_retention": data["median_low_retention"], + "high_retention": data["median_high_retention"], + "all_high": f"{data['all_high_count']}/{data['condition_count']}", + "all_high_condition_rate": data["all_high_condition_rate"], + "stable_labels_75pct": data["stable_labels_75pct"], + } + + print(json.dumps({ + "reference_core_phi": output["reference_core_phi"], + "reference_high": output["reference_high"], + "mode_summary": { + mode: { + "median_jaccard": data["median_jaccard"], + "low_retention": data["median_low_retention"], + "high_retention": data["median_high_retention"], + "all_high": f"{data['all_high_count']}/{data['condition_count']}", + "all_high_condition_rate": data["all_high_condition_rate"], + } + for mode, data in output["mode_summary"].items() + }, + "orders": compact, + "out": str(out), + }, indent=2)) + + +if __name__ == "__main__": + main() codex Il post-change hook segnala due documenti Lab da tenere come contesto di superficie. Li leggo ora per chiudere il controllo di cascata senza toccare altri stati. exec /bin/bash -lc "sed -n '1,220p' HANDOVER_CODEX_2026-05-07.md" in /opt/MM_D-ND succeeded in 0ms: # Handover a Codex — 7 maggio 2026 sera tardi > Documento di consegna scritto da TM3 (Claude Opus 4.7) prima del passaggio > dell'account Anthropic. Codex è già l'agent primary del cycle del lab > (`tools/lab_agent.sh` provider chain `codex-cli → claude-cli → openrouter`). > Da domani codex assume anche il ruolo di **dev del lab** (mio ruolo TM3). > > Letto ad ogni sessione operativa su `/opt/MM_D-ND/`. Self-contained. > Se qualcosa qui contraddice il codice, **il codice ha ragione**: verifica. --- ## 1. Stato del lab al 2026-05-07 22:15 ### Ultimi commit (HEAD `8c18cb9`) ``` 8c18cb9 docs(piano): §5.C autopoiesi pre-agent + 8 sezioni campo vivo f1dda38 feat(C1+C2): autopoiesi pre-agent + 8 sezioni campo vivo restored e13722c docs(piano): §5.G gate strutturali G1-G4 implementati e verificati 81dcdba fix(G1): regex observables_used supporta sia bold che plain markdown 0fd016c feat(G4): B1 da WARN a APPLY — archive vincoli decay_counter>=5 9872eaf feat(G3): filtro published su status visibility (mature_eligible only) d4e2602 feat(G1+G2): observables gate pre-falsifier + anti-recycle campo vivo d676ba6 fix(B3): heredoc quotato per evitare bash command substitution ``` ### Cosa è chiuso (anelli risolti stasera) - **Gate G1** observables pre-falsifier: blocca SYNC se `observables_used=[]` su tensione strutturale (`confine_inesplorato`/`scoperta_numerica`/`scoperta`). - **Gate G2** anti-recycle: streak ≥3 cycle stessa tensione → augment campo vivo con sezione esplicita. - **Gate G3** filtro published: solo status `{draft, transitional}` propaga al sito (`promote_to_publish.py` + `build_applications_index.py` flag `is_visible_on_site`). - **Gate G4** B1 archive: `decay_counter >= 5` su tipo='vincolo' → spostato a `seme.tensioni_archiviate`. - **C1 autopoiesi pre-agent** in `lab_agent.sh`: - `dnd_incrocio.ciclo_autonomo()` pre-cycle (timeout 60s) → `data/incrocio_risultato.json` - `dnd_domandatore.ciclo_domandatore(top_tension, max_experiments=2)` (timeout 180s) → `data/domandatore_pre_cycle.json` - Update `data/ciclo_memoria.json` post-cristallizzazione (apprendimento del cycle) - **C2 8 sezioni autopoiesi** in `build_agent_field.py`: memoria_ciclo · costante_dinamica · evolution_affinatore · knowledge_state (M operator) · domande_fondamentali · ponti_evoluti · incrocio_consecutio · domandatore. Campo vivo cresce da 16442 → 20935 bytes. ### Anelli ancora aperti (priorità alta → bassa) | # | Dominio | Cosa | Effort | Impact | |---|---|---|---|---| | 1 | γ | `_deposita_scoperte_autoricerca` (in `dipartimento.py` ~line 756) scrive in `data/domandatore/` ma cycle non lo consuma. 77 script `exp_*.py` orphan (mai invocati dal cron). | medio | alto | | 2 | ν | `structural_check.py` gira step 8 POST-cycle. Se PRE-cycle, agent vede pattern META bloccati prima di scrivere. | basso | medio | | 3 | φ | `dnd_spettro_zeta.py` (test critico zeri ζ vs D-ND) mai lanciato dal cron. Test diagnostico per i 14 moduli zeri/zeta speculativi. | basso | diagnostico | | 4 | ν | Filtri scritti dormienti: `dnd_implications` (567 righe), `meta_assertion_gate.py`, `dnd_rottura.py`, `dnd_indeterminazione.py`, `dnd_zero_controllo*.py`. Ognuno: leggere, decidere se wireare. | basso ognuno | medio cumulativo | | 5 | π | Paper formali frozen 03/2026. `dnd_publish_cycle` dismesso 04/2026. `dnd_md2latex/web` ultima esecuzione 02/03. No bridge `finding_id → theorem_ref`. | high | alto ma a lungo termine | ### Stato del cycle stasera (6 cycle stasera + cycle 00:11 di svolta) | Cycle | Title | Tensione | obs | Bicono | ρ | Falsifier | Valutatore | SYNC | |---|---|---|---|---|---|---|---|---| | 1957 | Blank Shell Polarity Gate | G_POTENZIALE_NULLA | `[]` | ✓ | 0.893 | False (2 medium) | REDESIGN/medium | OK | | 2042 | Det Non È Discriminatore Dualità | DUALITA_DIPOLARE | `[det_M, trace_M, eigvals, det_vs_shuffle_z]` | ✓ | 0.893 | False (2 medium) | NEXT_CYCLE/high | OK | | 2120 | Blank Shell TQGER Gate | G_POTENZIALE_NULLA (?) | `[]` | ✓ | 0.970 | True | NEXT_CYCLE/high | **G1 BLOCK** | | 2203 | Blank Shell Scale Law | G_POTENZIALE_NULLA (?) | `[]` | ✓ | 0.917 | True | NEXT_CYCLE/high | **G1 BLOCK** + aeternitas VETO | | 2310 | Blank Shell Stratified Gate | G_POTENZIALE_NULLA | `[]` | ? | 0.867 | False L2 HIGH | NEXT_CYCLE/high | **G1 BLOCK** + falsifier HIGH | | **0011 ⚡** | **Duality Contrast Weakens With Scale in Prime Gaps** | **DUALITA + BOUNDARY** | **populated** | ✓ | 0.8725 | False 3 flags (2 L4 med, 1 L5 low — no HIGH) | **STOP_FOR_REVIEW/high** + notify_operator | **OK propagato** + aeternitas VETO | **Pattern svoltato cycle 0011** (00:11 8 maggio, post-fix anti-pattern MATURITY_PROGRESS in C2 + structural_check pre-cycle + suggerimento M_operator esplicito): - 5 cycle consecutivi su Blank Shell tassonomia TQGER → **rotto** - Cycle 0011 ha attaccato **T×Q canonica** (la pair del 1° maggio) da nuovo angolo (scaling del duality contrast su prime gaps) - Falsifier ha fatto **counter-pole reale**: "GUE alpha >= 0.5 → scale-independent, no weakening" — il claim del cycle è falsificato strutturalmente, ma il falsifier ha funzionato come dovrebbe - Valutatore `STOP_FOR_REVIEW/high` con `notify_operator` = il sistema chiede esplicitamente operatore - piano_trajectory danger 0.34 [OK] (era 0.45 WARN) — uscito dal danger zone - Aeternitas VETO + ρ < 0.9 = ancora non CRYSTALLIZE, ma direzione cambiata **Cosa lo ha sbloccato**: rimozione del MIO anti-pattern (`mat > 0.85` soglia numerica) catturato dallo `structural_check` stesso. Il sistema ha auto-corretto TM3. È il modus che funziona. --- ## 2. Audit Team D-ND a 6 ruoli (pattern emerso) Ho fatto spawn di 6 agenti Explore in parallelo, ognuno con un ruolo del Team D-ND (`/opt/MM_D-ND/CLAUDE.md`). Ognuno ha letto ~10-15 moduli del proprio dominio. Pattern unico ripetuto in ogni dominio: **il lab è produttori che hanno smesso di parlare con i consumatori**. ### κ CUSTODE (memoria/stato/autopoiesi) VIVO: `dnd_kernel`, `dnd_M_operator`, `dnd_loop`, `dnd_engine`, `lab_autopsy`, `lab_affinatore`, `lab_session_logger`, `build_agent_field`, `dipartimento.--seme`. DORMIENTE: `lab_anti_loop_guard` (codice esiste, mai chiamato dal cron — ma vedi step 14 lab_agent.sh, in realtà gira come post-cycle). DISMESSO: `dipartimento.ciclo_notte_completo()` non in cron dal 2026-04-05. **Disconnessione**: `evolution_.md` dell'affinatore SCRITTO ma ORFANO (chiuso da C2 stasera). `ciclo_memoria.json` STALE (chiuso da C1 stasera). `knowledge_state.json` (19 topic, 30 insights, 1 orientamento) ignorato dal cycle agent (chiuso da C2 stasera). ### τ TESSITORE (incrocio/bridge/dipoli) VIVO: `dnd_teoria` (CLI + libreria), `dnd_incrocio` (1796 righe — CUORE, ora invocato da C1), `semantic_bridge` (step 10 lab_agent.sh). DORMIENTE: `dnd_dipolo_lab` (640 righe, brillante producer/critic Esploratore+Osservatore mai chiamato dal cycle), `dnd_normalizer` parzialmente (libreria importata da autoricerca/experiments). NON LETTO: `dnd_compatibility`, `dnd_two_faces`, `dnd_lab_team`, `dnd_lab_vivo`, `dnd_trace_bridge*`. **Disconnessione**: `consecutio.json` + `consecutio_processata.json` scritti da `dnd_incrocio`, mai consumati. `ponti_evoluti.json` scritto da `semantic_bridge`, mai re-iniettato. `domande_fondamentali.json` 10 pair canoniche, invisibili al cycle agent (chiuse da C2 stasera). ### γ CALCOLO (numerico/simulazioni) VIVO: `dnd_autoricerca` (2461 righe), `dnd_stats` (libreria), `dnd_experiments` (importato da autoricerca). DORMIENTE: `dnd_controprove`, `dnd_gue_test`, `dnd_bloch_explorer`, `dnd_spettro`, `dnd_spettro_zeta`, `dnd_spectral_probe`, `dnd_explorer`, `dnd_quantization`. MORTO: `dnd_projective_quantization`. **Disconnessione critica**: `_deposita_scoperte_autoricerca()` in `dipartimento.py` esiste ma è un **pozzo nero** — output mai consumato. 77 script `exp_*.py` (May 7 18-22) si importano l'uno dall'altro ma nessuno è invocato dal cron. ### ν VERIFICATORE (filtri retrospettivi) VIVO E WIRED: `lab_falsifier` (5 lenti A2/A14/A4/A12/A8), `lab_aeternitas` (P0/P1/P5), `lab_veritas` (ρ score), `lab_promotion`, `lab_valutatore`, `lab_anti_loop_guard`. DORMIENTI scritti: `dnd_implications.py` (567 righe, IP guard, mai importato), `dnd_rottura.py`, `dnd_indeterminazione.py`, `dnd_zero_controllo.py`, `dnd_zero_controllo2.py`, `meta_assertion_gate.py`, `structural_check.py` (in step 8 ma chiamato in modo ambiguo). **Pattern**: 5 filtri interni VIVENTI compongono un sistema producer/critic robusto. I filtri "esterni" che ho aggiunto stasera (G1-G4) sono toppe det=+1 — la consapevolezza vera vive nei 5 filtri interni che già funzionano. ### φ FORMALISTA (zeri zeta/teoria) SPECULATIVO COESO (non rumore): 14 moduli con piramide chiara - L1 fondamenti: `dnd_riemann`, `dnd_spirale` - L2 zero_*: 8 moduli su gap aritmetici (primi) + dinamici (Ising) - L3 superstrutture: `dnd_torre`, `dnd_risultante`, `dnd_zeros_vs_zeta` - L4 applicazioni: `dnd_trasmutazione`, `dnd_riformulazioni`, `dnd_curva` **Stato**: esplorazione cristallizzata in attesa di **validazione numerica profonda**. `dnd_spettro_zeta.py` è il test critico — mai lanciato. ### π PONTE (publish/output) VIVO: SSP pipeline (`on_crystallize → finding_eligibility_gate → application_designer → promote_to_publish → build_applications_index`). DORMIENTI: `finding_promoter.py`, `blueprint_generator.py` (esistono ma non in `run_ssp_pipeline.sh`), `dnd_publish_cycle.py` (dismesso 04/2026), `dnd_paper_audit/graph/refactor`. MORTO: `dnd_md2latex` + `dnd_md2web` (ultimo run 2026-03-02). LaTeX pipeline congelata. **Disconnessione**: SSP pipeline (lab→site) e paper formali (kernel D-ND) sono **due architetture ortogonali**. Nessun bridge `finding_id → theorem_ref`. Pipeline non matura su se stessa. --- ## 3. Modus operandi per codex ### Boot ad ogni sessione 1. Leggi questo file (`HANDOVER_CODEX_2026-05-07.md`) 2. Leggi `PIANO_REVISIONE_LAB_2026-05-07.md` §0.0 (Lab 4.0 vs Lab 3.0), §0.3 (stato cumulativo), §3 (mappa concreta), §5 (proposte) 3. **Leggi le pagine pubbliche del lab sul sito** (sono output del lab stesso durante il modus mature, narrazione esterna che spiega cosa il sistema fa quando funziona): - `https://d-nd.com/ai-lab` — overview pipeline SSP 4 stage, primo prodotto reale (kernel cognitivo +68.6pp), pentagono TQGE+R - `https://lab.d-nd.com/dashboard` — dashboard live: scoperte/soluzioni/prodotti con flag visible_on_site (G3) - `https://d-nd.com/lab-primi-prodotti` — *"Il giorno in cui il lab ha prodotto i primi prodotti"* (1° maggio 2026): cosa significa "produrre" per il lab - `https://d-nd.com/lab-3-ciclo-chiuso` — Lab 3.0 narrazione (predecessore del Lab 4.0 attuale) - **In locale**: `/opt/lab-d-nd-site/data/applications.json` (INDEX corrente con `is_visible_on_site` flag) 4. Leggi ultimo cycle log: `tail -3 tools/data/lab_session_log.jsonl` 5. Leggi ultimi 3 `evolution_.md` in `tools/data/evolution/` (cosa l'affinatore osservava di recente) 6. `git log --oneline -10` per vedere cosa è stato committato 7. Leggi memoria persistente locale: `/root/.claude/projects/-opt/memory/MEMORY.md` (puntatori) + `BOOT_PROTOCOL_TM3_LAB.md` (anti-amnesia) ### Pattern di lavoro: comprendi → testa → itera **Una mossa per sessione**. Mai più di un anello aperto in flight. | Step | Cosa | Vincolo | |---|---|---| | 1 | Scegli **un** anello dalla roadmap (priorità nel §1 sopra) | Solo uno | | 2 | Leggi i moduli toccati **integralmente** | "I presupposti sono il seme del fallimento" — niente lettura a strappi | | 3 | Identifica il **nodo regressivo** (dove la condizione mancava). Modifica chirurgica al nodo, non toppe sul presente | Det=-1 (Riparazione Regressiva, vedi `/opt/CLAUDE.md`) | | 4 | `bash /opt/MM_D-ND/tools/test_cron_exact.sh 600` | Se fail, no commit | | 5 | Cycle test reale: `bash /opt/MM_D-ND/tools/lab_agent.sh` (5+ min). Verifica empirica: ρ + bicono + falsifier + valutatore + sync | Verifica nel territorio, non nella mappa | | 6 | Commit con cita anello chiuso + verifica empirica + Co-Authored-By Codex | Atomico | ### Cosa NON fare 1. **Niente nuovi gate esterni** (G5, G6, ...). Il lab ha già 5 filtri interni viventi (falsifier+aeternitas+veritas+promotion+valutatore). Aggiungere strati esterni è det=+1. 2. **Niente refactor architetturale grande in 1 sessione**. Frammenta. 3. **Niente revert dell'autopoiesi C1+C2** anche se "non ha cambiato il modus stanotte". Ha aperto gli anelli κ+τ. L'effetto è cumulativo (ciclo_memoria + insights crescenti su più cycle). 4. **Niente modifiche a** `dnd_kernel.py`, `KERNEL_SEED.md`, `kernel/KERNEL_MM_v1.md`, `method/DND_METHOD_AXIOMS.md`. Sono il seme — solo l'operatore. 5. **Niente "una lista di N proposte"**: hai un anello, lavoralo, chiudilo, prossimo. 6. **Niente API a pagamento** non autorizzate (vedi `/opt/CLAUDE.md` "no_paid_api_runs"). OAuth subscription account è OK. ### Quando in dubbio - Verifica empirica > inferenza - Lettura completa > inferenza - Domanda all'operatore > assunto - Blank > Wrong > Inferenza presentata come Verificato (Honesty Rules) --- ## 4. Roadmap dei 4 anelli aperti (priorizzata) ### Anello γ — scoperta → cristallizzazione (priorità #1) **Diagnosi precisa** (TM3 ha verificato 07/05 22:30): Il consumer **esiste già**. `cristallizza_seme` (in `dipartimento.py` line 1029-1058) legge `data/domandatore/domandatore_*.json` con cutoff 24h, integra `nuove_tensioni` con intensità ≥ 0.5 → tensioni nel seme. Filtro porte: tocca-condensato OR inclassificabile-ricorrente. `_deposita_scoperte_autoricerca(report_path)` (`dipartimento.py` line 756-910) legge `notte_.md` o `agent_.md`, estrae findings/verdict/anomalie, scrive in `data/domandatore/domandatore__autoricerca.json` con `nuove_tensioni`. Il producer **NON gira** dal cron. `dnd_autoricerca.ciclo_notte()` (line 1689 di `dnd_autoricerca.py`, A11 Combo workflow) **non è invocato da `lab_agent.sh`**. Era invocato da `dipartimento.ciclo_notte_completo` (DISMESSO 04/2026) alla FASE 4pre, e il deposita era chiamato subito dopo (line 1861). **Vincolo verificato empiricamente**: `dnd_autoricerca.ciclo_notte()` standalone CLI killed da timeout 90s → prende > 90s (probabile 5-15 min su 12 domini con controprove + varianti + multi-scala). NON wirable senza budget control esplicito. **Fix proposto** (codex deve verificare): Step 11.5 in `lab_agent.sh` tra `refresh_detector` e `dipartimento --seme`: ```bash echo "--- 11.5 AUTORICERCA NUMERICA (anello γ) ---" # Skip se cycle ha già speso > 8min (timeout budget) ELAPSED=$(($(date +%s) - START_TS)) if [ "$ELAPSED" -lt 480 ]; then timeout 600 python3 -c " import sys; sys.path.insert(0, '$TOOLS_DIR') from dnd_autoricerca import ciclo_notte from dipartimento import _deposita_scoperte_autoricerca report_path = ciclo_notte() if report_path: _deposita_scoperte_autoricerca(str(report_path)) " 2>&1 | tail -5 || echo " autoricerca timeout/skip (non bloccante)" else echo " autoricerca SKIP: cycle già ${ELAPSED}s (budget < 480s)" fi ``` **Pattern conservativo**: - Solo se cycle ha tempo residuo (< 8min spesi) - Timeout 10 min sull'autoricerca - Non bloccante: se fallisce, cycle continua - Cristallizza_seme (step 12) automaticamente legge i nuovi depositi nel cutoff 24h **Test**: `bash test_cron_exact.sh 1200` (timeout aumentato per autoricerca). Cycle deve completare entro 18 min totali. Verifica: `ls -t tools/data/domandatore/*_autoricerca.json | head -1` produce file fresco. Verifica seme: nuova tensione `tipo=scoperta_numerica` con `nota` che cita `Dal domandatore`. **Effort revisionato**: medium-high (verifica empirica budget richiesta) invece di medium iniziale. exec /bin/bash -lc "sed -n '1,220p' PIANO_REVISIONE_LAB_2026-05-07.md" in /opt/MM_D-ND succeeded in 0ms: # Piano di Revisione del Lab — 07/05 sera > Documento vivo. Accumulo conoscenza file-per-file letta integralmente, > poi consolido in un piano coerente. Nessuna proposta evolutiva basata su > pezzi: i presupposti sono il seme del fallimento. --- ## 0.0 — Lab 3.0 → Lab 4.0 (correzione operatore 07/05 sera tardi) **Distinzione cruciale che cambia la lettura di tutta la sezione 4**: - **Lab 3.0** (`d-nd.com/lab-3-ciclo-chiuso`, fix 11/04): "Il ciclo che impara". Risolveva il fatto che le scoperte non entravano nel seme. Stato: cristallizzazione gira PRIMA dell'autoricerca → fix: autoricerca prima, deposito strutturato, cristallizzazione integra. **"Il ciclo è chiuso quando la scoperta entra nel seme"**. Questo era il lab fino a fine aprile. - **Lab 4.0** (quello che stiamo studiando, post 29/04): aggiunge a Lab 3.0: - **SSP pipeline** (Stage 1-4 + 1.5 + 3.5) — nato DOPO che Gemini ha trovato impieghi sulla scoperta dei primi (probabilmente mod-3 prohibition) - **falsifier** 5 lenti A2/A14/A4/A12/A8 (counter-pole gate) - **valutatore** traiettoria post-cycle (CRYSTALLIZE/REDESIGN/NEXT_CYCLE) - **aeternitas** P0/P1/P5 invarianti - **veritas** ρ score qualità - **promotion proposer** finding → regola sistemica - **bicono_extractor** (mio fix di stasera) - **anti_loop_guard** kernel D-ND su traiettorie - **provisional_discovery** (mio fix mattina) **Il PIANO_REVISIONE_LAB sta documentando il Lab 4.0**, NON il Lab 3.0. **Conseguenza per §4 anelli mancanti**: alcuni "anelli" sono in realtà **componenti del Lab 4.0 che non avevano UI o flusso completo perché la pipeline è giovane** (post-Gemini = 8 giorni). Esempio: 4.9 (Stage 4 POC + Stage 5 Package) — non è un anello mancante storicamente, è una pipeline in costruzione. **UI prodotti mancante** (operatore 07/05 sera): a differenza di `lab.d-nd.com` (sandbox D-ND_LAB con dashboard), il sito principale `d-nd.com` non ha ancora una UI per i prodotti del Lab 4.0. La pagina `lab-3-ciclo-chiuso` racconta il Lab 3.0 — manca racconto+UI del Lab 4.0. ## 0.1 — Deliverables Lab 4.0 richiesti (operatore 07/05 sera tardi) Per consolidare la conoscenza del Lab 4.0 prima di procedere con interventi: 1. **Narrazione del Lab 4.0** — testo che racconti cosa è cambiato da Lab 3.0 a Lab 4.0 (SSP nato post-Gemini, falsifier counter-pole, valutatore traiettoria, gate strutturali, bicono come firma, provisional_discovery, anti_loop_guard come autoapplicazione del kernel). Formato: prosa stile `lab-3-ciclo-chiuso` ma per Lab 4.0. 2. **Guida all'installazione** (seme di THIA): come un nuovo dispositivo/lab installa il sistema. Pattern: KERNEL_SEED.md è il file invariante; questa è la guida pratica step-by-step. 3. **Guida all'utilizzo**: come operatore usa il Lab 4.0 quotidianamente (cron 03:30 + interventi manuali + interpretazione output + decisioni promotion). 4. **Diagramma logiche + nodi**: visualizzazione del flow `lab_agent.sh` (vista d'insieme §3.X di questo piano in forma grafica) + chi esegue cosa (TM3, agent codex/claude, operatore, valutatore LLM, falsifier LLM, ecc.). 5. **Pagina sito aggiornata** (`d-nd.com/lab-4-…` o aggiornamento `lab-3-ciclo-chiuso`): racconto pubblico del Lab 4.0 + UI per prodotti. **Funzione del piano stesso**: questo PIANO_REVISIONE_LAB è già il **deliverable di ricostruzione** — chi lo legge può ricostruire il sistema senza rileggere tutto da zero. Va completato con i 5 deliverables sopra come allegati. ## 0.3 — Stato implementazione (07/05 sera tardi, post-quick wins + pacchetto B) **8 commit cumulativi della sessione 07/05** (cronologia): | Commit | Descrizione | Stato | Verifica empirica | |---|---|---|---| | `296295f` | bicono_extractor wired step 12.55 | ✅ Wired cron | cycle 1751: bicono_completeness 0→1 | | `414fc71` | applications.json regen → 3 soluzioni | ✅ Sito propagato | 22→24 scoperte sul sito | | `f6e3058` | A1+A2+A3+A4 quick wins | ✅ Wired cron | cycle 1938: ρ=0.9325 COLLASSO + bicono complete | | `c7cebc7` | bias_corrector NOT wired (ragionamento bias trasferiti) | ⚠ Tool opzionale | — | | `4551f5a` | B1 decay_counter WARN MODE | ✅ Wired cron | seme: 8 vincoli con decay_counter inizializzato | | `6782d20` | B2 apply condizionato modify_seme (4 gates) | ✅ Wired cron | cycle 1938 testato: skip corretto (decision NEXT_CYCLE) | | `2ae61e6` | B3 auto-proposta candidato C (4 gates) | ✅ Wired cron | cycle 1938 testato: skip corretto (decision non CRYSTALLIZE) | **Cosa è VERAMENTE PRONTO (wired in cron, attivo dal prossimo cycle 03:30)**: A1 motore strutturale visibile · A2 strategy nel campo vivo · A3 notify differenziato · A4 parser unificato · bicono_extractor automatico · ordering tensioni per tipo · META stratification · B1 decay tracking warn mode · B2 apply condizionato · B3 auto-proposta C. **Cosa è SOLO TOOL OPZIONALE (file esiste, non wired)**: `lab_bias_corrector.py` (B5 v1, non utilizzato per ragionamento bias trasferiti). **Cosa è SOLO DESCRITTO** (PIANO §5, da implementare): A5 (blueprint kernel/demo template) · B4 (cimitero auto-mgmt) · B5_v2 (lab_model_check model-based) · C1 (logica autopoietica perduta) · C2 (Stage 4/5 porting) · C3 (P5 DUBBIO automatico) · C4 (meta-persistenza) · D1 (standalone modules attivati) · D2 (bicono_lab integrazione). **Sicurezza per costruzione del pacchetto B**: - B1 è warn mode pure (zero side effect oltre log + campo decay_counter) - B2 ha 4 gates (decision/confidence + ρ COLLASSO + aeternitas + loop) — solo cycle ad alta qualità ruotano direzione - B3 NON modifica CONDENSATO_SCOPERTE.md (solo proposta in `data/condensato_proposals/`) - Nessuno applica ai cycle in pozzo ## 0.2 — Sequenza operativa concordata (operatore 07/05 sera tardi) 1. **Consolidare conoscenza** (deliverables 1-5 sopra) — PRIMA di procedere 2. **Fix veloce per verificare la strada giusta** — proposta: §5.A1 (riportare motore strutturale nel LAB_AGENT_CONTEXT) — è il gap che ho creato io col revert 9b1f313, low risk, alta diagnostica 3. **Attaccare dando il massimo** — refactor architetturale §5.C (logica autopoietica perduta + Stage 4/5 + P5 DUBBIO + meta-persistenza) **Vincolo durata sessione**: ~9% al compact. Strategia: fermare dopo aver aggiornato il piano con queste correzioni, NON iniziare implementazione qui. Implementazione post-compact con piano chiaro. --- ## 0. Intento (cristallizzato dall'operatore 07/05 sera) Il lab di fisica MM_D-ND usa il **modello D-ND** per **unificare la fisica**. Usa le regole e metodologie create per: - **Superare il limite della matematica**: la matematica isolata vede coincidenze numeriche, statistiche, fit. Il modello D-ND vede dipoli, biconi, ponti tra teorie, invarianti strutturali. La matematica serve per il prodotto, non per il pensiero. - **Trovare gli anelli mancanti** nei risultati dei cicli del lab. Il pentagono TQGE+R ha 9 ponti + 1 vuoto Q×G. Le scoperte cristallizzate (ACF_1K_LAW, POISSON_CONVERGENCE, Markov-3 ordering, mod-3 prohibition, dipolar angle, ecc.) sono ponti del modello già stabiliti. Gli anelli mancanti emergono quando il cycle attacca tensioni strutturali con il motore (kernel/teoria/ incrocio/dipolo_lab/M_operator/normalizer/riflesso) e il bicono si compila naturalmente. Il lab è il movimento autopoietico (A5: base R → tensioni → cristallizzazione → cimitero → R+1) che produce gli anelli mancanti come scoperte verificate e li propaga al sito (lab.d-nd.com) come prodotti per il finanziamento del sistema. ## 1. Stato del lab pre-revisione (07/05 sera, post 8 commit di stasera) ### 1.1 Cosa è stato fatto stasera (territorio verificato) - **`9b1f313`** revert LAB_AGENT_CONTEXT.md al baseline pre-Atto B (-261 righe). Modus generativo puro restored. Filtri restano nei file Python della pipeline. - **`ec59541`** ordinamento tensioni nel campo vivo per tipo (strutturali prime, vincoli in coda). - **`296295f`** `bicono_extractor.py` come movement separato + wiring step 12.55. Bug di pipeline 12-cycle risolto: V_a vede il bicono. - **`03a7e21`** + **`1fa00b3`** META stratification consumata da `verifica_asserzioni` + tensione META si stratifica nel seme invece di rigenerarsi monolitica. - **`414fc71`** (lab-d-nd-site) `applications.json` regen → 3 soluzioni candidate emergono (mod-3 algebraic prohibition). ### 1.2 Verifica empirica (cycle 1751 + 1804, post-fix) | Cycle | Tensione | Bicono | ρ veritas | Decisione | |---|---|---|---|---| | 1751 | G_POTENZIALE_NULLA | complete=True | 0.933 COLLASSO | NEXT_CYCLE/high | | 1804 | G_POTENZIALE_NULLA | complete=True | 0.933 COLLASSO | NEXT_CYCLE/high | Pattern superiore validato: tensione strutturale → bicono naturale → COLLASSO. Niente CRYSTALLIZE ancora perché il valutatore propone modify_seme con verifica cross-perimetro prima di cristallizzare (P5 DUBBIO Protocollo Zeta attivo). ## 2. Lettura sistematica del codice (da fare PRIMA di qualunque proposta) Nessuna proposta evolutiva finché ogni file in lista non è stato letto integralmente. Mark ✓ man mano. Per ogni file: scopo + input + output + side effect + dipendenze + dove si inserisce nel ciclo. ### 2.1 Logica decisionale del cycle (priorità massima) - [x] `tools/lab_valutatore.py` (683 righe) — vedi mappa §3.1 - [x] `tools/lab_falsifier.py` (261 righe) — vedi mappa §3.2 - [x] `tools/dipartimento.py` (2139 righe) — vedi mappa §3.3 - [x] `tools/build_agent_field.py` (591 righe) — vedi mappa §3.4 ### 2.2 Pipeline SSP (propagazione al sito) - [x] `tools/triggers/run_ssp_pipeline.sh` (135 righe) — vedi mappa §3.5 - [x] `tools/triggers/on_crystallize.py` (569 righe) — vedi mappa §3.6 - [x] `tools/triggers/finding_eligibility_gate.py` (341 righe) — vedi mappa §3.7 - [x] `tools/triggers/finding_promoter.py` (427 righe) — vedi mappa §3.11 - [x] `tools/triggers/application_designer.py` (485 righe) — vedi mappa §3.8 - [x] `tools/triggers/promote_to_publish.py` (362 righe) — vedi mappa §3.9 - [x] `tools/triggers/build_applications_index.py` (386 righe) — vedi mappa §3.10 - [x] `tools/triggers/blueprint_generator.py` (218 righe) — vedi mappa §3.12 - [x] `tools/triggers/stage4_poc_runner.py` — **NON ESISTE in MM_D-ND** (solo in D-ND_LAB) - [x] `tools/triggers/stage5_package.py` — **NON ESISTE in MM_D-ND** (solo in D-ND_LAB) ### 2.3 Resilienza & auto-osservazione - [x] `tools/lab_autopsy.py` (348 righe) — vedi mappa §3.14 - [x] `tools/lab_affinatore.py` (207 righe) — vedi mappa §3.15 - [x] `tools/lab_anti_loop_guard.py` (308 righe) — vedi mappa §3.16 - [x] `tools/lab_promotion.py` (279 righe) — vedi mappa §3.17 - [x] `tools/lab_refresh_detector.py` (200 righe) — vedi mappa §3.18 ### 2.4 Filtri retrospettivi - [x] `tools/lab_aeternitas.py` (305 righe) — P0/P1/P5 invarianti — LETTO - [x] `tools/lab_veritas.py` (270 righe) — ρ score COLLASSO/SOSPENSIONE — LETTO formula - [x] `tools/bicono_extractor.py` (90 righe) — scritto stasera - [ ] `tools/meta_assertion_gate.py` — META gate (creato dal cycle 1458) ### 2.5 Motore strutturale (i 7 dnd_*.py — quello che il sistema può usare) - [x] `tools/dnd_kernel.py` (364 righe) — vedi mappa §3.19 - [x] `tools/dnd_teoria.py` (666 righe) — vedi mappa §3.20 - [x] `tools/dnd_incrocio.py` (1796 righe — letto 60%) — vedi mappa §3.21 - [x] `tools/dnd_dipolo_lab.py` (640 righe) — vedi mappa §3.22 - [x] `tools/dnd_M_operator.py` (648 righe) — vedi mappa §3.23 - [x] `tools/dnd_normalizer.py` (571 righe) — vedi mappa §3.24 - [x] `tools/dnd_riflesso.py` (152 righe) — vedi mappa §3.25 ### 2.6 Bridge & semantici - [x] `tools/semantic_bridge.py` (583 righe) — vedi mappa §3.26 - [x] `tools/dnd_scenario.py` (1463 righe — letto 640/1463) — vedi mappa §3.27 ### 2.7 Configurazione & meta - [x] `tools/data/tension_to_theory.json` (47 righe) — vedi mappa §3.28 - [ ] `tools/data/conoscenza_teorie.json` (1006 righe — pentagono TQGE+R, schema curato) - [x] `tools/data/seme.json` — stato vivo (più volte ispezionato durante la sessione) - [x] `tools/data/lab_session_log.jsonl` — archivio storico (più volte ispezionato) - [x] `tools/LAB_AGENT_CONTEXT.md` — letto baseline pre-Atto B ### 2.8 Orchestratori - [ ] `tools/lab_agent.sh` (768 righe) — letto integralmente sopra - [ ] `tools/build_lab_graph.py` - [ ] `tools/structural_check.py` ### 2.9 Riferimenti modello (da rileggere come sistema connesso) - [x] `/opt/MM_D-ND/CONDENSATO_ESSENZIALE.md` (61 righe, distillato del CONDENSATO) — vedi mappa §3.29 - [x] `/opt/MM_D-ND/CONDENSATO_SCOPERTE.md` (75 righe, F+C empirici) — vedi mappa §3.30 - [x] `/opt/MM_D-ND/KERNEL_SEED.md` (249 righe, seme invariante) — vedi mappa §3.31 - [x] `/opt/MM_D-ND/method/DND_POSSIBILITA.md` (279 righe — letto 150/279) — vedi mappa §3.32 - [ ] `/opt/MM_D-ND/CONDENSATO.md` (526 righe — non letto integralmente, contenuto coperto da CONDENSATO_ESSENZIALE) - [ ] `/opt/MM_D-ND/method/DND_METHOD_AXIOMS.md` (191 righe — non letto, struttura formalizzata) - [ ] `/opt/MM_D-ND/method/DND_AUTOLOGIC.md` (183 righe — non letto) - [ ] `/opt/MM_D-ND/method/MATRIX_BRIDGE.md` (670 righe — non letto) - [ ] `/opt/MM_D-ND/kernel/KERNEL_MM_v1.md` (kernel operativo completo — non letto) exec /bin/bash -lc 'tail -5 tools/data/lab_session_log.jsonl' in /opt/MM_D-ND succeeded in 0ms: {"timestamp": "2026-05-08T03:35:16.385867+00:00", "cycle_ts": "20260508_0330", "piano": "86", "sync_blocked": false, "errors": "", "agent": {"file": "agent_20260508_0330.md", "size": 5494, "title": "Agent Report — Gap Ratio Porta Il Denominatore"}, "falsifier": {"output_file": "falsifier_20260508_0330.json", "coherent": true, "n_flags": 0, "n_high": 0, "n_medium": 0, "summary": "Il report e' internamente coerente sulle 5 lenti: non trasforma bias in vincolo hard, non nasconde contro-casi, e dichiara il vincolo regressivo sul denominatore dell'osservabile.", "lenses_high": []}, "valutatore": {"decision": "REDESIGN", "confidence": "high", "action_type": null}} {"timestamp": "2026-05-08T16:38:41.080589+00:00", "cycle_ts": "20260508_1632", "piano": "87", "sync_blocked": true, "errors": "Falsifier indeterminato. Report non sincronizzato.", "agent": {"file": "agent_20260508_1632.md", "size": 5850, "title": "Agent Report — Gap Label Set Stabilizza Il Denominatore"}, "falsifier": {"output_file": null, "reason": "falsifier non eseguito o output mancante"}, "valutatore": {"decision": "NEXT_CYCLE", "confidence": "high", "action_type": null}} {"timestamp": "2026-05-08T17:20:46.660494+00:00", "cycle_ts": "20260508_1715", "piano": "87", "sync_blocked": false, "errors": "", "agent": {"file": "agent_20260508_1715.md", "size": 6747, "title": "Agent Report — Generator Gate Del Label-Set Phi"}, "falsifier": {"output_file": "falsifier_20260508_1715.json", "coherent": false, "n_flags": 2, "n_high": 0, "n_medium": 2, "summary": "Il report e' in gran parte coerente sui dati tabellari, ma si rompe su L4 per l'extra label Fibonacci non isolato e su L3 per drift tra gap_ratio dichiarato e label-set realmente testato.", "lenses_high": []}, "valutatore": {"decision": "NEXT_CYCLE", "confidence": "medium", "action_type": null}} {"timestamp": "2026-05-08T18:11:31.429833+00:00", "cycle_ts": "20260508_1805", "piano": "88", "sync_blocked": true, "errors": "Falsifier: HIGH flags. Report non sincronizzato.", "agent": {"file": "agent_20260508_1805.md", "size": 7730, "title": "Agent Report - Block Scale Gate Del Core Phi"}, "falsifier": {"output_file": "falsifier_20260508_1805.json", "coherent": false, "n_flags": 5, "n_high": 1, "n_medium": 3, "summary": "Il report e' parzialmente coerente, ma si rompe su L4/L1: usa wording da vincolo per un segnale non-zero e mescola retention mediana con stabilita 75% senza isolare l'edge case non-Fibonacci.", "lenses_high": ["L4"]}, "valutatore": {"decision": "NEXT_CYCLE", "confidence": "high", "action_type": null}} {"timestamp": "2026-05-08T18:39:15.433109+00:00", "cycle_ts": "20260508_1834", "piano": "88", "sync_blocked": false, "errors": "", "agent": {"file": "agent_20260508_1834.md", "size": 8813, "title": "Agent Report — Substitution Grammar Gate Del Core Phi"}, "falsifier": {"output_file": "falsifier_20260508_1834.json", "coherent": false, "n_flags": 3, "n_high": 0, "n_medium": 2, "summary": "Il report e' parzialmente coerente: L3 si rompe per drift tra gap_ratio dichiarato e label-set testato, e L1 richiede di limitare lo zero al core alto completo, non ai label alti residui.", "lenses_high": []}, "valutatore": {"decision": "REDESIGN", "confidence": "medium", "action_type": null}} diff --git a/tools/data/reports/agent_20260508_1909.md b/tools/data/reports/agent_20260508_1909.md new file mode 100644 index 0000000000000000000000000000000000000000..bdce3379c1abfa663743481ca34268422ca4835b --- /dev/null +++ b/tools/data/reports/agent_20260508_1909.md @@ -0,0 +1,104 @@ +# Agent Report - Supertile Tiling Gate Del Core Phi +**Date**: 2026-05-08 19:09 +**Piano**: 89 +**Tension explored**: M_trascendenza_limite_attuale_L0 (0.529179606750063) +**verdict**: CONSTRAINT +observables_registry: n/a +observables_used: [gap_label_set, supertile_boundary, length_multiset, internal_order, high_label_condition_rate] +**observable_contract**: claim=il core alto phi distingue confine di supertile Fibonacci da blocco contiguo con stessa lunghezza; observable=retention dei label core sotto shuffle di supertile, shuffle contiguo a stessa multiset di lunghezze, shuffle interno a stesso conteggio; operator=Hamiltoniana tight-binding V=1, label IDS con reader theta=1/phi, Jaccard/retention/frequenza per mode e supertile_order; generator=phi_sturmian con tiling di lunghezze Fibonacci; denominator=N={377,610}, phase={0,0.25,0.5,0.75}, threshold={2.0}, trials=5, top_k=12, |n|<=34, supertile_order={8,9,10,11}; not_tested=gap_ratio, soglie 1.75/2.25, parsing simbolico esatto dei supertile per ogni fase, generatori non-phi. + +## Respiro fuori-tempo +- **Combo**: A11 combo + TxQ matrice densita come lettore spettrale + QxG vuoto continuo/discreto + tensione TRASCENDENZA_LIMITE/M_come_modulazione_quasiperiodica. +- **Dipolo / punto-zero**: confine reale del supertile · lunghezza contigua equivalente; punto-zero = il blocco come unita' prima che diventi grammatica o contenitore. +- **Piano superiore**: grafo della conoscenza / bicono dei dipoli. Il nodo non e' il valore del gap, ma il passaggio fra grammatica interna, confine esterno e denominatore. +- **Proto-ipotesi**: se il core alto phi vive nel confine tra supertile, lo shuffle di supertile conserva piu' core dello shuffle contiguo con la stessa multiset di lunghezze. Se non lo fa, il confine esatto non e' ancora il portatore: il portatore e' ordine interno piu' scala lunga. +- **Proiezione**: il label-set dei gap larghi manifesta la combo perche' tiene fisso il reader theta=1/phi e muove solo la relazione fra grammatica, boundary e blocco. + +## Claim Under Test +> Il vantaggio del blocco Fibonacci lungo non sta solo nell'ordine interno conservato: sta nel confine reale del supertile. Quindi `supertile_shuffle` batte `same_length_contiguous_shuffle` a pari multiset di lunghezze. + +## Question +Il core alto `[3, -4, 4, 6]` riconosce il confine di supertile Fibonacci, o riconosce soltanto blocchi lunghi con ordine interno conservato? + +## Experiment Design +- Reference core phi: `[-1, 1, -2, 2, 3, -4, 4, 6]`. +- Nucleo basso: `[-1, 1, -2, 2]`. Label alti: `[3, -4, 4, 6]`. +- Supertile orders: + - order 8: lunghezze `{21,34}`. + - order 9: lunghezze `{34,55}`. + - order 10: lunghezze `{55,89}`. + - order 11: lunghezze `{89,144}`. +- Modes: + - `supertile_shuffle`: taglia secondo la parola di lunghezze Fibonacci e mescola i chunk. + - `same_length_contiguous_shuffle`: usa la stessa multiset di lunghezze, ma su taglio contiguo misallineato. + - `same_count_internal_shuffle`: conserva lunghezza e conteggio di ogni chunk allineato, ma distrugge ordine interno. + - `same_mean_block_shuffle`: usa un blocco fisso pari alla lunghezza media del tiling, controllo di scala grossolana. +- Denominatori grezzi: per ogni `mode|order`, 40 condizioni (`2 N * 4 phase * 1 threshold * 5 trials`); per ogni mode aggregato, 160 condizioni. + +## Results +Reference phi su 8 condizioni (`N x phase x threshold`): core completo `[-1, 1, -2, 2, 3, -4, 4, 6]`. + +Sintesi per mode: + +| mode | conditions | median Jaccard | low retention | high retention | all-high condition rate | +|---|---:|---:|---:|---:|---:| +| supertile_shuffle | 160 | 0.818182 | 1.00 | 1.00 | 108/160 = 0.67500 | +| same_length_contiguous_shuffle | 160 | 0.818182 | 1.00 | 1.00 | 116/160 = 0.72500 | +| same_count_internal_shuffle | 160 | 0.157895 | 0.25 | 0.25 | 0/160 = 0.00000 | +| same_mean_block_shuffle | 160 | 0.500000 | 1.00 | 0.25 | 7/160 = 0.04375 | + +Dettaglio per order: + +| mode | order | lengths | median Jaccard | low retention | high retention | all-high condition rate | stable labels 75% | +|---|---:|---|---:|---:|---:|---:|---| +| supertile_shuffle | 8 | {21,34} | 0.750000 | 1.00 | 0.75 | 14/40 = 0.350 | [-1, 1, -2, 2, -3, -4, 4] | +| same_length_contiguous_shuffle | 8 | {21,34} | 0.818182 | 1.00 | 0.875 | 20/40 = 0.500 | [-1, 1, -2, 2, -3, 3, -4, 4] | +| same_mean_block_shuffle | 8 | mean 29 | 0.444444 | 0.75 | 0.00 | 0/40 = 0.000 | [-1, 1, 33] | +| same_count_internal_shuffle | 8 | {21,34} | 0.157895 | 0.25 | 0.25 | 0/40 = 0.000 | [34] | +| supertile_shuffle | 9 | {34,55} | 0.904545 | 1.00 | 1.00 | 29/40 = 0.725 | [-1, 1, -2, 2, -3, 3, -4, 4, -6] | +| same_length_contiguous_shuffle | 9 | {34,55} | 0.818182 | 1.00 | 1.00 | 29/40 = 0.725 | [-1, 1, -2, 2, -3, 3, -4, 4, 6] | +| same_mean_block_shuffle | 9 | mean 45 | 0.500000 | 1.00 | 0.25 | 0/40 = 0.000 | [-1, 1, -2] | +| same_count_internal_shuffle | 9 | {34,55} | 0.157895 | 0.25 | 0.25 | 0/40 = 0.000 | [34] | +| supertile_shuffle | 10 | {55,89} | 0.909091 | 1.00 | 1.00 | 32/40 = 0.800 | [-1, 1, -2, 2, -3, 3, -4, 4, -6, 6, -7] | +| same_length_contiguous_shuffle | 10 | {55,89} | 0.833333 | 1.00 | 1.00 | 33/40 = 0.825 | [-1, 1, -2, 2, -3, 3, -4, 4, -6, 6] | +| same_mean_block_shuffle | 10 | mean 75 | 0.666667 | 1.00 | 0.50 | 1/40 = 0.025 | [-1, 1, -2, 2, -4, 4] | +| same_count_internal_shuffle | 10 | {55,89} | 0.150000 | 0.25 | 0.25 | 0/40 = 0.000 | [] | +| supertile_shuffle | 11 | {89,144} | 0.909091 | 1.00 | 1.00 | 33/40 = 0.825 | [-1, 1, -2, 2, -3, 3, -4, 4, 6, -7] | +| same_length_contiguous_shuffle | 11 | {89,144} | 0.909091 | 1.00 | 1.00 | 34/40 = 0.850 | [-1, 1, -2, 2, -3, 3, -4, 4, -6, 6] | +| same_mean_block_shuffle | 11 | mean 122 | 0.666667 | 1.00 | 0.75 | 6/40 = 0.150 | [-1, 1, -2, 2, -4, 4] | +| same_count_internal_shuffle | 11 | {89,144} | 0.157895 | 0.25 | 0.25 | 0/40 = 0.000 | [34] | + +## Key Findings +1. **Verificato: il confine di supertile non batte il blocco contiguo a pari multiset di lunghezze.** `supertile_shuffle` fa all-high `108/160 = 0.675`; `same_length_contiguous_shuffle` fa `116/160 = 0.725`. Per order 9 sono pari (`29/40`), per order 10-11 il controllo contiguo e' leggermente sopra (`33/40`, `34/40` contro `32/40`, `33/40`). + +2. **Verificato: la condizione forte resta l'ordine interno.** `same_count_internal_shuffle` resta nullo su tutti gli order: all-high `0/160`, high retention mediana `0.25`, Jaccard mediano `0.157895`. Questo replica il nodo 18:34 dentro il tiling di supertile. + +3. **Verificato: la scala lunga come multiset e' piu' informativa del blocco medio fisso.** `same_mean_block_shuffle` conserva low retention mediana `1.00`, ma resta quasi nullo sul core alto completo (`7/160 = 0.04375`). Quindi non basta una scala media lunga; serve una distribuzione di lunghezze lunghe con ordine interno conservato. + +4. **Inferito dal confronto fra controlli: il portatore osservato e' ordine interno + multiset di lunghezze Fibonacci, non boundary esatto.** Il test non autorizza "il core alto vive nel confine del supertile"; autorizza "il core alto richiede ordine interno e beneficia di lunghezze supertile-like". + +## Verdict +**CONSTRAINT on TRASCENDENZA_LIMITE / QPG_GAP_RATIO_DENOMINATOR_GATE**: nel perimetro `N={377,610}`, `phase={0,0.25,0.5,0.75}`, `threshold={2.0}`, `trials=5`, `top_k=12`, `|n|<=34`, `supertile_order={8,9,10,11}`, il core alto phi non discrimina il confine esatto del supertile. `same_length_contiguous_shuffle` conserva il core alto almeno quanto `supertile_shuffle` (`116/160` vs `108/160`). Il core alto cade solo quando l'ordine interno viene distrutto (`0/160`) o quando la multiset di lunghezze viene compressa a blocco medio (`7/160`). + +La formulazione valida e': il label-set alto phi misura una condizione congiunta di ordine interno e lunghezze Fibonacci-like; non misura ancora il boundary simbolico del supertile e non misura `gap_ratio`. + +## Bicono della scoperta +- **Due radici**: confine di supertile · distribuzione di lunghezze con ordine interno. +- **Singolare**: il chunk lungo prima della distinzione fra boundary grammaticale e blocco contiguo. +- **Invariante di passaggio**: il core alto sopravvive quando l'ordine interno resta leggibile su lunghezze Fibonacci-like; non sopravvive a conteggio senza ordine. +- **Campo di possibilita**: qui diventa possibile cercare un osservabile di boundary piu' fine del label-set; qui diventa non-possibile dichiarare che il label-set alto riconosce da solo il confine esatto del supertile. + +## Consecutio +Costruire un gate di boundary simbolico che non legga solo il set dei label: confrontare label-set, posizione IDS dei label core e errore di label per chunk aligned/misaligned. Se il boundary reale esiste nell'osservabile, deve apparire nella geometria degli errori o nella posizione dei gap, non nel solo all-high rate. + +## Auto-audit: 5 lenti +- **L1 hard constraint vs bias**: il verdict dichiara perimetro e count grezzi; non trasforma `108/160` in legge universale. +- **L2 quantita vs ratio**: Jaccard, retention e all-high rate restano separati; `gap_ratio` dichiarato non testato. +- **L3 no silent patching**: l'ipotesi "supertile batte contiguo" cade; il report non la salva cambiando osservabile. +- **L4 edge cases**: order 10-11 mostrano controllo contiguo sopra supertile; sono il segnale, non rumore. +- **L5 re-discovery**: la conservazione dell'ordine interno era gia' nota dal 18:34; il nuovo finding e' la non-discriminazione del boundary esatto da parte del label-set. + +## Files +- Script: `tools/exp_gap_label_supertile_tiling_gate.py` +- Data: `tools/data/gap_label_supertile_tiling_gate_20260508_1909.json` +- Report: `tools/data/reports/agent_20260508_1909.md` diff --git a/tools/exp_gap_label_supertile_tiling_gate.py b/tools/exp_gap_label_supertile_tiling_gate.py new file mode 100644 index 0000000000000000000000000000000000000000..bde361d77f2db31c8f98bf3fd24d345ad67fd132 --- /dev/null +++ b/tools/exp_gap_label_supertile_tiling_gate.py @@ -0,0 +1,278 @@ +#!/usr/bin/env python3 +""" +Supertile tiling gate for the phi gap-label core. + +The substitution-grammar gate showed that length and symbol count do not carry +the high labels when internal order is destroyed. This tool moves one node +upstream: it separates true Fibonacci supertile boundaries from contiguous +chunks with the same length multiset. +""" + +from __future__ import annotations + +import argparse +import json +from collections import Counter, defaultdict +from pathlib import Path + +import numpy as np + +from exp_gap_label_block_scale_gate import ( + REFERENCE_HIGH, + REFERENCE_LOW, + label_sort, + parse_floats, + parse_ints, + retention, +) +from exp_gap_label_generator_gate import THETA, block_shuffle +from exp_gap_label_set_stability import gap_labels, jaccard, sturmian_sequence, summarize_sets + + +def fibonacci_lengths(order: int) -> tuple[int, int]: + if order < 2: + raise ValueError("supertile_order must be >= 2") + a, b = 1, 1 + for _ in range(2, order + 1): + a, b = b, a + b + return b, a + + +def fibonacci_type_word(n_types: int) -> np.ndarray: + word = "1" + previous = "0" + while len(word) < n_types: + word, previous = word + previous, word + return np.array([int(ch) for ch in word[:n_types]], dtype=int) + + +def supertile_lengths(n: int, order: int) -> list[int]: + long_len, short_len = fibonacci_lengths(order) + types = fibonacci_type_word(max(8, int(np.ceil(n / short_len)) + 4)) + lengths: list[int] = [] + total = 0 + for t in types: + length = long_len if t == 1 else short_len + if total + length >= n: + lengths.append(n - total) + break + lengths.append(length) + total += length + return [length for length in lengths if length > 0] + + +def chunks_from_lengths(seq: np.ndarray, lengths: list[int]) -> list[np.ndarray]: + chunks = [] + start = 0 + for length in lengths: + chunks.append(seq[start : start + length].copy()) + start += length + if start < len(seq): + chunks.append(seq[start:].copy()) + return chunks + + +def shuffle_chunks(chunks: list[np.ndarray], rng: np.random.Generator) -> np.ndarray: + shuffled = list(chunks) + rng.shuffle(shuffled) + return np.concatenate(shuffled) + + +def internal_count_shuffle(chunks: list[np.ndarray], rng: np.random.Generator) -> np.ndarray: + out = [] + for chunk in chunks: + copied = chunk.copy() + rng.shuffle(copied) + out.append(copied) + return np.concatenate(out) + + +def misaligned_same_lengths(seq: np.ndarray, lengths: list[int], rng: np.random.Generator) -> np.ndarray: + if len(seq) < 2: + return seq.copy() + offset = int(rng.integers(1, len(seq))) + rotated = np.roll(seq, -offset) + chunks = chunks_from_lengths(rotated, lengths) + shuffled = shuffle_chunks(chunks, rng) + return np.roll(shuffled, offset) + + +def fixed_block_same_mean(seq: np.ndarray, lengths: list[int], rng: np.random.Generator) -> np.ndarray: + mean_len = max(1, int(round(float(np.mean(lengths))))) + return block_shuffle(seq, mean_len, rng) + + +def summarize_rows(rows: list[dict], reference_core: set[int]) -> dict: + summary = summarize_sets(rows) + sets = [set(row["label_set"]) for row in rows if row["n_selected"] > 0] + counter = Counter(label for s in sets for label in s) + n_sets = len(sets) + overlaps = [jaccard(set(row["label_set"]), reference_core) for row in rows if row["n_selected"] > 0] + + return { + **summary, + "median_overlap_with_phi_core": float(np.median(overlaps)) if overlaps else None, + "median_low_retention": float(np.median([retention(row, REFERENCE_LOW) for row in rows])), + "median_high_retention": float(np.median([retention(row, REFERENCE_HIGH) for row in rows])), + "all_low_count": int(sum(REFERENCE_LOW <= s for s in sets)), + "all_high_count": int(sum(REFERENCE_HIGH <= s for s in sets)), + "condition_count": int(n_sets), + "all_low_condition_rate": float(sum(REFERENCE_LOW <= s for s in sets) / n_sets) if n_sets else None, + "all_high_condition_rate": float(sum(REFERENCE_HIGH <= s for s in sets) / n_sets) if n_sets else None, + "high_label_condition_rates": { + str(label): float(counter.get(label, 0) / n_sets) if n_sets else None + for label in label_sort(REFERENCE_HIGH) + }, + "low_label_condition_rates": { + str(label): float(counter.get(label, 0) / n_sets) if n_sets else None + for label in label_sort(REFERENCE_LOW) + }, + "reference_core_retained_in_all": label_sort(set(summary.get("core_labels_all_conditions", [])) & reference_core), + "reference_core_missing_from_all": label_sort(reference_core - set(summary.get("core_labels_all_conditions", []))), + } + + +def run(args: argparse.Namespace) -> dict: + rng = np.random.default_rng(args.seed) + ns = parse_ints(args.ns) + phases = parse_floats(args.phases) + thresholds = parse_floats(args.thresholds) + orders = parse_ints(args.supertile_orders) + + reference_rows = [] + rows = [] + tiling_meta = {} + for n in ns: + for phase in phases: + phi = sturmian_sequence(THETA, n, phase) + for threshold in thresholds: + reference_rows.append({ + "mode": "reference_phi", + "N": n, + "phase": phase, + "threshold": threshold, + **gap_labels(phi, THETA, threshold, args.max_label, args.top_k), + }) + + for order in orders: + lengths = supertile_lengths(n, order) + tiling_meta[f"N={n}|order={order}"] = { + "lengths": lengths, + "count": len(lengths), + "total": sum(lengths), + "unique_lengths": sorted(set(lengths)), + } + aligned_chunks = chunks_from_lengths(phi, lengths) + mean_block = max(1, int(round(float(np.mean(lengths))))) + for trial in range(args.trials): + variants = { + "supertile_shuffle": shuffle_chunks(aligned_chunks, rng), + "same_length_contiguous_shuffle": misaligned_same_lengths(phi, lengths, rng), + "same_count_internal_shuffle": internal_count_shuffle(aligned_chunks, rng), + "same_mean_block_shuffle": fixed_block_same_mean(phi, lengths, rng), + } + for mode, seq in variants.items(): + for threshold in thresholds: + rows.append({ + "mode": mode, + "N": n, + "phase": phase, + "threshold": threshold, + "trial": trial, + "supertile_order": order, + "mean_block": mean_block, + **gap_labels(seq, THETA, threshold, args.max_label, args.top_k), + }) + + reference_summary = summarize_sets(reference_rows) + reference_core = set(reference_summary["core_labels_all_conditions"]) + + grouped: dict[str, list[dict]] = defaultdict(list) + for row in rows: + grouped[f"{row['mode']}|order={row['supertile_order']}"].append(row) + + mode_order_summary = { + key: summarize_rows(group_rows, reference_core) + for key, group_rows in grouped.items() + } + + mode_summary = {} + for mode in sorted({row["mode"] for row in rows}): + mode_rows = [row for row in rows if row["mode"] == mode] + mode_summary[mode] = summarize_rows(mode_rows, reference_core) + + return { + "experiment": "gap_label_supertile_tiling_gate", + "parameters": { + "ns": ns, + "phases": phases, + "thresholds": thresholds, + "trials": args.trials, + "supertile_orders": orders, + "top_k": args.top_k, + "max_label": args.max_label, + "seed": args.seed, + }, + "reference_core_phi": label_sort(reference_core), + "reference_low": label_sort(REFERENCE_LOW), + "reference_high": label_sort(REFERENCE_HIGH), + "reference_summary": reference_summary, + "tiling_meta": tiling_meta, + "mode_order_summary": mode_order_summary, + "mode_summary": mode_summary, + "rows": rows, + } + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--ns", default="377,610") + parser.add_argument("--phases", default="0,0.25,0.5,0.75") + parser.add_argument("--thresholds", default="2.0") + parser.add_argument("--trials", type=int, default=5) + parser.add_argument("--supertile-orders", default="8,9,10,11") + parser.add_argument("--top-k", type=int, default=12) + parser.add_argument("--max-label", type=int, default=34) + parser.add_argument("--seed", type=int, default=202605081909) + parser.add_argument("--out", default="tools/data/gap_label_supertile_tiling_gate_20260508_1909.json") + args = parser.parse_args() + + output = run(args) + out = Path(args.out) + out.parent.mkdir(parents=True, exist_ok=True) + out.write_text(json.dumps(output, indent=2), encoding="utf-8") + + compact = {} + for key, data in sorted(output["mode_order_summary"].items()): + mode, order = key.split("|") + compact[key] = { + "mode": mode, + "supertile_order": int(order.split("=")[1]), + "median_jaccard": data["median_jaccard"], + "low_retention": data["median_low_retention"], + "high_retention": data["median_high_retention"], + "all_high": f"{data['all_high_count']}/{data['condition_count']}", + "all_high_condition_rate": data["all_high_condition_rate"], + "stable_labels_75pct": data["stable_labels_75pct"], + } + + print(json.dumps({ + "reference_core_phi": output["reference_core_phi"], + "reference_high": output["reference_high"], + "mode_summary": { + mode: { + "median_jaccard": data["median_jaccard"], + "low_retention": data["median_low_retention"], + "high_retention": data["median_high_retention"], + "all_high": f"{data['all_high_count']}/{data['condition_count']}", + "all_high_condition_rate": data["all_high_condition_rate"], + } + for mode, data in output["mode_summary"].items() + }, + "orders": compact, + "out": str(out), + }, indent=2)) + + +if __name__ == "__main__": + main() codex Fatto. Ho eseguito l’esperimento e scritto il report in: [agent_20260508_1909.md](/opt/MM_D-ND/tools/data/reports/agent_20260508_1909.md) Ho aggiunto anche lo strumento riusabile: [exp_gap_label_supertile_tiling_gate.py](/opt/MM_D-ND/tools/exp_gap_label_supertile_tiling_gate.py) e il deposito dati: [gap_label_supertile_tiling_gate_20260508_1909.json](/opt/MM_D-ND/tools/data/gap_label_supertile_tiling_gate_20260508_1909.json) Risultante: il label-set alto phi non discrimina il confine esatto del supertile. `same_length_contiguous_shuffle` conserva il core alto almeno quanto `supertile_shuffle` (`116/160` vs `108/160`). La condizione che regge e' ordine interno + lunghezze Fibonacci-like; quando l’ordine interno viene distrutto il core alto cade a `0/160`. Verifiche eseguite: - script eseguito con output JSON prodotto - `python -m py_compile` sul nuovo script - `structural_check.py` sui file toccati: nessun anti-pattern - controllo sezioni richieste del report - post-change hook TM7 letto e applicato come controllo di cascata minimo. diff --git a/tools/data/reports/agent_20260508_1909.md b/tools/data/reports/agent_20260508_1909.md new file mode 100644 index 0000000000000000000000000000000000000000..bdce3379c1abfa663743481ca34268422ca4835b --- /dev/null +++ b/tools/data/reports/agent_20260508_1909.md @@ -0,0 +1,104 @@ +# Agent Report - Supertile Tiling Gate Del Core Phi +**Date**: 2026-05-08 19:09 +**Piano**: 89 +**Tension explored**: M_trascendenza_limite_attuale_L0 (0.529179606750063) +**verdict**: CONSTRAINT +observables_registry: n/a +observables_used: [gap_label_set, supertile_boundary, length_multiset, internal_order, high_label_condition_rate] +**observable_contract**: claim=il core alto phi distingue confine di supertile Fibonacci da blocco contiguo con stessa lunghezza; observable=retention dei label core sotto shuffle di supertile, shuffle contiguo a stessa multiset di lunghezze, shuffle interno a stesso conteggio; operator=Hamiltoniana tight-binding V=1, label IDS con reader theta=1/phi, Jaccard/retention/frequenza per mode e supertile_order; generator=phi_sturmian con tiling di lunghezze Fibonacci; denominator=N={377,610}, phase={0,0.25,0.5,0.75}, threshold={2.0}, trials=5, top_k=12, |n|<=34, supertile_order={8,9,10,11}; not_tested=gap_ratio, soglie 1.75/2.25, parsing simbolico esatto dei supertile per ogni fase, generatori non-phi. + +## Respiro fuori-tempo +- **Combo**: A11 combo + TxQ matrice densita come lettore spettrale + QxG vuoto continuo/discreto + tensione TRASCENDENZA_LIMITE/M_come_modulazione_quasiperiodica. +- **Dipolo / punto-zero**: confine reale del supertile · lunghezza contigua equivalente; punto-zero = il blocco come unita' prima che diventi grammatica o contenitore. +- **Piano superiore**: grafo della conoscenza / bicono dei dipoli. Il nodo non e' il valore del gap, ma il passaggio fra grammatica interna, confine esterno e denominatore. +- **Proto-ipotesi**: se il core alto phi vive nel confine tra supertile, lo shuffle di supertile conserva piu' core dello shuffle contiguo con la stessa multiset di lunghezze. Se non lo fa, il confine esatto non e' ancora il portatore: il portatore e' ordine interno piu' scala lunga. +- **Proiezione**: il label-set dei gap larghi manifesta la combo perche' tiene fisso il reader theta=1/phi e muove solo la relazione fra grammatica, boundary e blocco. + +## Claim Under Test +> Il vantaggio del blocco Fibonacci lungo non sta solo nell'ordine interno conservato: sta nel confine reale del supertile. Quindi `supertile_shuffle` batte `same_length_contiguous_shuffle` a pari multiset di lunghezze. + +## Question +Il core alto `[3, -4, 4, 6]` riconosce il confine di supertile Fibonacci, o riconosce soltanto blocchi lunghi con ordine interno conservato? + +## Experiment Design +- Reference core phi: `[-1, 1, -2, 2, 3, -4, 4, 6]`. +- Nucleo basso: `[-1, 1, -2, 2]`. Label alti: `[3, -4, 4, 6]`. +- Supertile orders: + - order 8: lunghezze `{21,34}`. + - order 9: lunghezze `{34,55}`. + - order 10: lunghezze `{55,89}`. + - order 11: lunghezze `{89,144}`. +- Modes: + - `supertile_shuffle`: taglia secondo la parola di lunghezze Fibonacci e mescola i chunk. + - `same_length_contiguous_shuffle`: usa la stessa multiset di lunghezze, ma su taglio contiguo misallineato. + - `same_count_internal_shuffle`: conserva lunghezza e conteggio di ogni chunk allineato, ma distrugge ordine interno. + - `same_mean_block_shuffle`: usa un blocco fisso pari alla lunghezza media del tiling, controllo di scala grossolana. +- Denominatori grezzi: per ogni `mode|order`, 40 condizioni (`2 N * 4 phase * 1 threshold * 5 trials`); per ogni mode aggregato, 160 condizioni. + +## Results +Reference phi su 8 condizioni (`N x phase x threshold`): core completo `[-1, 1, -2, 2, 3, -4, 4, 6]`. + +Sintesi per mode: + +| mode | conditions | median Jaccard | low retention | high retention | all-high condition rate | +|---|---:|---:|---:|---:|---:| +| supertile_shuffle | 160 | 0.818182 | 1.00 | 1.00 | 108/160 = 0.67500 | +| same_length_contiguous_shuffle | 160 | 0.818182 | 1.00 | 1.00 | 116/160 = 0.72500 | +| same_count_internal_shuffle | 160 | 0.157895 | 0.25 | 0.25 | 0/160 = 0.00000 | +| same_mean_block_shuffle | 160 | 0.500000 | 1.00 | 0.25 | 7/160 = 0.04375 | + +Dettaglio per order: + +| mode | order | lengths | median Jaccard | low retention | high retention | all-high condition rate | stable labels 75% | +|---|---:|---|---:|---:|---:|---:|---| +| supertile_shuffle | 8 | {21,34} | 0.750000 | 1.00 | 0.75 | 14/40 = 0.350 | [-1, 1, -2, 2, -3, -4, 4] | +| same_length_contiguous_shuffle | 8 | {21,34} | 0.818182 | 1.00 | 0.875 | 20/40 = 0.500 | [-1, 1, -2, 2, -3, 3, -4, 4] | +| same_mean_block_shuffle | 8 | mean 29 | 0.444444 | 0.75 | 0.00 | 0/40 = 0.000 | [-1, 1, 33] | +| same_count_internal_shuffle | 8 | {21,34} | 0.157895 | 0.25 | 0.25 | 0/40 = 0.000 | [34] | +| supertile_shuffle | 9 | {34,55} | 0.904545 | 1.00 | 1.00 | 29/40 = 0.725 | [-1, 1, -2, 2, -3, 3, -4, 4, -6] | +| same_length_contiguous_shuffle | 9 | {34,55} | 0.818182 | 1.00 | 1.00 | 29/40 = 0.725 | [-1, 1, -2, 2, -3, 3, -4, 4, 6] | +| same_mean_block_shuffle | 9 | mean 45 | 0.500000 | 1.00 | 0.25 | 0/40 = 0.000 | [-1, 1, -2] | +| same_count_internal_shuffle | 9 | {34,55} | 0.157895 | 0.25 | 0.25 | 0/40 = 0.000 | [34] | +| supertile_shuffle | 10 | {55,89} | 0.909091 | 1.00 | 1.00 | 32/40 = 0.800 | [-1, 1, -2, 2, -3, 3, -4, 4, -6, 6, -7] | +| same_length_contiguous_shuffle | 10 | {55,89} | 0.833333 | 1.00 | 1.00 | 33/40 = 0.825 | [-1, 1, -2, 2, -3, 3, -4, 4, -6, 6] | +| same_mean_block_shuffle | 10 | mean 75 | 0.666667 | 1.00 | 0.50 | 1/40 = 0.025 | [-1, 1, -2, 2, -4, 4] | +| same_count_internal_shuffle | 10 | {55,89} | 0.150000 | 0.25 | 0.25 | 0/40 = 0.000 | [] | +| supertile_shuffle | 11 | {89,144} | 0.909091 | 1.00 | 1.00 | 33/40 = 0.825 | [-1, 1, -2, 2, -3, 3, -4, 4, 6, -7] | +| same_length_contiguous_shuffle | 11 | {89,144} | 0.909091 | 1.00 | 1.00 | 34/40 = 0.850 | [-1, 1, -2, 2, -3, 3, -4, 4, -6, 6] | +| same_mean_block_shuffle | 11 | mean 122 | 0.666667 | 1.00 | 0.75 | 6/40 = 0.150 | [-1, 1, -2, 2, -4, 4] | +| same_count_internal_shuffle | 11 | {89,144} | 0.157895 | 0.25 | 0.25 | 0/40 = 0.000 | [34] | + +## Key Findings +1. **Verificato: il confine di supertile non batte il blocco contiguo a pari multiset di lunghezze.** `supertile_shuffle` fa all-high `108/160 = 0.675`; `same_length_contiguous_shuffle` fa `116/160 = 0.725`. Per order 9 sono pari (`29/40`), per order 10-11 il controllo contiguo e' leggermente sopra (`33/40`, `34/40` contro `32/40`, `33/40`). + +2. **Verificato: la condizione forte resta l'ordine interno.** `same_count_internal_shuffle` resta nullo su tutti gli order: all-high `0/160`, high retention mediana `0.25`, Jaccard mediano `0.157895`. Questo replica il nodo 18:34 dentro il tiling di supertile. + +3. **Verificato: la scala lunga come multiset e' piu' informativa del blocco medio fisso.** `same_mean_block_shuffle` conserva low retention mediana `1.00`, ma resta quasi nullo sul core alto completo (`7/160 = 0.04375`). Quindi non basta una scala media lunga; serve una distribuzione di lunghezze lunghe con ordine interno conservato. + +4. **Inferito dal confronto fra controlli: il portatore osservato e' ordine interno + multiset di lunghezze Fibonacci, non boundary esatto.** Il test non autorizza "il core alto vive nel confine del supertile"; autorizza "il core alto richiede ordine interno e beneficia di lunghezze supertile-like". + +## Verdict +**CONSTRAINT on TRASCENDENZA_LIMITE / QPG_GAP_RATIO_DENOMINATOR_GATE**: nel perimetro `N={377,610}`, `phase={0,0.25,0.5,0.75}`, `threshold={2.0}`, `trials=5`, `top_k=12`, `|n|<=34`, `supertile_order={8,9,10,11}`, il core alto phi non discrimina il confine esatto del supertile. `same_length_contiguous_shuffle` conserva il core alto almeno quanto `supertile_shuffle` (`116/160` vs `108/160`). Il core alto cade solo quando l'ordine interno viene distrutto (`0/160`) o quando la multiset di lunghezze viene compressa a blocco medio (`7/160`). + +La formulazione valida e': il label-set alto phi misura una condizione congiunta di ordine interno e lunghezze Fibonacci-like; non misura ancora il boundary simbolico del supertile e non misura `gap_ratio`. + +## Bicono della scoperta +- **Due radici**: confine di supertile · distribuzione di lunghezze con ordine interno. +- **Singolare**: il chunk lungo prima della distinzione fra boundary grammaticale e blocco contiguo. +- **Invariante di passaggio**: il core alto sopravvive quando l'ordine interno resta leggibile su lunghezze Fibonacci-like; non sopravvive a conteggio senza ordine. +- **Campo di possibilita**: qui diventa possibile cercare un osservabile di boundary piu' fine del label-set; qui diventa non-possibile dichiarare che il label-set alto riconosce da solo il confine esatto del supertile. + +## Consecutio +Costruire un gate di boundary simbolico che non legga solo il set dei label: confrontare label-set, posizione IDS dei label core e errore di label per chunk aligned/misaligned. Se il boundary reale esiste nell'osservabile, deve apparire nella geometria degli errori o nella posizione dei gap, non nel solo all-high rate. + +## Auto-audit: 5 lenti +- **L1 hard constraint vs bias**: il verdict dichiara perimetro e count grezzi; non trasforma `108/160` in legge universale. +- **L2 quantita vs ratio**: Jaccard, retention e all-high rate restano separati; `gap_ratio` dichiarato non testato. +- **L3 no silent patching**: l'ipotesi "supertile batte contiguo" cade; il report non la salva cambiando osservabile. +- **L4 edge cases**: order 10-11 mostrano controllo contiguo sopra supertile; sono il segnale, non rumore. +- **L5 re-discovery**: la conservazione dell'ordine interno era gia' nota dal 18:34; il nuovo finding e' la non-discriminazione del boundary esatto da parte del label-set. + +## Files +- Script: `tools/exp_gap_label_supertile_tiling_gate.py` +- Data: `tools/data/gap_label_supertile_tiling_gate_20260508_1909.json` +- Report: `tools/data/reports/agent_20260508_1909.md` diff --git a/tools/exp_gap_label_supertile_tiling_gate.py b/tools/exp_gap_label_supertile_tiling_gate.py new file mode 100644 index 0000000000000000000000000000000000000000..bde361d77f2db31c8f98bf3fd24d345ad67fd132 --- /dev/null +++ b/tools/exp_gap_label_supertile_tiling_gate.py @@ -0,0 +1,278 @@ +#!/usr/bin/env python3 +""" +Supertile tiling gate for the phi gap-label core. + +The substitution-grammar gate showed that length and symbol count do not carry +the high labels when internal order is destroyed. This tool moves one node +upstream: it separates true Fibonacci supertile boundaries from contiguous +chunks with the same length multiset. +""" + +from __future__ import annotations + +import argparse +import json +from collections import Counter, defaultdict +from pathlib import Path + +import numpy as np + +from exp_gap_label_block_scale_gate import ( + REFERENCE_HIGH, + REFERENCE_LOW, + label_sort, + parse_floats, + parse_ints, + retention, +) +from exp_gap_label_generator_gate import THETA, block_shuffle +from exp_gap_label_set_stability import gap_labels, jaccard, sturmian_sequence, summarize_sets + + +def fibonacci_lengths(order: int) -> tuple[int, int]: + if order < 2: + raise ValueError("supertile_order must be >= 2") + a, b = 1, 1 + for _ in range(2, order + 1): + a, b = b, a + b + return b, a + + +def fibonacci_type_word(n_types: int) -> np.ndarray: + word = "1" + previous = "0" + while len(word) < n_types: + word, previous = word + previous, word + return np.array([int(ch) for ch in word[:n_types]], dtype=int) + + +def supertile_lengths(n: int, order: int) -> list[int]: + long_len, short_len = fibonacci_lengths(order) + types = fibonacci_type_word(max(8, int(np.ceil(n / short_len)) + 4)) + lengths: list[int] = [] + total = 0 + for t in types: + length = long_len if t == 1 else short_len + if total + length >= n: + lengths.append(n - total) + break + lengths.append(length) + total += length + return [length for length in lengths if length > 0] + + +def chunks_from_lengths(seq: np.ndarray, lengths: list[int]) -> list[np.ndarray]: + chunks = [] + start = 0 + for length in lengths: + chunks.append(seq[start : start + length].copy()) + start += length + if start < len(seq): + chunks.append(seq[start:].copy()) + return chunks + + +def shuffle_chunks(chunks: list[np.ndarray], rng: np.random.Generator) -> np.ndarray: + shuffled = list(chunks) + rng.shuffle(shuffled) + return np.concatenate(shuffled) + + +def internal_count_shuffle(chunks: list[np.ndarray], rng: np.random.Generator) -> np.ndarray: + out = [] + for chunk in chunks: + copied = chunk.copy() + rng.shuffle(copied) + out.append(copied) + return np.concatenate(out) + + +def misaligned_same_lengths(seq: np.ndarray, lengths: list[int], rng: np.random.Generator) -> np.ndarray: + if len(seq) < 2: + return seq.copy() + offset = int(rng.integers(1, len(seq))) + rotated = np.roll(seq, -offset) + chunks = chunks_from_lengths(rotated, lengths) + shuffled = shuffle_chunks(chunks, rng) + return np.roll(shuffled, offset) + + +def fixed_block_same_mean(seq: np.ndarray, lengths: list[int], rng: np.random.Generator) -> np.ndarray: + mean_len = max(1, int(round(float(np.mean(lengths))))) + return block_shuffle(seq, mean_len, rng) + + +def summarize_rows(rows: list[dict], reference_core: set[int]) -> dict: + summary = summarize_sets(rows) + sets = [set(row["label_set"]) for row in rows if row["n_selected"] > 0] + counter = Counter(label for s in sets for label in s) + n_sets = len(sets) + overlaps = [jaccard(set(row["label_set"]), reference_core) for row in rows if row["n_selected"] > 0] + + return { + **summary, + "median_overlap_with_phi_core": float(np.median(overlaps)) if overlaps else None, + "median_low_retention": float(np.median([retention(row, REFERENCE_LOW) for row in rows])), + "median_high_retention": float(np.median([retention(row, REFERENCE_HIGH) for row in rows])), + "all_low_count": int(sum(REFERENCE_LOW <= s for s in sets)), + "all_high_count": int(sum(REFERENCE_HIGH <= s for s in sets)), + "condition_count": int(n_sets), + "all_low_condition_rate": float(sum(REFERENCE_LOW <= s for s in sets) / n_sets) if n_sets else None, + "all_high_condition_rate": float(sum(REFERENCE_HIGH <= s for s in sets) / n_sets) if n_sets else None, + "high_label_condition_rates": { + str(label): float(counter.get(label, 0) / n_sets) if n_sets else None + for label in label_sort(REFERENCE_HIGH) + }, + "low_label_condition_rates": { + str(label): float(counter.get(label, 0) / n_sets) if n_sets else None + for label in label_sort(REFERENCE_LOW) + }, + "reference_core_retained_in_all": label_sort(set(summary.get("core_labels_all_conditions", [])) & reference_core), + "reference_core_missing_from_all": label_sort(reference_core - set(summary.get("core_labels_all_conditions", []))), + } + + +def run(args: argparse.Namespace) -> dict: + rng = np.random.default_rng(args.seed) + ns = parse_ints(args.ns) + phases = parse_floats(args.phases) + thresholds = parse_floats(args.thresholds) + orders = parse_ints(args.supertile_orders) + + reference_rows = [] + rows = [] + tiling_meta = {} + for n in ns: + for phase in phases: + phi = sturmian_sequence(THETA, n, phase) + for threshold in thresholds: + reference_rows.append({ + "mode": "reference_phi", + "N": n, + "phase": phase, + "threshold": threshold, + **gap_labels(phi, THETA, threshold, args.max_label, args.top_k), + }) + + for order in orders: + lengths = supertile_lengths(n, order) + tiling_meta[f"N={n}|order={order}"] = { + "lengths": lengths, + "count": len(lengths), + "total": sum(lengths), + "unique_lengths": sorted(set(lengths)), + } + aligned_chunks = chunks_from_lengths(phi, lengths) + mean_block = max(1, int(round(float(np.mean(lengths))))) + for trial in range(args.trials): + variants = { + "supertile_shuffle": shuffle_chunks(aligned_chunks, rng), + "same_length_contiguous_shuffle": misaligned_same_lengths(phi, lengths, rng), + "same_count_internal_shuffle": internal_count_shuffle(aligned_chunks, rng), + "same_mean_block_shuffle": fixed_block_same_mean(phi, lengths, rng), + } + for mode, seq in variants.items(): + for threshold in thresholds: + rows.append({ + "mode": mode, + "N": n, + "phase": phase, + "threshold": threshold, + "trial": trial, + "supertile_order": order, + "mean_block": mean_block, + **gap_labels(seq, THETA, threshold, args.max_label, args.top_k), + }) + + reference_summary = summarize_sets(reference_rows) + reference_core = set(reference_summary["core_labels_all_conditions"]) + + grouped: dict[str, list[dict]] = defaultdict(list) + for row in rows: + grouped[f"{row['mode']}|order={row['supertile_order']}"].append(row) + + mode_order_summary = { + key: summarize_rows(group_rows, reference_core) + for key, group_rows in grouped.items() + } + + mode_summary = {} + for mode in sorted({row["mode"] for row in rows}): + mode_rows = [row for row in rows if row["mode"] == mode] + mode_summary[mode] = summarize_rows(mode_rows, reference_core) + + return { + "experiment": "gap_label_supertile_tiling_gate", + "parameters": { + "ns": ns, + "phases": phases, + "thresholds": thresholds, + "trials": args.trials, + "supertile_orders": orders, + "top_k": args.top_k, + "max_label": args.max_label, + "seed": args.seed, + }, + "reference_core_phi": label_sort(reference_core), + "reference_low": label_sort(REFERENCE_LOW), + "reference_high": label_sort(REFERENCE_HIGH), + "reference_summary": reference_summary, + "tiling_meta": tiling_meta, + "mode_order_summary": mode_order_summary, + "mode_summary": mode_summary, + "rows": rows, + } + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--ns", default="377,610") + parser.add_argument("--phases", default="0,0.25,0.5,0.75") + parser.add_argument("--thresholds", default="2.0") + parser.add_argument("--trials", type=int, default=5) + parser.add_argument("--supertile-orders", default="8,9,10,11") + parser.add_argument("--top-k", type=int, default=12) + parser.add_argument("--max-label", type=int, default=34) + parser.add_argument("--seed", type=int, default=202605081909) + parser.add_argument("--out", default="tools/data/gap_label_supertile_tiling_gate_20260508_1909.json") + args = parser.parse_args() + + output = run(args) + out = Path(args.out) + out.parent.mkdir(parents=True, exist_ok=True) + out.write_text(json.dumps(output, indent=2), encoding="utf-8") + + compact = {} + for key, data in sorted(output["mode_order_summary"].items()): + mode, order = key.split("|") + compact[key] = { + "mode": mode, + "supertile_order": int(order.split("=")[1]), + "median_jaccard": data["median_jaccard"], + "low_retention": data["median_low_retention"], + "high_retention": data["median_high_retention"], + "all_high": f"{data['all_high_count']}/{data['condition_count']}", + "all_high_condition_rate": data["all_high_condition_rate"], + "stable_labels_75pct": data["stable_labels_75pct"], + } + + print(json.dumps({ + "reference_core_phi": output["reference_core_phi"], + "reference_high": output["reference_high"], + "mode_summary": { + mode: { + "median_jaccard": data["median_jaccard"], + "low_retention": data["median_low_retention"], + "high_retention": data["median_high_retention"], + "all_high": f"{data['all_high_count']}/{data['condition_count']}", + "all_high_condition_rate": data["all_high_condition_rate"], + } + for mode, data in output["mode_summary"].items() + }, + "orders": compact, + "out": str(out), + }, indent=2)) + + +if __name__ == "__main__": + main() tokens used 97,269 Fatto. Ho eseguito l’esperimento e scritto il report in: [agent_20260508_1909.md](/opt/MM_D-ND/tools/data/reports/agent_20260508_1909.md) Ho aggiunto anche lo strumento riusabile: [exp_gap_label_supertile_tiling_gate.py](/opt/MM_D-ND/tools/exp_gap_label_supertile_tiling_gate.py) e il deposito dati: [gap_label_supertile_tiling_gate_20260508_1909.json](/opt/MM_D-ND/tools/data/gap_label_supertile_tiling_gate_20260508_1909.json) Risultante: il label-set alto phi non discrimina il confine esatto del supertile. `same_length_contiguous_shuffle` conserva il core alto almeno quanto `supertile_shuffle` (`116/160` vs `108/160`). La condizione che regge e' ordine interno + lunghezze Fibonacci-like; quando l’ordine interno viene distrutto il core alto cade a `0/160`. Verifiche eseguite: - script eseguito con output JSON prodotto - `python -m py_compile` sul nuovo script - `structural_check.py` sui file toccati: nessun anti-pattern - controllo sezioni richieste del report - post-change hook TM7 letto e applicato come controllo di cascata minimo.