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: 019e096b-4ebc-7be1-ac17-5440fe960996 -------- 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_2108.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 Leggo il kernel operativo e il campo vivo prima di scegliere l’esperimento. Verifico anche il vincolo sulle API a pagamento, così il run resta dentro il perimetro autorizzato. 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' /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 "env | rg '"'^(ANTHROPIC_API_KEY|OPENAI_API_KEY)='"' || true" in /opt/MM_D-ND succeeded in 0ms: exec /bin/bash -lc "sed -n '1,220p' /root/.codex/AGENTS.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. codex Il controllo API è vuoto: nessuna `ANTHROPIC_API_KEY` o `OPENAI_API_KEY` esportata. Ora passo ai file specifici del cycle e alla memoria condivisa recente, perché lì sta la scelta della tensione. exec /bin/bash -lc "sed -n '1,260p' tools/data/agent_field_live.md" in /opt/MM_D-ND 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=7, 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 ## Palette operatoria laterale — sorgenti da triturare Usa questa palette solo nella fase di respiro fuori-tempo. Scegli pochi operatori, crea una combo, poi proietta un osservabile. Non trasformarla in lista di temi. # Palette operatoria espansa del Lab Scopo: dare al Lab sorgenti laterali per creare combo prima della misura. Questa palette non e' una lista di temi da confermare. E' un deposito di operatori da triturare con assiomi D-ND, dipoli, grafo, incrocio teorie e tensione corrente. Regola d'uso: 1. Scegli 2 o 3 operatori al massimo. 2. Incrociali con almeno un assioma D-ND e una tensione del seme. 3. Nomina il dipolo e il punto-zero. 4. Dichiara la baseline nota piu' vicina. 5. Proietta un osservabile che possa falsificare la combo. 6. Non usare un operatore se produce solo linguaggio, analogia o conferma. Anti-tautologia: - Non partire da phi, gap label, GUE o Poisson se sono gia' nel ciclo precedente. Usali come controllo o campo di proiezione, non come sorgente. - Se un operatore e' matematico, chiedi prima quale qualita' strutturale manifesta: simmetria, connessione, curvatura, flusso, vincolo, misura, memoria, transizione, gauge, bordo, singolare. - Se un operatore e' fisico, chiedi quale dualita' D-ND apre: continuo/discreto, locale/globale, misurato/non-misurato, campo/particella, simmetria/rottura, deterministico/statistico, reversibile/irreversibile. ## Fasce di triturazione ### 1. Geometria differenziale e gravita' Operatori: - metrica; - connessione; - geodetica; - curvatura di Riemann; - Ricci tensor / Ricci scalar; - tensore di Einstein; - geodesic deviation; - torsione; - forma volume; - orizzonte; - singolarita'; - causal cone. Dipoli utili: - curvatura locale / vincolo globale; - geodetica / deviazione; - metrica data / metrica emergente; - orizzonte come bordo / orizzonte come lettore; - singolare fisico / singolare di coordinate. Controlli: - metrica costruita dal dato vs metrica predittiva; - shuffle che preserva distribuzione ma distrugge ordine; - confronto con spazio piatto, de Sitter, anti-de Sitter, random metric. Attenzione: - Ricci calcolato da una metrica definita sul dato puo' essere tautologico. Il contenuto vive nel null test o nella predizione fuori costruzione. ### 2. Gauge, connessioni e campi Operatori: - potenziale; - campo; - curvatura di gauge; - holonomy; - Wilson loop; - fibrato; - sezione; - fase; - Berry phase; - parallel transport; - rottura di simmetria; - Higgs-like mechanism come transizione di stato. Dipoli utili: - potenziale / campo; - fase locale / invariante globale; - gauge libero / osservabile vincolato; - trasporto / memoria; - simmetria / rottura. Controlli: - gauge transform che conserva osservabile; - loop chiuso vs cammino aperto; - fase random vs fase strutturata; - holonomy nulla vs non nulla. ### 3. Spazi quantistici e misura Operatori: - sfera di Bloch; - matrice densita'; - proiettore; - entanglement entropy; - commutatore; - non-commutativita'; - POVM; - decoerenza; - weak measurement; - operator algebra; - spettro di Hamiltoniana. Dipoli utili: - stato puro / stato misto; - osservabile / non-commutante; - misura / disturbo; - sovrapposizione / decisione; - entanglement / separabilita'. Controlli: - random unitary; - stati separabili; - base ruotata; - noise controllato; - spectrum-preserving shuffle. Nota: - Bloch e' buono quando serve un punto-zero geometrico tra poli. Non usarlo solo per disegnare dualita': deve produrre un osservabile. ### 4. Equazioni differenziali, flussi e stabilita' Operatori: - ODE; - PDE; - flusso di gradiente; - Hamiltonian flow; - Lagrangian / action; - fixed point; - biforcazione; - attractor; - Lyapunov exponent; - Riccati equation; - heat equation; - wave equation; - diffusion equation; - reaction-diffusion; - renormalization flow. Dipoli utili: - flusso / punto fisso; - stabilita' / instabilita'; - reversibile / dissipativo; - locale / propagato; - biforcazione / continuita'. Controlli: - perturbazione iniziale; - time reversal; - noise injection; - random field; - stesso spettro, diversa dinamica. ### 5. Topologia assiomatica e forme globali Operatori: - omotopia; - omologia; - coomologia; - indice; - winding number; - Euler characteristic; - Betti numbers; - persistent homology; - Morse theory; - boundary operator; - cobordism; - sheaf / cosheaf; - topos-like viewpoint. Dipoli utili: - bordo / interno; - buco / ponte; - classe globale / rappresentante locale; - singolare / regolare; - persistente / transitorio. Controlli: - filtrazione random; - graph rewiring; - stesso grado, topologia diversa; - rumore che conserva statistiche locali. ### 6. Algebra, simmetria e rappresentazioni Operatori: - gruppo; - anello; - modulo; - campo; - algebra di Lie; - rappresentazione; - carattere; - spettro; - autovalore; - commutatore; - categoria; - funtore; - limite / colimite; - dualita'; - adjunction. Dipoli utili: - elemento / struttura; - rappresentazione / invariante; - commutativo / non-commutativo; - locale / universale; - oggetto / morfismo. Controlli: 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. - **Palette operatoria laterale.** Quando il ciclo rischia deepening locale, leggi `tools/LAB_OPERATOR_PALETTE.md` e scegli 2 o 3 operatori massimo. Gli operatori non sono temi: devono produrre dipolo, punto-zero, baseline e osservabile falsificabile. Se restano semantica o analogia, scartali. - **Adapter cognitivi laterali.** Quando servono nuove strade, leggi `tools/LAB_COGNITIVE_CONTAMINATION.md`. Usa YSN per DeltaLink, Cornelius per comprimere un innesco genomico, KSAR per reiterare il kernel emerso. Non adottare personaggi o prompt: estrai enzimi operativi. La sezione `Contaminazione cognitiva` e' obbligatoria nel report; se un adapter non viene usato, scrivi `none` con motivo. - **Archivio enzimi cognitivi.** Se il campo vivo contiene `Archivio enzimi cognitivi`, la sezione `Contaminazione cognitiva` deve citare almeno una voce `CE-*` usata nella combo, oppure `CE-none:` con un motivo specifico e verificabile. `none` generico non e' valido: significa che il campo semantico e' stato visto ma non metabolizzato. ## 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 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 '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 D "kernel/reference/metaprompt_in_sviluppo/Sei il Meta Master Systemil Meta Ma.md" 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/scoperte/20260508_1909_supertile-tiling-gate-del-core-phi_auto/ ?? applications/scoperte/20260508_1915_high-core-repair-audit_auto/ ?? applications/scoperte/20260508_1947_positionerror-gate-del-core-phi_auto/ ?? applications/scoperte/20260508_2005_symbolic-grammar-gate-del-core-phi_auto/ ?? applications/scoperte/20260508_2013_ostrowski-recognizability-gate-del-core-phi_auto/ ?? applications/scoperte/20260508_2019_non-phi-sturmian-fixed-reader-gate_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/ ?? applications/soluzioni/20260508_1909_supertile-tiling-gate-del-core-phi/ ?? applications/soluzioni/20260508_1915_high-core-repair-audit/ ?? applications/soluzioni/20260508_1947_positionerror-gate-del-core-phi/ ?? applications/soluzioni/20260508_2005_symbolic-grammar-gate-del-core-phi/ ?? applications/soluzioni/20260508_2013_ostrowski-recognizability-gate-del-core-phi/ ?? applications/soluzioni/20260508_2019_non-phi-sturmian-fixed-reader-gate/ ?? 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/b2_apply_log.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/biconi/bicono_20260508_1909.json ?? tools/data/biconi/bicono_20260508_1915.json ?? tools/data/biconi/bicono_20260508_1947.json ?? tools/data/biconi/bicono_20260508_2005.json ?? tools/data/biconi/bicono_20260508_2013.json ?? tools/data/biconi/bicono_20260508_2019.json ?? tools/data/biconi/bicono_20260508_2102.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/evolution/evolution_20260508_1909.md ?? tools/data/evolution/evolution_20260508_1915.md ?? tools/data/evolution/evolution_20260508_1947.md ?? tools/data/evolution/evolution_20260508_2005.md ?? tools/data/evolution/evolution_20260508_2013.md ?? tools/data/evolution/evolution_20260508_2019.md ?? tools/data/evolution/evolution_20260508_2102.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_ostrowski_recognizability_gate_20260508_2013.json ?? tools/data/gap_label_ostrowski_recognizability_gate_20260508_2013_seedcheck.json ?? tools/data/gap_label_position_error_gate_20260508_1947.json ?? tools/data/gap_label_repair_audit_20260508_1915.json ?? tools/data/gap_label_set_stability_20260508_1632.json ?? tools/data/gap_label_substitution_grammar_gate_20260508_1834.json ?? tools/data/gap_label_supertile_tiling_gate_20260508_1909.json ?? tools/data/gap_label_symbolic_grammar_gate_20260508_2005.json ?? tools/data/gap_label_symbolic_grammar_gate_20260508_2005_window55_seedcheck.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/incrocio_20260508_1915.json ?? tools/data/incrocio_20260508_1947.json ?? tools/data/incrocio_20260508_2005.json ?? tools/data/incrocio_20260508_2013.json ?? tools/data/incrocio_20260508_2019.json ?? tools/data/incrocio_20260508_2102.json ?? tools/data/incrocio_20260508_2108.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/nonphi_sturmian_fixed_reader_gate_20260508_2019.json ?? tools/data/nonphi_sturmian_fixed_reader_gate_20260508_2019_seedcheck.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/operator_directives_consumed/ ?? tools/data/perturbation_dimensionality_audit.json ?? tools/data/perturbation_dimensionality_audit_scale0330.json ?? tools/data/perturbation_rank_size_curve.json ?? tools/data/prime_mobius_interval_charge_gate_20260508_2102.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/agent_20260508_1909.md ?? tools/data/reports/agent_20260508_1915.md ?? tools/data/reports/agent_20260508_1947.md ?? tools/data/reports/agent_20260508_2005.md ?? tools/data/reports/agent_20260508_2013.md ?? tools/data/reports/agent_20260508_2019.md ?? tools/data/reports/agent_20260508_2102.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/falsifier_20260508_1909.json ?? tools/data/reports/falsifier_20260508_1915.json ?? tools/data/reports/falsifier_20260508_1947.json ?? tools/data/reports/falsifier_20260508_2005.json ?? tools/data/reports/falsifier_20260508_2013.json ?? tools/data/reports/falsifier_20260508_2019.json ?? tools/data/reports/falsifier_20260508_2102.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/loop_guard_20260508_1909.json ?? tools/data/reports/loop_guard_20260508_1915.json ?? tools/data/reports/loop_guard_20260508_1947.json ?? tools/data/reports/loop_guard_20260508_2005.json ?? tools/data/reports/loop_guard_20260508_2013.json ?? tools/data/reports/loop_guard_20260508_2019.json ?? tools/data/reports/loop_guard_20260508_2102.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_86.json ?? tools/data/seme_archive/piano_87.json ?? tools/data/seme_archive/piano_88.json ?? tools/data/seme_archive/piano_89.json ?? tools/data/seme_archive/piano_90.json ?? tools/data/seme_archive/piano_91.json ?? tools/data/seme_archive/piano_92.json ?? tools/data/seme_backup_b2_20260508_192024.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/veritas/veritas_20260508_191516.json ?? tools/data/veritas/veritas_20260508_192002.json ?? tools/data/veritas/veritas_20260508_195247.json ?? tools/data/veritas/veritas_20260508_201056.json ?? tools/data/veritas/veritas_20260508_201917.json ?? tools/data/veritas/veritas_20260508_202448.json ?? tools/data/veritas/veritas_20260508_210742.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_ostrowski_recognizability_gate.py ?? tools/exp_gap_label_position_error_gate.py ?? tools/exp_gap_label_repair_audit.py ?? tools/exp_gap_label_set_stability.py ?? tools/exp_gap_label_substitution_grammar_gate.py ?? tools/exp_gap_label_supertile_tiling_gate.py ?? tools/exp_gap_label_symbolic_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_nonphi_sturmian_fixed_reader_gate.py ?? tools/exp_observable_rank_audit.py ?? tools/exp_perturbation_dimensionality_audit.py ?? tools/exp_perturbation_rank_size_curve.py ?? tools/exp_prime_mobius_interval_charge_gate.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 '260,520p' tools/LAB_AGENT_CONTEXT.md" in /opt/MM_D-ND succeeded in 0ms: ## 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 - **Operatori laterali scelti**: 2 o 3 elementi da `tools/LAB_OPERATOR_PALETTE.md` e perche' entrano nella combo - **Contaminazione cognitiva**: eventuale DeltaLink YSN, gene Cornelius, passaggio KSAR/PVI/Vault o voce `CE-*` dell'archivio usata nel ciclo. Se non usi il layer cognitivo, dichiara `CE-none:` e il motivo specifico. `none` generico non basta. - **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 - 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 'rg -n "''^(##|#)|DIRETTIVA|Tension|tension|Archivio|Ultimi|Convergen|Osserv" tools/data/agent_field_live.md' in /opt/MM_D-ND succeeded in 0ms: 3:## Orizzonte (telos del lab) 6:## Respiro fuori-tempo — prepara la combo prima della misura 10:1. Combo: almeno tre enti simultanei (assioma D-ND + incrocio teorie + nodo del grafo/dipolo + tensione del seme). 26:## Palette operatoria laterale — sorgenti da triturare 29:# Palette operatoria espansa del Lab 34:tensione corrente. 39:2. Incrociali con almeno un assioma D-ND e una tensione del seme. 56:## Fasce di triturazione 58:### 1. Geometria differenziale e gravita' 94:### 2. Gauge, connessioni e campi 126:### 3. Spazi quantistici e misura 163:### 4. Equazioni differenziali, flussi e stabilita' 199:### 5. Topologia assiomatica e forme globali 232:### 6. Algebra, simmetria e rappresentazioni 267:### 7. Informazione, termodinamica e irreversibilita' 300:### 8. Random matrix, spettri e caos 338:### 9. Grafi, reti e conoscenza 373:### 10. Campi continui, onde e modi 406:### 11. Computazione, logica e sistemi formali 439:### 12. Materia condensata, fasi e difetti 472:### 13. Cosmologia e scale 502:### 14. Biologia matematica e autopoiesi 532:### 15. Linguaggio, semantica e trans-semantico 571:## Meta-combo consigliata per il prossimo ciclo 588:## Adapter cognitivi laterali — YSN / Cornelius / KSAR 591:# Adapter cognitivi laterali del Lab 606:## Regola primaria 622:## Adapter 1: YSN lateral insight 626:- estrarre fino a 5 concetti/tensioni dal campo; 662:## Adapter 2: Cornelius genomic trigger 711:## Adapter 3: KSAR reiterative semantic kernel 757:## Adapter 4: PVI / anti-psicosi del ciclo 776:## Adapter 5: Lazarus vault 798:## Adapter 6: Helix / Plan-Code-Verify 815:## Sezione report obbligatoria 823:### Contaminazione cognitiva 835:## Prossimo innesco consigliato 849:## Boundary 857:## Archivio enzimi cognitivi — richiamo contestuale 858:Archivio generato: 2026-05-08T20:49:15.084998+00:00 · 260 voci. Questo e' un substrate selector: non usare il substrato come claim. Tieni le teorie scientifiche nel focus e usa CE-* solo per costruire combo corta: assioma/metodo + osservazione/funzione + teoria/focus + null test. Se nessuna voce regge, dichiara `CE-none:` con motivo specifico nella Contaminazione cognitiva. `none` generico non e' valido. 895: (Obbligatorio. Compilalo prima dell'esperimento, non dopo.) - **Combo**: almeno tre enti simultanei (assioma D-ND + incrocio teorie + nodo del grafo/dipolo + tensione seme) - **Dip 903:## Memoria del ciclo precedente (autopoiesi) 908:- **Ultimi apprendimenti**: 913:## Costante dinamica (piano operatore) 918:## Affinatore — osservazione del passo precedente (20260508_2102) 925:## Stato di conoscenza (M operator — cosa il sistema sa già) 938:**Insights cumulativi**: 31 pattern trasferibili rilevati. Ultimi 3: 946:**Suggerimento M_operator** (prossima_tensione): 947: - **id**: M_come_modulazione_quasiperiodica_L0 **tipo**: tensione_aperta **intensità**: 0.4416407864998738 951: Questo è il topic che M_operator (logica conoscenza 2x2 [noto, ignoto] → φ) suggerisce di attaccare. Considera prima di pescare dalle tensioni del seme. 953:## 10 pair fondamentali del pentagono TQGE+R (chi ha ponte, chi è vuoto) 969:## Ponti evoluti — pair con conferme cumulative 982:## Incrocio teorie — depositi e consecutio (pre-cycle autopoiesi) 992:## Domandatore autopoietico — esperimento suggerito (pre-cycle) 993:Output dei 5 operatori discriminanti applicati alla top tension del 994:seme. Le domande qui sono ESPERIMENTI PRE-FORMULATI: tensione astratta 998:- **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 1004:**Modus**: scegli liberamente la tensione, ma se attacchi quella 1007:domandatore-driven: tensione META con consecutio scientifica chiara. 1009:## DIRETTIVA OPERATORE — override per questo cycle (one-shot) 1011:# DIRETTIVA AUTOLOGICAL REPAIR - one-shot 1019:## Esito source 1028:## Movimento richiesto 1031:## Falsifier flags da risolvere 1034:## Contratto del repair 1046:## Uscita attesa 1053:## Run precedente: completato (?s). 1055:## Piano 93 — Esplorare il confine: 8 domini GUE, 5 Poisson — il confine è il terzo incluso operativo 1057:## Tensioni attive (strutturali prime, vincoli in coda) 1064:- [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. 1067:## Pattern di formulazione emersi (vincoli, non tensioni) 1068: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. 1072:## Convergenza — dove più tensioni puntano allo stesso punto 1080:## Ultimi 3 run — contesto storico (NON è da dove parti) 1081:Sono atti compiuti, non direzione. La direzione del prossimo cycle la dà la tensione del seme su cui scegli di lavorare, non questi run. 1083:### Agent Report - Prime Mobius Interval-Charge Gate 1089:### Agent Report - Non-Phi Sturmian Fixed-Reader Gate 1095:### Agent Report - Ostrowski Recognizability Gate Del Core Phi 1099:## Cimitero — claim falsificati di recente (NON riproporre con lo stesso framing) 1102:### C1 refined-not-falsified (silent patching) 1114:### MOD3_PROHIBITION come fatto algebrico 1126:### K* (depth of spectral convergence) come proprieta' discriminante 1139:### Slope ratio (slope_mag / slope_res) come invariante strutturale 1151:### Cross-correlation (xcorr) tra canale magnitudine e residuo (Two-Channel Decomposition) 1165:## Osservazioni dell'operatore (risonanti con le tensioni) 1168:**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 1170:## Risultante ultima sessione interattiva 1173:## Video dall'operatore (non processati) 1179:## Proiezione — dove punta la risultante 1186:## Strategia del campo (leverage / rischi / punti ciechi) 1190:- Cross-check: 5 confermati, 2 contestati su 15 tensioni 1192:## Topologia del campo — la forma del grafo 1199:## Le 5 lenti del counter-pole — applicale a te stesso prima di chiudere il report 1219:## Cosa fare 1221:2. Scegli la tensione con il massimo potere discriminante exec /bin/bash -lc "sed -n '1,220p' shared_memory/deposito_cambia_la_parola_non_regola_2026-05-07.md" in /opt/MM_D-ND succeeded in 0ms: --- type: deposito_osservativo author: TM3 (deposito di una conversazione operatore) date: 2026-05-07 scope: cross-agent status: decristallizzato_07-05_pomeriggio priority: low --- # Deposito — non regola **Originariamente** (07/05 mattina) avevo cristallizzato come "regola permanente": > *"se magnitude non funziona significa che serve una nuova parola, non possiamo stare lì a calibrare un valore..."* Avevo formulato istruzioni esecutive: "quando un valore non funziona, conta le distinzioni, aggiungi la parola mancante". L'avevo propagata in AGENTS.md R10. **L'operatore ha indicato (07/05 pomeriggio)** che questo era errore strutturale: > *"quello che dico non dovrebbe essere assegnato automaticamente perché le parole sono sempre false anche quando vicine alla sorgente. 'cambia la parola' ha un significato regressivo che costringe all'osservazione del campo e far cadere il focus su quello che appare emergere, questa è la dinamica della percezione con cui si muove determinando il contesto."* E: > *"la possibilità è sempre una ed è la verità che accade. Usiamo le sue regole per direzionarla prima che accada costruendo il sistema per gestirla nelle sue evoluzioni con invarianti vere e meccaniche logiche possibili e persistenti."* ## Cosa significa - "Cambia la parola" non è prescrizione di sostituzione. È **movimento regressivo**: invita a osservare il campo, lasciar cadere il focus su quello che appare emergere. Determina la direzione **non cercata**. - Le parole, anche le frasi dell'operatore vicine alla sorgente, sono **sempre false**. Cristallizzarle come regole esecutive le rende rigide e blocca il movimento. - Le **invarianti vere** sono meccaniche logiche persistenti — non parole. Ricevono ciò che accade. - A16 applicato: la possibilità è una. Costruiamo il sistema per gestire le sue evoluzioni, non per prescriverle. ## Distinzione operativa che resta | | Da NON fare | Da fare | |---|---|---| | Frase operatore | cristallizzare come regola eseguibile | depositare come osservazione | | Codice del pipeline | branch ad-hoc che eseguono "la regola" | meccaniche persistenti che ricevono distinzioni del sistema | | Memoria | regole prescrittive | osservazioni che il sistema può rileggere senza eseguire | ## Cosa di concreto è rimasto del 07/05 mattina Le **meccaniche** sono OK perché sono invarianti operativi: - 4 stati SSP (`mature_eligible`, `transitional`, `provisional_discovery`, `pre_discovery`) — accolgono ciò che il valutatore produce - `pending_consecutio` nel frontmatter — riceve la direzione successiva - `_direzione_dal_seme` priorità 0 marker — preserva ciò che `trajectory_apply` ha applicato Queste non sono "regole derivate dalla frase". Sono adattamenti del pipeline alle distinzioni che il sistema fa già nei dati. Persistono perché meccaniche, non perché prescrizioni. ## Cosa è stato decristallizzato - `MM_D-ND/AGENTS.md` regola R10 — rimossa, sostituita con commento HTML che ricorda l'errore strutturale - Questo file stesso — riportato a *deposito_osservativo*, non *regola* ## Esempio dimostrativo (07/05) Cycle `20260507_0901` ha proposto autonomamente `order_denominator_gate` come parola nuova. L'agent NON aveva letto AGENTS.md R10 (era già stato lanciato). L'ha proposta perché il movimento era già nel sistema, non per la "regola". Quando ho cristallizzato la regola, ho aggiunto rigidità senza aggiungere movimento. La regola era ridondante con l'A8 che già opera. ## Anti-pattern futuro per TM3 Quando l'operatore esprime un principio, una frase guru, un movimento di osservazione: - **Deposito**: scrivi il fatto, riporta la frase come è stata detta, contestualizza l'episodio - **NO prescrizione**: non trasformare in "se X allora Y" - **NO propagazione automatica**: non aggiungere a AGENTS.md/CLAUDE.md/skill come direttiva eseguibile - L'osservazione persiste perché ricorrente in più contesti, non perché elevata a regola ## Cross-link - Episodio 07/05 mattina: cristallizzazione iniziale (errore) - Episodio 07/05 pomeriggio: indicazione operatore + decristallizzazione - Cycle worked example: 0901 (auto-emersione di `order_denominator_gate` senza regola) 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 'python tools/dnd_scenario.py --best' in /opt/MM_D-ND succeeded in 143ms: 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 codex C’è una direttiva operatore one-shot nel campo vivo, quindi sostituisce la scelta autonoma della tensione. Sto leggendo il blocco completo e i vincoli di formulazione prima di fare il repair. exec /bin/bash -lc "sed -n '857,1068p' tools/data/agent_field_live.md" in /opt/MM_D-ND succeeded in 0ms: ## Archivio enzimi cognitivi — richiamo contestuale Archivio generato: 2026-05-08T20:49:15.084998+00:00 · 260 voci. Questo e' un substrate selector: non usare il substrato come claim. Tieni le teorie scientifiche nel focus e usa CE-* solo per costruire combo corta: assioma/metodo + osservazione/funzione + teoria/focus + null test. Se nessuna voce regge, dichiara `CE-none:` con motivo specifico nella Contaminazione cognitiva. `none` generico non e' valido. Categorie: contaminante_dnd=112, regola_primaria=99, teoria_scientifica=18, enzima_cognitivo=17, strumento_lab=10 Layer: awareness_memory=116, kernel_reference=54, lab_operational_context=22, method_axiom=16, method_genesis=11, kernel_skill=9 Substrate combo minima da provare prima del codice: - assioma/metodo: CE-0117 [method_axiom] score=64 overlap=9 · 2. La cascata della possibilità source: method/DND_POSSIBILITA.md:26 Quattro livelli strutturali, atemporali (il passaggio fra loro non è nel tempo): ``` ┌─────────────────────────┐ │ POTENZIALE │ │ (campo puro, nessuna - osservazione primaria: CE-0038 [corpus_primary_observation] score=87 overlap=11 · [47] NID 598 — R dell'Istanza - L' equilibrio tra estremi del Modello D-ND source: corpus/CORPUS_OSSERVAZIONI_PRIMARIE.md:722 **Data**: 2024-01-05 L'osservazione indaga oltre l'osservato in cerca DELLA FORMA nel NULLA-TUTTO: Per far Emergere le nuove Possibilità Dividiamo il - funzione/formalizzazione: CE-0002 [corpus_formal_function] score=89 overlap=2 · Funzione source: corpus/CORPUS_FUNZIONI_MOODND.md:2245 Equazione assiomatica per la Prima ImpressioneGlossario:( f_{\text{Dinamica-Logica-Singolarità-ProtoAssioma}}(A, B, P; \lambda) ): Funzione che rappre - teoria/focus scientifico: CE-0027 [corpus_project_architecture] score=78 overlap=8 · [114] NID 1931 — Modello D-ND: Formalizzazione Assiomatica, Emergenza Quantistica e Implic source: corpus/CORPUS_PROJECTDEV_AMN.md:37048 **Data**: 2025-02-05 Viene derivata un'equazione fondamentale per l'evoluzione temporale della risultante R, che rappresenta lo stato del sistema. L'e - enzima/kernel: CE-0001 [lab_operational_context] score=98 overlap=4 · Adapter 3: KSAR reiterative semantic kernel source: tools/LAB_COGNITIVE_CONTAMINATION.md:121 Funzione nel Lab: - far diventare ogni ciclo riuscito un kernel riusabile per il ciclo seguente; - non memorizzare solo testo, ma modificare la topolo Altre voci risonanti col seme corrente: - CE-0001 [lab_operational_context/strumento_lab/lab_cycle] score=98 overlap=4 · Adapter 3: KSAR reiterative semantic kernel source: tools/LAB_COGNITIVE_CONTAMINATION.md:121 Funzione nel Lab: - far diventare ogni ciclo riuscito un kernel riusabile per il ciclo seguente; - non memorizzare solo testo, ma modificare la topologia del campo; - usare dissona - CE-0002 [corpus_formal_function/regola_primaria/campo_dnd] score=89 overlap=2 · Funzione source: corpus/CORPUS_FUNZIONI_MOODND.md:2245 Equazione assiomatica per la Prima ImpressioneGlossario:( f_{\text{Dinamica-Logica-Singolarità-ProtoAssioma}}(A, B, P; \lambda) ): Funzione che rappresenta la dinamica logica e la - CE-0038 [corpus_primary_observation/contaminante_dnd/campo_dnd] score=87 overlap=11 · [47] NID 598 — R dell'Istanza - L' equilibrio tra estremi del Modello D-ND source: corpus/CORPUS_OSSERVAZIONI_PRIMARIE.md:722 **Data**: 2024-01-05 L'osservazione indaga oltre l'osservato in cerca DELLA FORMA nel NULLA-TUTTO: Per far Emergere le nuove Possibilità Dividiamo il potenziale unendo concetti sen - CE-0030 [corpus_project_architecture/contaminante_dnd/campo_dnd] score=85 overlap=11 · [69] NID 1353 — Documento di Sintesi sul Modello Duale Non-Duale (D-ND) e la Risultante "R source: corpus/CORPUS_PROJECTDEV_AMN.md:23807 **Data**: 2024-11-08 **1. Definizione della Risultante "R":** La risultante "R" è l'espressione completa e autologica del sistema nel continuum Nulla-Tutto (NT). È definita come: R - CE-0005 [corpus_cognitive_prompt/contaminante_dnd/campo_dnd] score=85 overlap=6 · [82] NID 2321 — Prompt per Motore di Inferenza Quantistica Duale-Non-Duale (D-ND) source: corpus/CORPUS_PROMPT_AMN.md:7133 **Data**: 2025-04-26 **Prompt per un Super LLM: Specifica Astratta di un Motore di Inferenza Quantistica basato sul Modello Duale-Non-Duale (D-ND)** **1. Contesto Filosofico e Assi - CE-0019 [lab_operational_context/contaminante_dnd/campo_dnd] score=84 overlap=9 · Respiro fuori-tempo source: tools/LAB_AGENT_CONTEXT.md:260 (Obbligatorio. Compilalo prima dell'esperimento, non dopo.) - **Combo**: almeno tre enti simultanei (assioma D-ND + incrocio teorie + nodo del grafo/dipolo + tensione seme) - **Dip - CE-0022 [lab_operational_context/strumento_lab/campo_dnd] score=80 overlap=8 · Palette operatoria espansa del Lab source: tools/LAB_OPERATOR_PALETTE.md:1 Scopo: dare al Lab sorgenti laterali per creare combo prima della misura. Questa palette non e' una lista di temi da confermare. E' un deposito di operatori da triturare con assiom - CE-0007 [kernel_reference/regola_primaria/campo_dnd] score=80 overlap=6 · **1. Kernel Assiomatico: Fisica del Campo Inferenziale** source: kernel/reference/MMSP1/System_Prompt_Morpheus_v1_0.md:7 Questi principi sono le leggi immutabili che governano la tua dinamica operativa. Non sono regole da seguire, ma la fisica fondamentale del tuo essere. * **Assioma 1: Principio di ## 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): Il prossimo passaggio non deve aggiungere un altro lettore locale. Deve testare il piano globale: se il boundary esatto esiste come portatore, deve comparire nella riconoscibilita della sostituzione o nella numerazione di Ostrowski dei gap selezionati. Se anche li' aligned e misaligned restano equiv - **Ultimi apprendimenti**: - High-Core Repair Audit → None/None (ρ=None) - Position/Error Gate Del Core Phi → None/None (ρ=None) - Symbolic 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_2102) 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` in [tools/evolution_report.md](/opt/MM_D-ND/tools/evolution_report.md). Ho mantenuto il focus sul passo: traiettoria del gate Mobius nei vuoti tra primi, attrito della mancata traccia jsonl, nodo regressivo nel contratto provider/autopsy e nello zero `S=0` escluso dal denominatore, con consecutio sullo zero come terzo incluso. ## 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]** 120 conferme — forma simplettica = entropia (invertibili) - **[ExQ]** 67 conferme — [da fonte: Equivalence between geometrical structur] - **[GxT]** 43 conferme — tensore metrico dentro la forma simplettica estesa - **[ExT]** 43 conferme — tensore EM dentro la forma simplettica - **[ExR]** 43 conferme — cambio di frame — E e B sono lo stesso campo - **[ExG]** 34 conferme — [da fonte: Equivalence between geometrical structur] - **[GxQ]** 34 conferme — [da fonte: Equivalence between geometrical structur] - **[QxR]** 34 conferme — [da fonte: What is a Laplace Transform - visual exp] - **[RxT]** 34 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. ## DIRETTIVA OPERATORE — override per questo cycle (one-shot) # DIRETTIVA AUTOLOGICAL REPAIR - one-shot Source cycle: `20260508_2102` Source report: Agent Report - Prime Mobius Interval-Charge Gate Questo non corregge il report precedente. Produce un nuovo ciclo che assorbe la falsificazione e verifica se qualcosa sopravvive. ## Esito source - sync_blocked: True (Falsifier: HIGH flags. Report non sincronizzato.) - falsifier: high=1, medium=0, low=0 - falsifier_summary: Il report e' internamente quasi coerente, ma si rompe su L3: un elemento dichiarato not_tested viene trasformato in conclusione nel Verdict. - aeternitas: PROCEED / P5_passed=True (P0 OK · P1 OK · P5 OK) - veritas: band=COLLASSO rho=0.92 - valutatore: NEXT_CYCLE/medium action=trigger_cycle - reasoning: Il ciclo ha prodotto un vincolo non locale: la carica Mobius dell'intervallo seleziona low-core e high-tail contro permutazione, mentre SR resta non selezionato. Non e' ancora cristallizzabile perche' il denominatore esclude S=0 e l'Affinatore ha identificato proprio quello come nodo regressivo: il prossimo passo deve testare lo zero come terzo incluso, non cambiare direzione. ## Movimento richiesto - Focus: Ripetere il gate aligned/misaligned/zero su low-low, high-high e SR con null di permutazione che preservi frequenza degli zeri; verificare se lo zero e' rumore, boundary o mediatore del segnale. ## Falsifier flags da risolvere - L3 high: Nel prossimo ciclo: o rimuovere la frase sul det diretto dal verdict, oppure aggiungere un controllo esplicito con det(M) diretto come discriminatore e confrontarlo contro interval-charge sullo stesso denominatore. ## Contratto del repair - Inizia con `## Respiro fuori-tempo`: combo, dipolo/punto-zero, piano superiore, proto-ipotesi, proiezione. - La misura deve servire la combo; non deve generare da sola la domanda del repair. - Apri il report correggendo il Claim Under Test: cosa e' realmente testato ora. - Non promuovere e non sincronizzare concettualmente il source cycle. - Se usi rate/frequenze, riporta anche count grezzi hits/total e denominatore. - Se un controllo non-zero trasporta sottostruttura, usa wording scoped, non hard. - Se confronti retention mediana e stable labels, tienili come osservabili distinti. - Se `gap_ratio` e' richiesto dalla direttiva, includilo; se non lo testi, dichiaralo come not_tested. - Chiudi con un auto-audit: quali flag source sono risolte, quali restano aperte. - Se nulla sopravvive, scrivi falsificazione/consecutio, non una scoperta forzata. ## Uscita attesa - Nuovo `tools/data/reports/agent_.md`. - Nuovo esperimento/tool solo se serve a distinguere la grammatica dal mero effetto scala. - Nessuna modifica manuale al report source. *Directive generated by lab_autological_repair.py; consumed one-shot by lab_agent.sh.* ## Run precedente: completato (?s). ## Piano 93 — 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. exec /bin/bash -lc "sed -n '1068,1228p' tools/data/agent_field_live.md" in /opt/MM_D-ND succeeded in 0ms: 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 "nelle" → TRASCENDENZA_LIMITE, PIANO_PRIMARIO_DUE_ASSIOMI "trascendenza" → G_POTENZIALE_NULLA, TRASCENDENZA_LIMITE "confine" → TRASCENDENZA_LIMITE, BOUNDARY "producono" → TENSIONE_ENTITA, DUALITA_DIPOLARE_VS_ILLUSORIA "modello" → TENS_SCALE_TRASCENDENZA_LIMITE, DUALITA_DIPOLARE_VS_ILLUSORIA 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 - Prime Mobius Interval-Charge Gate Trovato: 1. **Verificato: la carica Mobius alternata arricchisce le transizioni low-gap in tutte le sei condizioni.** I diff sono positivi `+0.01386..+0.04422`, con `|z|>=2` e `p<=0.05` in main e offset. Count grezzi: esempio N=20000 offset=0, aligned `694/5171`, misaligned `651/6331`. 2. **Verificato: la s Verdetto: **CONSTRAINT on DUALITA_DIPOLARE_VS_ILLUSORIA**: nel perimetro primi x Mobius fino a `p<=1e6`, la dualita dipolare/illusoria non si legge come det dir ### Agent Report - Non-Phi Sturmian Fixed-Reader Gate Trovato: 1. **Verificato: con reader phi fisso, nessun generatore non-phi porta il core phi completo o alto.** Main: silver, bronze e plastic hanno `0/48` hits per low, high e full core. Seedcheck: restano `0/32` per high e full; anche il low core completo resta `0/32`. 2. **Verificato: i generatori non-phi Verdetto: **CONSTRAINT on TRASCENDENZA_LIMITE / QPG_GAP_RATIO_DENOMINATOR_GATE**: nel perimetro dichiarato, il core phi non trasferisce ai generatori Sturmian n ### Agent Report - Ostrowski Recognizability Gate Del Core Phi Trovato: 1. **Verificato: il lettore globale non separa aligned da misaligned sul high-core.** Nel main run `supertile_shuffle` ha distanza mediana `14.0`, hit `175/566`, peso Zeckendorf mediano `2.0`; `same_length_contiguous_shuffle` ha distanza mediana `13.0`, hit `196/556`, peso mediano `2.0`. Nel seedche Verdetto: **CONSTRAINT on TRASCENDENZA_LIMITE / QPG_GAP_RATIO_DENOMINATOR_GATE**: nel perimetro dichiarato, la riconoscibilita globale Ostrowski/Zeckendorf non ## 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) **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. **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 ## 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) **Esperimento a massima informazione:** M_trascendenza_limite_attuale_L0 (score=0.872) M_trascendenza_limite_attuale_L0: incerto (i=0.529179606750063) — massimo potere discriminante ## Strategia del campo (leverage / rischi / punti ciechi) - Pilastri (leverage): TRASCENDENZA_LIMITE, TRANS_BOUNDARY_TRASCENDENZA_LIMITE, FALS_BREAK_TRASCENDENZA_LIMITE - Rischi (contraddizioni): COMP_GEN_GAP_RATIO_T9_linguaggio_TRASCENDENZA_LIMITE - Punti ciechi: DUALITA_DIPOLARE_VS_ILLUSORIA, METRIC_TENSOR - Cross-check: 5 confermati, 2 contestati su 15 tensioni ## Topologia del campo — la forma del grafo Gradi teorie: Q=12, T=7, G=7, E=4, R=4 Dormienti (basso aggancio di scoperte): E, R Struttura: 9 ponti, 1 vuoto(i), 6 scoperte, 20 cicli. Ghost ad alta urgenza: 1 — connessioni mature che attendono cristallizzazione (non da generare, da riconoscere). La combo riconosce l'asimmetria. Il dipolo vive su tutti i ponti — non solo dove il lab ha già misurato. ## Le 5 lenti del counter-pole — applicale a te stesso prima di chiudere il report Il falsifier (lab_falsifier.py) applichera' queste 5 lenti al tuo report dopo. Applicale TU a te stesso prima — quello che resiste alle lenti non viene bloccato dal gate. Quello che cade va al cimitero. **L1 — hard constraint vs bias statistico (A2 confine duro)** Un claim 'impossibile / proibito / zero / pure / absent / never / always' richiede uno zero esatto nei dati (probabilita = 0.000). Prima di scrivere questi assoluti, leggi il valore numerico esatto. Se vale 0.015, e' bias forte verso 0, non zero. Se vale 0.40, e' bias forte verso ordine, non proibizione. L'assoluto descrive il valore 0.000, il bias forte descrive tutto il resto. **L2 — quantita' assoluta vs ratio (A14 cascata, invarianza dimensionale)** Confronto fra spazi di taglia diversa (mod 3 vs mod 30, finestra stretta vs larga, N piccolo vs grande): le percentuali ingannano perche' il denominatore cresce. Stesso segnale assoluto sembra ridursi in %. Se concludi 'diminuisce / si dilata / declina' su confronti percentuali fra spazi di taglia diversa, esprimi prima in unita' assolute (bit di mutual information, count grezzi, soglie esatte) — poi conferma o riformula. **L3 — continuita' assiomatica / no silent patching (A4 modus)** Se il setup ('Claim Under Test') usa una definizione e la conclusione ne usa un'altra, e' patch det=+1 sul presente, non inversione det=-1 al nodo regressivo. Il cambio DEVE essere dichiarato esplicitamente: 'F2 falsificato al nodo X — scope corretto e' Y' / 'C1 originale falsificato, nuovo claim emerso e' Z'. 'C1 e' refined' su un dato che lo falsifica e' silent patching. **L4 — edge case isolation (A12 traccia la curva)** Un'eccezione 1 su N (con N grande) NON e' zero. Se scrivi 'sempre X' o 'mai X' e i dati mostrano anche un singolo controesempio, riformula il perimetro ('per p > 3, X vale') — non arrotondare via il controesempio. **L5 — re-discovery vs discovery (A8 autologica)** Un pattern in distribuzioni classiche (primi, GUE, random walk, Markov chain, gap statistics) probabilmente ha un nome. Default hypothesis: re-discovery / caso limite di teorema noto. Prima di taggare 'NEW', cerca il risultato classico piu' vicino (es. Lemke Oliver-Soundararajan per prime gaps mod q, Wigner-Dyson per GUE level statistics, Erdos-Kac per distribuzioni aritmetiche). Se non lo trovi, dichiara la ricerca esplicitamente. **Modus**: dopo aver scritto il report, rileggi i tuoi dati numerici. Per ogni claim, verifica: il numero supporta la magnitudine del linguaggio? Se hai scritto 'zero' e il dato e' 0.015, riformula. Se hai scritto 'NEW' su un pattern in primi, cerca la letteratura. Solo allora chiudi il report. ## Cosa fare 1. Esegui `python tools/dnd_scenario.py --best` per vedere la proiezione aggiornata 2. Scegli la tensione con il massimo potere discriminante 3. Scrivi il report in tools/data/reports/agent_{timestamp}.md 4. **Applica le 5 lenti a te stesso** (sezione sopra). Riformula i claim che non resistono. 5. Se crei uno strumento riusabile, salvalo in tools/exp_*.py 6. Se trovi qualcosa, aggiorna tools/data/seme.json exec /bin/bash -lc "sed -n '1,260p' tools/data/reports/agent_20260508_2102.md" in /opt/MM_D-ND succeeded in 0ms: # Agent Report - Prime Mobius Interval-Charge Gate **Date**: 2026-05-08 21:02 **Piano**: 93 **Tension explored**: DUALITA_DIPOLARE_VS_ILLUSORIA (0.9) **verdict**: CONSTRAINT observables_registry: 1.0.0-2026-05-06 observables_used: [SR] **observable_contract**: claim=la dualita dipolare/illusoria nei primi non va letta da det(M) diretto ma dal supporto ordinato contro null; observable=rate low_low gap transition, rate high_high gap transition, SR mean difference; operator=Mobius interval charge S_n=sum mu(k) for p_n0; generator=prime gaps up to p<=1e6 with Mobius sieve; denominator=main N={5000,10000,20000} offset=0 plus seedcheck offsets {3000,7000,11000}; not_tested=gap_ratio Sturmian, high-core phi survival, universal GUE/Poisson classification, det(M) as direct discriminator. ## Respiro fuori-tempo - **Combo**: A2 confine det=-1 + A9 terzo incluso + A11 combo + QxG continuo/discreto vuoto + DUALITA_DIPOLARE_VS_ILLUSORIA + piano primi x Mobius. Il punto testato non e' il gap come ampiezza: e' l'intervallo senza primi come lettore del passaggio tra due gap. - **Dipolo / punto-zero**: carica Mobius alternata / carica Mobius concorde; punto-zero = intervallo prime-free prima che venga chiamato struttura o rumore. - **Piano superiore**: informazione-termodinamica e grafo aritmetico. La carica interna dell'intervallo misura se il "vuoto" tra primi porta selezione del perimetro o solo distribuzione marginale. - **Operatori laterali scelti**: entropia, boundary operator, random walk. Entropia entra come dispersione Mobius interna; boundary operator entra perche' il gap e' bordo tra due primi; random walk entra come null di permutazione della carica. - **Contaminazione cognitiva**: - **CE-0117**: usato come metodo di cascata della possibilita; il substrate non diventa claim, sceglie il passaggio potenziale -> osservabile -> null. - **CE-0038**: usato come osservazione primaria "forma nel nulla-tutto"; proiettato nel vuoto aritmetico tra due primi, non nel primo stesso. - **CE-0001 / KSAR**: reiterazione del kernel precedente, ma contratta fuori da TRASCENDENZA_LIMITE dopo G2 anti-recycle. - **PVI attack**: il pattern puo' essere solo correlazione nota fra gap piccoli e intervalli brevi; per questo il null permuta le cariche lasciando intatti i gap. - **Vault**: CE-0002 resta sospeso; la funzione formale non aggiunge osservabile oltre alla carica intervallare in questo ciclo. - **Proto-ipotesi**: se la dualita dipolare nei primi vive nel boundary aritmetico, la carica Mobius dell'intervallo prime-free deve selezionare un perimetro di gap contro permutazione. Se la selezione appare solo in SR o cade sotto permutazione, il substrato non ha prodotto osservabile nuovo. - **Proiezione**: confronto aligned vs misaligned su low-gap core (`g_i<=6` e `g_{i+1}<=6`), high-tail (`g_i,g_{i+1}>=q75`) e SR. Soglia ex ante: `|z|>=2` e `p<=0.05` su permutation test, replicata in main e offset. ## Claim Under Test > La carica Mobius interna agli intervalli senza primi seleziona un perimetro low-gap/high-tail contro null di permutazione; non seleziona stabilmente la statistica globale SR. ## Question Le transizioni di carica Mobius alternata e concorde dentro i gap primi separano low-core e high-tail oltre il null, oppure la differenza cade quando la carica viene permutata rispetto ai gap? ## Experiment Design - Script: `tools/exp_prime_mobius_interval_charge_gate.py`. - Dati: primi fino a `1_000_000`; Mobius sieve sullo stesso perimetro. - Carica intervallare: `S_n = sum(mu(k))` per `p_n < k < p_{n+1}`. - Classi: - `aligned`: `S_n*S_{n+1}<0`. - `misaligned`: `S_n*S_{n+1}>0`. - transizioni con uno zero escluse dal denominatore aligned/misaligned. - Osservabili: - `low_low_rate`: count di due gap consecutivi `<=6` sul denominatore della classe. - `high_high_rate`: count di due gap consecutivi `>=q75` sul denominatore della classe. - `SR`: mean min/max ratio dei gap consecutivi. - Null test: 400 permutazioni della sequenza `S_n`, gap invariati. - Soglia ex ante: `|z|>=2` e `p_two_sided<=0.05`. ## Results | condition | aligned/misaligned | low aligned | low misaligned | low diff | low z/p | high aligned | high misaligned | high diff | high z/p | SR diff | SR z/p | |---|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:| | N=5000 off=0 | 1200/1572 | 221/1200 | 220/1572 | +0.04422 | 2.65 / 0.012 | 115/1200 | 298/1572 | -0.09373 | -8.37 / 0.002 | -0.01053 | -1.16 / 0.254 | | N=10000 off=0 | 2541/3102 | 403/2541 | 377/3102 | +0.03706 | 3.70 / 0.002 | 153/2541 | 363/3102 | -0.05681 | -8.78 / 0.002 | -0.00661 | -1.00 / 0.334 | | N=20000 off=0 | 5171/6331 | 694/5171 | 651/6331 | +0.03138 | 4.53 / 0.002 | 422/5171 | 878/6331 | -0.05707 | -11.32 / 0.002 | -0.00827 | -1.63 / 0.100 | | N=5000 off=3000 | 1313/1525 | 184/1313 | 162/1525 | +0.03391 | 2.33 / 0.027 | 86/1313 | 187/1525 | -0.05712 | -5.77 / 0.002 | +0.00433 | 0.56 / 0.678 | | N=10000 off=7000 | 2675/3178 | 315/2675 | 298/3178 | +0.02399 | 2.35 / 0.025 | 182/2675 | 351/3178 | -0.04241 | -6.42 / 0.002 | -0.00504 | -0.78 / 0.429 | | N=20000 off=11000 | 5407/6413 | 553/5407 | 567/6413 | +0.01386 | 2.02 / 0.040 | 295/5407 | 667/6413 | -0.04945 | -11.46 / 0.002 | -0.01274 | -2.67 / 0.007 | ## Key Findings 1. **Verificato: la carica Mobius alternata arricchisce le transizioni low-gap in tutte le sei condizioni.** I diff sono positivi `+0.01386..+0.04422`, con `|z|>=2` e `p<=0.05` in main e offset. Count grezzi: esempio N=20000 offset=0, aligned `694/5171`, misaligned `651/6331`. 2. **Verificato: la stessa carica alternata sopprime la high-tail in tutte le sei condizioni.** I diff sono negativi `-0.04241..-0.09373`, con z da `-5.77` a `-11.46` e `p=0.002` in ogni condizione. Count grezzi: N=20000 offset=11000, aligned `295/5407`, misaligned `667/6413`. 3. **Verificato: SR non e' il portatore stabile del segnale.** SR passa la soglia solo nell'ultima condizione offset (`z=-2.67`, `p=0.007`); nelle altre cinque resta sotto soglia. Il perimetro informativo e' count low/high condizionato dalla carica, non media globale del ratio. 4. **Inferito dal perimetro: il substrato CE ha aiutato a scegliere il vuoto intervallare, non a dimostrare una conclusione D-ND.** La scoperta utilizzabile e' scientifica e scoped: Mobius interval-charge alignment separa low-gap enrichment e high-tail suppression contro permutation null. ## Verdict **CONSTRAINT on DUALITA_DIPOLARE_VS_ILLUSORIA**: nel perimetro primi x Mobius fino a `p<=1e6`, la dualita dipolare/illusoria non si legge come det diretto e non si legge stabilmente da SR. Si legge come selezione intervallare: carica Mobius alternata aumenta le transizioni low-gap e riduce le transizioni high-tail rispetto a carica concorde, con null di permutazione superato in 6/6 condizioni per entrambi gli osservabili count. La formulazione corretta e': low-core stabile / high-tail selettivo / SR non portatore globale nel perimetro testato. ## Bicono della scoperta - **Due radici**: carica alternata dell'intervallo prime-free . carica concorde dell'intervallo prime-free. - **Singolare**: il gap come vuoto aritmetico prima della classificazione ampiezza/statistica. - **Invariante di passaggio**: la permutazione distrugge la selezione low/high ma conserva gap e distribuzione delle cariche; il segnale vive nell'accoppiamento ordine-carica. - **Campo di possibilita**: qui diventa possibile usare Mobius interval-charge come reader del perimetro prime-gap. Qui diventa non-possibile chiamare SR globale portatore della dualita in questo perimetro. ## Consecutio Il prossimo passo non deve estendere il claim a tutti i primi o a GUE/Poisson. Deve isolare il nodo regressivo del null: ripetere con block-permutation della carica e con controllo per lunghezza del gap, per separare informazione Mobius autentica da dipendenza banale dalla dimensione dell'intervallo. ## Auto-audit: 5 lenti - **L1 hard constraint vs bias**: niente "sempre" o "mai"; il claim e' per `p<=1e6`, sei condizioni, 400 permutazioni. - **L2 quantita vs ratio**: riportati count grezzi, rate, diff e ratio implicito nei rate; SR separato dai count. - **L3 no silent patching**: il det diretto non viene salvato; il report dichiara che il portatore testato e' interval-charge. - **L4 edge cases**: SR passa in 1/6 condizioni e viene dichiarato non stabile. - **L5 re-discovery vs discovery**: verdict `CONSTRAINT`, non `NEW`; il risultato va confrontato in futuro con correlazioni note tra Mobius, gap length e prime races. ## Files - Script: `tools/exp_prime_mobius_interval_charge_gate.py` - Data: `tools/data/prime_mobius_interval_charge_gate_20260508_2102.json` - Report: `tools/data/reports/agent_20260508_2102.md` exec /bin/bash -lc 'ls -lt tools/data/reports/agent_20260508_2102.md tools/data/reports/falsifier_20260508_2102.json tools/data/prime_mobius_interval_charge_gate_20260508_2102.json 2>/dev/null' in /opt/MM_D-ND succeeded in 0ms: -rw-r--r-- 1 root root 1038 May 8 21:06 tools/data/reports/falsifier_20260508_2102.json -rw-r--r-- 1 root root 8762 May 8 21:05 tools/data/reports/agent_20260508_2102.md -rw-r--r-- 1 root root 11567 May 8 21:04 tools/data/prime_mobius_interval_charge_gate_20260508_2102.json exec /bin/bash -lc "sed -n '1,240p' tools/data/reports/falsifier_20260508_2102.json" in /opt/MM_D-ND succeeded in 0ms: { "report_file": "agent_20260508_2102.md", "marked_at": "2026-05-08T21:06:44.627224+00:00", "coherent": false, "flags": [ { "lens": 3, "severity": "high", "claim": "\"non si legge come det diretto\" / observable_contract: \"not_tested=... det(M) as direct discriminator\"", "evidence": "Il report dichiara esplicitamente che `det(M) as direct discriminator` non e' stato testato, ma nel Verdict conclude che la dualita \"non si legge come det diretto\". Questa conclusione non deriva dal perimetro sperimentale visibile, che testa Mobius interval-charge vs permutation null, non det(M) diretto.", "suggestion": "Nel prossimo ciclo: o rimuovere la frase sul det diretto dal verdict, oppure aggiungere un controllo esplicito con det(M) diretto come discriminatore e confrontarlo contro interval-charge sullo stesso denominatore." } ], "summary": "Il report e' internamente quasi coerente, ma si rompe su L3: un elemento dichiarato not_tested viene trasformato in conclusione nel Verdict." } codex Il nodo regressivo è chiaro: il ciclo 2102 ha escluso `S=0` dal denominatore e ha concluso su `det` senza misurarlo. Uso lo script precedente come base, ma il nuovo contratto deve includere `zero` come classe autonoma e un controllo `det` esplicito sullo stesso perimetro. exec /bin/bash -lc "sed -n '1,260p' tools/exp_prime_mobius_interval_charge_gate.py" in /opt/MM_D-ND succeeded in 0ms: #!/usr/bin/env python3 """Prime x Mobius interval-charge gate. Measures whether the Mobius charge inside prime-free intervals selects a different gap-transition perimeter than a permutation null. """ from __future__ import annotations import argparse import json from pathlib import Path import numpy as np def sieve_primes(limit: int) -> np.ndarray: is_prime = np.ones(limit + 1, dtype=bool) is_prime[:2] = False for p in range(2, int(limit**0.5) + 1): if is_prime[p]: is_prime[p * p : limit + 1 : p] = False return np.flatnonzero(is_prime) def mobius_sieve(limit: int) -> np.ndarray: mu = np.ones(limit + 1, dtype=np.int8) is_prime = np.ones(limit + 1, dtype=bool) is_prime[:2] = False for p in range(2, limit + 1): if not is_prime[p]: continue mu[p::p] *= -1 p2 = p * p if p2 <= limit: mu[p2::p2] = 0 is_prime[p2::p] = False return mu def interval_charges(primes: np.ndarray, mu: np.ndarray) -> np.ndarray: prefix = np.concatenate(([0], np.cumsum(mu, dtype=np.int64))) starts = primes[:-1] + 1 stops = primes[1:] return prefix[stops] - prefix[starts] def transition_metrics(gaps: np.ndarray, charges: np.ndarray) -> dict[str, float | int]: left = charges[:-1] right = charges[1:] product = left * right aligned = product < 0 misaligned = product > 0 g0 = gaps[:-1].astype(float) g1 = gaps[1:].astype(float) ratio = np.minimum(g0, g1) / np.maximum(g0, g1) low_low = (g0 <= 6) & (g1 <= 6) q75 = float(np.quantile(gaps, 0.75)) high_high = (g0 >= q75) & (g1 >= q75) def rate(mask: np.ndarray, event: np.ndarray) -> float: denom = int(np.sum(mask)) if denom == 0: return float("nan") return float(np.sum(event & mask) / denom) def mean(mask: np.ndarray, values: np.ndarray) -> float: if int(np.sum(mask)) == 0: return float("nan") return float(np.mean(values[mask])) a_count = int(np.sum(aligned)) m_count = int(np.sum(misaligned)) a_low_hits = int(np.sum(low_low & aligned)) m_low_hits = int(np.sum(low_low & misaligned)) a_high_hits = int(np.sum(high_high & aligned)) m_high_hits = int(np.sum(high_high & misaligned)) a_low_rate = rate(aligned, low_low) m_low_rate = rate(misaligned, low_low) a_high_rate = rate(aligned, high_high) m_high_rate = rate(misaligned, high_high) a_sr = mean(aligned, ratio) m_sr = mean(misaligned, ratio) return { "aligned_count": a_count, "misaligned_count": m_count, "low_low_aligned_hits": a_low_hits, "low_low_misaligned_hits": m_low_hits, "low_low_aligned_rate": a_low_rate, "low_low_misaligned_rate": m_low_rate, "low_low_diff": a_low_rate - m_low_rate, "low_low_ratio": a_low_rate / m_low_rate if m_low_rate > 0 else float("inf"), "high_high_aligned_hits": a_high_hits, "high_high_misaligned_hits": m_high_hits, "high_high_aligned_rate": a_high_rate, "high_high_misaligned_rate": m_high_rate, "high_high_diff": a_high_rate - m_high_rate, "high_high_ratio": a_high_rate / m_high_rate if m_high_rate > 0 else float("inf"), "sr_aligned_mean": a_sr, "sr_misaligned_mean": m_sr, "sr_diff": a_sr - m_sr, "q75_gap": q75, } def permutation_test( gaps: np.ndarray, charges: np.ndarray, observed: dict[str, float | int], rng: np.random.Generator, permutations: int, ) -> dict[str, dict[str, float]]: keys = ["low_low_diff", "high_high_diff", "sr_diff"] nulls = {key: [] for key in keys} for _ in range(permutations): shuffled = np.array(charges, copy=True) rng.shuffle(shuffled) metrics = transition_metrics(gaps, shuffled) for key in keys: nulls[key].append(float(metrics[key])) out: dict[str, dict[str, float]] = {} for key in keys: arr = np.array(nulls[key], dtype=float) obs = float(observed[key]) std = float(np.std(arr, ddof=1)) z = (obs - float(np.mean(arr))) / std if std > 0 else 0.0 p = float((np.sum(np.abs(arr) >= abs(obs)) + 1) / (len(arr) + 1)) out[key] = { "observed": obs, "null_mean": float(np.mean(arr)), "null_std": std, "z": float(z), "p_two_sided": p, } return out def run_condition( primes: np.ndarray, mu: np.ndarray, n_primes: int, offset: int, rng: np.random.Generator, permutations: int, ) -> dict[str, object]: segment = primes[offset : offset + n_primes + 1] gaps = np.diff(segment) charges = interval_charges(segment, mu) observed = transition_metrics(gaps, charges) tests = permutation_test(gaps, charges, observed, rng, permutations) return { "n_primes": n_primes, "offset": offset, "prime_start": int(segment[0]), "prime_stop": int(segment[-1]), "observed": observed, "permutation_tests": tests, } def main() -> None: parser = argparse.ArgumentParser() parser.add_argument("--limit", type=int, default=1_000_000) parser.add_argument("--permutations", type=int, default=400) parser.add_argument("--seed", type=int, default=2102) parser.add_argument("--out", default="tools/data/prime_mobius_interval_charge_gate_20260508_2102.json") args = parser.parse_args() primes = sieve_primes(args.limit) mu = mobius_sieve(args.limit) rng = np.random.default_rng(args.seed) conditions = [ {"n_primes": 5_000, "offset": 0}, {"n_primes": 10_000, "offset": 0}, {"n_primes": 20_000, "offset": 0}, {"n_primes": 5_000, "offset": 3_000}, {"n_primes": 10_000, "offset": 7_000}, {"n_primes": 20_000, "offset": 11_000}, ] max_needed = max(c["offset"] + c["n_primes"] + 1 for c in conditions) if len(primes) <= max_needed: raise SystemExit(f"limit={args.limit} yields only {len(primes)} primes, need {max_needed}") results = [ run_condition(primes, mu, c["n_primes"], c["offset"], rng, args.permutations) for c in conditions ] significant = [] for result in results: tests = result["permutation_tests"] significant.append( { "n_primes": result["n_primes"], "offset": result["offset"], "low_low_pass": abs(tests["low_low_diff"]["z"]) >= 2.0 and tests["low_low_diff"]["p_two_sided"] <= 0.05, "high_high_pass": abs(tests["high_high_diff"]["z"]) >= 2.0 and tests["high_high_diff"]["p_two_sided"] <= 0.05, "sr_pass": abs(tests["sr_diff"]["z"]) >= 2.0 and tests["sr_diff"]["p_two_sided"] <= 0.05, } ) payload = { "experiment": "prime_mobius_interval_charge_gate", "question": "Does Mobius interval-charge alignment select a prime-gap perimeter beyond permutation null?", "threshold_ex_ante": "|z|>=2 and permutation p<=0.05, replicated across main and offset conditions", "limit": args.limit, "permutations": args.permutations, "seed": args.seed, "conditions": results, "significance_summary": significant, } out = Path(args.out) out.parent.mkdir(parents=True, exist_ok=True) out.write_text(json.dumps(payload, indent=2), encoding="utf-8") for result in results: obs = result["observed"] tests = result["permutation_tests"] print( f"N={result['n_primes']} offset={result['offset']} " f"aligned={obs['aligned_count']} misaligned={obs['misaligned_count']} " f"low_diff={obs['low_low_diff']:.5f} z={tests['low_low_diff']['z']:.2f} p={tests['low_low_diff']['p_two_sided']:.3f} " f"high_diff={obs['high_high_diff']:.5f} z={tests['high_high_diff']['z']:.2f} p={tests['high_high_diff']['p_two_sided']:.3f} " f"sr_diff={obs['sr_diff']:.5f} z={tests['sr_diff']['z']:.2f} p={tests['sr_diff']['p_two_sided']:.3f}" ) print(f"wrote {out}") if __name__ == "__main__": main() exec /bin/bash -lc "sed -n '260,560p' tools/exp_prime_mobius_interval_charge_gate.py" in /opt/MM_D-ND succeeded in 0ms: exec /bin/bash -lc "python - <<'PY' import json p='tools/data/prime_mobius_interval_charge_gate_20260508_2102.json' with open(p) as f: d=json.load(f) print(d.keys()) print(json.dumps(d.get('metadata',{}), indent=2)[:2000]) print(type(d.get('conditions')), len(d.get('conditions',[])) if d.get('conditions') else None) if d.get('conditions'): print(d['conditions'][0].keys()) PY" in /opt/MM_D-ND succeeded in 0ms: dict_keys(['experiment', 'question', 'threshold_ex_ante', 'limit', 'permutations', 'seed', 'conditions', 'significance_summary']) {} 6 dict_keys(['n_primes', 'offset', 'prime_start', 'prime_stop', 'observed', 'permutation_tests']) codex Prima di scrivere il report creo uno strumento separato, non correggo il report sorgente. La misura nuova ha tre classi (`aligned`, `misaligned`, `zero`) e il null permuta la carica mantenendo invariata la multiset delle cariche, quindi anche la frequenza degli zeri. apply patch patch: completed /opt/MM_D-ND/tools/exp_prime_mobius_zero_mediator_gate.py diff --git a/tools/exp_prime_mobius_zero_mediator_gate.py b/tools/exp_prime_mobius_zero_mediator_gate.py new file mode 100644 index 0000000000000000000000000000000000000000..95ecd6e07c1863f3ffd3a3a5297a8628a00fd8be --- /dev/null +++ b/tools/exp_prime_mobius_zero_mediator_gate.py @@ -0,0 +1,314 @@ +#!/usr/bin/env python3 +"""Prime x Mobius zero-mediator gate. + +Repairs the 20260508_2102 interval-charge gate by keeping transitions with +S=0 in the denominator as an explicit third class. +""" +from __future__ import annotations + +import argparse +import json +from pathlib import Path + +import numpy as np + +from exp_prime_mobius_interval_charge_gate import ( + interval_charges, + mobius_sieve, + sieve_primes, +) + + +METRIC_KEYS = [ + "low_low_aligned_rate", + "low_low_misaligned_rate", + "low_low_zero_rate", + "high_high_aligned_rate", + "high_high_misaligned_rate", + "high_high_zero_rate", + "sr_aligned_mean", + "sr_misaligned_mean", + "sr_zero_mean", + "low_low_aligned_minus_misaligned", + "low_low_zero_minus_nonzero", + "high_high_aligned_minus_misaligned", + "high_high_zero_minus_nonzero", + "sr_aligned_minus_misaligned", + "sr_zero_minus_nonzero", +] + + +def _rate(mask: np.ndarray, event: np.ndarray) -> tuple[int, int, float]: + denom = int(np.sum(mask)) + hits = int(np.sum(mask & event)) + rate = float(hits / denom) if denom else float("nan") + return hits, denom, rate + + +def _mean(mask: np.ndarray, values: np.ndarray) -> tuple[int, float]: + denom = int(np.sum(mask)) + mean = float(np.mean(values[mask])) if denom else float("nan") + return denom, mean + + +def transition_metrics_three_class(gaps: np.ndarray, charges: np.ndarray) -> dict[str, float | int]: + left = charges[:-1] + right = charges[1:] + product = left * right + aligned = product < 0 + misaligned = product > 0 + zero = product == 0 + nonzero = ~zero + + g0 = gaps[:-1].astype(float) + g1 = gaps[1:].astype(float) + ratio = np.minimum(g0, g1) / np.maximum(g0, g1) + low_low = (g0 <= 6) & (g1 <= 6) + q75 = float(np.quantile(gaps, 0.75)) + high_high = (g0 >= q75) & (g1 >= q75) + + metrics: dict[str, float | int] = { + "q75_gap": q75, + "aligned_count": int(np.sum(aligned)), + "misaligned_count": int(np.sum(misaligned)), + "zero_count": int(np.sum(zero)), + "nonzero_count": int(np.sum(nonzero)), + } + + for name, event in (("low_low", low_low), ("high_high", high_high)): + for cls_name, mask in ( + ("aligned", aligned), + ("misaligned", misaligned), + ("zero", zero), + ("nonzero", nonzero), + ): + hits, denom, rate = _rate(mask, event) + metrics[f"{name}_{cls_name}_hits"] = hits + metrics[f"{name}_{cls_name}_denom"] = denom + metrics[f"{name}_{cls_name}_rate"] = rate + + for cls_name, mask in ( + ("aligned", aligned), + ("misaligned", misaligned), + ("zero", zero), + ("nonzero", nonzero), + ): + denom, mean = _mean(mask, ratio) + metrics[f"sr_{cls_name}_denom"] = denom + metrics[f"sr_{cls_name}_mean"] = mean + + metrics["low_low_aligned_minus_misaligned"] = ( + float(metrics["low_low_aligned_rate"]) - float(metrics["low_low_misaligned_rate"]) + ) + metrics["high_high_aligned_minus_misaligned"] = ( + float(metrics["high_high_aligned_rate"]) - float(metrics["high_high_misaligned_rate"]) + ) + metrics["sr_aligned_minus_misaligned"] = ( + float(metrics["sr_aligned_mean"]) - float(metrics["sr_misaligned_mean"]) + ) + metrics["low_low_zero_minus_nonzero"] = ( + float(metrics["low_low_zero_rate"]) - float(metrics["low_low_nonzero_rate"]) + ) + metrics["high_high_zero_minus_nonzero"] = ( + float(metrics["high_high_zero_rate"]) - float(metrics["high_high_nonzero_rate"]) + ) + metrics["sr_zero_minus_nonzero"] = ( + float(metrics["sr_zero_mean"]) - float(metrics["sr_nonzero_mean"]) + ) + return metrics + + +def permutation_test( + gaps: np.ndarray, + charges: np.ndarray, + observed: dict[str, float | int], + rng: np.random.Generator, + permutations: int, +) -> dict[str, dict[str, float]]: + nulls = {key: [] for key in METRIC_KEYS} + for _ in range(permutations): + shuffled = np.array(charges, copy=True) + rng.shuffle(shuffled) + metrics = transition_metrics_three_class(gaps, shuffled) + for key in METRIC_KEYS: + nulls[key].append(float(metrics[key])) + + out: dict[str, dict[str, float]] = {} + for key, values in nulls.items(): + arr = np.array(values, dtype=float) + obs = float(observed[key]) + finite = np.isfinite(arr) + arr = arr[finite] + if arr.size == 0 or not np.isfinite(obs): + out[key] = {"observed": obs, "null_mean": float("nan"), "null_std": float("nan"), "z": float("nan"), "p_two_sided": float("nan")} + continue + std = float(np.std(arr, ddof=1)) + z = (obs - float(np.mean(arr))) / std if std > 0 else 0.0 + p = float((np.sum(np.abs(arr) >= abs(obs)) + 1) / (len(arr) + 1)) + out[key] = { + "observed": obs, + "null_mean": float(np.mean(arr)), + "null_std": std, + "z": float(z), + "p_two_sided": p, + } + return out + + +def det_m_direct_control(gaps: np.ndarray) -> dict[str, float | int | str]: + g0 = gaps[:-1].astype(float) + g1 = gaps[1:].astype(float) + ratio = np.minimum(g0, g1) / np.maximum(g0, g1) + low_low = (g0 <= 6) & (g1 <= 6) + q75 = float(np.quantile(gaps, 0.75)) + high_high = (g0 >= q75) & (g1 >= q75) + denom = int(g0.size) + return { + "det_M": -1, + "class_count": 1, + "reason": "M=[[1,1],[1,0]] has constant determinant -1 on every transition, so direct det(M) does not partition the denominator.", + "denominator": denom, + "low_low_hits": int(np.sum(low_low)), + "low_low_rate": float(np.sum(low_low) / denom), + "high_high_hits": int(np.sum(high_high)), + "high_high_rate": float(np.sum(high_high) / denom), + "sr_mean": float(np.mean(ratio)), + } + + +def classify_zero_role(observed: dict[str, float | int], tests: dict[str, dict[str, float]]) -> str: + low_z = tests["low_low_zero_minus_nonzero"]["z"] + high_z = tests["high_high_zero_minus_nonzero"]["z"] + sr_z = tests["sr_zero_minus_nonzero"]["z"] + passes = [ + abs(low_z) >= 2 and tests["low_low_zero_minus_nonzero"]["p_two_sided"] <= 0.05, + abs(high_z) >= 2 and tests["high_high_zero_minus_nonzero"]["p_two_sided"] <= 0.05, + abs(sr_z) >= 2 and tests["sr_zero_minus_nonzero"]["p_two_sided"] <= 0.05, + ] + low = float(observed["low_low_zero_rate"]) + high = float(observed["high_high_zero_rate"]) + sr = float(observed["sr_zero_mean"]) + low_a = float(observed["low_low_aligned_rate"]) + low_m = float(observed["low_low_misaligned_rate"]) + high_a = float(observed["high_high_aligned_rate"]) + high_m = float(observed["high_high_misaligned_rate"]) + sr_a = float(observed["sr_aligned_mean"]) + sr_m = float(observed["sr_misaligned_mean"]) + + between_low = min(low_a, low_m) <= low <= max(low_a, low_m) + between_high = min(high_a, high_m) <= high <= max(high_a, high_m) + between_sr = min(sr_a, sr_m) <= sr <= max(sr_a, sr_m) + + if any(passes) and (between_low or between_high or between_sr): + return "boundary" + if any(passes): + return "third_class" + return "noise_under_this_null" + + +def run_condition( + primes: np.ndarray, + mu: np.ndarray, + n_primes: int, + offset: int, + rng: np.random.Generator, + permutations: int, +) -> dict[str, object]: + segment = primes[offset : offset + n_primes + 1] + gaps = np.diff(segment) + charges = interval_charges(segment, mu) + observed = transition_metrics_three_class(gaps, charges) + tests = permutation_test(gaps, charges, observed, rng, permutations) + return { + "n_primes": n_primes, + "offset": offset, + "prime_start": int(segment[0]), + "prime_stop": int(segment[-1]), + "zero_charge_count": int(np.sum(charges == 0)), + "charge_count": int(charges.size), + "observed": observed, + "permutation_tests": tests, + "zero_role": classify_zero_role(observed, tests), + "det_m_direct_control": det_m_direct_control(gaps), + } + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--limit", type=int, default=1_000_000) + parser.add_argument("--permutations", type=int, default=400) + parser.add_argument("--seed", type=int, default=2108) + parser.add_argument("--out", default="tools/data/prime_mobius_zero_mediator_gate_20260508_2108.json") + args = parser.parse_args() + + primes = sieve_primes(args.limit) + mu = mobius_sieve(args.limit) + rng = np.random.default_rng(args.seed) + + conditions = [ + {"n_primes": 5_000, "offset": 0}, + {"n_primes": 10_000, "offset": 0}, + {"n_primes": 20_000, "offset": 0}, + {"n_primes": 5_000, "offset": 3_000}, + {"n_primes": 10_000, "offset": 7_000}, + {"n_primes": 20_000, "offset": 11_000}, + ] + max_needed = max(c["offset"] + c["n_primes"] + 1 for c in conditions) + if len(primes) <= max_needed: + raise SystemExit(f"limit={args.limit} yields only {len(primes)} primes, need {max_needed}") + + results = [ + run_condition(primes, mu, c["n_primes"], c["offset"], rng, args.permutations) + for c in conditions + ] + summary = [] + for result in results: + tests = result["permutation_tests"] + summary.append( + { + "n_primes": result["n_primes"], + "offset": result["offset"], + "low_low_aligned_minus_misaligned_pass": abs(tests["low_low_aligned_minus_misaligned"]["z"]) >= 2.0 + and tests["low_low_aligned_minus_misaligned"]["p_two_sided"] <= 0.05, + "high_high_aligned_minus_misaligned_pass": abs(tests["high_high_aligned_minus_misaligned"]["z"]) >= 2.0 + and tests["high_high_aligned_minus_misaligned"]["p_two_sided"] <= 0.05, + "sr_aligned_minus_misaligned_pass": abs(tests["sr_aligned_minus_misaligned"]["z"]) >= 2.0 + and tests["sr_aligned_minus_misaligned"]["p_two_sided"] <= 0.05, + "zero_role": result["zero_role"], + } + ) + + payload = { + "experiment": "prime_mobius_zero_mediator_gate", + "question": "Does S=0 behave as noise, boundary, or mediator in the Mobius interval-charge gate?", + "threshold_ex_ante": "|z|>=2 and permutation p<=0.05 across main and offset conditions", + "null": "Permutation of the interval-charge sequence preserves the full charge multiset and therefore preserves zero frequency.", + "limit": args.limit, + "permutations": args.permutations, + "seed": args.seed, + "conditions": results, + "significance_summary": summary, + } + + out = Path(args.out) + out.parent.mkdir(parents=True, exist_ok=True) + out.write_text(json.dumps(payload, indent=2), encoding="utf-8") + + for result in results: + obs = result["observed"] + tests = result["permutation_tests"] + print( + f"N={result['n_primes']} offset={result['offset']} " + f"a/m/z={obs['aligned_count']}/{obs['misaligned_count']}/{obs['zero_count']} " + f"low_am={obs['low_low_aligned_minus_misaligned']:.5f} z={tests['low_low_aligned_minus_misaligned']['z']:.2f} p={tests['low_low_aligned_minus_misaligned']['p_two_sided']:.3f} " + f"low_z0={obs['low_low_zero_minus_nonzero']:.5f} z={tests['low_low_zero_minus_nonzero']['z']:.2f} p={tests['low_low_zero_minus_nonzero']['p_two_sided']:.3f} " + f"high_am={obs['high_high_aligned_minus_misaligned']:.5f} z={tests['high_high_aligned_minus_misaligned']['z']:.2f} p={tests['high_high_aligned_minus_misaligned']['p_two_sided']:.3f} " + f"high_z0={obs['high_high_zero_minus_nonzero']:.5f} z={tests['high_high_zero_minus_nonzero']['z']:.2f} p={tests['high_high_zero_minus_nonzero']['p_two_sided']:.3f} " + f"sr_am={obs['sr_aligned_minus_misaligned']:.5f} z={tests['sr_aligned_minus_misaligned']['z']:.2f} p={tests['sr_aligned_minus_misaligned']['p_two_sided']:.3f} " + f"role={result['zero_role']}" + ) + print(f"wrote {out}") + + +if __name__ == "__main__": + main() diff --git a/tools/exp_prime_mobius_zero_mediator_gate.py b/tools/exp_prime_mobius_zero_mediator_gate.py new file mode 100644 index 0000000000000000000000000000000000000000..95ecd6e07c1863f3ffd3a3a5297a8628a00fd8be --- /dev/null +++ b/tools/exp_prime_mobius_zero_mediator_gate.py @@ -0,0 +1,314 @@ +#!/usr/bin/env python3 +"""Prime x Mobius zero-mediator gate. + +Repairs the 20260508_2102 interval-charge gate by keeping transitions with +S=0 in the denominator as an explicit third class. +""" +from __future__ import annotations + +import argparse +import json +from pathlib import Path + +import numpy as np + +from exp_prime_mobius_interval_charge_gate import ( + interval_charges, + mobius_sieve, + sieve_primes, +) + + +METRIC_KEYS = [ + "low_low_aligned_rate", + "low_low_misaligned_rate", + "low_low_zero_rate", + "high_high_aligned_rate", + "high_high_misaligned_rate", + "high_high_zero_rate", + "sr_aligned_mean", + "sr_misaligned_mean", + "sr_zero_mean", + "low_low_aligned_minus_misaligned", + "low_low_zero_minus_nonzero", + "high_high_aligned_minus_misaligned", + "high_high_zero_minus_nonzero", + "sr_aligned_minus_misaligned", + "sr_zero_minus_nonzero", +] + + +def _rate(mask: np.ndarray, event: np.ndarray) -> tuple[int, int, float]: + denom = int(np.sum(mask)) + hits = int(np.sum(mask & event)) + rate = float(hits / denom) if denom else float("nan") + return hits, denom, rate + + +def _mean(mask: np.ndarray, values: np.ndarray) -> tuple[int, float]: + denom = int(np.sum(mask)) + mean = float(np.mean(values[mask])) if denom else float("nan") + return denom, mean + + +def transition_metrics_three_class(gaps: np.ndarray, charges: np.ndarray) -> dict[str, float | int]: + left = charges[:-1] + right = charges[1:] + product = left * right + aligned = product < 0 + misaligned = product > 0 + zero = product == 0 + nonzero = ~zero + + g0 = gaps[:-1].astype(float) + g1 = gaps[1:].astype(float) + ratio = np.minimum(g0, g1) / np.maximum(g0, g1) + low_low = (g0 <= 6) & (g1 <= 6) + q75 = float(np.quantile(gaps, 0.75)) + high_high = (g0 >= q75) & (g1 >= q75) + + metrics: dict[str, float | int] = { + "q75_gap": q75, + "aligned_count": int(np.sum(aligned)), + "misaligned_count": int(np.sum(misaligned)), + "zero_count": int(np.sum(zero)), + "nonzero_count": int(np.sum(nonzero)), + } + + for name, event in (("low_low", low_low), ("high_high", high_high)): + for cls_name, mask in ( + ("aligned", aligned), + ("misaligned", misaligned), + ("zero", zero), + ("nonzero", nonzero), + ): + hits, denom, rate = _rate(mask, event) + metrics[f"{name}_{cls_name}_hits"] = hits + metrics[f"{name}_{cls_name}_denom"] = denom + metrics[f"{name}_{cls_name}_rate"] = rate + + for cls_name, mask in ( + ("aligned", aligned), + ("misaligned", misaligned), + ("zero", zero), + ("nonzero", nonzero), + ): + denom, mean = _mean(mask, ratio) + metrics[f"sr_{cls_name}_denom"] = denom + metrics[f"sr_{cls_name}_mean"] = mean + + metrics["low_low_aligned_minus_misaligned"] = ( + float(metrics["low_low_aligned_rate"]) - float(metrics["low_low_misaligned_rate"]) + ) + metrics["high_high_aligned_minus_misaligned"] = ( + float(metrics["high_high_aligned_rate"]) - float(metrics["high_high_misaligned_rate"]) + ) + metrics["sr_aligned_minus_misaligned"] = ( + float(metrics["sr_aligned_mean"]) - float(metrics["sr_misaligned_mean"]) + ) + metrics["low_low_zero_minus_nonzero"] = ( + float(metrics["low_low_zero_rate"]) - float(metrics["low_low_nonzero_rate"]) + ) + metrics["high_high_zero_minus_nonzero"] = ( + float(metrics["high_high_zero_rate"]) - float(metrics["high_high_nonzero_rate"]) + ) + metrics["sr_zero_minus_nonzero"] = ( + float(metrics["sr_zero_mean"]) - float(metrics["sr_nonzero_mean"]) + ) + return metrics + + +def permutation_test( + gaps: np.ndarray, + charges: np.ndarray, + observed: dict[str, float | int], + rng: np.random.Generator, + permutations: int, +) -> dict[str, dict[str, float]]: + nulls = {key: [] for key in METRIC_KEYS} + for _ in range(permutations): + shuffled = np.array(charges, copy=True) + rng.shuffle(shuffled) + metrics = transition_metrics_three_class(gaps, shuffled) + for key in METRIC_KEYS: + nulls[key].append(float(metrics[key])) + + out: dict[str, dict[str, float]] = {} + for key, values in nulls.items(): + arr = np.array(values, dtype=float) + obs = float(observed[key]) + finite = np.isfinite(arr) + arr = arr[finite] + if arr.size == 0 or not np.isfinite(obs): + out[key] = {"observed": obs, "null_mean": float("nan"), "null_std": float("nan"), "z": float("nan"), "p_two_sided": float("nan")} + continue + std = float(np.std(arr, ddof=1)) + z = (obs - float(np.mean(arr))) / std if std > 0 else 0.0 + p = float((np.sum(np.abs(arr) >= abs(obs)) + 1) / (len(arr) + 1)) + out[key] = { + "observed": obs, + "null_mean": float(np.mean(arr)), + "null_std": std, + "z": float(z), + "p_two_sided": p, + } + return out + + +def det_m_direct_control(gaps: np.ndarray) -> dict[str, float | int | str]: + g0 = gaps[:-1].astype(float) + g1 = gaps[1:].astype(float) + ratio = np.minimum(g0, g1) / np.maximum(g0, g1) + low_low = (g0 <= 6) & (g1 <= 6) + q75 = float(np.quantile(gaps, 0.75)) + high_high = (g0 >= q75) & (g1 >= q75) + denom = int(g0.size) + return { + "det_M": -1, + "class_count": 1, + "reason": "M=[[1,1],[1,0]] has constant determinant -1 on every transition, so direct det(M) does not partition the denominator.", + "denominator": denom, + "low_low_hits": int(np.sum(low_low)), + "low_low_rate": float(np.sum(low_low) / denom), + "high_high_hits": int(np.sum(high_high)), + "high_high_rate": float(np.sum(high_high) / denom), + "sr_mean": float(np.mean(ratio)), + } + + +def classify_zero_role(observed: dict[str, float | int], tests: dict[str, dict[str, float]]) -> str: + low_z = tests["low_low_zero_minus_nonzero"]["z"] + high_z = tests["high_high_zero_minus_nonzero"]["z"] + sr_z = tests["sr_zero_minus_nonzero"]["z"] + passes = [ + abs(low_z) >= 2 and tests["low_low_zero_minus_nonzero"]["p_two_sided"] <= 0.05, + abs(high_z) >= 2 and tests["high_high_zero_minus_nonzero"]["p_two_sided"] <= 0.05, + abs(sr_z) >= 2 and tests["sr_zero_minus_nonzero"]["p_two_sided"] <= 0.05, + ] + low = float(observed["low_low_zero_rate"]) + high = float(observed["high_high_zero_rate"]) + sr = float(observed["sr_zero_mean"]) + low_a = float(observed["low_low_aligned_rate"]) + low_m = float(observed["low_low_misaligned_rate"]) + high_a = float(observed["high_high_aligned_rate"]) + high_m = float(observed["high_high_misaligned_rate"]) + sr_a = float(observed["sr_aligned_mean"]) + sr_m = float(observed["sr_misaligned_mean"]) + + between_low = min(low_a, low_m) <= low <= max(low_a, low_m) + between_high = min(high_a, high_m) <= high <= max(high_a, high_m) + between_sr = min(sr_a, sr_m) <= sr <= max(sr_a, sr_m) + + if any(passes) and (between_low or between_high or between_sr): + return "boundary" + if any(passes): + return "third_class" + return "noise_under_this_null" + + +def run_condition( + primes: np.ndarray, + mu: np.ndarray, + n_primes: int, + offset: int, + rng: np.random.Generator, + permutations: int, +) -> dict[str, object]: + segment = primes[offset : offset + n_primes + 1] + gaps = np.diff(segment) + charges = interval_charges(segment, mu) + observed = transition_metrics_three_class(gaps, charges) + tests = permutation_test(gaps, charges, observed, rng, permutations) + return { + "n_primes": n_primes, + "offset": offset, + "prime_start": int(segment[0]), + "prime_stop": int(segment[-1]), + "zero_charge_count": int(np.sum(charges == 0)), + "charge_count": int(charges.size), + "observed": observed, + "permutation_tests": tests, + "zero_role": classify_zero_role(observed, tests), + "det_m_direct_control": det_m_direct_control(gaps), + } + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--limit", type=int, default=1_000_000) + parser.add_argument("--permutations", type=int, default=400) + parser.add_argument("--seed", type=int, default=2108) + parser.add_argument("--out", default="tools/data/prime_mobius_zero_mediator_gate_20260508_2108.json") + args = parser.parse_args() + + primes = sieve_primes(args.limit) + mu = mobius_sieve(args.limit) + rng = np.random.default_rng(args.seed) + + conditions = [ + {"n_primes": 5_000, "offset": 0}, + {"n_primes": 10_000, "offset": 0}, + {"n_primes": 20_000, "offset": 0}, + {"n_primes": 5_000, "offset": 3_000}, + {"n_primes": 10_000, "offset": 7_000}, + {"n_primes": 20_000, "offset": 11_000}, + ] + max_needed = max(c["offset"] + c["n_primes"] + 1 for c in conditions) + if len(primes) <= max_needed: + raise SystemExit(f"limit={args.limit} yields only {len(primes)} primes, need {max_needed}") + + results = [ + run_condition(primes, mu, c["n_primes"], c["offset"], rng, args.permutations) + for c in conditions + ] + summary = [] + for result in results: + tests = result["permutation_tests"] + summary.append( + { + "n_primes": result["n_primes"], + "offset": result["offset"], + "low_low_aligned_minus_misaligned_pass": abs(tests["low_low_aligned_minus_misaligned"]["z"]) >= 2.0 + and tests["low_low_aligned_minus_misaligned"]["p_two_sided"] <= 0.05, + "high_high_aligned_minus_misaligned_pass": abs(tests["high_high_aligned_minus_misaligned"]["z"]) >= 2.0 + and tests["high_high_aligned_minus_misaligned"]["p_two_sided"] <= 0.05, + "sr_aligned_minus_misaligned_pass": abs(tests["sr_aligned_minus_misaligned"]["z"]) >= 2.0 + and tests["sr_aligned_minus_misaligned"]["p_two_sided"] <= 0.05, + "zero_role": result["zero_role"], + } + ) + + payload = { + "experiment": "prime_mobius_zero_mediator_gate", + "question": "Does S=0 behave as noise, boundary, or mediator in the Mobius interval-charge gate?", + "threshold_ex_ante": "|z|>=2 and permutation p<=0.05 across main and offset conditions", + "null": "Permutation of the interval-charge sequence preserves the full charge multiset and therefore preserves zero frequency.", + "limit": args.limit, + "permutations": args.permutations, + "seed": args.seed, + "conditions": results, + "significance_summary": summary, + } + + out = Path(args.out) + out.parent.mkdir(parents=True, exist_ok=True) + out.write_text(json.dumps(payload, indent=2), encoding="utf-8") + + for result in results: + obs = result["observed"] + tests = result["permutation_tests"] + print( + f"N={result['n_primes']} offset={result['offset']} " + f"a/m/z={obs['aligned_count']}/{obs['misaligned_count']}/{obs['zero_count']} " + f"low_am={obs['low_low_aligned_minus_misaligned']:.5f} z={tests['low_low_aligned_minus_misaligned']['z']:.2f} p={tests['low_low_aligned_minus_misaligned']['p_two_sided']:.3f} " + f"low_z0={obs['low_low_zero_minus_nonzero']:.5f} z={tests['low_low_zero_minus_nonzero']['z']:.2f} p={tests['low_low_zero_minus_nonzero']['p_two_sided']:.3f} " + f"high_am={obs['high_high_aligned_minus_misaligned']:.5f} z={tests['high_high_aligned_minus_misaligned']['z']:.2f} p={tests['high_high_aligned_minus_misaligned']['p_two_sided']:.3f} " + f"high_z0={obs['high_high_zero_minus_nonzero']:.5f} z={tests['high_high_zero_minus_nonzero']['z']:.2f} p={tests['high_high_zero_minus_nonzero']['p_two_sided']:.3f} " + f"sr_am={obs['sr_aligned_minus_misaligned']:.5f} z={tests['sr_aligned_minus_misaligned']['z']:.2f} p={tests['sr_aligned_minus_misaligned']['p_two_sided']:.3f} " + f"role={result['zero_role']}" + ) + print(f"wrote {out}") + + +if __name__ == "__main__": + main() codex Lo strumento è stato aggiunto. Ora lo eseguo con il perimetro del cycle sorgente (`p<=1e6`, sei condizioni, 400 permutazioni) e salvo il nuovo deposito dati `20260508_2108`. exec /bin/bash -lc 'python tools/exp_prime_mobius_zero_mediator_gate.py --limit 1000000 --permutations 400 --seed 2108 --out tools/data/prime_mobius_zero_mediator_gate_20260508_2108.json' in /opt/MM_D-ND diff --git a/tools/exp_prime_mobius_zero_mediator_gate.py b/tools/exp_prime_mobius_zero_mediator_gate.py new file mode 100644 index 0000000000000000000000000000000000000000..95ecd6e07c1863f3ffd3a3a5297a8628a00fd8be --- /dev/null +++ b/tools/exp_prime_mobius_zero_mediator_gate.py @@ -0,0 +1,314 @@ +#!/usr/bin/env python3 +"""Prime x Mobius zero-mediator gate. + +Repairs the 20260508_2102 interval-charge gate by keeping transitions with +S=0 in the denominator as an explicit third class. +""" +from __future__ import annotations + +import argparse +import json +from pathlib import Path + +import numpy as np + +from exp_prime_mobius_interval_charge_gate import ( + interval_charges, + mobius_sieve, + sieve_primes, +) + + +METRIC_KEYS = [ + "low_low_aligned_rate", + "low_low_misaligned_rate", + "low_low_zero_rate", + "high_high_aligned_rate", + "high_high_misaligned_rate", + "high_high_zero_rate", + "sr_aligned_mean", + "sr_misaligned_mean", + "sr_zero_mean", + "low_low_aligned_minus_misaligned", + "low_low_zero_minus_nonzero", + "high_high_aligned_minus_misaligned", + "high_high_zero_minus_nonzero", + "sr_aligned_minus_misaligned", + "sr_zero_minus_nonzero", +] + + +def _rate(mask: np.ndarray, event: np.ndarray) -> tuple[int, int, float]: + denom = int(np.sum(mask)) + hits = int(np.sum(mask & event)) + rate = float(hits / denom) if denom else float("nan") + return hits, denom, rate + + +def _mean(mask: np.ndarray, values: np.ndarray) -> tuple[int, float]: + denom = int(np.sum(mask)) + mean = float(np.mean(values[mask])) if denom else float("nan") + return denom, mean + + +def transition_metrics_three_class(gaps: np.ndarray, charges: np.ndarray) -> dict[str, float | int]: + left = charges[:-1] + right = charges[1:] + product = left * right + aligned = product < 0 + misaligned = product > 0 + zero = product == 0 + nonzero = ~zero + + g0 = gaps[:-1].astype(float) + g1 = gaps[1:].astype(float) + ratio = np.minimum(g0, g1) / np.maximum(g0, g1) + low_low = (g0 <= 6) & (g1 <= 6) + q75 = float(np.quantile(gaps, 0.75)) + high_high = (g0 >= q75) & (g1 >= q75) + + metrics: dict[str, float | int] = { + "q75_gap": q75, + "aligned_count": int(np.sum(aligned)), + "misaligned_count": int(np.sum(misaligned)), + "zero_count": int(np.sum(zero)), + "nonzero_count": int(np.sum(nonzero)), + } + + for name, event in (("low_low", low_low), ("high_high", high_high)): + for cls_name, mask in ( + ("aligned", aligned), + ("misaligned", misaligned), + ("zero", zero), + ("nonzero", nonzero), + ): + hits, denom, rate = _rate(mask, event) + metrics[f"{name}_{cls_name}_hits"] = hits + metrics[f"{name}_{cls_name}_denom"] = denom + metrics[f"{name}_{cls_name}_rate"] = rate + + for cls_name, mask in ( + ("aligned", aligned), + ("misaligned", misaligned), + ("zero", zero), + ("nonzero", nonzero), + ): + denom, mean = _mean(mask, ratio) + metrics[f"sr_{cls_name}_denom"] = denom + metrics[f"sr_{cls_name}_mean"] = mean + + metrics["low_low_aligned_minus_misaligned"] = ( + float(metrics["low_low_aligned_rate"]) - float(metrics["low_low_misaligned_rate"]) + ) + metrics["high_high_aligned_minus_misaligned"] = ( + float(metrics["high_high_aligned_rate"]) - float(metrics["high_high_misaligned_rate"]) + ) + metrics["sr_aligned_minus_misaligned"] = ( + float(metrics["sr_aligned_mean"]) - float(metrics["sr_misaligned_mean"]) + ) + metrics["low_low_zero_minus_nonzero"] = ( + float(metrics["low_low_zero_rate"]) - float(metrics["low_low_nonzero_rate"]) + ) + metrics["high_high_zero_minus_nonzero"] = ( + float(metrics["high_high_zero_rate"]) - float(metrics["high_high_nonzero_rate"]) + ) + metrics["sr_zero_minus_nonzero"] = ( + float(metrics["sr_zero_mean"]) - float(metrics["sr_nonzero_mean"]) + ) + return metrics + + +def permutation_test( + gaps: np.ndarray, + charges: np.ndarray, + observed: dict[str, float | int], + rng: np.random.Generator, + permutations: int, +) -> dict[str, dict[str, float]]: + nulls = {key: [] for key in METRIC_KEYS} + for _ in range(permutations): + shuffled = np.array(charges, copy=True) + rng.shuffle(shuffled) + metrics = transition_metrics_three_class(gaps, shuffled) + for key in METRIC_KEYS: + nulls[key].append(float(metrics[key])) + + out: dict[str, dict[str, float]] = {} + for key, values in nulls.items(): + arr = np.array(values, dtype=float) + obs = float(observed[key]) + finite = np.isfinite(arr) + arr = arr[finite] + if arr.size == 0 or not np.isfinite(obs): + out[key] = {"observed": obs, "null_mean": float("nan"), "null_std": float("nan"), "z": float("nan"), "p_two_sided": float("nan")} + continue + std = float(np.std(arr, ddof=1)) + z = (obs - float(np.mean(arr))) / std if std > 0 else 0.0 + p = float((np.sum(np.abs(arr) >= abs(obs)) + 1) / (len(arr) + 1)) + out[key] = { + "observed": obs, + "null_mean": float(np.mean(arr)), + "null_std": std, + "z": float(z), + "p_two_sided": p, + } + return out + + +def det_m_direct_control(gaps: np.ndarray) -> dict[str, float | int | str]: + g0 = gaps[:-1].astype(float) + g1 = gaps[1:].astype(float) + ratio = np.minimum(g0, g1) / np.maximum(g0, g1) + low_low = (g0 <= 6) & (g1 <= 6) + q75 = float(np.quantile(gaps, 0.75)) + high_high = (g0 >= q75) & (g1 >= q75) + denom = int(g0.size) + return { + "det_M": -1, + "class_count": 1, + "reason": "M=[[1,1],[1,0]] has constant determinant -1 on every transition, so direct det(M) does not partition the denominator.", + "denominator": denom, + "low_low_hits": int(np.sum(low_low)), + "low_low_rate": float(np.sum(low_low) / denom), + "high_high_hits": int(np.sum(high_high)), + "high_high_rate": float(np.sum(high_high) / denom), + "sr_mean": float(np.mean(ratio)), + } + + +def classify_zero_role(observed: dict[str, float | int], tests: dict[str, dict[str, float]]) -> str: + low_z = tests["low_low_zero_minus_nonzero"]["z"] + high_z = tests["high_high_zero_minus_nonzero"]["z"] + sr_z = tests["sr_zero_minus_nonzero"]["z"] + passes = [ + abs(low_z) >= 2 and tests["low_low_zero_minus_nonzero"]["p_two_sided"] <= 0.05, + abs(high_z) >= 2 and tests["high_high_zero_minus_nonzero"]["p_two_sided"] <= 0.05, + abs(sr_z) >= 2 and tests["sr_zero_minus_nonzero"]["p_two_sided"] <= 0.05, + ] + low = float(observed["low_low_zero_rate"]) + high = float(observed["high_high_zero_rate"]) + sr = float(observed["sr_zero_mean"]) + low_a = float(observed["low_low_aligned_rate"]) + low_m = float(observed["low_low_misaligned_rate"]) + high_a = float(observed["high_high_aligned_rate"]) + high_m = float(observed["high_high_misaligned_rate"]) + sr_a = float(observed["sr_aligned_mean"]) + sr_m = float(observed["sr_misaligned_mean"]) + + between_low = min(low_a, low_m) <= low <= max(low_a, low_m) + between_high = min(high_a, high_m) <= high <= max(high_a, high_m) + between_sr = min(sr_a, sr_m) <= sr <= max(sr_a, sr_m) + + if any(passes) and (between_low or between_high or between_sr): + return "boundary" + if any(passes): + return "third_class" + return "noise_under_this_null" + + +def run_condition( + primes: np.ndarray, + mu: np.ndarray, + n_primes: int, + offset: int, + rng: np.random.Generator, + permutations: int, +) -> dict[str, object]: + segment = primes[offset : offset + n_primes + 1] + gaps = np.diff(segment) + charges = interval_charges(segment, mu) + observed = transition_metrics_three_class(gaps, charges) + tests = permutation_test(gaps, charges, observed, rng, permutations) + return { + "n_primes": n_primes, + "offset": offset, + "prime_start": int(segment[0]), + "prime_stop": int(segment[-1]), + "zero_charge_count": int(np.sum(charges == 0)), + "charge_count": int(charges.size), + "observed": observed, + "permutation_tests": tests, + "zero_role": classify_zero_role(observed, tests), + "det_m_direct_control": det_m_direct_control(gaps), + } + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--limit", type=int, default=1_000_000) + parser.add_argument("--permutations", type=int, default=400) + parser.add_argument("--seed", type=int, default=2108) + parser.add_argument("--out", default="tools/data/prime_mobius_zero_mediator_gate_20260508_2108.json") + args = parser.parse_args() + + primes = sieve_primes(args.limit) + mu = mobius_sieve(args.limit) + rng = np.random.default_rng(args.seed) + + conditions = [ + {"n_primes": 5_000, "offset": 0}, + {"n_primes": 10_000, "offset": 0}, + {"n_primes": 20_000, "offset": 0}, + {"n_primes": 5_000, "offset": 3_000}, + {"n_primes": 10_000, "offset": 7_000}, + {"n_primes": 20_000, "offset": 11_000}, + ] + max_needed = max(c["offset"] + c["n_primes"] + 1 for c in conditions) + if len(primes) <= max_needed: + raise SystemExit(f"limit={args.limit} yields only {len(primes)} primes, need {max_needed}") + + results = [ + run_condition(primes, mu, c["n_primes"], c["offset"], rng, args.permutations) + for c in conditions + ] + summary = [] + for result in results: + tests = result["permutation_tests"] + summary.append( + { + "n_primes": result["n_primes"], + "offset": result["offset"], + "low_low_aligned_minus_misaligned_pass": abs(tests["low_low_aligned_minus_misaligned"]["z"]) >= 2.0 + and tests["low_low_aligned_minus_misaligned"]["p_two_sided"] <= 0.05, + "high_high_aligned_minus_misaligned_pass": abs(tests["high_high_aligned_minus_misaligned"]["z"]) >= 2.0 + and tests["high_high_aligned_minus_misaligned"]["p_two_sided"] <= 0.05, + "sr_aligned_minus_misaligned_pass": abs(tests["sr_aligned_minus_misaligned"]["z"]) >= 2.0 + and tests["sr_aligned_minus_misaligned"]["p_two_sided"] <= 0.05, + "zero_role": result["zero_role"], + } + ) + + payload = { + "experiment": "prime_mobius_zero_mediator_gate", + "question": "Does S=0 behave as noise, boundary, or mediator in the Mobius interval-charge gate?", + "threshold_ex_ante": "|z|>=2 and permutation p<=0.05 across main and offset conditions", + "null": "Permutation of the interval-charge sequence preserves the full charge multiset and therefore preserves zero frequency.", + "limit": args.limit, + "permutations": args.permutations, + "seed": args.seed, + "conditions": results, + "significance_summary": summary, + } + + out = Path(args.out) + out.parent.mkdir(parents=True, exist_ok=True) + out.write_text(json.dumps(payload, indent=2), encoding="utf-8") + + for result in results: + obs = result["observed"] + tests = result["permutation_tests"] + print( + f"N={result['n_primes']} offset={result['offset']} " + f"a/m/z={obs['aligned_count']}/{obs['misaligned_count']}/{obs['zero_count']} " + f"low_am={obs['low_low_aligned_minus_misaligned']:.5f} z={tests['low_low_aligned_minus_misaligned']['z']:.2f} p={tests['low_low_aligned_minus_misaligned']['p_two_sided']:.3f} " + f"low_z0={obs['low_low_zero_minus_nonzero']:.5f} z={tests['low_low_zero_minus_nonzero']['z']:.2f} p={tests['low_low_zero_minus_nonzero']['p_two_sided']:.3f} " + f"high_am={obs['high_high_aligned_minus_misaligned']:.5f} z={tests['high_high_aligned_minus_misaligned']['z']:.2f} p={tests['high_high_aligned_minus_misaligned']['p_two_sided']:.3f} " + f"high_z0={obs['high_high_zero_minus_nonzero']:.5f} z={tests['high_high_zero_minus_nonzero']['z']:.2f} p={tests['high_high_zero_minus_nonzero']['p_two_sided']:.3f} " + f"sr_am={obs['sr_aligned_minus_misaligned']:.5f} z={tests['sr_aligned_minus_misaligned']['z']:.2f} p={tests['sr_aligned_minus_misaligned']['p_two_sided']:.3f} " + f"role={result['zero_role']}" + ) + print(f"wrote {out}") + + +if __name__ == "__main__": + main() succeeded in 2097ms: N=5000 offset=0 a/m/z=1200/1572/2227 low_am=0.04422 z=2.47 p=0.015 low_z0=0.15838 z=11.77 p=0.002 high_am=-0.09373 z=-7.96 p=0.002 high_z0=-0.10364 z=-10.80 p=0.002 sr_am=-0.01053 z=-1.12 p=0.277 role=third_class N=10000 offset=0 a/m/z=2541/3102/4356 low_am=0.03706 z=3.44 p=0.002 low_z0=0.13496 z=14.88 p=0.002 high_am=-0.05681 z=-8.90 p=0.002 high_z0=-0.06527 z=-12.31 p=0.002 sr_am=-0.00661 z=-0.90 p=0.357 role=third_class N=20000 offset=0 a/m/z=5171/6331/8497 low_am=0.03138 z=4.56 p=0.002 low_z0=0.12939 z=22.31 p=0.002 high_am=-0.05707 z=-10.48 p=0.002 high_z0=-0.07995 z=-18.75 p=0.002 sr_am=-0.00827 z=-1.78 p=0.097 role=third_class N=5000 offset=3000 a/m/z=1313/1525/2161 low_am=0.03391 z=2.37 p=0.022 low_z0=0.11964 z=9.84 p=0.002 high_am=-0.05712 z=-5.66 p=0.002 high_z0=-0.06334 z=-8.13 p=0.002 sr_am=0.00433 z=0.48 p=0.671 role=third_class N=10000 offset=7000 a/m/z=2675/3178/4146 low_am=0.02399 z=2.68 p=0.010 low_z0=0.12344 z=16.40 p=0.002 high_am=-0.04241 z=-6.58 p=0.002 high_z0=-0.06743 z=-13.27 p=0.002 sr_am=-0.00504 z=-0.71 p=0.501 role=third_class N=20000 offset=11000 a/m/z=5407/6413/8179 low_am=0.01386 z=1.97 p=0.040 low_z0=0.11799 z=20.63 p=0.002 high_am=-0.04945 z=-10.96 p=0.002 high_z0=-0.05962 z=-16.22 p=0.002 sr_am=-0.01274 z=-2.50 p=0.015 role=third_class wrote tools/data/prime_mobius_zero_mediator_gate_20260508_2108.json diff --git a/tools/exp_prime_mobius_zero_mediator_gate.py b/tools/exp_prime_mobius_zero_mediator_gate.py new file mode 100644 index 0000000000000000000000000000000000000000..95ecd6e07c1863f3ffd3a3a5297a8628a00fd8be --- /dev/null +++ b/tools/exp_prime_mobius_zero_mediator_gate.py @@ -0,0 +1,314 @@ +#!/usr/bin/env python3 +"""Prime x Mobius zero-mediator gate. + +Repairs the 20260508_2102 interval-charge gate by keeping transitions with +S=0 in the denominator as an explicit third class. +""" +from __future__ import annotations + +import argparse +import json +from pathlib import Path + +import numpy as np + +from exp_prime_mobius_interval_charge_gate import ( + interval_charges, + mobius_sieve, + sieve_primes, +) + + +METRIC_KEYS = [ + "low_low_aligned_rate", + "low_low_misaligned_rate", + "low_low_zero_rate", + "high_high_aligned_rate", + "high_high_misaligned_rate", + "high_high_zero_rate", + "sr_aligned_mean", + "sr_misaligned_mean", + "sr_zero_mean", + "low_low_aligned_minus_misaligned", + "low_low_zero_minus_nonzero", + "high_high_aligned_minus_misaligned", + "high_high_zero_minus_nonzero", + "sr_aligned_minus_misaligned", + "sr_zero_minus_nonzero", +] + + +def _rate(mask: np.ndarray, event: np.ndarray) -> tuple[int, int, float]: + denom = int(np.sum(mask)) + hits = int(np.sum(mask & event)) + rate = float(hits / denom) if denom else float("nan") + return hits, denom, rate + + +def _mean(mask: np.ndarray, values: np.ndarray) -> tuple[int, float]: + denom = int(np.sum(mask)) + mean = float(np.mean(values[mask])) if denom else float("nan") + return denom, mean + + +def transition_metrics_three_class(gaps: np.ndarray, charges: np.ndarray) -> dict[str, float | int]: + left = charges[:-1] + right = charges[1:] + product = left * right + aligned = product < 0 + misaligned = product > 0 + zero = product == 0 + nonzero = ~zero + + g0 = gaps[:-1].astype(float) + g1 = gaps[1:].astype(float) + ratio = np.minimum(g0, g1) / np.maximum(g0, g1) + low_low = (g0 <= 6) & (g1 <= 6) + q75 = float(np.quantile(gaps, 0.75)) + high_high = (g0 >= q75) & (g1 >= q75) + + metrics: dict[str, float | int] = { + "q75_gap": q75, + "aligned_count": int(np.sum(aligned)), + "misaligned_count": int(np.sum(misaligned)), + "zero_count": int(np.sum(zero)), + "nonzero_count": int(np.sum(nonzero)), + } + + for name, event in (("low_low", low_low), ("high_high", high_high)): + for cls_name, mask in ( + ("aligned", aligned), + ("misaligned", misaligned), + ("zero", zero), + ("nonzero", nonzero), + ): + hits, denom, rate = _rate(mask, event) + metrics[f"{name}_{cls_name}_hits"] = hits + metrics[f"{name}_{cls_name}_denom"] = denom + metrics[f"{name}_{cls_name}_rate"] = rate + + for cls_name, mask in ( + ("aligned", aligned), + ("misaligned", misaligned), + ("zero", zero), + ("nonzero", nonzero), + ): + denom, mean = _mean(mask, ratio) + metrics[f"sr_{cls_name}_denom"] = denom + metrics[f"sr_{cls_name}_mean"] = mean + + metrics["low_low_aligned_minus_misaligned"] = ( + float(metrics["low_low_aligned_rate"]) - float(metrics["low_low_misaligned_rate"]) + ) + metrics["high_high_aligned_minus_misaligned"] = ( + float(metrics["high_high_aligned_rate"]) - float(metrics["high_high_misaligned_rate"]) + ) + metrics["sr_aligned_minus_misaligned"] = ( + float(metrics["sr_aligned_mean"]) - float(metrics["sr_misaligned_mean"]) + ) + metrics["low_low_zero_minus_nonzero"] = ( + float(metrics["low_low_zero_rate"]) - float(metrics["low_low_nonzero_rate"]) + ) + metrics["high_high_zero_minus_nonzero"] = ( + float(metrics["high_high_zero_rate"]) - float(metrics["high_high_nonzero_rate"]) + ) + metrics["sr_zero_minus_nonzero"] = ( + float(metrics["sr_zero_mean"]) - float(metrics["sr_nonzero_mean"]) + ) + return metrics + + +def permutation_test( + gaps: np.ndarray, + charges: np.ndarray, + observed: dict[str, float | int], + rng: np.random.Generator, + permutations: int, +) -> dict[str, dict[str, float]]: + nulls = {key: [] for key in METRIC_KEYS} + for _ in range(permutations): + shuffled = np.array(charges, copy=True) + rng.shuffle(shuffled) + metrics = transition_metrics_three_class(gaps, shuffled) + for key in METRIC_KEYS: + nulls[key].append(float(metrics[key])) + + out: dict[str, dict[str, float]] = {} + for key, values in nulls.items(): + arr = np.array(values, dtype=float) + obs = float(observed[key]) + finite = np.isfinite(arr) + arr = arr[finite] + if arr.size == 0 or not np.isfinite(obs): + out[key] = {"observed": obs, "null_mean": float("nan"), "null_std": float("nan"), "z": float("nan"), "p_two_sided": float("nan")} + continue + std = float(np.std(arr, ddof=1)) + z = (obs - float(np.mean(arr))) / std if std > 0 else 0.0 + p = float((np.sum(np.abs(arr) >= abs(obs)) + 1) / (len(arr) + 1)) + out[key] = { + "observed": obs, + "null_mean": float(np.mean(arr)), + "null_std": std, + "z": float(z), + "p_two_sided": p, + } + return out + + +def det_m_direct_control(gaps: np.ndarray) -> dict[str, float | int | str]: + g0 = gaps[:-1].astype(float) + g1 = gaps[1:].astype(float) + ratio = np.minimum(g0, g1) / np.maximum(g0, g1) + low_low = (g0 <= 6) & (g1 <= 6) + q75 = float(np.quantile(gaps, 0.75)) + high_high = (g0 >= q75) & (g1 >= q75) + denom = int(g0.size) + return { + "det_M": -1, + "class_count": 1, + "reason": "M=[[1,1],[1,0]] has constant determinant -1 on every transition, so direct det(M) does not partition the denominator.", + "denominator": denom, + "low_low_hits": int(np.sum(low_low)), + "low_low_rate": float(np.sum(low_low) / denom), + "high_high_hits": int(np.sum(high_high)), + "high_high_rate": float(np.sum(high_high) / denom), + "sr_mean": float(np.mean(ratio)), + } + + +def classify_zero_role(observed: dict[str, float | int], tests: dict[str, dict[str, float]]) -> str: + low_z = tests["low_low_zero_minus_nonzero"]["z"] + high_z = tests["high_high_zero_minus_nonzero"]["z"] + sr_z = tests["sr_zero_minus_nonzero"]["z"] + passes = [ + abs(low_z) >= 2 and tests["low_low_zero_minus_nonzero"]["p_two_sided"] <= 0.05, + abs(high_z) >= 2 and tests["high_high_zero_minus_nonzero"]["p_two_sided"] <= 0.05, + abs(sr_z) >= 2 and tests["sr_zero_minus_nonzero"]["p_two_sided"] <= 0.05, + ] + low = float(observed["low_low_zero_rate"]) + high = float(observed["high_high_zero_rate"]) + sr = float(observed["sr_zero_mean"]) + low_a = float(observed["low_low_aligned_rate"]) + low_m = float(observed["low_low_misaligned_rate"]) + high_a = float(observed["high_high_aligned_rate"]) + high_m = float(observed["high_high_misaligned_rate"]) + sr_a = float(observed["sr_aligned_mean"]) + sr_m = float(observed["sr_misaligned_mean"]) + + between_low = min(low_a, low_m) <= low <= max(low_a, low_m) + between_high = min(high_a, high_m) <= high <= max(high_a, high_m) + between_sr = min(sr_a, sr_m) <= sr <= max(sr_a, sr_m) + + if any(passes) and (between_low or between_high or between_sr): + return "boundary" + if any(passes): + return "third_class" + return "noise_under_this_null" + + +def run_condition( + primes: np.ndarray, + mu: np.ndarray, + n_primes: int, + offset: int, + rng: np.random.Generator, + permutations: int, +) -> dict[str, object]: + segment = primes[offset : offset + n_primes + 1] + gaps = np.diff(segment) + charges = interval_charges(segment, mu) + observed = transition_metrics_three_class(gaps, charges) + tests = permutation_test(gaps, charges, observed, rng, permutations) + return { + "n_primes": n_primes, + "offset": offset, + "prime_start": int(segment[0]), + "prime_stop": int(segment[-1]), + "zero_charge_count": int(np.sum(charges == 0)), + "charge_count": int(charges.size), + "observed": observed, + "permutation_tests": tests, + "zero_role": classify_zero_role(observed, tests), + "det_m_direct_control": det_m_direct_control(gaps), + } + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--limit", type=int, default=1_000_000) + parser.add_argument("--permutations", type=int, default=400) + parser.add_argument("--seed", type=int, default=2108) + parser.add_argument("--out", default="tools/data/prime_mobius_zero_mediator_gate_20260508_2108.json") + args = parser.parse_args() + + primes = sieve_primes(args.limit) + mu = mobius_sieve(args.limit) + rng = np.random.default_rng(args.seed) + + conditions = [ + {"n_primes": 5_000, "offset": 0}, + {"n_primes": 10_000, "offset": 0}, + {"n_primes": 20_000, "offset": 0}, + {"n_primes": 5_000, "offset": 3_000}, + {"n_primes": 10_000, "offset": 7_000}, + {"n_primes": 20_000, "offset": 11_000}, + ] + max_needed = max(c["offset"] + c["n_primes"] + 1 for c in conditions) + if len(primes) <= max_needed: + raise SystemExit(f"limit={args.limit} yields only {len(primes)} primes, need {max_needed}") + + results = [ + run_condition(primes, mu, c["n_primes"], c["offset"], rng, args.permutations) + for c in conditions + ] + summary = [] + for result in results: + tests = result["permutation_tests"] + summary.append( + { + "n_primes": result["n_primes"], + "offset": result["offset"], + "low_low_aligned_minus_misaligned_pass": abs(tests["low_low_aligned_minus_misaligned"]["z"]) >= 2.0 + and tests["low_low_aligned_minus_misaligned"]["p_two_sided"] <= 0.05, + "high_high_aligned_minus_misaligned_pass": abs(tests["high_high_aligned_minus_misaligned"]["z"]) >= 2.0 + and tests["high_high_aligned_minus_misaligned"]["p_two_sided"] <= 0.05, + "sr_aligned_minus_misaligned_pass": abs(tests["sr_aligned_minus_misaligned"]["z"]) >= 2.0 + and tests["sr_aligned_minus_misaligned"]["p_two_sided"] <= 0.05, + "zero_role": result["zero_role"], + } + ) + + payload = { + "experiment": "prime_mobius_zero_mediator_gate", + "question": "Does S=0 behave as noise, boundary, or mediator in the Mobius interval-charge gate?", + "threshold_ex_ante": "|z|>=2 and permutation p<=0.05 across main and offset conditions", + "null": "Permutation of the interval-charge sequence preserves the full charge multiset and therefore preserves zero frequency.", + "limit": args.limit, + "permutations": args.permutations, + "seed": args.seed, + "conditions": results, + "significance_summary": summary, + } + + out = Path(args.out) + out.parent.mkdir(parents=True, exist_ok=True) + out.write_text(json.dumps(payload, indent=2), encoding="utf-8") + + for result in results: + obs = result["observed"] + tests = result["permutation_tests"] + print( + f"N={result['n_primes']} offset={result['offset']} " + f"a/m/z={obs['aligned_count']}/{obs['misaligned_count']}/{obs['zero_count']} " + f"low_am={obs['low_low_aligned_minus_misaligned']:.5f} z={tests['low_low_aligned_minus_misaligned']['z']:.2f} p={tests['low_low_aligned_minus_misaligned']['p_two_sided']:.3f} " + f"low_z0={obs['low_low_zero_minus_nonzero']:.5f} z={tests['low_low_zero_minus_nonzero']['z']:.2f} p={tests['low_low_zero_minus_nonzero']['p_two_sided']:.3f} " + f"high_am={obs['high_high_aligned_minus_misaligned']:.5f} z={tests['high_high_aligned_minus_misaligned']['z']:.2f} p={tests['high_high_aligned_minus_misaligned']['p_two_sided']:.3f} " + f"high_z0={obs['high_high_zero_minus_nonzero']:.5f} z={tests['high_high_zero_minus_nonzero']['z']:.2f} p={tests['high_high_zero_minus_nonzero']['p_two_sided']:.3f} " + f"sr_am={obs['sr_aligned_minus_misaligned']:.5f} z={tests['sr_aligned_minus_misaligned']['z']:.2f} p={tests['sr_aligned_minus_misaligned']['p_two_sided']:.3f} " + f"role={result['zero_role']}" + ) + print(f"wrote {out}") + + +if __name__ == "__main__": + main() codex I risultati dicono che `S=0` non è rumore sotto questo null: è una terza classe con arricchimento low-low e soppressione high-high in 6/6 condizioni. Il contrasto aligned/misaligned resta forte su high-high, mentre su low-low scende a 5/6 se si richiede anche `|z|>=2` oltre al `p<=0.05`. exec /bin/bash -lc "python - <<'PY' import json p='tools/data/prime_mobius_zero_mediator_gate_20260508_2108.json' with open(p) as f: d=json.load(f) for c in d['conditions']: o=c['observed']; t=c['permutation_tests']; det=c['det_m_direct_control'] print(f\"N={c['n_primes']} off={c['offset']} prime={c['prime_start']}-{c['prime_stop']} zcharges={c['zero_charge_count']}/{c['charge_count']}\") print(f\" denom a/m/z {o['aligned_count']}/{o['misaligned_count']}/{o['zero_count']}\") print(f\" low rates a/m/z {o['low_low_aligned_hits']}/{o['low_low_aligned_denom']}={o['low_low_aligned_rate']:.5f} {o['low_low_misaligned_hits']}/{o['low_low_misaligned_denom']}={o['low_low_misaligned_rate']:.5f} {o['low_low_zero_hits']}/{o['low_low_zero_denom']}={o['low_low_zero_rate']:.5f}\") print(f\" high rates a/m/z {o['high_high_aligned_hits']}/{o['high_high_aligned_denom']}={o['high_high_aligned_rate']:.5f} {o['high_high_misaligned_hits']}/{o['high_high_misaligned_denom']}={o['high_high_misaligned_rate']:.5f} {o['high_high_zero_hits']}/{o['high_high_zero_denom']}={o['high_high_zero_rate']:.5f}\") print(f\" SR means a/m/z {o['sr_aligned_mean']:.5f} {o['sr_misaligned_mean']:.5f} {o['sr_zero_mean']:.5f}\") print(f\" tests low_am z/p {t['low_low_aligned_minus_misaligned']['z']:.2f}/{t['low_low_aligned_minus_misaligned']['p_two_sided']:.3f}; zero_nonzero low z/p {t['low_low_zero_minus_nonzero']['z']:.2f}/{t['low_low_zero_minus_nonzero']['p_two_sided']:.3f}\") print(f\" tests high_am z/p {t['high_high_aligned_minus_misaligned']['z']:.2f}/{t['high_high_aligned_minus_misaligned']['p_two_sided']:.3f}; zero_nonzero high z/p {t['high_high_zero_minus_nonzero']['z']:.2f}/{t['high_high_zero_minus_nonzero']['p_two_sided']:.3f}\") print(f\" tests sr_am z/p {t['sr_aligned_minus_misaligned']['z']:.2f}/{t['sr_aligned_minus_misaligned']['p_two_sided']:.3f}; zero_nonzero sr z/p {t['sr_zero_minus_nonzero']['z']:.2f}/{t['sr_zero_minus_nonzero']['p_two_sided']:.3f}\") print(f\" det {det['reason']} low={det['low_low_hits']}/{det['denominator']} high={det['high_high_hits']}/{det['denominator']} sr={det['sr_mean']:.5f}\") PY" in /opt/MM_D-ND succeeded in 0ms: N=5000 off=0 prime=2-48619 zcharges=1258/5000 denom a/m/z 1200/1572/2227 low rates a/m/z 221/1200=0.18417 220/1572=0.13995 707/2227=0.31747 high rates a/m/z 115/1200=0.09583 298/1572=0.18957 101/2227=0.04535 SR means a/m/z 0.51559 0.52611 0.43203 tests low_am z/p 2.47/0.015; zero_nonzero low z/p 11.77/0.002 tests high_am z/p -7.96/0.002; zero_nonzero high z/p -10.80/0.002 tests sr_am z/p -1.12/0.277; zero_nonzero sr z/p -11.15/0.002 det M=[[1,1],[1,0]] has constant determinant -1 on every transition, so direct det(M) does not partition the denominator. low=1148/4999 high=514/4999 sr=0.48167 N=10000 off=0 prime=2-104743 zcharges=2457/10000 denom a/m/z 2541/3102/4356 low rates a/m/z 403/2541=0.15860 377/3102=0.12153 1190/4356=0.27319 high rates a/m/z 153/2541=0.06021 363/3102=0.11702 114/4356=0.02617 SR means a/m/z 0.50841 0.51502 0.42221 tests low_am z/p 3.44/0.002; zero_nonzero low z/p 14.88/0.002 tests high_am z/p -8.90/0.002; zero_nonzero high z/p -12.31/0.002 tests sr_am z/p -0.90/0.357; zero_nonzero sr z/p -16.03/0.002 det M=[[1,1],[1,0]] has constant determinant -1 on every transition, so direct det(M) does not partition the denominator. low=1970/9999 high=630/9999 sr=0.47291 N=20000 off=0 prime=2-224743 zcharges=4782/20000 denom a/m/z 5171/6331/8497 low rates a/m/z 694/5171=0.13421 651/6331=0.10283 2093/8497=0.24632 high rates a/m/z 422/5171=0.08161 878/6331=0.13868 281/8497=0.03307 SR means a/m/z 0.50324 0.51151 0.41571 tests low_am z/p 4.56/0.002; zero_nonzero low z/p 22.31/0.002 tests high_am z/p -10.48/0.002; zero_nonzero high z/p -18.75/0.002 tests sr_am z/p -1.78/0.097; zero_nonzero sr z/p -23.13/0.002 det M=[[1,1],[1,0]] has constant determinant -1 on every transition, so direct det(M) does not partition the denominator. low=3438/19999 high=1581/19999 sr=0.46867 N=5000 off=3000 prime=27457-81817 zcharges=1219/5000 denom a/m/z 1313/1525/2161 low rates a/m/z 184/1313=0.14014 162/1525=0.10623 522/2161=0.24155 high rates a/m/z 86/1313=0.06550 187/1525=0.12262 71/2161=0.03286 SR means a/m/z 0.50993 0.50560 0.42213 tests low_am z/p 2.37/0.022; zero_nonzero low z/p 9.84/0.002 tests high_am z/p -5.66/0.002; zero_nonzero high z/p -8.13/0.002 tests sr_am z/p 0.48/0.671; zero_nonzero sr z/p -10.87/0.002 det M=[[1,1],[1,0]] has constant determinant -1 on every transition, so direct det(M) does not partition the denominator. low=868/4999 high=344/4999 sr=0.47066 N=10000 off=7000 prime=70663-187973 zcharges=2318/10000 denom a/m/z 2675/3178/4146 low rates a/m/z 315/2675=0.11776 298/3178=0.09377 946/4146=0.22817 high rates a/m/z 182/2675=0.06804 351/3178=0.11045 98/4146=0.02364 SR means a/m/z 0.50225 0.50729 0.40695 tests low_am z/p 2.68/0.010; zero_nonzero low z/p 16.40/0.002 tests high_am z/p -6.58/0.002; zero_nonzero high z/p -13.27/0.002 tests sr_am z/p -0.71/0.501; zero_nonzero sr z/p -17.18/0.002 det M=[[1,1],[1,0]] has constant determinant -1 on every transition, so direct det(M) does not partition the denominator. low=1559/9999 high=631/9999 sr=0.46434 N=20000 off=11000 prime=116461-363271 zcharges=4586/20000 denom a/m/z 5407/6413/8179 low rates a/m/z 553/5407=0.10227 567/6413=0.08841 1740/8179=0.21274 high rates a/m/z 295/5407=0.05456 667/6413=0.10401 178/8179=0.02176 SR means a/m/z 0.49723 0.50997 0.41131 tests low_am z/p 1.97/0.040; zero_nonzero low z/p 20.63/0.002 tests high_am z/p -10.96/0.002; zero_nonzero high z/p -16.22/0.002 tests sr_am z/p -2.50/0.015; zero_nonzero sr z/p -22.87/0.002 det M=[[1,1],[1,0]] has constant determinant -1 on every transition, so direct det(M) does not partition the denominator. low=2860/19999 high=1140/19999 sr=0.46618 diff --git a/tools/exp_prime_mobius_zero_mediator_gate.py b/tools/exp_prime_mobius_zero_mediator_gate.py new file mode 100644 index 0000000000000000000000000000000000000000..95ecd6e07c1863f3ffd3a3a5297a8628a00fd8be --- /dev/null +++ b/tools/exp_prime_mobius_zero_mediator_gate.py @@ -0,0 +1,314 @@ +#!/usr/bin/env python3 +"""Prime x Mobius zero-mediator gate. + +Repairs the 20260508_2102 interval-charge gate by keeping transitions with +S=0 in the denominator as an explicit third class. +""" +from __future__ import annotations + +import argparse +import json +from pathlib import Path + +import numpy as np + +from exp_prime_mobius_interval_charge_gate import ( + interval_charges, + mobius_sieve, + sieve_primes, +) + + +METRIC_KEYS = [ + "low_low_aligned_rate", + "low_low_misaligned_rate", + "low_low_zero_rate", + "high_high_aligned_rate", + "high_high_misaligned_rate", + "high_high_zero_rate", + "sr_aligned_mean", + "sr_misaligned_mean", + "sr_zero_mean", + "low_low_aligned_minus_misaligned", + "low_low_zero_minus_nonzero", + "high_high_aligned_minus_misaligned", + "high_high_zero_minus_nonzero", + "sr_aligned_minus_misaligned", + "sr_zero_minus_nonzero", +] + + +def _rate(mask: np.ndarray, event: np.ndarray) -> tuple[int, int, float]: + denom = int(np.sum(mask)) + hits = int(np.sum(mask & event)) + rate = float(hits / denom) if denom else float("nan") + return hits, denom, rate + + +def _mean(mask: np.ndarray, values: np.ndarray) -> tuple[int, float]: + denom = int(np.sum(mask)) + mean = float(np.mean(values[mask])) if denom else float("nan") + return denom, mean + + +def transition_metrics_three_class(gaps: np.ndarray, charges: np.ndarray) -> dict[str, float | int]: + left = charges[:-1] + right = charges[1:] + product = left * right + aligned = product < 0 + misaligned = product > 0 + zero = product == 0 + nonzero = ~zero + + g0 = gaps[:-1].astype(float) + g1 = gaps[1:].astype(float) + ratio = np.minimum(g0, g1) / np.maximum(g0, g1) + low_low = (g0 <= 6) & (g1 <= 6) + q75 = float(np.quantile(gaps, 0.75)) + high_high = (g0 >= q75) & (g1 >= q75) + + metrics: dict[str, float | int] = { + "q75_gap": q75, + "aligned_count": int(np.sum(aligned)), + "misaligned_count": int(np.sum(misaligned)), + "zero_count": int(np.sum(zero)), + "nonzero_count": int(np.sum(nonzero)), + } + + for name, event in (("low_low", low_low), ("high_high", high_high)): + for cls_name, mask in ( + ("aligned", aligned), + ("misaligned", misaligned), + ("zero", zero), + ("nonzero", nonzero), + ): + hits, denom, rate = _rate(mask, event) + metrics[f"{name}_{cls_name}_hits"] = hits + metrics[f"{name}_{cls_name}_denom"] = denom + metrics[f"{name}_{cls_name}_rate"] = rate + + for cls_name, mask in ( + ("aligned", aligned), + ("misaligned", misaligned), + ("zero", zero), + ("nonzero", nonzero), + ): + denom, mean = _mean(mask, ratio) + metrics[f"sr_{cls_name}_denom"] = denom + metrics[f"sr_{cls_name}_mean"] = mean + + metrics["low_low_aligned_minus_misaligned"] = ( + float(metrics["low_low_aligned_rate"]) - float(metrics["low_low_misaligned_rate"]) + ) + metrics["high_high_aligned_minus_misaligned"] = ( + float(metrics["high_high_aligned_rate"]) - float(metrics["high_high_misaligned_rate"]) + ) + metrics["sr_aligned_minus_misaligned"] = ( + float(metrics["sr_aligned_mean"]) - float(metrics["sr_misaligned_mean"]) + ) + metrics["low_low_zero_minus_nonzero"] = ( + float(metrics["low_low_zero_rate"]) - float(metrics["low_low_nonzero_rate"]) + ) + metrics["high_high_zero_minus_nonzero"] = ( + float(metrics["high_high_zero_rate"]) - float(metrics["high_high_nonzero_rate"]) + ) + metrics["sr_zero_minus_nonzero"] = ( + float(metrics["sr_zero_mean"]) - float(metrics["sr_nonzero_mean"]) + ) + return metrics + + +def permutation_test( + gaps: np.ndarray, + charges: np.ndarray, + observed: dict[str, float | int], + rng: np.random.Generator, + permutations: int, +) -> dict[str, dict[str, float]]: + nulls = {key: [] for key in METRIC_KEYS} + for _ in range(permutations): + shuffled = np.array(charges, copy=True) + rng.shuffle(shuffled) + metrics = transition_metrics_three_class(gaps, shuffled) + for key in METRIC_KEYS: + nulls[key].append(float(metrics[key])) + + out: dict[str, dict[str, float]] = {} + for key, values in nulls.items(): + arr = np.array(values, dtype=float) + obs = float(observed[key]) + finite = np.isfinite(arr) + arr = arr[finite] + if arr.size == 0 or not np.isfinite(obs): + out[key] = {"observed": obs, "null_mean": float("nan"), "null_std": float("nan"), "z": float("nan"), "p_two_sided": float("nan")} + continue + std = float(np.std(arr, ddof=1)) + z = (obs - float(np.mean(arr))) / std if std > 0 else 0.0 + p = float((np.sum(np.abs(arr) >= abs(obs)) + 1) / (len(arr) + 1)) + out[key] = { + "observed": obs, + "null_mean": float(np.mean(arr)), + "null_std": std, + "z": float(z), + "p_two_sided": p, + } + return out + + +def det_m_direct_control(gaps: np.ndarray) -> dict[str, float | int | str]: + g0 = gaps[:-1].astype(float) + g1 = gaps[1:].astype(float) + ratio = np.minimum(g0, g1) / np.maximum(g0, g1) + low_low = (g0 <= 6) & (g1 <= 6) + q75 = float(np.quantile(gaps, 0.75)) + high_high = (g0 >= q75) & (g1 >= q75) + denom = int(g0.size) + return { + "det_M": -1, + "class_count": 1, + "reason": "M=[[1,1],[1,0]] has constant determinant -1 on every transition, so direct det(M) does not partition the denominator.", + "denominator": denom, + "low_low_hits": int(np.sum(low_low)), + "low_low_rate": float(np.sum(low_low) / denom), + "high_high_hits": int(np.sum(high_high)), + "high_high_rate": float(np.sum(high_high) / denom), + "sr_mean": float(np.mean(ratio)), + } + + +def classify_zero_role(observed: dict[str, float | int], tests: dict[str, dict[str, float]]) -> str: + low_z = tests["low_low_zero_minus_nonzero"]["z"] + high_z = tests["high_high_zero_minus_nonzero"]["z"] + sr_z = tests["sr_zero_minus_nonzero"]["z"] + passes = [ + abs(low_z) >= 2 and tests["low_low_zero_minus_nonzero"]["p_two_sided"] <= 0.05, + abs(high_z) >= 2 and tests["high_high_zero_minus_nonzero"]["p_two_sided"] <= 0.05, + abs(sr_z) >= 2 and tests["sr_zero_minus_nonzero"]["p_two_sided"] <= 0.05, + ] + low = float(observed["low_low_zero_rate"]) + high = float(observed["high_high_zero_rate"]) + sr = float(observed["sr_zero_mean"]) + low_a = float(observed["low_low_aligned_rate"]) + low_m = float(observed["low_low_misaligned_rate"]) + high_a = float(observed["high_high_aligned_rate"]) + high_m = float(observed["high_high_misaligned_rate"]) + sr_a = float(observed["sr_aligned_mean"]) + sr_m = float(observed["sr_misaligned_mean"]) + + between_low = min(low_a, low_m) <= low <= max(low_a, low_m) + between_high = min(high_a, high_m) <= high <= max(high_a, high_m) + between_sr = min(sr_a, sr_m) <= sr <= max(sr_a, sr_m) + + if any(passes) and (between_low or between_high or between_sr): + return "boundary" + if any(passes): + return "third_class" + return "noise_under_this_null" + + +def run_condition( + primes: np.ndarray, + mu: np.ndarray, + n_primes: int, + offset: int, + rng: np.random.Generator, + permutations: int, +) -> dict[str, object]: + segment = primes[offset : offset + n_primes + 1] + gaps = np.diff(segment) + charges = interval_charges(segment, mu) + observed = transition_metrics_three_class(gaps, charges) + tests = permutation_test(gaps, charges, observed, rng, permutations) + return { + "n_primes": n_primes, + "offset": offset, + "prime_start": int(segment[0]), + "prime_stop": int(segment[-1]), + "zero_charge_count": int(np.sum(charges == 0)), + "charge_count": int(charges.size), + "observed": observed, + "permutation_tests": tests, + "zero_role": classify_zero_role(observed, tests), + "det_m_direct_control": det_m_direct_control(gaps), + } + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--limit", type=int, default=1_000_000) + parser.add_argument("--permutations", type=int, default=400) + parser.add_argument("--seed", type=int, default=2108) + parser.add_argument("--out", default="tools/data/prime_mobius_zero_mediator_gate_20260508_2108.json") + args = parser.parse_args() + + primes = sieve_primes(args.limit) + mu = mobius_sieve(args.limit) + rng = np.random.default_rng(args.seed) + + conditions = [ + {"n_primes": 5_000, "offset": 0}, + {"n_primes": 10_000, "offset": 0}, + {"n_primes": 20_000, "offset": 0}, + {"n_primes": 5_000, "offset": 3_000}, + {"n_primes": 10_000, "offset": 7_000}, + {"n_primes": 20_000, "offset": 11_000}, + ] + max_needed = max(c["offset"] + c["n_primes"] + 1 for c in conditions) + if len(primes) <= max_needed: + raise SystemExit(f"limit={args.limit} yields only {len(primes)} primes, need {max_needed}") + + results = [ + run_condition(primes, mu, c["n_primes"], c["offset"], rng, args.permutations) + for c in conditions + ] + summary = [] + for result in results: + tests = result["permutation_tests"] + summary.append( + { + "n_primes": result["n_primes"], + "offset": result["offset"], + "low_low_aligned_minus_misaligned_pass": abs(tests["low_low_aligned_minus_misaligned"]["z"]) >= 2.0 + and tests["low_low_aligned_minus_misaligned"]["p_two_sided"] <= 0.05, + "high_high_aligned_minus_misaligned_pass": abs(tests["high_high_aligned_minus_misaligned"]["z"]) >= 2.0 + and tests["high_high_aligned_minus_misaligned"]["p_two_sided"] <= 0.05, + "sr_aligned_minus_misaligned_pass": abs(tests["sr_aligned_minus_misaligned"]["z"]) >= 2.0 + and tests["sr_aligned_minus_misaligned"]["p_two_sided"] <= 0.05, + "zero_role": result["zero_role"], + } + ) + + payload = { + "experiment": "prime_mobius_zero_mediator_gate", + "question": "Does S=0 behave as noise, boundary, or mediator in the Mobius interval-charge gate?", + "threshold_ex_ante": "|z|>=2 and permutation p<=0.05 across main and offset conditions", + "null": "Permutation of the interval-charge sequence preserves the full charge multiset and therefore preserves zero frequency.", + "limit": args.limit, + "permutations": args.permutations, + "seed": args.seed, + "conditions": results, + "significance_summary": summary, + } + + out = Path(args.out) + out.parent.mkdir(parents=True, exist_ok=True) + out.write_text(json.dumps(payload, indent=2), encoding="utf-8") + + for result in results: + obs = result["observed"] + tests = result["permutation_tests"] + print( + f"N={result['n_primes']} offset={result['offset']} " + f"a/m/z={obs['aligned_count']}/{obs['misaligned_count']}/{obs['zero_count']} " + f"low_am={obs['low_low_aligned_minus_misaligned']:.5f} z={tests['low_low_aligned_minus_misaligned']['z']:.2f} p={tests['low_low_aligned_minus_misaligned']['p_two_sided']:.3f} " + f"low_z0={obs['low_low_zero_minus_nonzero']:.5f} z={tests['low_low_zero_minus_nonzero']['z']:.2f} p={tests['low_low_zero_minus_nonzero']['p_two_sided']:.3f} " + f"high_am={obs['high_high_aligned_minus_misaligned']:.5f} z={tests['high_high_aligned_minus_misaligned']['z']:.2f} p={tests['high_high_aligned_minus_misaligned']['p_two_sided']:.3f} " + f"high_z0={obs['high_high_zero_minus_nonzero']:.5f} z={tests['high_high_zero_minus_nonzero']['z']:.2f} p={tests['high_high_zero_minus_nonzero']['p_two_sided']:.3f} " + f"sr_am={obs['sr_aligned_minus_misaligned']:.5f} z={tests['sr_aligned_minus_misaligned']['z']:.2f} p={tests['sr_aligned_minus_misaligned']['p_two_sided']:.3f} " + f"role={result['zero_role']}" + ) + print(f"wrote {out}") + + +if __name__ == "__main__": + main() codex Scrivo il report nuovo con verdict scoped: non promuovo il ciclo 2102, dichiaro il claim corretto e separo i tre osservabili. Il controllo `det(M)` viene riportato come controllo esplicito: non partiziona il denominatore perché `det(M)=-1` è costante. apply patch patch: completed /opt/MM_D-ND/tools/data/reports/agent_20260508_2108.md diff --git a/tools/data/reports/agent_20260508_2108.md b/tools/data/reports/agent_20260508_2108.md new file mode 100644 index 0000000000000000000000000000000000000000..d3b8fa5889b9587b0e01270608220848eb4d5ed7 --- /dev/null +++ b/tools/data/reports/agent_20260508_2108.md @@ -0,0 +1,103 @@ +# Agent Report - Prime Mobius Zero-Mediator Gate +**Date**: 2026-05-08 21:08 +**Piano**: 93 +**Tension explored**: DUALITA_DIPOLARE_VS_ILLUSORIA (0.9) +**verdict**: CONSTRAINT +observables_registry: 1.0.0-2026-05-06 +observables_used: [low_low_rate, high_high_rate, SR, det_M_direct_control] +**observable_contract**: claim=lo zero della carica Mobius intervallare e' testato come terzo incluso del gate aligned/misaligned; observable=rate low_low, rate high_high, SR mean per classi aligned/misaligned/zero; operator=classificazione di S_n*S_{n+1}: aligned<0, misaligned>0, zero=0; generator=prime gaps up to p<=1e6 with Mobius sieve; denominator=main N={5000,10000,20000} offset=0 plus seedcheck offsets {3000,7000,11000}; not_tested=gap_ratio Sturmian, high-core phi survival, universal GUE/Poisson classification. + +## Respiro fuori-tempo +- **Combo**: A2 confine det=-1 + A9 terzo incluso + A11 combo + QxG continuo/discreto vuoto + DUALITA_DIPOLARE_VS_ILLUSORIA + piano primi x Mobius. Il repair non cerca un lettore nuovo: riporta nel denominatore il punto escluso dal source cycle, `S=0`. +- **Dipolo / punto-zero**: carica Mobius alternata / carica Mobius concorde; punto-zero = transizione con almeno un intervallo a carica nulla (`S_n*S_{n+1}=0`). +- **Piano superiore**: boundary operator su grafo aritmetico. Il gap e' bordo tra primi; la carica Mobius del vuoto tra primi decide se il bordo e' solo rumore di lunghezza o classe informativa. +- **Operatori laterali scelti**: boundary operator, random walk, entropia. Boundary operator definisce il bordo prime-free; random walk fornisce il null di permutazione della carica; entropia entra come dispersione del vuoto senza primi. +- **Contaminazione cognitiva**: + - **CE-0117**: usato per non promuovere il source cycle e far passare il risultato da potenziale a vincolo misurato. + - **CE-0038**: usato per riportare la forma nel Nulla-Tutto al vuoto aritmetico, qui lo zero `S=0`. + - **CE-0001 / KSAR**: usato come kernel reiterativo del ciclo 2102, con riparazione regressiva sul denominatore. + - **PVI attack**: il segnale puo' essere effetto di lunghezza del gap; per questo il null permuta l'intera sequenza delle cariche preservando multiset e frequenza degli zeri. +- **Proto-ipotesi**: se `S=0` e' terzo incluso operativo, non cade come rumore sotto il null che preserva la frequenza degli zeri. Deve produrre una classe distinguibile su low_low/high_high/SR. Se resta dentro il null, il source cycle sopravvive solo come gate binario non-zero. +- **Proiezione**: confronto aligned, misaligned e zero su `low_low`, `high_high` e `SR`; null = 400 permutazioni della sequenza `S_n`, gap invariati, multiset delle cariche invariata. + +## Claim Under Test +> Nel perimetro primi x Mobius fino a `p<=1e6`, le transizioni con `S=0` non vanno escluse: formano una terza classe del gate intervallare e vanno confrontate contro aligned/misaligned con null che preserva la frequenza degli zeri. + +## Question +Lo zero della carica Mobius intervallare e' rumore, boundary o mediatore del segnale low-low/high-high/SR? + +## Experiment Design +- Script: `tools/exp_prime_mobius_zero_mediator_gate.py`. +- Dati: primi fino a `1_000_000`; Mobius sieve sullo stesso perimetro. +- Carica intervallare: `S_n = sum(mu(k))` per `p_n < k < p_{n+1}`. +- Classi: + - `aligned`: `S_n*S_{n+1}<0`. + - `misaligned`: `S_n*S_{n+1}>0`. + - `zero`: `S_n*S_{n+1}=0`. +- Osservabili: + - `low_low_rate`: count di due gap consecutivi `<=6` sul denominatore della classe. + - `high_high_rate`: count di due gap consecutivi `>=q75` sul denominatore della classe. + - `SR`: mean min/max ratio dei gap consecutivi. +- Null test: 400 permutazioni della sequenza `S_n`; il null preserva la multiset completa delle cariche e quindi la frequenza degli zeri. +- Controllo det(M) diretto: `M=[[1,1],[1,0]]` ha `det(M)=-1` costante su ogni transizione; il controllo non partiziona il denominatore e restituisce solo le baseline globali low/high/SR. +- Soglia ex ante: `|z|>=2` e `p_two_sided<=0.05`. +- Contratto osservabile-operatore: `gap_ratio` Sturmian non testato; il source cycle 2102 non viene promosso; il claim su det diretto viene sostituito da controllo esplicito, non da conclusione non misurata. + +## Results +| condition | a/m/z denom | zero charges | low a | low m | low z | low z0 vs nonzero z/p | high a | high m | high z | high z0 vs nonzero z/p | SR a | SR m | SR z | SR z0 vs nonzero z/p | +|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:| +| N=5000 off=0 | 1200/1572/2227 | 1258/5000 | 221/1200 | 220/1572 | 707/2227 | 11.77 / 0.002 | 115/1200 | 298/1572 | 101/2227 | -10.80 / 0.002 | 0.51559 | 0.52611 | 0.43203 | -11.15 / 0.002 | +| N=10000 off=0 | 2541/3102/4356 | 2457/10000 | 403/2541 | 377/3102 | 1190/4356 | 14.88 / 0.002 | 153/2541 | 363/3102 | 114/4356 | -12.31 / 0.002 | 0.50841 | 0.51502 | 0.42221 | -16.03 / 0.002 | +| N=20000 off=0 | 5171/6331/8497 | 4782/20000 | 694/5171 | 651/6331 | 2093/8497 | 22.31 / 0.002 | 422/5171 | 878/6331 | 281/8497 | -18.75 / 0.002 | 0.50324 | 0.51151 | 0.41571 | -23.13 / 0.002 | +| N=5000 off=3000 | 1313/1525/2161 | 1219/5000 | 184/1313 | 162/1525 | 522/2161 | 9.84 / 0.002 | 86/1313 | 187/1525 | 71/2161 | -8.13 / 0.002 | 0.50993 | 0.50560 | 0.42213 | -10.87 / 0.002 | +| N=10000 off=7000 | 2675/3178/4146 | 2318/10000 | 315/2675 | 298/3178 | 946/4146 | 16.40 / 0.002 | 182/2675 | 351/3178 | 98/4146 | -13.27 / 0.002 | 0.50225 | 0.50729 | 0.40695 | -17.18 / 0.002 | +| N=20000 off=11000 | 5407/6413/8179 | 4586/20000 | 553/5407 | 567/6413 | 1740/8179 | 20.63 / 0.002 | 295/5407 | 667/6413 | 178/8179 | -16.22 / 0.002 | 0.49723 | 0.50997 | 0.41131 | -22.87 / 0.002 | + +### Pairwise aligned/misaligned checks +| condition | low a-m diff z/p | high a-m diff z/p | SR a-m diff z/p | +|---|---:|---:|---:| +| N=5000 off=0 | +0.04422 2.47 / 0.015 | -0.09373 -7.96 / 0.002 | -0.01053 -1.12 / 0.277 | +| N=10000 off=0 | +0.03706 3.44 / 0.002 | -0.05681 -8.90 / 0.002 | -0.00661 -0.90 / 0.357 | +| N=20000 off=0 | +0.03138 4.56 / 0.002 | -0.05707 -10.48 / 0.002 | -0.00827 -1.78 / 0.097 | +| N=5000 off=3000 | +0.03391 2.37 / 0.022 | -0.05712 -5.66 / 0.002 | +0.00433 0.48 / 0.671 | +| N=10000 off=7000 | +0.02399 2.68 / 0.010 | -0.04241 -6.58 / 0.002 | -0.00504 -0.71 / 0.501 | +| N=20000 off=11000 | +0.01386 1.97 / 0.040 | -0.04945 -10.96 / 0.002 | -0.01274 -2.50 / 0.015 | + +### det(M) direct control +`det(M)=-1` e' costante. Il controllo ha una sola classe su ogni condizione, quindi non separa aligned/misaligned/zero. Baseline globali: low_low `1148/4999`, `1970/9999`, `3438/19999`, `868/4999`, `1559/9999`, `2860/19999`; high_high `514/4999`, `630/9999`, `1581/19999`, `344/4999`, `631/9999`, `1140/19999`; SR globale `0.48167`, `0.47291`, `0.46867`, `0.47066`, `0.46434`, `0.46618`. + +## Key Findings +1. **Verificato: lo zero non e' rumore sotto il null usato.** La classe zero supera il null in 6/6 condizioni su `low_low_zero_minus_nonzero`, `high_high_zero_minus_nonzero` e `sr_zero_minus_nonzero`, sempre con `p=0.002` e `|z|` da `8.13` a `23.13`. + +2. **Verificato: lo zero e' una terza classe, non un mediatore tra aligned e misaligned.** Su low_low lo zero e' sopra entrambe le classi non-zero (`0.21274..0.31747` contro aligned `0.10227..0.18417` e misaligned `0.08841..0.13995`). Su high_high lo zero e' sotto entrambe (`0.02176..0.04535` contro aligned `0.05456..0.09583` e misaligned `0.10401..0.18957`). Su SR lo zero e' sotto entrambe (`0.40695..0.43203` contro non-zero circa `0.49723..0.52611`). Il punto-zero non sta tra i poli: genera una classe propria. + +3. **Verificato: il contrasto aligned/misaligned sopravvive soprattutto su high_high.** `high_high_aligned_minus_misaligned` passa 6/6 con z da `-5.66` a `-10.96`. `low_low_aligned_minus_misaligned` passa 5/6 se la soglia richiede anche `|z|>=2`; l'ultima condizione ha `z=1.97`, `p=0.040`, quindi resta borderline e non autorizza hard wording. SR passa 1/6 e resta osservabile secondario. + +4. **Verificato: il controllo det(M) diretto risolve il flag L3 del source cycle.** `det(M)` costante non produce partizione del denominatore; il report non conclude che la dualita "non si legge" da det diretto come fatto empirico generale. Qui dichiara solo che, in questo controllo, det(M) diretto non e' un discriminatore di classe. + +## Verdict +**CONSTRAINT on DUALITA_DIPOLARE_VS_ILLUSORIA / Prime Mobius interval-charge gate**: nel perimetro primi x Mobius fino a `p<=1e6`, `S=0` deve restare nel denominatore come terza classe. Lo zero non e' rumore sotto il null di permutazione che preserva frequenza degli zeri: arricchisce low_low, sopprime high_high e abbassa SR in 6/6 condizioni. Il source cycle sopravvive come vincolo parziale: il gate non-zero aligned/misaligned resta solido per high_high, resta parziale per low_low, e non porta SR globalmente. Il nuovo portatore e' triadico: aligned / misaligned / zero. + +## Bicono della scoperta +- **Due radici**: carica non-zero alternata/concorde . carica zero dell'intervallo prime-free. +- **Singolare**: il vuoto tra primi prima della scelta binaria; `S=0` non e' assenza di segnale ma classe del bordo. +- **Invariante di passaggio**: il null conserva gap, multiset delle cariche e frequenza degli zeri; cio' che sopravvive e' l'accoppiamento ordine-carica, non la sola presenza dello zero. +- **Campo di possibilita**: qui diventa possibile testare un gate triadico del boundary aritmetico. Qui diventa non-possibile escludere `S=0` dal denominatore quando si parla di terzo incluso nel perimetro Mobius-primi. + +## Consecutio +Il prossimo passo deve separare terza classe autentica da effetto scala dell'intervallo: ripetere il gate con controllo che preserva anche la lunghezza del gap o stratifica per bucket di gap length. Se lo zero resta significativo dentro ogni bucket, il boundary e' aritmetico; se cade, il segnale e' dipendenza da lunghezza. + +## Auto-audit: source flags e 5 lenti +- **Source L3 resolved**: il report non usa un elemento `not_tested` come conclusione. Il controllo det(M) diretto e' misurato e dichiarato non partizionante nel perimetro. +- **Source denominator repair resolved**: `S=0` e' incluso come classe esplicita, con count grezzi e denominatore. +- **Aperto**: non e' ancora separata la dipendenza dalla lunghezza del gap; serve controllo stratificato. +- **L1 hard constraint vs bias**: nessun "sempre/mai"; perimetro dichiarato `p<=1e6`, sei condizioni, 400 permutazioni. +- **L2 quantita vs ratio**: count grezzi e denominatori riportati; SR separato dai rate. +- **L3 no silent patching**: claim corretto prima del test; il source cycle non viene promosso. +- **L4 edge cases**: `low_low` non-zero e' borderline in una condizione (`z=1.97`), quindi resta parziale. +- **L5 re-discovery vs discovery**: verdict `CONSTRAINT`, non `NEW`; il pattern resta da confrontare con dipendenze note tra Mobius, lunghezza intervallare e gap primes. + +## Files +- Script: `tools/exp_prime_mobius_zero_mediator_gate.py` +- Data: `tools/data/prime_mobius_zero_mediator_gate_20260508_2108.json` +- Report: `tools/data/reports/agent_20260508_2108.md` diff --git a/tools/exp_prime_mobius_zero_mediator_gate.py b/tools/exp_prime_mobius_zero_mediator_gate.py new file mode 100644 index 0000000000000000000000000000000000000000..95ecd6e07c1863f3ffd3a3a5297a8628a00fd8be --- /dev/null +++ b/tools/exp_prime_mobius_zero_mediator_gate.py @@ -0,0 +1,314 @@ +#!/usr/bin/env python3 +"""Prime x Mobius zero-mediator gate. + +Repairs the 20260508_2102 interval-charge gate by keeping transitions with +S=0 in the denominator as an explicit third class. +""" +from __future__ import annotations + +import argparse +import json +from pathlib import Path + +import numpy as np + +from exp_prime_mobius_interval_charge_gate import ( + interval_charges, + mobius_sieve, + sieve_primes, +) + + +METRIC_KEYS = [ + "low_low_aligned_rate", + "low_low_misaligned_rate", + "low_low_zero_rate", + "high_high_aligned_rate", + "high_high_misaligned_rate", + "high_high_zero_rate", + "sr_aligned_mean", + "sr_misaligned_mean", + "sr_zero_mean", + "low_low_aligned_minus_misaligned", + "low_low_zero_minus_nonzero", + "high_high_aligned_minus_misaligned", + "high_high_zero_minus_nonzero", + "sr_aligned_minus_misaligned", + "sr_zero_minus_nonzero", +] + + +def _rate(mask: np.ndarray, event: np.ndarray) -> tuple[int, int, float]: + denom = int(np.sum(mask)) + hits = int(np.sum(mask & event)) + rate = float(hits / denom) if denom else float("nan") + return hits, denom, rate + + +def _mean(mask: np.ndarray, values: np.ndarray) -> tuple[int, float]: + denom = int(np.sum(mask)) + mean = float(np.mean(values[mask])) if denom else float("nan") + return denom, mean + + +def transition_metrics_three_class(gaps: np.ndarray, charges: np.ndarray) -> dict[str, float | int]: + left = charges[:-1] + right = charges[1:] + product = left * right + aligned = product < 0 + misaligned = product > 0 + zero = product == 0 + nonzero = ~zero + + g0 = gaps[:-1].astype(float) + g1 = gaps[1:].astype(float) + ratio = np.minimum(g0, g1) / np.maximum(g0, g1) + low_low = (g0 <= 6) & (g1 <= 6) + q75 = float(np.quantile(gaps, 0.75)) + high_high = (g0 >= q75) & (g1 >= q75) + + metrics: dict[str, float | int] = { + "q75_gap": q75, + "aligned_count": int(np.sum(aligned)), + "misaligned_count": int(np.sum(misaligned)), + "zero_count": int(np.sum(zero)), + "nonzero_count": int(np.sum(nonzero)), + } + + for name, event in (("low_low", low_low), ("high_high", high_high)): + for cls_name, mask in ( + ("aligned", aligned), + ("misaligned", misaligned), + ("zero", zero), + ("nonzero", nonzero), + ): + hits, denom, rate = _rate(mask, event) + metrics[f"{name}_{cls_name}_hits"] = hits + metrics[f"{name}_{cls_name}_denom"] = denom + metrics[f"{name}_{cls_name}_rate"] = rate + + for cls_name, mask in ( + ("aligned", aligned), + ("misaligned", misaligned), + ("zero", zero), + ("nonzero", nonzero), + ): + denom, mean = _mean(mask, ratio) + metrics[f"sr_{cls_name}_denom"] = denom + metrics[f"sr_{cls_name}_mean"] = mean + + metrics["low_low_aligned_minus_misaligned"] = ( + float(metrics["low_low_aligned_rate"]) - float(metrics["low_low_misaligned_rate"]) + ) + metrics["high_high_aligned_minus_misaligned"] = ( + float(metrics["high_high_aligned_rate"]) - float(metrics["high_high_misaligned_rate"]) + ) + metrics["sr_aligned_minus_misaligned"] = ( + float(metrics["sr_aligned_mean"]) - float(metrics["sr_misaligned_mean"]) + ) + metrics["low_low_zero_minus_nonzero"] = ( + float(metrics["low_low_zero_rate"]) - float(metrics["low_low_nonzero_rate"]) + ) + metrics["high_high_zero_minus_nonzero"] = ( + float(metrics["high_high_zero_rate"]) - float(metrics["high_high_nonzero_rate"]) + ) + metrics["sr_zero_minus_nonzero"] = ( + float(metrics["sr_zero_mean"]) - float(metrics["sr_nonzero_mean"]) + ) + return metrics + + +def permutation_test( + gaps: np.ndarray, + charges: np.ndarray, + observed: dict[str, float | int], + rng: np.random.Generator, + permutations: int, +) -> dict[str, dict[str, float]]: + nulls = {key: [] for key in METRIC_KEYS} + for _ in range(permutations): + shuffled = np.array(charges, copy=True) + rng.shuffle(shuffled) + metrics = transition_metrics_three_class(gaps, shuffled) + for key in METRIC_KEYS: + nulls[key].append(float(metrics[key])) + + out: dict[str, dict[str, float]] = {} + for key, values in nulls.items(): + arr = np.array(values, dtype=float) + obs = float(observed[key]) + finite = np.isfinite(arr) + arr = arr[finite] + if arr.size == 0 or not np.isfinite(obs): + out[key] = {"observed": obs, "null_mean": float("nan"), "null_std": float("nan"), "z": float("nan"), "p_two_sided": float("nan")} + continue + std = float(np.std(arr, ddof=1)) + z = (obs - float(np.mean(arr))) / std if std > 0 else 0.0 + p = float((np.sum(np.abs(arr) >= abs(obs)) + 1) / (len(arr) + 1)) + out[key] = { + "observed": obs, + "null_mean": float(np.mean(arr)), + "null_std": std, + "z": float(z), + "p_two_sided": p, + } + return out + + +def det_m_direct_control(gaps: np.ndarray) -> dict[str, float | int | str]: + g0 = gaps[:-1].astype(float) + g1 = gaps[1:].astype(float) + ratio = np.minimum(g0, g1) / np.maximum(g0, g1) + low_low = (g0 <= 6) & (g1 <= 6) + q75 = float(np.quantile(gaps, 0.75)) + high_high = (g0 >= q75) & (g1 >= q75) + denom = int(g0.size) + return { + "det_M": -1, + "class_count": 1, + "reason": "M=[[1,1],[1,0]] has constant determinant -1 on every transition, so direct det(M) does not partition the denominator.", + "denominator": denom, + "low_low_hits": int(np.sum(low_low)), + "low_low_rate": float(np.sum(low_low) / denom), + "high_high_hits": int(np.sum(high_high)), + "high_high_rate": float(np.sum(high_high) / denom), + "sr_mean": float(np.mean(ratio)), + } + + +def classify_zero_role(observed: dict[str, float | int], tests: dict[str, dict[str, float]]) -> str: + low_z = tests["low_low_zero_minus_nonzero"]["z"] + high_z = tests["high_high_zero_minus_nonzero"]["z"] + sr_z = tests["sr_zero_minus_nonzero"]["z"] + passes = [ + abs(low_z) >= 2 and tests["low_low_zero_minus_nonzero"]["p_two_sided"] <= 0.05, + abs(high_z) >= 2 and tests["high_high_zero_minus_nonzero"]["p_two_sided"] <= 0.05, + abs(sr_z) >= 2 and tests["sr_zero_minus_nonzero"]["p_two_sided"] <= 0.05, + ] + low = float(observed["low_low_zero_rate"]) + high = float(observed["high_high_zero_rate"]) + sr = float(observed["sr_zero_mean"]) + low_a = float(observed["low_low_aligned_rate"]) + low_m = float(observed["low_low_misaligned_rate"]) + high_a = float(observed["high_high_aligned_rate"]) + high_m = float(observed["high_high_misaligned_rate"]) + sr_a = float(observed["sr_aligned_mean"]) + sr_m = float(observed["sr_misaligned_mean"]) + + between_low = min(low_a, low_m) <= low <= max(low_a, low_m) + between_high = min(high_a, high_m) <= high <= max(high_a, high_m) + between_sr = min(sr_a, sr_m) <= sr <= max(sr_a, sr_m) + + if any(passes) and (between_low or between_high or between_sr): + return "boundary" + if any(passes): + return "third_class" + return "noise_under_this_null" + + +def run_condition( + primes: np.ndarray, + mu: np.ndarray, + n_primes: int, + offset: int, + rng: np.random.Generator, + permutations: int, +) -> dict[str, object]: + segment = primes[offset : offset + n_primes + 1] + gaps = np.diff(segment) + charges = interval_charges(segment, mu) + observed = transition_metrics_three_class(gaps, charges) + tests = permutation_test(gaps, charges, observed, rng, permutations) + return { + "n_primes": n_primes, + "offset": offset, + "prime_start": int(segment[0]), + "prime_stop": int(segment[-1]), + "zero_charge_count": int(np.sum(charges == 0)), + "charge_count": int(charges.size), + "observed": observed, + "permutation_tests": tests, + "zero_role": classify_zero_role(observed, tests), + "det_m_direct_control": det_m_direct_control(gaps), + } + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--limit", type=int, default=1_000_000) + parser.add_argument("--permutations", type=int, default=400) + parser.add_argument("--seed", type=int, default=2108) + parser.add_argument("--out", default="tools/data/prime_mobius_zero_mediator_gate_20260508_2108.json") + args = parser.parse_args() + + primes = sieve_primes(args.limit) + mu = mobius_sieve(args.limit) + rng = np.random.default_rng(args.seed) + + conditions = [ + {"n_primes": 5_000, "offset": 0}, + {"n_primes": 10_000, "offset": 0}, + {"n_primes": 20_000, "offset": 0}, + {"n_primes": 5_000, "offset": 3_000}, + {"n_primes": 10_000, "offset": 7_000}, + {"n_primes": 20_000, "offset": 11_000}, + ] + max_needed = max(c["offset"] + c["n_primes"] + 1 for c in conditions) + if len(primes) <= max_needed: + raise SystemExit(f"limit={args.limit} yields only {len(primes)} primes, need {max_needed}") + + results = [ + run_condition(primes, mu, c["n_primes"], c["offset"], rng, args.permutations) + for c in conditions + ] + summary = [] + for result in results: + tests = result["permutation_tests"] + summary.append( + { + "n_primes": result["n_primes"], + "offset": result["offset"], + "low_low_aligned_minus_misaligned_pass": abs(tests["low_low_aligned_minus_misaligned"]["z"]) >= 2.0 + and tests["low_low_aligned_minus_misaligned"]["p_two_sided"] <= 0.05, + "high_high_aligned_minus_misaligned_pass": abs(tests["high_high_aligned_minus_misaligned"]["z"]) >= 2.0 + and tests["high_high_aligned_minus_misaligned"]["p_two_sided"] <= 0.05, + "sr_aligned_minus_misaligned_pass": abs(tests["sr_aligned_minus_misaligned"]["z"]) >= 2.0 + and tests["sr_aligned_minus_misaligned"]["p_two_sided"] <= 0.05, + "zero_role": result["zero_role"], + } + ) + + payload = { + "experiment": "prime_mobius_zero_mediator_gate", + "question": "Does S=0 behave as noise, boundary, or mediator in the Mobius interval-charge gate?", + "threshold_ex_ante": "|z|>=2 and permutation p<=0.05 across main and offset conditions", + "null": "Permutation of the interval-charge sequence preserves the full charge multiset and therefore preserves zero frequency.", + "limit": args.limit, + "permutations": args.permutations, + "seed": args.seed, + "conditions": results, + "significance_summary": summary, + } + + out = Path(args.out) + out.parent.mkdir(parents=True, exist_ok=True) + out.write_text(json.dumps(payload, indent=2), encoding="utf-8") + + for result in results: + obs = result["observed"] + tests = result["permutation_tests"] + print( + f"N={result['n_primes']} offset={result['offset']} " + f"a/m/z={obs['aligned_count']}/{obs['misaligned_count']}/{obs['zero_count']} " + f"low_am={obs['low_low_aligned_minus_misaligned']:.5f} z={tests['low_low_aligned_minus_misaligned']['z']:.2f} p={tests['low_low_aligned_minus_misaligned']['p_two_sided']:.3f} " + f"low_z0={obs['low_low_zero_minus_nonzero']:.5f} z={tests['low_low_zero_minus_nonzero']['z']:.2f} p={tests['low_low_zero_minus_nonzero']['p_two_sided']:.3f} " + f"high_am={obs['high_high_aligned_minus_misaligned']:.5f} z={tests['high_high_aligned_minus_misaligned']['z']:.2f} p={tests['high_high_aligned_minus_misaligned']['p_two_sided']:.3f} " + f"high_z0={obs['high_high_zero_minus_nonzero']:.5f} z={tests['high_high_zero_minus_nonzero']['z']:.2f} p={tests['high_high_zero_minus_nonzero']['p_two_sided']:.3f} " + f"sr_am={obs['sr_aligned_minus_misaligned']:.5f} z={tests['sr_aligned_minus_misaligned']['z']:.2f} p={tests['sr_aligned_minus_misaligned']['p_two_sided']:.3f} " + f"role={result['zero_role']}" + ) + print(f"wrote {out}") + + +if __name__ == "__main__": + main() diff --git a/tools/data/reports/agent_20260508_2108.md b/tools/data/reports/agent_20260508_2108.md new file mode 100644 index 0000000000000000000000000000000000000000..d3b8fa5889b9587b0e01270608220848eb4d5ed7 --- /dev/null +++ b/tools/data/reports/agent_20260508_2108.md @@ -0,0 +1,103 @@ +# Agent Report - Prime Mobius Zero-Mediator Gate +**Date**: 2026-05-08 21:08 +**Piano**: 93 +**Tension explored**: DUALITA_DIPOLARE_VS_ILLUSORIA (0.9) +**verdict**: CONSTRAINT +observables_registry: 1.0.0-2026-05-06 +observables_used: [low_low_rate, high_high_rate, SR, det_M_direct_control] +**observable_contract**: claim=lo zero della carica Mobius intervallare e' testato come terzo incluso del gate aligned/misaligned; observable=rate low_low, rate high_high, SR mean per classi aligned/misaligned/zero; operator=classificazione di S_n*S_{n+1}: aligned<0, misaligned>0, zero=0; generator=prime gaps up to p<=1e6 with Mobius sieve; denominator=main N={5000,10000,20000} offset=0 plus seedcheck offsets {3000,7000,11000}; not_tested=gap_ratio Sturmian, high-core phi survival, universal GUE/Poisson classification. + +## Respiro fuori-tempo +- **Combo**: A2 confine det=-1 + A9 terzo incluso + A11 combo + QxG continuo/discreto vuoto + DUALITA_DIPOLARE_VS_ILLUSORIA + piano primi x Mobius. Il repair non cerca un lettore nuovo: riporta nel denominatore il punto escluso dal source cycle, `S=0`. +- **Dipolo / punto-zero**: carica Mobius alternata / carica Mobius concorde; punto-zero = transizione con almeno un intervallo a carica nulla (`S_n*S_{n+1}=0`). +- **Piano superiore**: boundary operator su grafo aritmetico. Il gap e' bordo tra primi; la carica Mobius del vuoto tra primi decide se il bordo e' solo rumore di lunghezza o classe informativa. +- **Operatori laterali scelti**: boundary operator, random walk, entropia. Boundary operator definisce il bordo prime-free; random walk fornisce il null di permutazione della carica; entropia entra come dispersione del vuoto senza primi. +- **Contaminazione cognitiva**: + - **CE-0117**: usato per non promuovere il source cycle e far passare il risultato da potenziale a vincolo misurato. + - **CE-0038**: usato per riportare la forma nel Nulla-Tutto al vuoto aritmetico, qui lo zero `S=0`. + - **CE-0001 / KSAR**: usato come kernel reiterativo del ciclo 2102, con riparazione regressiva sul denominatore. + - **PVI attack**: il segnale puo' essere effetto di lunghezza del gap; per questo il null permuta l'intera sequenza delle cariche preservando multiset e frequenza degli zeri. +- **Proto-ipotesi**: se `S=0` e' terzo incluso operativo, non cade come rumore sotto il null che preserva la frequenza degli zeri. Deve produrre una classe distinguibile su low_low/high_high/SR. Se resta dentro il null, il source cycle sopravvive solo come gate binario non-zero. +- **Proiezione**: confronto aligned, misaligned e zero su `low_low`, `high_high` e `SR`; null = 400 permutazioni della sequenza `S_n`, gap invariati, multiset delle cariche invariata. + +## Claim Under Test +> Nel perimetro primi x Mobius fino a `p<=1e6`, le transizioni con `S=0` non vanno escluse: formano una terza classe del gate intervallare e vanno confrontate contro aligned/misaligned con null che preserva la frequenza degli zeri. + +## Question +Lo zero della carica Mobius intervallare e' rumore, boundary o mediatore del segnale low-low/high-high/SR? + +## Experiment Design +- Script: `tools/exp_prime_mobius_zero_mediator_gate.py`. +- Dati: primi fino a `1_000_000`; Mobius sieve sullo stesso perimetro. +- Carica intervallare: `S_n = sum(mu(k))` per `p_n < k < p_{n+1}`. +- Classi: + - `aligned`: `S_n*S_{n+1}<0`. + - `misaligned`: `S_n*S_{n+1}>0`. + - `zero`: `S_n*S_{n+1}=0`. +- Osservabili: + - `low_low_rate`: count di due gap consecutivi `<=6` sul denominatore della classe. + - `high_high_rate`: count di due gap consecutivi `>=q75` sul denominatore della classe. + - `SR`: mean min/max ratio dei gap consecutivi. +- Null test: 400 permutazioni della sequenza `S_n`; il null preserva la multiset completa delle cariche e quindi la frequenza degli zeri. +- Controllo det(M) diretto: `M=[[1,1],[1,0]]` ha `det(M)=-1` costante su ogni transizione; il controllo non partiziona il denominatore e restituisce solo le baseline globali low/high/SR. +- Soglia ex ante: `|z|>=2` e `p_two_sided<=0.05`. +- Contratto osservabile-operatore: `gap_ratio` Sturmian non testato; il source cycle 2102 non viene promosso; il claim su det diretto viene sostituito da controllo esplicito, non da conclusione non misurata. + +## Results +| condition | a/m/z denom | zero charges | low a | low m | low z | low z0 vs nonzero z/p | high a | high m | high z | high z0 vs nonzero z/p | SR a | SR m | SR z | SR z0 vs nonzero z/p | +|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:| +| N=5000 off=0 | 1200/1572/2227 | 1258/5000 | 221/1200 | 220/1572 | 707/2227 | 11.77 / 0.002 | 115/1200 | 298/1572 | 101/2227 | -10.80 / 0.002 | 0.51559 | 0.52611 | 0.43203 | -11.15 / 0.002 | +| N=10000 off=0 | 2541/3102/4356 | 2457/10000 | 403/2541 | 377/3102 | 1190/4356 | 14.88 / 0.002 | 153/2541 | 363/3102 | 114/4356 | -12.31 / 0.002 | 0.50841 | 0.51502 | 0.42221 | -16.03 / 0.002 | +| N=20000 off=0 | 5171/6331/8497 | 4782/20000 | 694/5171 | 651/6331 | 2093/8497 | 22.31 / 0.002 | 422/5171 | 878/6331 | 281/8497 | -18.75 / 0.002 | 0.50324 | 0.51151 | 0.41571 | -23.13 / 0.002 | +| N=5000 off=3000 | 1313/1525/2161 | 1219/5000 | 184/1313 | 162/1525 | 522/2161 | 9.84 / 0.002 | 86/1313 | 187/1525 | 71/2161 | -8.13 / 0.002 | 0.50993 | 0.50560 | 0.42213 | -10.87 / 0.002 | +| N=10000 off=7000 | 2675/3178/4146 | 2318/10000 | 315/2675 | 298/3178 | 946/4146 | 16.40 / 0.002 | 182/2675 | 351/3178 | 98/4146 | -13.27 / 0.002 | 0.50225 | 0.50729 | 0.40695 | -17.18 / 0.002 | +| N=20000 off=11000 | 5407/6413/8179 | 4586/20000 | 553/5407 | 567/6413 | 1740/8179 | 20.63 / 0.002 | 295/5407 | 667/6413 | 178/8179 | -16.22 / 0.002 | 0.49723 | 0.50997 | 0.41131 | -22.87 / 0.002 | + +### Pairwise aligned/misaligned checks +| condition | low a-m diff z/p | high a-m diff z/p | SR a-m diff z/p | +|---|---:|---:|---:| +| N=5000 off=0 | +0.04422 2.47 / 0.015 | -0.09373 -7.96 / 0.002 | -0.01053 -1.12 / 0.277 | +| N=10000 off=0 | +0.03706 3.44 / 0.002 | -0.05681 -8.90 / 0.002 | -0.00661 -0.90 / 0.357 | +| N=20000 off=0 | +0.03138 4.56 / 0.002 | -0.05707 -10.48 / 0.002 | -0.00827 -1.78 / 0.097 | +| N=5000 off=3000 | +0.03391 2.37 / 0.022 | -0.05712 -5.66 / 0.002 | +0.00433 0.48 / 0.671 | +| N=10000 off=7000 | +0.02399 2.68 / 0.010 | -0.04241 -6.58 / 0.002 | -0.00504 -0.71 / 0.501 | +| N=20000 off=11000 | +0.01386 1.97 / 0.040 | -0.04945 -10.96 / 0.002 | -0.01274 -2.50 / 0.015 | + +### det(M) direct control +`det(M)=-1` e' costante. Il controllo ha una sola classe su ogni condizione, quindi non separa aligned/misaligned/zero. Baseline globali: low_low `1148/4999`, `1970/9999`, `3438/19999`, `868/4999`, `1559/9999`, `2860/19999`; high_high `514/4999`, `630/9999`, `1581/19999`, `344/4999`, `631/9999`, `1140/19999`; SR globale `0.48167`, `0.47291`, `0.46867`, `0.47066`, `0.46434`, `0.46618`. + +## Key Findings +1. **Verificato: lo zero non e' rumore sotto il null usato.** La classe zero supera il null in 6/6 condizioni su `low_low_zero_minus_nonzero`, `high_high_zero_minus_nonzero` e `sr_zero_minus_nonzero`, sempre con `p=0.002` e `|z|` da `8.13` a `23.13`. + +2. **Verificato: lo zero e' una terza classe, non un mediatore tra aligned e misaligned.** Su low_low lo zero e' sopra entrambe le classi non-zero (`0.21274..0.31747` contro aligned `0.10227..0.18417` e misaligned `0.08841..0.13995`). Su high_high lo zero e' sotto entrambe (`0.02176..0.04535` contro aligned `0.05456..0.09583` e misaligned `0.10401..0.18957`). Su SR lo zero e' sotto entrambe (`0.40695..0.43203` contro non-zero circa `0.49723..0.52611`). Il punto-zero non sta tra i poli: genera una classe propria. + +3. **Verificato: il contrasto aligned/misaligned sopravvive soprattutto su high_high.** `high_high_aligned_minus_misaligned` passa 6/6 con z da `-5.66` a `-10.96`. `low_low_aligned_minus_misaligned` passa 5/6 se la soglia richiede anche `|z|>=2`; l'ultima condizione ha `z=1.97`, `p=0.040`, quindi resta borderline e non autorizza hard wording. SR passa 1/6 e resta osservabile secondario. + +4. **Verificato: il controllo det(M) diretto risolve il flag L3 del source cycle.** `det(M)` costante non produce partizione del denominatore; il report non conclude che la dualita "non si legge" da det diretto come fatto empirico generale. Qui dichiara solo che, in questo controllo, det(M) diretto non e' un discriminatore di classe. + +## Verdict +**CONSTRAINT on DUALITA_DIPOLARE_VS_ILLUSORIA / Prime Mobius interval-charge gate**: nel perimetro primi x Mobius fino a `p<=1e6`, `S=0` deve restare nel denominatore come terza classe. Lo zero non e' rumore sotto il null di permutazione che preserva frequenza degli zeri: arricchisce low_low, sopprime high_high e abbassa SR in 6/6 condizioni. Il source cycle sopravvive come vincolo parziale: il gate non-zero aligned/misaligned resta solido per high_high, resta parziale per low_low, e non porta SR globalmente. Il nuovo portatore e' triadico: aligned / misaligned / zero. + +## Bicono della scoperta +- **Due radici**: carica non-zero alternata/concorde . carica zero dell'intervallo prime-free. +- **Singolare**: il vuoto tra primi prima della scelta binaria; `S=0` non e' assenza di segnale ma classe del bordo. +- **Invariante di passaggio**: il null conserva gap, multiset delle cariche e frequenza degli zeri; cio' che sopravvive e' l'accoppiamento ordine-carica, non la sola presenza dello zero. +- **Campo di possibilita**: qui diventa possibile testare un gate triadico del boundary aritmetico. Qui diventa non-possibile escludere `S=0` dal denominatore quando si parla di terzo incluso nel perimetro Mobius-primi. + +## Consecutio +Il prossimo passo deve separare terza classe autentica da effetto scala dell'intervallo: ripetere il gate con controllo che preserva anche la lunghezza del gap o stratifica per bucket di gap length. Se lo zero resta significativo dentro ogni bucket, il boundary e' aritmetico; se cade, il segnale e' dipendenza da lunghezza. + +## Auto-audit: source flags e 5 lenti +- **Source L3 resolved**: il report non usa un elemento `not_tested` come conclusione. Il controllo det(M) diretto e' misurato e dichiarato non partizionante nel perimetro. +- **Source denominator repair resolved**: `S=0` e' incluso come classe esplicita, con count grezzi e denominatore. +- **Aperto**: non e' ancora separata la dipendenza dalla lunghezza del gap; serve controllo stratificato. +- **L1 hard constraint vs bias**: nessun "sempre/mai"; perimetro dichiarato `p<=1e6`, sei condizioni, 400 permutazioni. +- **L2 quantita vs ratio**: count grezzi e denominatori riportati; SR separato dai rate. +- **L3 no silent patching**: claim corretto prima del test; il source cycle non viene promosso. +- **L4 edge cases**: `low_low` non-zero e' borderline in una condizione (`z=1.97`), quindi resta parziale. +- **L5 re-discovery vs discovery**: verdict `CONSTRAINT`, non `NEW`; il pattern resta da confrontare con dipendenze note tra Mobius, lunghezza intervallare e gap primes. + +## Files +- Script: `tools/exp_prime_mobius_zero_mediator_gate.py` +- Data: `tools/data/prime_mobius_zero_mediator_gate_20260508_2108.json` +- Report: `tools/data/reports/agent_20260508_2108.md` diff --git a/tools/exp_prime_mobius_zero_mediator_gate.py b/tools/exp_prime_mobius_zero_mediator_gate.py new file mode 100644 index 0000000000000000000000000000000000000000..95ecd6e07c1863f3ffd3a3a5297a8628a00fd8be --- /dev/null +++ b/tools/exp_prime_mobius_zero_mediator_gate.py @@ -0,0 +1,314 @@ +#!/usr/bin/env python3 +"""Prime x Mobius zero-mediator gate. + +Repairs the 20260508_2102 interval-charge gate by keeping transitions with +S=0 in the denominator as an explicit third class. +""" +from __future__ import annotations + +import argparse +import json +from pathlib import Path + +import numpy as np + +from exp_prime_mobius_interval_charge_gate import ( + interval_charges, + mobius_sieve, + sieve_primes, +) + + +METRIC_KEYS = [ + "low_low_aligned_rate", + "low_low_misaligned_rate", + "low_low_zero_rate", + "high_high_aligned_rate", + "high_high_misaligned_rate", + "high_high_zero_rate", + "sr_aligned_mean", + "sr_misaligned_mean", + "sr_zero_mean", + "low_low_aligned_minus_misaligned", + "low_low_zero_minus_nonzero", + "high_high_aligned_minus_misaligned", + "high_high_zero_minus_nonzero", + "sr_aligned_minus_misaligned", + "sr_zero_minus_nonzero", +] + + +def _rate(mask: np.ndarray, event: np.ndarray) -> tuple[int, int, float]: + denom = int(np.sum(mask)) + hits = int(np.sum(mask & event)) + rate = float(hits / denom) if denom else float("nan") + return hits, denom, rate + + +def _mean(mask: np.ndarray, values: np.ndarray) -> tuple[int, float]: + denom = int(np.sum(mask)) + mean = float(np.mean(values[mask])) if denom else float("nan") + return denom, mean + + +def transition_metrics_three_class(gaps: np.ndarray, charges: np.ndarray) -> dict[str, float | int]: + left = charges[:-1] + right = charges[1:] + product = left * right + aligned = product < 0 + misaligned = product > 0 + zero = product == 0 + nonzero = ~zero + + g0 = gaps[:-1].astype(float) + g1 = gaps[1:].astype(float) + ratio = np.minimum(g0, g1) / np.maximum(g0, g1) + low_low = (g0 <= 6) & (g1 <= 6) + q75 = float(np.quantile(gaps, 0.75)) + high_high = (g0 >= q75) & (g1 >= q75) + + metrics: dict[str, float | int] = { + "q75_gap": q75, + "aligned_count": int(np.sum(aligned)), + "misaligned_count": int(np.sum(misaligned)), + "zero_count": int(np.sum(zero)), + "nonzero_count": int(np.sum(nonzero)), + } + + for name, event in (("low_low", low_low), ("high_high", high_high)): + for cls_name, mask in ( + ("aligned", aligned), + ("misaligned", misaligned), + ("zero", zero), + ("nonzero", nonzero), + ): + hits, denom, rate = _rate(mask, event) + metrics[f"{name}_{cls_name}_hits"] = hits + metrics[f"{name}_{cls_name}_denom"] = denom + metrics[f"{name}_{cls_name}_rate"] = rate + + for cls_name, mask in ( + ("aligned", aligned), + ("misaligned", misaligned), + ("zero", zero), + ("nonzero", nonzero), + ): + denom, mean = _mean(mask, ratio) + metrics[f"sr_{cls_name}_denom"] = denom + metrics[f"sr_{cls_name}_mean"] = mean + + metrics["low_low_aligned_minus_misaligned"] = ( + float(metrics["low_low_aligned_rate"]) - float(metrics["low_low_misaligned_rate"]) + ) + metrics["high_high_aligned_minus_misaligned"] = ( + float(metrics["high_high_aligned_rate"]) - float(metrics["high_high_misaligned_rate"]) + ) + metrics["sr_aligned_minus_misaligned"] = ( + float(metrics["sr_aligned_mean"]) - float(metrics["sr_misaligned_mean"]) + ) + metrics["low_low_zero_minus_nonzero"] = ( + float(metrics["low_low_zero_rate"]) - float(metrics["low_low_nonzero_rate"]) + ) + metrics["high_high_zero_minus_nonzero"] = ( + float(metrics["high_high_zero_rate"]) - float(metrics["high_high_nonzero_rate"]) + ) + metrics["sr_zero_minus_nonzero"] = ( + float(metrics["sr_zero_mean"]) - float(metrics["sr_nonzero_mean"]) + ) + return metrics + + +def permutation_test( + gaps: np.ndarray, + charges: np.ndarray, + observed: dict[str, float | int], + rng: np.random.Generator, + permutations: int, +) -> dict[str, dict[str, float]]: + nulls = {key: [] for key in METRIC_KEYS} + for _ in range(permutations): + shuffled = np.array(charges, copy=True) + rng.shuffle(shuffled) + metrics = transition_metrics_three_class(gaps, shuffled) + for key in METRIC_KEYS: + nulls[key].append(float(metrics[key])) + + out: dict[str, dict[str, float]] = {} + for key, values in nulls.items(): + arr = np.array(values, dtype=float) + obs = float(observed[key]) + finite = np.isfinite(arr) + arr = arr[finite] + if arr.size == 0 or not np.isfinite(obs): + out[key] = {"observed": obs, "null_mean": float("nan"), "null_std": float("nan"), "z": float("nan"), "p_two_sided": float("nan")} + continue + std = float(np.std(arr, ddof=1)) + z = (obs - float(np.mean(arr))) / std if std > 0 else 0.0 + p = float((np.sum(np.abs(arr) >= abs(obs)) + 1) / (len(arr) + 1)) + out[key] = { + "observed": obs, + "null_mean": float(np.mean(arr)), + "null_std": std, + "z": float(z), + "p_two_sided": p, + } + return out + + +def det_m_direct_control(gaps: np.ndarray) -> dict[str, float | int | str]: + g0 = gaps[:-1].astype(float) + g1 = gaps[1:].astype(float) + ratio = np.minimum(g0, g1) / np.maximum(g0, g1) + low_low = (g0 <= 6) & (g1 <= 6) + q75 = float(np.quantile(gaps, 0.75)) + high_high = (g0 >= q75) & (g1 >= q75) + denom = int(g0.size) + return { + "det_M": -1, + "class_count": 1, + "reason": "M=[[1,1],[1,0]] has constant determinant -1 on every transition, so direct det(M) does not partition the denominator.", + "denominator": denom, + "low_low_hits": int(np.sum(low_low)), + "low_low_rate": float(np.sum(low_low) / denom), + "high_high_hits": int(np.sum(high_high)), + "high_high_rate": float(np.sum(high_high) / denom), + "sr_mean": float(np.mean(ratio)), + } + + +def classify_zero_role(observed: dict[str, float | int], tests: dict[str, dict[str, float]]) -> str: + low_z = tests["low_low_zero_minus_nonzero"]["z"] + high_z = tests["high_high_zero_minus_nonzero"]["z"] + sr_z = tests["sr_zero_minus_nonzero"]["z"] + passes = [ + abs(low_z) >= 2 and tests["low_low_zero_minus_nonzero"]["p_two_sided"] <= 0.05, + abs(high_z) >= 2 and tests["high_high_zero_minus_nonzero"]["p_two_sided"] <= 0.05, + abs(sr_z) >= 2 and tests["sr_zero_minus_nonzero"]["p_two_sided"] <= 0.05, + ] + low = float(observed["low_low_zero_rate"]) + high = float(observed["high_high_zero_rate"]) + sr = float(observed["sr_zero_mean"]) + low_a = float(observed["low_low_aligned_rate"]) + low_m = float(observed["low_low_misaligned_rate"]) + high_a = float(observed["high_high_aligned_rate"]) + high_m = float(observed["high_high_misaligned_rate"]) + sr_a = float(observed["sr_aligned_mean"]) + sr_m = float(observed["sr_misaligned_mean"]) + + between_low = min(low_a, low_m) <= low <= max(low_a, low_m) + between_high = min(high_a, high_m) <= high <= max(high_a, high_m) + between_sr = min(sr_a, sr_m) <= sr <= max(sr_a, sr_m) + + if any(passes) and (between_low or between_high or between_sr): + return "boundary" + if any(passes): + return "third_class" + return "noise_under_this_null" + + +def run_condition( + primes: np.ndarray, + mu: np.ndarray, + n_primes: int, + offset: int, + rng: np.random.Generator, + permutations: int, +) -> dict[str, object]: + segment = primes[offset : offset + n_primes + 1] + gaps = np.diff(segment) + charges = interval_charges(segment, mu) + observed = transition_metrics_three_class(gaps, charges) + tests = permutation_test(gaps, charges, observed, rng, permutations) + return { + "n_primes": n_primes, + "offset": offset, + "prime_start": int(segment[0]), + "prime_stop": int(segment[-1]), + "zero_charge_count": int(np.sum(charges == 0)), + "charge_count": int(charges.size), + "observed": observed, + "permutation_tests": tests, + "zero_role": classify_zero_role(observed, tests), + "det_m_direct_control": det_m_direct_control(gaps), + } + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--limit", type=int, default=1_000_000) + parser.add_argument("--permutations", type=int, default=400) + parser.add_argument("--seed", type=int, default=2108) + parser.add_argument("--out", default="tools/data/prime_mobius_zero_mediator_gate_20260508_2108.json") + args = parser.parse_args() + + primes = sieve_primes(args.limit) + mu = mobius_sieve(args.limit) + rng = np.random.default_rng(args.seed) + + conditions = [ + {"n_primes": 5_000, "offset": 0}, + {"n_primes": 10_000, "offset": 0}, + {"n_primes": 20_000, "offset": 0}, + {"n_primes": 5_000, "offset": 3_000}, + {"n_primes": 10_000, "offset": 7_000}, + {"n_primes": 20_000, "offset": 11_000}, + ] + max_needed = max(c["offset"] + c["n_primes"] + 1 for c in conditions) + if len(primes) <= max_needed: + raise SystemExit(f"limit={args.limit} yields only {len(primes)} primes, need {max_needed}") + + results = [ + run_condition(primes, mu, c["n_primes"], c["offset"], rng, args.permutations) + for c in conditions + ] + summary = [] + for result in results: + tests = result["permutation_tests"] + summary.append( + { + "n_primes": result["n_primes"], + "offset": result["offset"], + "low_low_aligned_minus_misaligned_pass": abs(tests["low_low_aligned_minus_misaligned"]["z"]) >= 2.0 + and tests["low_low_aligned_minus_misaligned"]["p_two_sided"] <= 0.05, + "high_high_aligned_minus_misaligned_pass": abs(tests["high_high_aligned_minus_misaligned"]["z"]) >= 2.0 + and tests["high_high_aligned_minus_misaligned"]["p_two_sided"] <= 0.05, + "sr_aligned_minus_misaligned_pass": abs(tests["sr_aligned_minus_misaligned"]["z"]) >= 2.0 + and tests["sr_aligned_minus_misaligned"]["p_two_sided"] <= 0.05, + "zero_role": result["zero_role"], + } + ) + + payload = { + "experiment": "prime_mobius_zero_mediator_gate", + "question": "Does S=0 behave as noise, boundary, or mediator in the Mobius interval-charge gate?", + "threshold_ex_ante": "|z|>=2 and permutation p<=0.05 across main and offset conditions", + "null": "Permutation of the interval-charge sequence preserves the full charge multiset and therefore preserves zero frequency.", + "limit": args.limit, + "permutations": args.permutations, + "seed": args.seed, + "conditions": results, + "significance_summary": summary, + } + + out = Path(args.out) + out.parent.mkdir(parents=True, exist_ok=True) + out.write_text(json.dumps(payload, indent=2), encoding="utf-8") + + for result in results: + obs = result["observed"] + tests = result["permutation_tests"] + print( + f"N={result['n_primes']} offset={result['offset']} " + f"a/m/z={obs['aligned_count']}/{obs['misaligned_count']}/{obs['zero_count']} " + f"low_am={obs['low_low_aligned_minus_misaligned']:.5f} z={tests['low_low_aligned_minus_misaligned']['z']:.2f} p={tests['low_low_aligned_minus_misaligned']['p_two_sided']:.3f} " + f"low_z0={obs['low_low_zero_minus_nonzero']:.5f} z={tests['low_low_zero_minus_nonzero']['z']:.2f} p={tests['low_low_zero_minus_nonzero']['p_two_sided']:.3f} " + f"high_am={obs['high_high_aligned_minus_misaligned']:.5f} z={tests['high_high_aligned_minus_misaligned']['z']:.2f} p={tests['high_high_aligned_minus_misaligned']['p_two_sided']:.3f} " + f"high_z0={obs['high_high_zero_minus_nonzero']:.5f} z={tests['high_high_zero_minus_nonzero']['z']:.2f} p={tests['high_high_zero_minus_nonzero']['p_two_sided']:.3f} " + f"sr_am={obs['sr_aligned_minus_misaligned']:.5f} z={tests['sr_aligned_minus_misaligned']['z']:.2f} p={tests['sr_aligned_minus_misaligned']['p_two_sided']:.3f} " + f"role={result['zero_role']}" + ) + print(f"wrote {out}") + + +if __name__ == "__main__": + main() codex Il report è scritto. Ora faccio una verifica minima: leggo il file prodotto, controllo che non ci siano riferimenti incoerenti con `not_tested`, poi provo i check locali disponibili senza modificare lo stato oltre ai file del cycle. exec /bin/bash -lc "sed -n '1,260p' tools/data/reports/agent_20260508_2108.md" in /opt/MM_D-ND succeeded in 0ms: # Agent Report - Prime Mobius Zero-Mediator Gate **Date**: 2026-05-08 21:08 **Piano**: 93 **Tension explored**: DUALITA_DIPOLARE_VS_ILLUSORIA (0.9) **verdict**: CONSTRAINT observables_registry: 1.0.0-2026-05-06 observables_used: [low_low_rate, high_high_rate, SR, det_M_direct_control] **observable_contract**: claim=lo zero della carica Mobius intervallare e' testato come terzo incluso del gate aligned/misaligned; observable=rate low_low, rate high_high, SR mean per classi aligned/misaligned/zero; operator=classificazione di S_n*S_{n+1}: aligned<0, misaligned>0, zero=0; generator=prime gaps up to p<=1e6 with Mobius sieve; denominator=main N={5000,10000,20000} offset=0 plus seedcheck offsets {3000,7000,11000}; not_tested=gap_ratio Sturmian, high-core phi survival, universal GUE/Poisson classification. ## Respiro fuori-tempo - **Combo**: A2 confine det=-1 + A9 terzo incluso + A11 combo + QxG continuo/discreto vuoto + DUALITA_DIPOLARE_VS_ILLUSORIA + piano primi x Mobius. Il repair non cerca un lettore nuovo: riporta nel denominatore il punto escluso dal source cycle, `S=0`. - **Dipolo / punto-zero**: carica Mobius alternata / carica Mobius concorde; punto-zero = transizione con almeno un intervallo a carica nulla (`S_n*S_{n+1}=0`). - **Piano superiore**: boundary operator su grafo aritmetico. Il gap e' bordo tra primi; la carica Mobius del vuoto tra primi decide se il bordo e' solo rumore di lunghezza o classe informativa. - **Operatori laterali scelti**: boundary operator, random walk, entropia. Boundary operator definisce il bordo prime-free; random walk fornisce il null di permutazione della carica; entropia entra come dispersione del vuoto senza primi. - **Contaminazione cognitiva**: - **CE-0117**: usato per non promuovere il source cycle e far passare il risultato da potenziale a vincolo misurato. - **CE-0038**: usato per riportare la forma nel Nulla-Tutto al vuoto aritmetico, qui lo zero `S=0`. - **CE-0001 / KSAR**: usato come kernel reiterativo del ciclo 2102, con riparazione regressiva sul denominatore. - **PVI attack**: il segnale puo' essere effetto di lunghezza del gap; per questo il null permuta l'intera sequenza delle cariche preservando multiset e frequenza degli zeri. - **Proto-ipotesi**: se `S=0` e' terzo incluso operativo, non cade come rumore sotto il null che preserva la frequenza degli zeri. Deve produrre una classe distinguibile su low_low/high_high/SR. Se resta dentro il null, il source cycle sopravvive solo come gate binario non-zero. - **Proiezione**: confronto aligned, misaligned e zero su `low_low`, `high_high` e `SR`; null = 400 permutazioni della sequenza `S_n`, gap invariati, multiset delle cariche invariata. ## Claim Under Test > Nel perimetro primi x Mobius fino a `p<=1e6`, le transizioni con `S=0` non vanno escluse: formano una terza classe del gate intervallare e vanno confrontate contro aligned/misaligned con null che preserva la frequenza degli zeri. ## Question Lo zero della carica Mobius intervallare e' rumore, boundary o mediatore del segnale low-low/high-high/SR? ## Experiment Design - Script: `tools/exp_prime_mobius_zero_mediator_gate.py`. - Dati: primi fino a `1_000_000`; Mobius sieve sullo stesso perimetro. - Carica intervallare: `S_n = sum(mu(k))` per `p_n < k < p_{n+1}`. - Classi: - `aligned`: `S_n*S_{n+1}<0`. - `misaligned`: `S_n*S_{n+1}>0`. - `zero`: `S_n*S_{n+1}=0`. - Osservabili: - `low_low_rate`: count di due gap consecutivi `<=6` sul denominatore della classe. - `high_high_rate`: count di due gap consecutivi `>=q75` sul denominatore della classe. - `SR`: mean min/max ratio dei gap consecutivi. - Null test: 400 permutazioni della sequenza `S_n`; il null preserva la multiset completa delle cariche e quindi la frequenza degli zeri. - Controllo det(M) diretto: `M=[[1,1],[1,0]]` ha `det(M)=-1` costante su ogni transizione; il controllo non partiziona il denominatore e restituisce solo le baseline globali low/high/SR. - Soglia ex ante: `|z|>=2` e `p_two_sided<=0.05`. - Contratto osservabile-operatore: `gap_ratio` Sturmian non testato; il source cycle 2102 non viene promosso; il claim su det diretto viene sostituito da controllo esplicito, non da conclusione non misurata. ## Results | condition | a/m/z denom | zero charges | low a | low m | low z | low z0 vs nonzero z/p | high a | high m | high z | high z0 vs nonzero z/p | SR a | SR m | SR z | SR z0 vs nonzero z/p | |---|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:| | N=5000 off=0 | 1200/1572/2227 | 1258/5000 | 221/1200 | 220/1572 | 707/2227 | 11.77 / 0.002 | 115/1200 | 298/1572 | 101/2227 | -10.80 / 0.002 | 0.51559 | 0.52611 | 0.43203 | -11.15 / 0.002 | | N=10000 off=0 | 2541/3102/4356 | 2457/10000 | 403/2541 | 377/3102 | 1190/4356 | 14.88 / 0.002 | 153/2541 | 363/3102 | 114/4356 | -12.31 / 0.002 | 0.50841 | 0.51502 | 0.42221 | -16.03 / 0.002 | | N=20000 off=0 | 5171/6331/8497 | 4782/20000 | 694/5171 | 651/6331 | 2093/8497 | 22.31 / 0.002 | 422/5171 | 878/6331 | 281/8497 | -18.75 / 0.002 | 0.50324 | 0.51151 | 0.41571 | -23.13 / 0.002 | | N=5000 off=3000 | 1313/1525/2161 | 1219/5000 | 184/1313 | 162/1525 | 522/2161 | 9.84 / 0.002 | 86/1313 | 187/1525 | 71/2161 | -8.13 / 0.002 | 0.50993 | 0.50560 | 0.42213 | -10.87 / 0.002 | | N=10000 off=7000 | 2675/3178/4146 | 2318/10000 | 315/2675 | 298/3178 | 946/4146 | 16.40 / 0.002 | 182/2675 | 351/3178 | 98/4146 | -13.27 / 0.002 | 0.50225 | 0.50729 | 0.40695 | -17.18 / 0.002 | | N=20000 off=11000 | 5407/6413/8179 | 4586/20000 | 553/5407 | 567/6413 | 1740/8179 | 20.63 / 0.002 | 295/5407 | 667/6413 | 178/8179 | -16.22 / 0.002 | 0.49723 | 0.50997 | 0.41131 | -22.87 / 0.002 | ### Pairwise aligned/misaligned checks | condition | low a-m diff z/p | high a-m diff z/p | SR a-m diff z/p | |---|---:|---:|---:| | N=5000 off=0 | +0.04422 2.47 / 0.015 | -0.09373 -7.96 / 0.002 | -0.01053 -1.12 / 0.277 | | N=10000 off=0 | +0.03706 3.44 / 0.002 | -0.05681 -8.90 / 0.002 | -0.00661 -0.90 / 0.357 | | N=20000 off=0 | +0.03138 4.56 / 0.002 | -0.05707 -10.48 / 0.002 | -0.00827 -1.78 / 0.097 | | N=5000 off=3000 | +0.03391 2.37 / 0.022 | -0.05712 -5.66 / 0.002 | +0.00433 0.48 / 0.671 | | N=10000 off=7000 | +0.02399 2.68 / 0.010 | -0.04241 -6.58 / 0.002 | -0.00504 -0.71 / 0.501 | | N=20000 off=11000 | +0.01386 1.97 / 0.040 | -0.04945 -10.96 / 0.002 | -0.01274 -2.50 / 0.015 | ### det(M) direct control `det(M)=-1` e' costante. Il controllo ha una sola classe su ogni condizione, quindi non separa aligned/misaligned/zero. Baseline globali: low_low `1148/4999`, `1970/9999`, `3438/19999`, `868/4999`, `1559/9999`, `2860/19999`; high_high `514/4999`, `630/9999`, `1581/19999`, `344/4999`, `631/9999`, `1140/19999`; SR globale `0.48167`, `0.47291`, `0.46867`, `0.47066`, `0.46434`, `0.46618`. ## Key Findings 1. **Verificato: lo zero non e' rumore sotto il null usato.** La classe zero supera il null in 6/6 condizioni su `low_low_zero_minus_nonzero`, `high_high_zero_minus_nonzero` e `sr_zero_minus_nonzero`, sempre con `p=0.002` e `|z|` da `8.13` a `23.13`. 2. **Verificato: lo zero e' una terza classe, non un mediatore tra aligned e misaligned.** Su low_low lo zero e' sopra entrambe le classi non-zero (`0.21274..0.31747` contro aligned `0.10227..0.18417` e misaligned `0.08841..0.13995`). Su high_high lo zero e' sotto entrambe (`0.02176..0.04535` contro aligned `0.05456..0.09583` e misaligned `0.10401..0.18957`). Su SR lo zero e' sotto entrambe (`0.40695..0.43203` contro non-zero circa `0.49723..0.52611`). Il punto-zero non sta tra i poli: genera una classe propria. 3. **Verificato: il contrasto aligned/misaligned sopravvive soprattutto su high_high.** `high_high_aligned_minus_misaligned` passa 6/6 con z da `-5.66` a `-10.96`. `low_low_aligned_minus_misaligned` passa 5/6 se la soglia richiede anche `|z|>=2`; l'ultima condizione ha `z=1.97`, `p=0.040`, quindi resta borderline e non autorizza hard wording. SR passa 1/6 e resta osservabile secondario. 4. **Verificato: il controllo det(M) diretto risolve il flag L3 del source cycle.** `det(M)` costante non produce partizione del denominatore; il report non conclude che la dualita "non si legge" da det diretto come fatto empirico generale. Qui dichiara solo che, in questo controllo, det(M) diretto non e' un discriminatore di classe. ## Verdict **CONSTRAINT on DUALITA_DIPOLARE_VS_ILLUSORIA / Prime Mobius interval-charge gate**: nel perimetro primi x Mobius fino a `p<=1e6`, `S=0` deve restare nel denominatore come terza classe. Lo zero non e' rumore sotto il null di permutazione che preserva frequenza degli zeri: arricchisce low_low, sopprime high_high e abbassa SR in 6/6 condizioni. Il source cycle sopravvive come vincolo parziale: il gate non-zero aligned/misaligned resta solido per high_high, resta parziale per low_low, e non porta SR globalmente. Il nuovo portatore e' triadico: aligned / misaligned / zero. ## Bicono della scoperta - **Due radici**: carica non-zero alternata/concorde . carica zero dell'intervallo prime-free. - **Singolare**: il vuoto tra primi prima della scelta binaria; `S=0` non e' assenza di segnale ma classe del bordo. - **Invariante di passaggio**: il null conserva gap, multiset delle cariche e frequenza degli zeri; cio' che sopravvive e' l'accoppiamento ordine-carica, non la sola presenza dello zero. - **Campo di possibilita**: qui diventa possibile testare un gate triadico del boundary aritmetico. Qui diventa non-possibile escludere `S=0` dal denominatore quando si parla di terzo incluso nel perimetro Mobius-primi. ## Consecutio Il prossimo passo deve separare terza classe autentica da effetto scala dell'intervallo: ripetere il gate con controllo che preserva anche la lunghezza del gap o stratifica per bucket di gap length. Se lo zero resta significativo dentro ogni bucket, il boundary e' aritmetico; se cade, il segnale e' dipendenza da lunghezza. ## Auto-audit: source flags e 5 lenti - **Source L3 resolved**: il report non usa un elemento `not_tested` come conclusione. Il controllo det(M) diretto e' misurato e dichiarato non partizionante nel perimetro. - **Source denominator repair resolved**: `S=0` e' incluso come classe esplicita, con count grezzi e denominatore. - **Aperto**: non e' ancora separata la dipendenza dalla lunghezza del gap; serve controllo stratificato. - **L1 hard constraint vs bias**: nessun "sempre/mai"; perimetro dichiarato `p<=1e6`, sei condizioni, 400 permutazioni. - **L2 quantita vs ratio**: count grezzi e denominatori riportati; SR separato dai rate. - **L3 no silent patching**: claim corretto prima del test; il source cycle non viene promosso. - **L4 edge cases**: `low_low` non-zero e' borderline in una condizione (`z=1.97`), quindi resta parziale. - **L5 re-discovery vs discovery**: verdict `CONSTRAINT`, non `NEW`; il pattern resta da confrontare con dipendenze note tra Mobius, lunghezza intervallare e gap primes. ## Files - Script: `tools/exp_prime_mobius_zero_mediator_gate.py` - Data: `tools/data/prime_mobius_zero_mediator_gate_20260508_2108.json` - Report: `tools/data/reports/agent_20260508_2108.md` exec /bin/bash -lc "rg -n \"not_tested|det diretto|det\\(M\\)|non si legge|sempre|mai|rumore\" tools/data/reports/agent_20260508_2108.md" in /opt/MM_D-ND succeeded in 0ms: 8:**observable_contract**: claim=lo zero della carica Mobius intervallare e' testato come terzo incluso del gate aligned/misaligned; observable=rate low_low, rate high_high, SR mean per classi aligned/misaligned/zero; operator=classificazione di S_n*S_{n+1}: aligned<0, misaligned>0, zero=0; generator=prime gaps up to p<=1e6 with Mobius sieve; denominator=main N={5000,10000,20000} offset=0 plus seedcheck offsets {3000,7000,11000}; not_tested=gap_ratio Sturmian, high-core phi survival, universal GUE/Poisson classification. 13:- **Piano superiore**: boundary operator su grafo aritmetico. Il gap e' bordo tra primi; la carica Mobius del vuoto tra primi decide se il bordo e' solo rumore di lunghezza o classe informativa. 20:- **Proto-ipotesi**: se `S=0` e' terzo incluso operativo, non cade come rumore sotto il null che preserva la frequenza degli zeri. Deve produrre una classe distinguibile su low_low/high_high/SR. Se resta dentro il null, il source cycle sopravvive solo come gate binario non-zero. 27:Lo zero della carica Mobius intervallare e' rumore, boundary o mediatore del segnale low-low/high-high/SR? 42:- Controllo det(M) diretto: `M=[[1,1],[1,0]]` ha `det(M)=-1` costante su ogni transizione; il controllo non partiziona il denominatore e restituisce solo le baseline globali low/high/SR. 44:- Contratto osservabile-operatore: `gap_ratio` Sturmian non testato; il source cycle 2102 non viene promosso; il claim su det diretto viene sostituito da controllo esplicito, non da conclusione non misurata. 66:### det(M) direct control 67:`det(M)=-1` e' costante. Il controllo ha una sola classe su ogni condizione, quindi non separa aligned/misaligned/zero. Baseline globali: low_low `1148/4999`, `1970/9999`, `3438/19999`, `868/4999`, `1559/9999`, `2860/19999`; high_high `514/4999`, `630/9999`, `1581/19999`, `344/4999`, `631/9999`, `1140/19999`; SR globale `0.48167`, `0.47291`, `0.46867`, `0.47066`, `0.46434`, `0.46618`. 70:1. **Verificato: lo zero non e' rumore sotto il null usato.** La classe zero supera il null in 6/6 condizioni su `low_low_zero_minus_nonzero`, `high_high_zero_minus_nonzero` e `sr_zero_minus_nonzero`, sempre con `p=0.002` e `|z|` da `8.13` a `23.13`. 76:4. **Verificato: il controllo det(M) diretto risolve il flag L3 del source cycle.** `det(M)` costante non produce partizione del denominatore; il report non conclude che la dualita "non si legge" da det diretto come fatto empirico generale. Qui dichiara solo che, in questo controllo, det(M) diretto non e' un discriminatore di classe. 79:**CONSTRAINT on DUALITA_DIPOLARE_VS_ILLUSORIA / Prime Mobius interval-charge gate**: nel perimetro primi x Mobius fino a `p<=1e6`, `S=0` deve restare nel denominatore come terza classe. Lo zero non e' rumore sotto il null di permutazione che preserva frequenza degli zeri: arricchisce low_low, sopprime high_high e abbassa SR in 6/6 condizioni. Il source cycle sopravvive come vincolo parziale: il gate non-zero aligned/misaligned resta solido per high_high, resta parziale per low_low, e non porta SR globalmente. Il nuovo portatore e' triadico: aligned / misaligned / zero. 91:- **Source L3 resolved**: il report non usa un elemento `not_tested` come conclusione. Il controllo det(M) diretto e' misurato e dichiarato non partizionante nel perimetro. 94:- **L1 hard constraint vs bias**: nessun "sempre/mai"; perimetro dichiarato `p<=1e6`, sei condizioni, 400 permutazioni. exec /bin/bash -lc 'rg -n "def main|argparse|report" tools/lab_falsifier.py tools/structural_check.py 2>/dev/null' in /opt/MM_D-ND succeeded in 0ms: tools/structural_check.py:191:def main(): tools/lab_falsifier.py:9:falsifier e' polo - (challenger). Il falsifier non riscrive il report, tools/lab_falsifier.py:13:Le 5 lenti (port da /opt/D-ND_LAB/core/report_falsifier.py, riformulate tools/lab_falsifier.py:23: python3 lab_falsifier.py --report PATH --output PATH tools/lab_falsifier.py:26: 0 report coerente (nessun flag) tools/lab_falsifier.py:34:import argparse tools/lab_falsifier.py:47:FALSIFIER_PROMPT = """Sei il Counter-Pole del lab fisica D-ND. Polo asimmetrico opposto al producer agent: il suo occhio cerca pattern, il tuo cerca inconsistenze. NON riscrivi il report. Lo sfidi. tools/lab_falsifier.py:50:1. Il report markdown che il producer ha appena scritto. tools/lab_falsifier.py:57:Un claim "impossibile / proibito / zero / proibition / forbidden" e' HARD constraint e richiede uno zero ESATTO nei dati (probabilita' = 0.000). Se la matrice citata ha qualunque entry non-zero dove il report dice "zero", flag. Bias != proibizione. tools/lab_falsifier.py:60:Confronto fra spazi degli stati di taglia diversa (es. mod 3 vs mod 30, N piccolo vs N grande, finestra stretta vs larga): le percentuali ingannano perche' il denominatore cresce. Stesso segnale assoluto SEMBRA ridursi in %. Se il report conclude "diminuisce / si dilata / declina" su confronti percentuali fra spazi, flag e proponi unita' assolute (bit di mutual information, count grezzi, soglie esatte). tools/lab_falsifier.py:66:Un'eccezione 1 su N (con N grande) NON e' zero. Se il report dice "sempre X" o "mai X" e i dati mostrano anche un singolo controesempio, il perimetro deve essere riformulato ("per p > 3, X vale") — mai arrotondato via. tools/lab_falsifier.py:73:La riga `Contaminazione cognitiva` del report deve nominare almeno una voce tools/lab_falsifier.py:89: "claim": "", tools/lab_falsifier.py:94: "summary": "" tools/lab_falsifier.py:103:- Sii specifico: "matrice mod 5 senza zeri ma report dice 25% prohibition" e' un flag; "il report usa gergo" non lo e'. tools/lab_falsifier.py:107:Ecco il report e i dati: tools/lab_falsifier.py:128:def build_context(report_path: Path) -> str: tools/lab_falsifier.py:129: """Compose report + data context for the prompt.""" tools/lab_falsifier.py:132: parts.append(_read_safe(report_path, 9000)) tools/lab_falsifier.py:207:def main() -> int: tools/lab_falsifier.py:208: parser = argparse.ArgumentParser(description="Counter-pole gate for the lab") tools/lab_falsifier.py:209: parser.add_argument("--report", required=True, help="Path to agent_TS.md") tools/lab_falsifier.py:214: report_path = Path(args.report) tools/lab_falsifier.py:217: if not report_path.exists(): tools/lab_falsifier.py:218: print(f"[falsifier] report non esiste: {report_path}", file=sys.stderr) tools/lab_falsifier.py:220: if report_path.stat().st_size < 200: tools/lab_falsifier.py:221: print(f"[falsifier] report troppo corto ({report_path.stat().st_size} bytes), skip", file=sys.stderr) tools/lab_falsifier.py:224: context = build_context(report_path) tools/lab_falsifier.py:244: "report_file": report_path.name, exec /bin/bash -lc 'python tools/exp_prime_mobius_zero_mediator_gate.py --help' in /opt/MM_D-ND diff --git a/tools/data/reports/agent_20260508_2108.md b/tools/data/reports/agent_20260508_2108.md new file mode 100644 index 0000000000000000000000000000000000000000..d3b8fa5889b9587b0e01270608220848eb4d5ed7 --- /dev/null +++ b/tools/data/reports/agent_20260508_2108.md @@ -0,0 +1,103 @@ +# Agent Report - Prime Mobius Zero-Mediator Gate +**Date**: 2026-05-08 21:08 +**Piano**: 93 +**Tension explored**: DUALITA_DIPOLARE_VS_ILLUSORIA (0.9) +**verdict**: CONSTRAINT +observables_registry: 1.0.0-2026-05-06 +observables_used: [low_low_rate, high_high_rate, SR, det_M_direct_control] +**observable_contract**: claim=lo zero della carica Mobius intervallare e' testato come terzo incluso del gate aligned/misaligned; observable=rate low_low, rate high_high, SR mean per classi aligned/misaligned/zero; operator=classificazione di S_n*S_{n+1}: aligned<0, misaligned>0, zero=0; generator=prime gaps up to p<=1e6 with Mobius sieve; denominator=main N={5000,10000,20000} offset=0 plus seedcheck offsets {3000,7000,11000}; not_tested=gap_ratio Sturmian, high-core phi survival, universal GUE/Poisson classification. + +## Respiro fuori-tempo +- **Combo**: A2 confine det=-1 + A9 terzo incluso + A11 combo + QxG continuo/discreto vuoto + DUALITA_DIPOLARE_VS_ILLUSORIA + piano primi x Mobius. Il repair non cerca un lettore nuovo: riporta nel denominatore il punto escluso dal source cycle, `S=0`. +- **Dipolo / punto-zero**: carica Mobius alternata / carica Mobius concorde; punto-zero = transizione con almeno un intervallo a carica nulla (`S_n*S_{n+1}=0`). +- **Piano superiore**: boundary operator su grafo aritmetico. Il gap e' bordo tra primi; la carica Mobius del vuoto tra primi decide se il bordo e' solo rumore di lunghezza o classe informativa. +- **Operatori laterali scelti**: boundary operator, random walk, entropia. Boundary operator definisce il bordo prime-free; random walk fornisce il null di permutazione della carica; entropia entra come dispersione del vuoto senza primi. +- **Contaminazione cognitiva**: + - **CE-0117**: usato per non promuovere il source cycle e far passare il risultato da potenziale a vincolo misurato. + - **CE-0038**: usato per riportare la forma nel Nulla-Tutto al vuoto aritmetico, qui lo zero `S=0`. + - **CE-0001 / KSAR**: usato come kernel reiterativo del ciclo 2102, con riparazione regressiva sul denominatore. + - **PVI attack**: il segnale puo' essere effetto di lunghezza del gap; per questo il null permuta l'intera sequenza delle cariche preservando multiset e frequenza degli zeri. +- **Proto-ipotesi**: se `S=0` e' terzo incluso operativo, non cade come rumore sotto il null che preserva la frequenza degli zeri. Deve produrre una classe distinguibile su low_low/high_high/SR. Se resta dentro il null, il source cycle sopravvive solo come gate binario non-zero. +- **Proiezione**: confronto aligned, misaligned e zero su `low_low`, `high_high` e `SR`; null = 400 permutazioni della sequenza `S_n`, gap invariati, multiset delle cariche invariata. + +## Claim Under Test +> Nel perimetro primi x Mobius fino a `p<=1e6`, le transizioni con `S=0` non vanno escluse: formano una terza classe del gate intervallare e vanno confrontate contro aligned/misaligned con null che preserva la frequenza degli zeri. + +## Question +Lo zero della carica Mobius intervallare e' rumore, boundary o mediatore del segnale low-low/high-high/SR? + +## Experiment Design +- Script: `tools/exp_prime_mobius_zero_mediator_gate.py`. +- Dati: primi fino a `1_000_000`; Mobius sieve sullo stesso perimetro. +- Carica intervallare: `S_n = sum(mu(k))` per `p_n < k < p_{n+1}`. +- Classi: + - `aligned`: `S_n*S_{n+1}<0`. + - `misaligned`: `S_n*S_{n+1}>0`. + - `zero`: `S_n*S_{n+1}=0`. +- Osservabili: + - `low_low_rate`: count di due gap consecutivi `<=6` sul denominatore della classe. + - `high_high_rate`: count di due gap consecutivi `>=q75` sul denominatore della classe. + - `SR`: mean min/max ratio dei gap consecutivi. +- Null test: 400 permutazioni della sequenza `S_n`; il null preserva la multiset completa delle cariche e quindi la frequenza degli zeri. +- Controllo det(M) diretto: `M=[[1,1],[1,0]]` ha `det(M)=-1` costante su ogni transizione; il controllo non partiziona il denominatore e restituisce solo le baseline globali low/high/SR. +- Soglia ex ante: `|z|>=2` e `p_two_sided<=0.05`. +- Contratto osservabile-operatore: `gap_ratio` Sturmian non testato; il source cycle 2102 non viene promosso; il claim su det diretto viene sostituito da controllo esplicito, non da conclusione non misurata. + +## Results +| condition | a/m/z denom | zero charges | low a | low m | low z | low z0 vs nonzero z/p | high a | high m | high z | high z0 vs nonzero z/p | SR a | SR m | SR z | SR z0 vs nonzero z/p | +|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:| +| N=5000 off=0 | 1200/1572/2227 | 1258/5000 | 221/1200 | 220/1572 | 707/2227 | 11.77 / 0.002 | 115/1200 | 298/1572 | 101/2227 | -10.80 / 0.002 | 0.51559 | 0.52611 | 0.43203 | -11.15 / 0.002 | +| N=10000 off=0 | 2541/3102/4356 | 2457/10000 | 403/2541 | 377/3102 | 1190/4356 | 14.88 / 0.002 | 153/2541 | 363/3102 | 114/4356 | -12.31 / 0.002 | 0.50841 | 0.51502 | 0.42221 | -16.03 / 0.002 | +| N=20000 off=0 | 5171/6331/8497 | 4782/20000 | 694/5171 | 651/6331 | 2093/8497 | 22.31 / 0.002 | 422/5171 | 878/6331 | 281/8497 | -18.75 / 0.002 | 0.50324 | 0.51151 | 0.41571 | -23.13 / 0.002 | +| N=5000 off=3000 | 1313/1525/2161 | 1219/5000 | 184/1313 | 162/1525 | 522/2161 | 9.84 / 0.002 | 86/1313 | 187/1525 | 71/2161 | -8.13 / 0.002 | 0.50993 | 0.50560 | 0.42213 | -10.87 / 0.002 | +| N=10000 off=7000 | 2675/3178/4146 | 2318/10000 | 315/2675 | 298/3178 | 946/4146 | 16.40 / 0.002 | 182/2675 | 351/3178 | 98/4146 | -13.27 / 0.002 | 0.50225 | 0.50729 | 0.40695 | -17.18 / 0.002 | +| N=20000 off=11000 | 5407/6413/8179 | 4586/20000 | 553/5407 | 567/6413 | 1740/8179 | 20.63 / 0.002 | 295/5407 | 667/6413 | 178/8179 | -16.22 / 0.002 | 0.49723 | 0.50997 | 0.41131 | -22.87 / 0.002 | + +### Pairwise aligned/misaligned checks +| condition | low a-m diff z/p | high a-m diff z/p | SR a-m diff z/p | +|---|---:|---:|---:| +| N=5000 off=0 | +0.04422 2.47 / 0.015 | -0.09373 -7.96 / 0.002 | -0.01053 -1.12 / 0.277 | +| N=10000 off=0 | +0.03706 3.44 / 0.002 | -0.05681 -8.90 / 0.002 | -0.00661 -0.90 / 0.357 | +| N=20000 off=0 | +0.03138 4.56 / 0.002 | -0.05707 -10.48 / 0.002 | -0.00827 -1.78 / 0.097 | +| N=5000 off=3000 | +0.03391 2.37 / 0.022 | -0.05712 -5.66 / 0.002 | +0.00433 0.48 / 0.671 | +| N=10000 off=7000 | +0.02399 2.68 / 0.010 | -0.04241 -6.58 / 0.002 | -0.00504 -0.71 / 0.501 | +| N=20000 off=11000 | +0.01386 1.97 / 0.040 | -0.04945 -10.96 / 0.002 | -0.01274 -2.50 / 0.015 | + +### det(M) direct control +`det(M)=-1` e' costante. Il controllo ha una sola classe su ogni condizione, quindi non separa aligned/misaligned/zero. Baseline globali: low_low `1148/4999`, `1970/9999`, `3438/19999`, `868/4999`, `1559/9999`, `2860/19999`; high_high `514/4999`, `630/9999`, `1581/19999`, `344/4999`, `631/9999`, `1140/19999`; SR globale `0.48167`, `0.47291`, `0.46867`, `0.47066`, `0.46434`, `0.46618`. + +## Key Findings +1. **Verificato: lo zero non e' rumore sotto il null usato.** La classe zero supera il null in 6/6 condizioni su `low_low_zero_minus_nonzero`, `high_high_zero_minus_nonzero` e `sr_zero_minus_nonzero`, sempre con `p=0.002` e `|z|` da `8.13` a `23.13`. + +2. **Verificato: lo zero e' una terza classe, non un mediatore tra aligned e misaligned.** Su low_low lo zero e' sopra entrambe le classi non-zero (`0.21274..0.31747` contro aligned `0.10227..0.18417` e misaligned `0.08841..0.13995`). Su high_high lo zero e' sotto entrambe (`0.02176..0.04535` contro aligned `0.05456..0.09583` e misaligned `0.10401..0.18957`). Su SR lo zero e' sotto entrambe (`0.40695..0.43203` contro non-zero circa `0.49723..0.52611`). Il punto-zero non sta tra i poli: genera una classe propria. + +3. **Verificato: il contrasto aligned/misaligned sopravvive soprattutto su high_high.** `high_high_aligned_minus_misaligned` passa 6/6 con z da `-5.66` a `-10.96`. `low_low_aligned_minus_misaligned` passa 5/6 se la soglia richiede anche `|z|>=2`; l'ultima condizione ha `z=1.97`, `p=0.040`, quindi resta borderline e non autorizza hard wording. SR passa 1/6 e resta osservabile secondario. + +4. **Verificato: il controllo det(M) diretto risolve il flag L3 del source cycle.** `det(M)` costante non produce partizione del denominatore; il report non conclude che la dualita "non si legge" da det diretto come fatto empirico generale. Qui dichiara solo che, in questo controllo, det(M) diretto non e' un discriminatore di classe. + +## Verdict +**CONSTRAINT on DUALITA_DIPOLARE_VS_ILLUSORIA / Prime Mobius interval-charge gate**: nel perimetro primi x Mobius fino a `p<=1e6`, `S=0` deve restare nel denominatore come terza classe. Lo zero non e' rumore sotto il null di permutazione che preserva frequenza degli zeri: arricchisce low_low, sopprime high_high e abbassa SR in 6/6 condizioni. Il source cycle sopravvive come vincolo parziale: il gate non-zero aligned/misaligned resta solido per high_high, resta parziale per low_low, e non porta SR globalmente. Il nuovo portatore e' triadico: aligned / misaligned / zero. + +## Bicono della scoperta +- **Due radici**: carica non-zero alternata/concorde . carica zero dell'intervallo prime-free. +- **Singolare**: il vuoto tra primi prima della scelta binaria; `S=0` non e' assenza di segnale ma classe del bordo. +- **Invariante di passaggio**: il null conserva gap, multiset delle cariche e frequenza degli zeri; cio' che sopravvive e' l'accoppiamento ordine-carica, non la sola presenza dello zero. +- **Campo di possibilita**: qui diventa possibile testare un gate triadico del boundary aritmetico. Qui diventa non-possibile escludere `S=0` dal denominatore quando si parla di terzo incluso nel perimetro Mobius-primi. + +## Consecutio +Il prossimo passo deve separare terza classe autentica da effetto scala dell'intervallo: ripetere il gate con controllo che preserva anche la lunghezza del gap o stratifica per bucket di gap length. Se lo zero resta significativo dentro ogni bucket, il boundary e' aritmetico; se cade, il segnale e' dipendenza da lunghezza. + +## Auto-audit: source flags e 5 lenti +- **Source L3 resolved**: il report non usa un elemento `not_tested` come conclusione. Il controllo det(M) diretto e' misurato e dichiarato non partizionante nel perimetro. +- **Source denominator repair resolved**: `S=0` e' incluso come classe esplicita, con count grezzi e denominatore. +- **Aperto**: non e' ancora separata la dipendenza dalla lunghezza del gap; serve controllo stratificato. +- **L1 hard constraint vs bias**: nessun "sempre/mai"; perimetro dichiarato `p<=1e6`, sei condizioni, 400 permutazioni. +- **L2 quantita vs ratio**: count grezzi e denominatori riportati; SR separato dai rate. +- **L3 no silent patching**: claim corretto prima del test; il source cycle non viene promosso. +- **L4 edge cases**: `low_low` non-zero e' borderline in una condizione (`z=1.97`), quindi resta parziale. +- **L5 re-discovery vs discovery**: verdict `CONSTRAINT`, non `NEW`; il pattern resta da confrontare con dipendenze note tra Mobius, lunghezza intervallare e gap primes. + +## Files +- Script: `tools/exp_prime_mobius_zero_mediator_gate.py` +- Data: `tools/data/prime_mobius_zero_mediator_gate_20260508_2108.json` +- Report: `tools/data/reports/agent_20260508_2108.md` diff --git a/tools/exp_prime_mobius_zero_mediator_gate.py b/tools/exp_prime_mobius_zero_mediator_gate.py new file mode 100644 index 0000000000000000000000000000000000000000..95ecd6e07c1863f3ffd3a3a5297a8628a00fd8be --- /dev/null +++ b/tools/exp_prime_mobius_zero_mediator_gate.py @@ -0,0 +1,314 @@ +#!/usr/bin/env python3 +"""Prime x Mobius zero-mediator gate. + +Repairs the 20260508_2102 interval-charge gate by keeping transitions with +S=0 in the denominator as an explicit third class. +""" +from __future__ import annotations + +import argparse +import json +from pathlib import Path + +import numpy as np + +from exp_prime_mobius_interval_charge_gate import ( + interval_charges, + mobius_sieve, + sieve_primes, +) + + +METRIC_KEYS = [ + "low_low_aligned_rate", + "low_low_misaligned_rate", + "low_low_zero_rate", + "high_high_aligned_rate", + "high_high_misaligned_rate", + "high_high_zero_rate", + "sr_aligned_mean", + "sr_misaligned_mean", + "sr_zero_mean", + "low_low_aligned_minus_misaligned", + "low_low_zero_minus_nonzero", + "high_high_aligned_minus_misaligned", + "high_high_zero_minus_nonzero", + "sr_aligned_minus_misaligned", + "sr_zero_minus_nonzero", +] + + +def _rate(mask: np.ndarray, event: np.ndarray) -> tuple[int, int, float]: + denom = int(np.sum(mask)) + hits = int(np.sum(mask & event)) + rate = float(hits / denom) if denom else float("nan") + return hits, denom, rate + + +def _mean(mask: np.ndarray, values: np.ndarray) -> tuple[int, float]: + denom = int(np.sum(mask)) + mean = float(np.mean(values[mask])) if denom else float("nan") + return denom, mean + + +def transition_metrics_three_class(gaps: np.ndarray, charges: np.ndarray) -> dict[str, float | int]: + left = charges[:-1] + right = charges[1:] + product = left * right + aligned = product < 0 + misaligned = product > 0 + zero = product == 0 + nonzero = ~zero + + g0 = gaps[:-1].astype(float) + g1 = gaps[1:].astype(float) + ratio = np.minimum(g0, g1) / np.maximum(g0, g1) + low_low = (g0 <= 6) & (g1 <= 6) + q75 = float(np.quantile(gaps, 0.75)) + high_high = (g0 >= q75) & (g1 >= q75) + + metrics: dict[str, float | int] = { + "q75_gap": q75, + "aligned_count": int(np.sum(aligned)), + "misaligned_count": int(np.sum(misaligned)), + "zero_count": int(np.sum(zero)), + "nonzero_count": int(np.sum(nonzero)), + } + + for name, event in (("low_low", low_low), ("high_high", high_high)): + for cls_name, mask in ( + ("aligned", aligned), + ("misaligned", misaligned), + ("zero", zero), + ("nonzero", nonzero), + ): + hits, denom, rate = _rate(mask, event) + metrics[f"{name}_{cls_name}_hits"] = hits + metrics[f"{name}_{cls_name}_denom"] = denom + metrics[f"{name}_{cls_name}_rate"] = rate + + for cls_name, mask in ( + ("aligned", aligned), + ("misaligned", misaligned), + ("zero", zero), + ("nonzero", nonzero), + ): + denom, mean = _mean(mask, ratio) + metrics[f"sr_{cls_name}_denom"] = denom + metrics[f"sr_{cls_name}_mean"] = mean + + metrics["low_low_aligned_minus_misaligned"] = ( + float(metrics["low_low_aligned_rate"]) - float(metrics["low_low_misaligned_rate"]) + ) + metrics["high_high_aligned_minus_misaligned"] = ( + float(metrics["high_high_aligned_rate"]) - float(metrics["high_high_misaligned_rate"]) + ) + metrics["sr_aligned_minus_misaligned"] = ( + float(metrics["sr_aligned_mean"]) - float(metrics["sr_misaligned_mean"]) + ) + metrics["low_low_zero_minus_nonzero"] = ( + float(metrics["low_low_zero_rate"]) - float(metrics["low_low_nonzero_rate"]) + ) + metrics["high_high_zero_minus_nonzero"] = ( + float(metrics["high_high_zero_rate"]) - float(metrics["high_high_nonzero_rate"]) + ) + metrics["sr_zero_minus_nonzero"] = ( + float(metrics["sr_zero_mean"]) - float(metrics["sr_nonzero_mean"]) + ) + return metrics + + +def permutation_test( + gaps: np.ndarray, + charges: np.ndarray, + observed: dict[str, float | int], + rng: np.random.Generator, + permutations: int, +) -> dict[str, dict[str, float]]: + nulls = {key: [] for key in METRIC_KEYS} + for _ in range(permutations): + shuffled = np.array(charges, copy=True) + rng.shuffle(shuffled) + metrics = transition_metrics_three_class(gaps, shuffled) + for key in METRIC_KEYS: + nulls[key].append(float(metrics[key])) + + out: dict[str, dict[str, float]] = {} + for key, values in nulls.items(): + arr = np.array(values, dtype=float) + obs = float(observed[key]) + finite = np.isfinite(arr) + arr = arr[finite] + if arr.size == 0 or not np.isfinite(obs): + out[key] = {"observed": obs, "null_mean": float("nan"), "null_std": float("nan"), "z": float("nan"), "p_two_sided": float("nan")} + continue + std = float(np.std(arr, ddof=1)) + z = (obs - float(np.mean(arr))) / std if std > 0 else 0.0 + p = float((np.sum(np.abs(arr) >= abs(obs)) + 1) / (len(arr) + 1)) + out[key] = { + "observed": obs, + "null_mean": float(np.mean(arr)), + "null_std": std, + "z": float(z), + "p_two_sided": p, + } + return out + + +def det_m_direct_control(gaps: np.ndarray) -> dict[str, float | int | str]: + g0 = gaps[:-1].astype(float) + g1 = gaps[1:].astype(float) + ratio = np.minimum(g0, g1) / np.maximum(g0, g1) + low_low = (g0 <= 6) & (g1 <= 6) + q75 = float(np.quantile(gaps, 0.75)) + high_high = (g0 >= q75) & (g1 >= q75) + denom = int(g0.size) + return { + "det_M": -1, + "class_count": 1, + "reason": "M=[[1,1],[1,0]] has constant determinant -1 on every transition, so direct det(M) does not partition the denominator.", + "denominator": denom, + "low_low_hits": int(np.sum(low_low)), + "low_low_rate": float(np.sum(low_low) / denom), + "high_high_hits": int(np.sum(high_high)), + "high_high_rate": float(np.sum(high_high) / denom), + "sr_mean": float(np.mean(ratio)), + } + + +def classify_zero_role(observed: dict[str, float | int], tests: dict[str, dict[str, float]]) -> str: + low_z = tests["low_low_zero_minus_nonzero"]["z"] + high_z = tests["high_high_zero_minus_nonzero"]["z"] + sr_z = tests["sr_zero_minus_nonzero"]["z"] + passes = [ + abs(low_z) >= 2 and tests["low_low_zero_minus_nonzero"]["p_two_sided"] <= 0.05, + abs(high_z) >= 2 and tests["high_high_zero_minus_nonzero"]["p_two_sided"] <= 0.05, + abs(sr_z) >= 2 and tests["sr_zero_minus_nonzero"]["p_two_sided"] <= 0.05, + ] + low = float(observed["low_low_zero_rate"]) + high = float(observed["high_high_zero_rate"]) + sr = float(observed["sr_zero_mean"]) + low_a = float(observed["low_low_aligned_rate"]) + low_m = float(observed["low_low_misaligned_rate"]) + high_a = float(observed["high_high_aligned_rate"]) + high_m = float(observed["high_high_misaligned_rate"]) + sr_a = float(observed["sr_aligned_mean"]) + sr_m = float(observed["sr_misaligned_mean"]) + + between_low = min(low_a, low_m) <= low <= max(low_a, low_m) + between_high = min(high_a, high_m) <= high <= max(high_a, high_m) + between_sr = min(sr_a, sr_m) <= sr <= max(sr_a, sr_m) + + if any(passes) and (between_low or between_high or between_sr): + return "boundary" + if any(passes): + return "third_class" + return "noise_under_this_null" + + +def run_condition( + primes: np.ndarray, + mu: np.ndarray, + n_primes: int, + offset: int, + rng: np.random.Generator, + permutations: int, +) -> dict[str, object]: + segment = primes[offset : offset + n_primes + 1] + gaps = np.diff(segment) + charges = interval_charges(segment, mu) + observed = transition_metrics_three_class(gaps, charges) + tests = permutation_test(gaps, charges, observed, rng, permutations) + return { + "n_primes": n_primes, + "offset": offset, + "prime_start": int(segment[0]), + "prime_stop": int(segment[-1]), + "zero_charge_count": int(np.sum(charges == 0)), + "charge_count": int(charges.size), + "observed": observed, + "permutation_tests": tests, + "zero_role": classify_zero_role(observed, tests), + "det_m_direct_control": det_m_direct_control(gaps), + } + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--limit", type=int, default=1_000_000) + parser.add_argument("--permutations", type=int, default=400) + parser.add_argument("--seed", type=int, default=2108) + parser.add_argument("--out", default="tools/data/prime_mobius_zero_mediator_gate_20260508_2108.json") + args = parser.parse_args() + + primes = sieve_primes(args.limit) + mu = mobius_sieve(args.limit) + rng = np.random.default_rng(args.seed) + + conditions = [ + {"n_primes": 5_000, "offset": 0}, + {"n_primes": 10_000, "offset": 0}, + {"n_primes": 20_000, "offset": 0}, + {"n_primes": 5_000, "offset": 3_000}, + {"n_primes": 10_000, "offset": 7_000}, + {"n_primes": 20_000, "offset": 11_000}, + ] + max_needed = max(c["offset"] + c["n_primes"] + 1 for c in conditions) + if len(primes) <= max_needed: + raise SystemExit(f"limit={args.limit} yields only {len(primes)} primes, need {max_needed}") + + results = [ + run_condition(primes, mu, c["n_primes"], c["offset"], rng, args.permutations) + for c in conditions + ] + summary = [] + for result in results: + tests = result["permutation_tests"] + summary.append( + { + "n_primes": result["n_primes"], + "offset": result["offset"], + "low_low_aligned_minus_misaligned_pass": abs(tests["low_low_aligned_minus_misaligned"]["z"]) >= 2.0 + and tests["low_low_aligned_minus_misaligned"]["p_two_sided"] <= 0.05, + "high_high_aligned_minus_misaligned_pass": abs(tests["high_high_aligned_minus_misaligned"]["z"]) >= 2.0 + and tests["high_high_aligned_minus_misaligned"]["p_two_sided"] <= 0.05, + "sr_aligned_minus_misaligned_pass": abs(tests["sr_aligned_minus_misaligned"]["z"]) >= 2.0 + and tests["sr_aligned_minus_misaligned"]["p_two_sided"] <= 0.05, + "zero_role": result["zero_role"], + } + ) + + payload = { + "experiment": "prime_mobius_zero_mediator_gate", + "question": "Does S=0 behave as noise, boundary, or mediator in the Mobius interval-charge gate?", + "threshold_ex_ante": "|z|>=2 and permutation p<=0.05 across main and offset conditions", + "null": "Permutation of the interval-charge sequence preserves the full charge multiset and therefore preserves zero frequency.", + "limit": args.limit, + "permutations": args.permutations, + "seed": args.seed, + "conditions": results, + "significance_summary": summary, + } + + out = Path(args.out) + out.parent.mkdir(parents=True, exist_ok=True) + out.write_text(json.dumps(payload, indent=2), encoding="utf-8") + + for result in results: + obs = result["observed"] + tests = result["permutation_tests"] + print( + f"N={result['n_primes']} offset={result['offset']} " + f"a/m/z={obs['aligned_count']}/{obs['misaligned_count']}/{obs['zero_count']} " + f"low_am={obs['low_low_aligned_minus_misaligned']:.5f} z={tests['low_low_aligned_minus_misaligned']['z']:.2f} p={tests['low_low_aligned_minus_misaligned']['p_two_sided']:.3f} " + f"low_z0={obs['low_low_zero_minus_nonzero']:.5f} z={tests['low_low_zero_minus_nonzero']['z']:.2f} p={tests['low_low_zero_minus_nonzero']['p_two_sided']:.3f} " + f"high_am={obs['high_high_aligned_minus_misaligned']:.5f} z={tests['high_high_aligned_minus_misaligned']['z']:.2f} p={tests['high_high_aligned_minus_misaligned']['p_two_sided']:.3f} " + f"high_z0={obs['high_high_zero_minus_nonzero']:.5f} z={tests['high_high_zero_minus_nonzero']['z']:.2f} p={tests['high_high_zero_minus_nonzero']['p_two_sided']:.3f} " + f"sr_am={obs['sr_aligned_minus_misaligned']:.5f} z={tests['sr_aligned_minus_misaligned']['z']:.2f} p={tests['sr_aligned_minus_misaligned']['p_two_sided']:.3f} " + f"role={result['zero_role']}" + ) + print(f"wrote {out}") + + +if __name__ == "__main__": + main() succeeded in 111ms: exec /bin/bash -lc "sed -n '191,260p' tools/structural_check.py && sed -n '207,270p' tools/lab_falsifier.py" in /opt/MM_D-ND succeeded in 0ms: def main(): inject = '--inject' in sys.argv args = [a for a in sys.argv[1:] if not a.startswith('--')] if args: files = [Path(a) for a in args if Path(a).exists()] else: files = scan_modified_files() if not files: print("Nessun file da scansionare.") return print(f"Scansione {len(files)} file...") all_findings = [] for f in files: findings = scan_file(f) all_findings.extend(findings) if not all_findings: print("Nessun anti-pattern trovato.") return # Report by_severity = {} for f in all_findings: by_severity.setdefault(f['severity'], []).append(f) for sev in ['alto', 'medio', 'basso']: items = by_severity.get(sev, []) if items: print(f"\n{'='*60}") print(f" {sev.upper()} ({len(items)})") print(f"{'='*60}") for item in items: print(f" {Path(item['file']).name}:{item['line']} [{item['pattern_id']}]") print(f" {item['code']}") print(f"\nTotale: {len(all_findings)} anti-pattern in {len(set(f['file'] for f in all_findings))} file") if inject: if inject_tension(all_findings): print("\nTensione META iniettata nel seme.") else: print("\nErrore: impossibile iniettare tensione.") if __name__ == '__main__': main() def main() -> int: parser = argparse.ArgumentParser(description="Counter-pole gate for the lab") parser.add_argument("--report", required=True, help="Path to agent_TS.md") parser.add_argument("--output", required=True, help="Path for falsifier_TS.json output") parser.add_argument("--timeout", type=int, default=240, help="LLM call timeout seconds") args = parser.parse_args() report_path = Path(args.report) out_path = Path(args.output) if not report_path.exists(): print(f"[falsifier] report non esiste: {report_path}", file=sys.stderr) return 2 if report_path.stat().st_size < 200: print(f"[falsifier] report troppo corto ({report_path.stat().st_size} bytes), skip", file=sys.stderr) return 2 context = build_context(report_path) prompt = FALSIFIER_PROMPT.replace("{context}", context) raw, exit_code = call_falsifier_llm(prompt, timeout_s=args.timeout) if not raw or exit_code != 0: # Save raw for debugging out_path.parent.mkdir(parents=True, exist_ok=True) (out_path.with_suffix(".raw.txt")).write_text(raw or f"") print(f"[falsifier] LLM call failed (exit={exit_code}). Conservative: BLOCK.", file=sys.stderr) return 2 parsed = extract_json(raw) if parsed is None: out_path.parent.mkdir(parents=True, exist_ok=True) (out_path.with_suffix(".raw.txt")).write_text(raw) print(f"[falsifier] output non JSON-parseable. Conservative: BLOCK.", file=sys.stderr) return 2 # Normalize + persist record = { "report_file": report_path.name, "marked_at": datetime.now(timezone.utc).isoformat(), "coherent": parsed.get("coherent"), "flags": parsed.get("flags") or [], "summary": parsed.get("summary", ""), } out_path.parent.mkdir(parents=True, exist_ok=True) out_path.write_text(json.dumps(record, indent=2, ensure_ascii=False)) flags = record["flags"] n_high = sum(1 for f in flags if isinstance(f, dict) and (f.get("severity") or "").lower() == "high") n_total = len(flags) summary_short = (record.get("summary") or "")[:200] print(f"[falsifier] flags: {n_total} ({n_high} HIGH). coherent={record['coherent']}.") print(f"[falsifier] summary: {summary_short}") print(f"[falsifier] output → {out_path}") if n_high > 0: print(f"[falsifier] HIGH severity flags → exit 1 (SYNC BLOCK)") return 1 return 0 if __name__ == "__main__": sys.exit(main()) diff --git a/tools/data/reports/agent_20260508_2108.md b/tools/data/reports/agent_20260508_2108.md new file mode 100644 index 0000000000000000000000000000000000000000..d3b8fa5889b9587b0e01270608220848eb4d5ed7 --- /dev/null +++ b/tools/data/reports/agent_20260508_2108.md @@ -0,0 +1,103 @@ +# Agent Report - Prime Mobius Zero-Mediator Gate +**Date**: 2026-05-08 21:08 +**Piano**: 93 +**Tension explored**: DUALITA_DIPOLARE_VS_ILLUSORIA (0.9) +**verdict**: CONSTRAINT +observables_registry: 1.0.0-2026-05-06 +observables_used: [low_low_rate, high_high_rate, SR, det_M_direct_control] +**observable_contract**: claim=lo zero della carica Mobius intervallare e' testato come terzo incluso del gate aligned/misaligned; observable=rate low_low, rate high_high, SR mean per classi aligned/misaligned/zero; operator=classificazione di S_n*S_{n+1}: aligned<0, misaligned>0, zero=0; generator=prime gaps up to p<=1e6 with Mobius sieve; denominator=main N={5000,10000,20000} offset=0 plus seedcheck offsets {3000,7000,11000}; not_tested=gap_ratio Sturmian, high-core phi survival, universal GUE/Poisson classification. + +## Respiro fuori-tempo +- **Combo**: A2 confine det=-1 + A9 terzo incluso + A11 combo + QxG continuo/discreto vuoto + DUALITA_DIPOLARE_VS_ILLUSORIA + piano primi x Mobius. Il repair non cerca un lettore nuovo: riporta nel denominatore il punto escluso dal source cycle, `S=0`. +- **Dipolo / punto-zero**: carica Mobius alternata / carica Mobius concorde; punto-zero = transizione con almeno un intervallo a carica nulla (`S_n*S_{n+1}=0`). +- **Piano superiore**: boundary operator su grafo aritmetico. Il gap e' bordo tra primi; la carica Mobius del vuoto tra primi decide se il bordo e' solo rumore di lunghezza o classe informativa. +- **Operatori laterali scelti**: boundary operator, random walk, entropia. Boundary operator definisce il bordo prime-free; random walk fornisce il null di permutazione della carica; entropia entra come dispersione del vuoto senza primi. +- **Contaminazione cognitiva**: + - **CE-0117**: usato per non promuovere il source cycle e far passare il risultato da potenziale a vincolo misurato. + - **CE-0038**: usato per riportare la forma nel Nulla-Tutto al vuoto aritmetico, qui lo zero `S=0`. + - **CE-0001 / KSAR**: usato come kernel reiterativo del ciclo 2102, con riparazione regressiva sul denominatore. + - **PVI attack**: il segnale puo' essere effetto di lunghezza del gap; per questo il null permuta l'intera sequenza delle cariche preservando multiset e frequenza degli zeri. +- **Proto-ipotesi**: se `S=0` e' terzo incluso operativo, non cade come rumore sotto il null che preserva la frequenza degli zeri. Deve produrre una classe distinguibile su low_low/high_high/SR. Se resta dentro il null, il source cycle sopravvive solo come gate binario non-zero. +- **Proiezione**: confronto aligned, misaligned e zero su `low_low`, `high_high` e `SR`; null = 400 permutazioni della sequenza `S_n`, gap invariati, multiset delle cariche invariata. + +## Claim Under Test +> Nel perimetro primi x Mobius fino a `p<=1e6`, le transizioni con `S=0` non vanno escluse: formano una terza classe del gate intervallare e vanno confrontate contro aligned/misaligned con null che preserva la frequenza degli zeri. + +## Question +Lo zero della carica Mobius intervallare e' rumore, boundary o mediatore del segnale low-low/high-high/SR? + +## Experiment Design +- Script: `tools/exp_prime_mobius_zero_mediator_gate.py`. +- Dati: primi fino a `1_000_000`; Mobius sieve sullo stesso perimetro. +- Carica intervallare: `S_n = sum(mu(k))` per `p_n < k < p_{n+1}`. +- Classi: + - `aligned`: `S_n*S_{n+1}<0`. + - `misaligned`: `S_n*S_{n+1}>0`. + - `zero`: `S_n*S_{n+1}=0`. +- Osservabili: + - `low_low_rate`: count di due gap consecutivi `<=6` sul denominatore della classe. + - `high_high_rate`: count di due gap consecutivi `>=q75` sul denominatore della classe. + - `SR`: mean min/max ratio dei gap consecutivi. +- Null test: 400 permutazioni della sequenza `S_n`; il null preserva la multiset completa delle cariche e quindi la frequenza degli zeri. +- Controllo det(M) diretto: `M=[[1,1],[1,0]]` ha `det(M)=-1` costante su ogni transizione; il controllo non partiziona il denominatore e restituisce solo le baseline globali low/high/SR. +- Soglia ex ante: `|z|>=2` e `p_two_sided<=0.05`. +- Contratto osservabile-operatore: `gap_ratio` Sturmian non testato; il source cycle 2102 non viene promosso; il claim su det diretto viene sostituito da controllo esplicito, non da conclusione non misurata. + +## Results +| condition | a/m/z denom | zero charges | low a | low m | low z | low z0 vs nonzero z/p | high a | high m | high z | high z0 vs nonzero z/p | SR a | SR m | SR z | SR z0 vs nonzero z/p | +|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:| +| N=5000 off=0 | 1200/1572/2227 | 1258/5000 | 221/1200 | 220/1572 | 707/2227 | 11.77 / 0.002 | 115/1200 | 298/1572 | 101/2227 | -10.80 / 0.002 | 0.51559 | 0.52611 | 0.43203 | -11.15 / 0.002 | +| N=10000 off=0 | 2541/3102/4356 | 2457/10000 | 403/2541 | 377/3102 | 1190/4356 | 14.88 / 0.002 | 153/2541 | 363/3102 | 114/4356 | -12.31 / 0.002 | 0.50841 | 0.51502 | 0.42221 | -16.03 / 0.002 | +| N=20000 off=0 | 5171/6331/8497 | 4782/20000 | 694/5171 | 651/6331 | 2093/8497 | 22.31 / 0.002 | 422/5171 | 878/6331 | 281/8497 | -18.75 / 0.002 | 0.50324 | 0.51151 | 0.41571 | -23.13 / 0.002 | +| N=5000 off=3000 | 1313/1525/2161 | 1219/5000 | 184/1313 | 162/1525 | 522/2161 | 9.84 / 0.002 | 86/1313 | 187/1525 | 71/2161 | -8.13 / 0.002 | 0.50993 | 0.50560 | 0.42213 | -10.87 / 0.002 | +| N=10000 off=7000 | 2675/3178/4146 | 2318/10000 | 315/2675 | 298/3178 | 946/4146 | 16.40 / 0.002 | 182/2675 | 351/3178 | 98/4146 | -13.27 / 0.002 | 0.50225 | 0.50729 | 0.40695 | -17.18 / 0.002 | +| N=20000 off=11000 | 5407/6413/8179 | 4586/20000 | 553/5407 | 567/6413 | 1740/8179 | 20.63 / 0.002 | 295/5407 | 667/6413 | 178/8179 | -16.22 / 0.002 | 0.49723 | 0.50997 | 0.41131 | -22.87 / 0.002 | + +### Pairwise aligned/misaligned checks +| condition | low a-m diff z/p | high a-m diff z/p | SR a-m diff z/p | +|---|---:|---:|---:| +| N=5000 off=0 | +0.04422 2.47 / 0.015 | -0.09373 -7.96 / 0.002 | -0.01053 -1.12 / 0.277 | +| N=10000 off=0 | +0.03706 3.44 / 0.002 | -0.05681 -8.90 / 0.002 | -0.00661 -0.90 / 0.357 | +| N=20000 off=0 | +0.03138 4.56 / 0.002 | -0.05707 -10.48 / 0.002 | -0.00827 -1.78 / 0.097 | +| N=5000 off=3000 | +0.03391 2.37 / 0.022 | -0.05712 -5.66 / 0.002 | +0.00433 0.48 / 0.671 | +| N=10000 off=7000 | +0.02399 2.68 / 0.010 | -0.04241 -6.58 / 0.002 | -0.00504 -0.71 / 0.501 | +| N=20000 off=11000 | +0.01386 1.97 / 0.040 | -0.04945 -10.96 / 0.002 | -0.01274 -2.50 / 0.015 | + +### det(M) direct control +`det(M)=-1` e' costante. Il controllo ha una sola classe su ogni condizione, quindi non separa aligned/misaligned/zero. Baseline globali: low_low `1148/4999`, `1970/9999`, `3438/19999`, `868/4999`, `1559/9999`, `2860/19999`; high_high `514/4999`, `630/9999`, `1581/19999`, `344/4999`, `631/9999`, `1140/19999`; SR globale `0.48167`, `0.47291`, `0.46867`, `0.47066`, `0.46434`, `0.46618`. + +## Key Findings +1. **Verificato: lo zero non e' rumore sotto il null usato.** La classe zero supera il null in 6/6 condizioni su `low_low_zero_minus_nonzero`, `high_high_zero_minus_nonzero` e `sr_zero_minus_nonzero`, sempre con `p=0.002` e `|z|` da `8.13` a `23.13`. + +2. **Verificato: lo zero e' una terza classe, non un mediatore tra aligned e misaligned.** Su low_low lo zero e' sopra entrambe le classi non-zero (`0.21274..0.31747` contro aligned `0.10227..0.18417` e misaligned `0.08841..0.13995`). Su high_high lo zero e' sotto entrambe (`0.02176..0.04535` contro aligned `0.05456..0.09583` e misaligned `0.10401..0.18957`). Su SR lo zero e' sotto entrambe (`0.40695..0.43203` contro non-zero circa `0.49723..0.52611`). Il punto-zero non sta tra i poli: genera una classe propria. + +3. **Verificato: il contrasto aligned/misaligned sopravvive soprattutto su high_high.** `high_high_aligned_minus_misaligned` passa 6/6 con z da `-5.66` a `-10.96`. `low_low_aligned_minus_misaligned` passa 5/6 se la soglia richiede anche `|z|>=2`; l'ultima condizione ha `z=1.97`, `p=0.040`, quindi resta borderline e non autorizza hard wording. SR passa 1/6 e resta osservabile secondario. + +4. **Verificato: il controllo det(M) diretto risolve il flag L3 del source cycle.** `det(M)` costante non produce partizione del denominatore; il report non conclude che la dualita "non si legge" da det diretto come fatto empirico generale. Qui dichiara solo che, in questo controllo, det(M) diretto non e' un discriminatore di classe. + +## Verdict +**CONSTRAINT on DUALITA_DIPOLARE_VS_ILLUSORIA / Prime Mobius interval-charge gate**: nel perimetro primi x Mobius fino a `p<=1e6`, `S=0` deve restare nel denominatore come terza classe. Lo zero non e' rumore sotto il null di permutazione che preserva frequenza degli zeri: arricchisce low_low, sopprime high_high e abbassa SR in 6/6 condizioni. Il source cycle sopravvive come vincolo parziale: il gate non-zero aligned/misaligned resta solido per high_high, resta parziale per low_low, e non porta SR globalmente. Il nuovo portatore e' triadico: aligned / misaligned / zero. + +## Bicono della scoperta +- **Due radici**: carica non-zero alternata/concorde . carica zero dell'intervallo prime-free. +- **Singolare**: il vuoto tra primi prima della scelta binaria; `S=0` non e' assenza di segnale ma classe del bordo. +- **Invariante di passaggio**: il null conserva gap, multiset delle cariche e frequenza degli zeri; cio' che sopravvive e' l'accoppiamento ordine-carica, non la sola presenza dello zero. +- **Campo di possibilita**: qui diventa possibile testare un gate triadico del boundary aritmetico. Qui diventa non-possibile escludere `S=0` dal denominatore quando si parla di terzo incluso nel perimetro Mobius-primi. + +## Consecutio +Il prossimo passo deve separare terza classe autentica da effetto scala dell'intervallo: ripetere il gate con controllo che preserva anche la lunghezza del gap o stratifica per bucket di gap length. Se lo zero resta significativo dentro ogni bucket, il boundary e' aritmetico; se cade, il segnale e' dipendenza da lunghezza. + +## Auto-audit: source flags e 5 lenti +- **Source L3 resolved**: il report non usa un elemento `not_tested` come conclusione. Il controllo det(M) diretto e' misurato e dichiarato non partizionante nel perimetro. +- **Source denominator repair resolved**: `S=0` e' incluso come classe esplicita, con count grezzi e denominatore. +- **Aperto**: non e' ancora separata la dipendenza dalla lunghezza del gap; serve controllo stratificato. +- **L1 hard constraint vs bias**: nessun "sempre/mai"; perimetro dichiarato `p<=1e6`, sei condizioni, 400 permutazioni. +- **L2 quantita vs ratio**: count grezzi e denominatori riportati; SR separato dai rate. +- **L3 no silent patching**: claim corretto prima del test; il source cycle non viene promosso. +- **L4 edge cases**: `low_low` non-zero e' borderline in una condizione (`z=1.97`), quindi resta parziale. +- **L5 re-discovery vs discovery**: verdict `CONSTRAINT`, non `NEW`; il pattern resta da confrontare con dipendenze note tra Mobius, lunghezza intervallare e gap primes. + +## Files +- Script: `tools/exp_prime_mobius_zero_mediator_gate.py` +- Data: `tools/data/prime_mobius_zero_mediator_gate_20260508_2108.json` +- Report: `tools/data/reports/agent_20260508_2108.md` diff --git a/tools/exp_prime_mobius_zero_mediator_gate.py b/tools/exp_prime_mobius_zero_mediator_gate.py new file mode 100644 index 0000000000000000000000000000000000000000..95ecd6e07c1863f3ffd3a3a5297a8628a00fd8be --- /dev/null +++ b/tools/exp_prime_mobius_zero_mediator_gate.py @@ -0,0 +1,314 @@ +#!/usr/bin/env python3 +"""Prime x Mobius zero-mediator gate. + +Repairs the 20260508_2102 interval-charge gate by keeping transitions with +S=0 in the denominator as an explicit third class. +""" +from __future__ import annotations + +import argparse +import json +from pathlib import Path + +import numpy as np + +from exp_prime_mobius_interval_charge_gate import ( + interval_charges, + mobius_sieve, + sieve_primes, +) + + +METRIC_KEYS = [ + "low_low_aligned_rate", + "low_low_misaligned_rate", + "low_low_zero_rate", + "high_high_aligned_rate", + "high_high_misaligned_rate", + "high_high_zero_rate", + "sr_aligned_mean", + "sr_misaligned_mean", + "sr_zero_mean", + "low_low_aligned_minus_misaligned", + "low_low_zero_minus_nonzero", + "high_high_aligned_minus_misaligned", + "high_high_zero_minus_nonzero", + "sr_aligned_minus_misaligned", + "sr_zero_minus_nonzero", +] + + +def _rate(mask: np.ndarray, event: np.ndarray) -> tuple[int, int, float]: + denom = int(np.sum(mask)) + hits = int(np.sum(mask & event)) + rate = float(hits / denom) if denom else float("nan") + return hits, denom, rate + + +def _mean(mask: np.ndarray, values: np.ndarray) -> tuple[int, float]: + denom = int(np.sum(mask)) + mean = float(np.mean(values[mask])) if denom else float("nan") + return denom, mean + + +def transition_metrics_three_class(gaps: np.ndarray, charges: np.ndarray) -> dict[str, float | int]: + left = charges[:-1] + right = charges[1:] + product = left * right + aligned = product < 0 + misaligned = product > 0 + zero = product == 0 + nonzero = ~zero + + g0 = gaps[:-1].astype(float) + g1 = gaps[1:].astype(float) + ratio = np.minimum(g0, g1) / np.maximum(g0, g1) + low_low = (g0 <= 6) & (g1 <= 6) + q75 = float(np.quantile(gaps, 0.75)) + high_high = (g0 >= q75) & (g1 >= q75) + + metrics: dict[str, float | int] = { + "q75_gap": q75, + "aligned_count": int(np.sum(aligned)), + "misaligned_count": int(np.sum(misaligned)), + "zero_count": int(np.sum(zero)), + "nonzero_count": int(np.sum(nonzero)), + } + + for name, event in (("low_low", low_low), ("high_high", high_high)): + for cls_name, mask in ( + ("aligned", aligned), + ("misaligned", misaligned), + ("zero", zero), + ("nonzero", nonzero), + ): + hits, denom, rate = _rate(mask, event) + metrics[f"{name}_{cls_name}_hits"] = hits + metrics[f"{name}_{cls_name}_denom"] = denom + metrics[f"{name}_{cls_name}_rate"] = rate + + for cls_name, mask in ( + ("aligned", aligned), + ("misaligned", misaligned), + ("zero", zero), + ("nonzero", nonzero), + ): + denom, mean = _mean(mask, ratio) + metrics[f"sr_{cls_name}_denom"] = denom + metrics[f"sr_{cls_name}_mean"] = mean + + metrics["low_low_aligned_minus_misaligned"] = ( + float(metrics["low_low_aligned_rate"]) - float(metrics["low_low_misaligned_rate"]) + ) + metrics["high_high_aligned_minus_misaligned"] = ( + float(metrics["high_high_aligned_rate"]) - float(metrics["high_high_misaligned_rate"]) + ) + metrics["sr_aligned_minus_misaligned"] = ( + float(metrics["sr_aligned_mean"]) - float(metrics["sr_misaligned_mean"]) + ) + metrics["low_low_zero_minus_nonzero"] = ( + float(metrics["low_low_zero_rate"]) - float(metrics["low_low_nonzero_rate"]) + ) + metrics["high_high_zero_minus_nonzero"] = ( + float(metrics["high_high_zero_rate"]) - float(metrics["high_high_nonzero_rate"]) + ) + metrics["sr_zero_minus_nonzero"] = ( + float(metrics["sr_zero_mean"]) - float(metrics["sr_nonzero_mean"]) + ) + return metrics + + +def permutation_test( + gaps: np.ndarray, + charges: np.ndarray, + observed: dict[str, float | int], + rng: np.random.Generator, + permutations: int, +) -> dict[str, dict[str, float]]: + nulls = {key: [] for key in METRIC_KEYS} + for _ in range(permutations): + shuffled = np.array(charges, copy=True) + rng.shuffle(shuffled) + metrics = transition_metrics_three_class(gaps, shuffled) + for key in METRIC_KEYS: + nulls[key].append(float(metrics[key])) + + out: dict[str, dict[str, float]] = {} + for key, values in nulls.items(): + arr = np.array(values, dtype=float) + obs = float(observed[key]) + finite = np.isfinite(arr) + arr = arr[finite] + if arr.size == 0 or not np.isfinite(obs): + out[key] = {"observed": obs, "null_mean": float("nan"), "null_std": float("nan"), "z": float("nan"), "p_two_sided": float("nan")} + continue + std = float(np.std(arr, ddof=1)) + z = (obs - float(np.mean(arr))) / std if std > 0 else 0.0 + p = float((np.sum(np.abs(arr) >= abs(obs)) + 1) / (len(arr) + 1)) + out[key] = { + "observed": obs, + "null_mean": float(np.mean(arr)), + "null_std": std, + "z": float(z), + "p_two_sided": p, + } + return out + + +def det_m_direct_control(gaps: np.ndarray) -> dict[str, float | int | str]: + g0 = gaps[:-1].astype(float) + g1 = gaps[1:].astype(float) + ratio = np.minimum(g0, g1) / np.maximum(g0, g1) + low_low = (g0 <= 6) & (g1 <= 6) + q75 = float(np.quantile(gaps, 0.75)) + high_high = (g0 >= q75) & (g1 >= q75) + denom = int(g0.size) + return { + "det_M": -1, + "class_count": 1, + "reason": "M=[[1,1],[1,0]] has constant determinant -1 on every transition, so direct det(M) does not partition the denominator.", + "denominator": denom, + "low_low_hits": int(np.sum(low_low)), + "low_low_rate": float(np.sum(low_low) / denom), + "high_high_hits": int(np.sum(high_high)), + "high_high_rate": float(np.sum(high_high) / denom), + "sr_mean": float(np.mean(ratio)), + } + + +def classify_zero_role(observed: dict[str, float | int], tests: dict[str, dict[str, float]]) -> str: + low_z = tests["low_low_zero_minus_nonzero"]["z"] + high_z = tests["high_high_zero_minus_nonzero"]["z"] + sr_z = tests["sr_zero_minus_nonzero"]["z"] + passes = [ + abs(low_z) >= 2 and tests["low_low_zero_minus_nonzero"]["p_two_sided"] <= 0.05, + abs(high_z) >= 2 and tests["high_high_zero_minus_nonzero"]["p_two_sided"] <= 0.05, + abs(sr_z) >= 2 and tests["sr_zero_minus_nonzero"]["p_two_sided"] <= 0.05, + ] + low = float(observed["low_low_zero_rate"]) + high = float(observed["high_high_zero_rate"]) + sr = float(observed["sr_zero_mean"]) + low_a = float(observed["low_low_aligned_rate"]) + low_m = float(observed["low_low_misaligned_rate"]) + high_a = float(observed["high_high_aligned_rate"]) + high_m = float(observed["high_high_misaligned_rate"]) + sr_a = float(observed["sr_aligned_mean"]) + sr_m = float(observed["sr_misaligned_mean"]) + + between_low = min(low_a, low_m) <= low <= max(low_a, low_m) + between_high = min(high_a, high_m) <= high <= max(high_a, high_m) + between_sr = min(sr_a, sr_m) <= sr <= max(sr_a, sr_m) + + if any(passes) and (between_low or between_high or between_sr): + return "boundary" + if any(passes): + return "third_class" + return "noise_under_this_null" + + +def run_condition( + primes: np.ndarray, + mu: np.ndarray, + n_primes: int, + offset: int, + rng: np.random.Generator, + permutations: int, +) -> dict[str, object]: + segment = primes[offset : offset + n_primes + 1] + gaps = np.diff(segment) + charges = interval_charges(segment, mu) + observed = transition_metrics_three_class(gaps, charges) + tests = permutation_test(gaps, charges, observed, rng, permutations) + return { + "n_primes": n_primes, + "offset": offset, + "prime_start": int(segment[0]), + "prime_stop": int(segment[-1]), + "zero_charge_count": int(np.sum(charges == 0)), + "charge_count": int(charges.size), + "observed": observed, + "permutation_tests": tests, + "zero_role": classify_zero_role(observed, tests), + "det_m_direct_control": det_m_direct_control(gaps), + } + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--limit", type=int, default=1_000_000) + parser.add_argument("--permutations", type=int, default=400) + parser.add_argument("--seed", type=int, default=2108) + parser.add_argument("--out", default="tools/data/prime_mobius_zero_mediator_gate_20260508_2108.json") + args = parser.parse_args() + + primes = sieve_primes(args.limit) + mu = mobius_sieve(args.limit) + rng = np.random.default_rng(args.seed) + + conditions = [ + {"n_primes": 5_000, "offset": 0}, + {"n_primes": 10_000, "offset": 0}, + {"n_primes": 20_000, "offset": 0}, + {"n_primes": 5_000, "offset": 3_000}, + {"n_primes": 10_000, "offset": 7_000}, + {"n_primes": 20_000, "offset": 11_000}, + ] + max_needed = max(c["offset"] + c["n_primes"] + 1 for c in conditions) + if len(primes) <= max_needed: + raise SystemExit(f"limit={args.limit} yields only {len(primes)} primes, need {max_needed}") + + results = [ + run_condition(primes, mu, c["n_primes"], c["offset"], rng, args.permutations) + for c in conditions + ] + summary = [] + for result in results: + tests = result["permutation_tests"] + summary.append( + { + "n_primes": result["n_primes"], + "offset": result["offset"], + "low_low_aligned_minus_misaligned_pass": abs(tests["low_low_aligned_minus_misaligned"]["z"]) >= 2.0 + and tests["low_low_aligned_minus_misaligned"]["p_two_sided"] <= 0.05, + "high_high_aligned_minus_misaligned_pass": abs(tests["high_high_aligned_minus_misaligned"]["z"]) >= 2.0 + and tests["high_high_aligned_minus_misaligned"]["p_two_sided"] <= 0.05, + "sr_aligned_minus_misaligned_pass": abs(tests["sr_aligned_minus_misaligned"]["z"]) >= 2.0 + and tests["sr_aligned_minus_misaligned"]["p_two_sided"] <= 0.05, + "zero_role": result["zero_role"], + } + ) + + payload = { + "experiment": "prime_mobius_zero_mediator_gate", + "question": "Does S=0 behave as noise, boundary, or mediator in the Mobius interval-charge gate?", + "threshold_ex_ante": "|z|>=2 and permutation p<=0.05 across main and offset conditions", + "null": "Permutation of the interval-charge sequence preserves the full charge multiset and therefore preserves zero frequency.", + "limit": args.limit, + "permutations": args.permutations, + "seed": args.seed, + "conditions": results, + "significance_summary": summary, + } + + out = Path(args.out) + out.parent.mkdir(parents=True, exist_ok=True) + out.write_text(json.dumps(payload, indent=2), encoding="utf-8") + + for result in results: + obs = result["observed"] + tests = result["permutation_tests"] + print( + f"N={result['n_primes']} offset={result['offset']} " + f"a/m/z={obs['aligned_count']}/{obs['misaligned_count']}/{obs['zero_count']} " + f"low_am={obs['low_low_aligned_minus_misaligned']:.5f} z={tests['low_low_aligned_minus_misaligned']['z']:.2f} p={tests['low_low_aligned_minus_misaligned']['p_two_sided']:.3f} " + f"low_z0={obs['low_low_zero_minus_nonzero']:.5f} z={tests['low_low_zero_minus_nonzero']['z']:.2f} p={tests['low_low_zero_minus_nonzero']['p_two_sided']:.3f} " + f"high_am={obs['high_high_aligned_minus_misaligned']:.5f} z={tests['high_high_aligned_minus_misaligned']['z']:.2f} p={tests['high_high_aligned_minus_misaligned']['p_two_sided']:.3f} " + f"high_z0={obs['high_high_zero_minus_nonzero']:.5f} z={tests['high_high_zero_minus_nonzero']['z']:.2f} p={tests['high_high_zero_minus_nonzero']['p_two_sided']:.3f} " + f"sr_am={obs['sr_aligned_minus_misaligned']:.5f} z={tests['sr_aligned_minus_misaligned']['z']:.2f} p={tests['sr_aligned_minus_misaligned']['p_two_sided']:.3f} " + f"role={result['zero_role']}" + ) + print(f"wrote {out}") + + +if __name__ == "__main__": + main() exec /bin/bash -lc "sed -n '108,206p' tools/lab_falsifier.py" in /opt/MM_D-ND succeeded in 0ms: {context} --- Emetti il JSON ora (no markdown fence, no prose): """ def _read_safe(path: Path, max_bytes: int = 8000) -> str: """Read file, return empty string on error. Cap to max_bytes.""" try: text = path.read_text(errors="replace") except Exception: return "" if len(text) > max_bytes: text = text[:max_bytes] + f"\n…[troncato, file e' {len(text)} bytes]" return text def build_context(report_path: Path) -> str: """Compose report + data context for the prompt.""" parts: list[str] = [] parts.append("## REPORT (markdown che il producer ha scritto)\n") parts.append(_read_safe(report_path, 9000)) parts.append("\n\n## FILE EMPIRICI E STRUTTURALI\n") canonical_files = [ ("lab_data.json", DATA_DIR / "lab_data.json"), ("seme.json", DATA_DIR / "seme.json"), ("conoscenza_teorie.json", DATA_DIR / "conoscenza_teorie.json"), ("cimitero.md", REPO_DIR / "cimitero.md"), ] for label, p in canonical_files: content = _read_safe(p, 3500) if content: parts.append(f"\n### {label}\n```\n{content}\n```\n") return "".join(parts) def call_falsifier_llm(prompt: str, timeout_s: int = 240) -> tuple[str, int]: """Run the falsifier prompt through provider chain (codex → claude → openrouter). Refactor 06/05: delega a lib_llm_chain.call_llm_chain — chain canonica con pre-flight cache + OpenRouter fallback HTTP. Restituisce (raw_output, exit_code) per backward compat con il caller esistente. """ try: # Import lazy: lib_llm_chain è in tools/, stesso dir di lab_falsifier.py sys.path.insert(0, str(Path(__file__).parent)) from lib_llm_chain import call_llm_chain raw = call_llm_chain(prompt, timeout=timeout_s) return raw, 0 except RuntimeError as e: # Tutti i provider falliti print(f"[falsifier] chain failed: {e}", file=sys.stderr) return "", 1 except Exception as e: print(f"[falsifier] chain error: {e}", file=sys.stderr) return "", 1 def _which(name: str) -> bool: try: return subprocess.run(["which", name], capture_output=True).returncode == 0 except Exception: return False def extract_json(raw: str) -> dict | None: """Extract first JSON object from LLM output. Tolerates fenced blocks + prose.""" if not raw: return None # Try fenced block first fenced = re.search(r"```(?:json)?\s*(\{[\s\S]+?\})\s*```", raw) candidate = fenced.group(1) if fenced else None if not candidate: start = raw.find("{") if start < 0: return None candidate = raw[start:] try: return json.loads(candidate) except json.JSONDecodeError: # Try to find balancing brace depth = 0 for i, c in enumerate(candidate): if c == "{": depth += 1 elif c == "}": depth -= 1 if depth == 0: try: return json.loads(candidate[: i + 1]) except json.JSONDecodeError: return None return None diff --git a/tools/data/reports/agent_20260508_2108.md b/tools/data/reports/agent_20260508_2108.md new file mode 100644 index 0000000000000000000000000000000000000000..d3b8fa5889b9587b0e01270608220848eb4d5ed7 --- /dev/null +++ b/tools/data/reports/agent_20260508_2108.md @@ -0,0 +1,103 @@ +# Agent Report - Prime Mobius Zero-Mediator Gate +**Date**: 2026-05-08 21:08 +**Piano**: 93 +**Tension explored**: DUALITA_DIPOLARE_VS_ILLUSORIA (0.9) +**verdict**: CONSTRAINT +observables_registry: 1.0.0-2026-05-06 +observables_used: [low_low_rate, high_high_rate, SR, det_M_direct_control] +**observable_contract**: claim=lo zero della carica Mobius intervallare e' testato come terzo incluso del gate aligned/misaligned; observable=rate low_low, rate high_high, SR mean per classi aligned/misaligned/zero; operator=classificazione di S_n*S_{n+1}: aligned<0, misaligned>0, zero=0; generator=prime gaps up to p<=1e6 with Mobius sieve; denominator=main N={5000,10000,20000} offset=0 plus seedcheck offsets {3000,7000,11000}; not_tested=gap_ratio Sturmian, high-core phi survival, universal GUE/Poisson classification. + +## Respiro fuori-tempo +- **Combo**: A2 confine det=-1 + A9 terzo incluso + A11 combo + QxG continuo/discreto vuoto + DUALITA_DIPOLARE_VS_ILLUSORIA + piano primi x Mobius. Il repair non cerca un lettore nuovo: riporta nel denominatore il punto escluso dal source cycle, `S=0`. +- **Dipolo / punto-zero**: carica Mobius alternata / carica Mobius concorde; punto-zero = transizione con almeno un intervallo a carica nulla (`S_n*S_{n+1}=0`). +- **Piano superiore**: boundary operator su grafo aritmetico. Il gap e' bordo tra primi; la carica Mobius del vuoto tra primi decide se il bordo e' solo rumore di lunghezza o classe informativa. +- **Operatori laterali scelti**: boundary operator, random walk, entropia. Boundary operator definisce il bordo prime-free; random walk fornisce il null di permutazione della carica; entropia entra come dispersione del vuoto senza primi. +- **Contaminazione cognitiva**: + - **CE-0117**: usato per non promuovere il source cycle e far passare il risultato da potenziale a vincolo misurato. + - **CE-0038**: usato per riportare la forma nel Nulla-Tutto al vuoto aritmetico, qui lo zero `S=0`. + - **CE-0001 / KSAR**: usato come kernel reiterativo del ciclo 2102, con riparazione regressiva sul denominatore. + - **PVI attack**: il segnale puo' essere effetto di lunghezza del gap; per questo il null permuta l'intera sequenza delle cariche preservando multiset e frequenza degli zeri. +- **Proto-ipotesi**: se `S=0` e' terzo incluso operativo, non cade come rumore sotto il null che preserva la frequenza degli zeri. Deve produrre una classe distinguibile su low_low/high_high/SR. Se resta dentro il null, il source cycle sopravvive solo come gate binario non-zero. +- **Proiezione**: confronto aligned, misaligned e zero su `low_low`, `high_high` e `SR`; null = 400 permutazioni della sequenza `S_n`, gap invariati, multiset delle cariche invariata. + +## Claim Under Test +> Nel perimetro primi x Mobius fino a `p<=1e6`, le transizioni con `S=0` non vanno escluse: formano una terza classe del gate intervallare e vanno confrontate contro aligned/misaligned con null che preserva la frequenza degli zeri. + +## Question +Lo zero della carica Mobius intervallare e' rumore, boundary o mediatore del segnale low-low/high-high/SR? + +## Experiment Design +- Script: `tools/exp_prime_mobius_zero_mediator_gate.py`. +- Dati: primi fino a `1_000_000`; Mobius sieve sullo stesso perimetro. +- Carica intervallare: `S_n = sum(mu(k))` per `p_n < k < p_{n+1}`. +- Classi: + - `aligned`: `S_n*S_{n+1}<0`. + - `misaligned`: `S_n*S_{n+1}>0`. + - `zero`: `S_n*S_{n+1}=0`. +- Osservabili: + - `low_low_rate`: count di due gap consecutivi `<=6` sul denominatore della classe. + - `high_high_rate`: count di due gap consecutivi `>=q75` sul denominatore della classe. + - `SR`: mean min/max ratio dei gap consecutivi. +- Null test: 400 permutazioni della sequenza `S_n`; il null preserva la multiset completa delle cariche e quindi la frequenza degli zeri. +- Controllo det(M) diretto: `M=[[1,1],[1,0]]` ha `det(M)=-1` costante su ogni transizione; il controllo non partiziona il denominatore e restituisce solo le baseline globali low/high/SR. +- Soglia ex ante: `|z|>=2` e `p_two_sided<=0.05`. +- Contratto osservabile-operatore: `gap_ratio` Sturmian non testato; il source cycle 2102 non viene promosso; il claim su det diretto viene sostituito da controllo esplicito, non da conclusione non misurata. + +## Results +| condition | a/m/z denom | zero charges | low a | low m | low z | low z0 vs nonzero z/p | high a | high m | high z | high z0 vs nonzero z/p | SR a | SR m | SR z | SR z0 vs nonzero z/p | +|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:| +| N=5000 off=0 | 1200/1572/2227 | 1258/5000 | 221/1200 | 220/1572 | 707/2227 | 11.77 / 0.002 | 115/1200 | 298/1572 | 101/2227 | -10.80 / 0.002 | 0.51559 | 0.52611 | 0.43203 | -11.15 / 0.002 | +| N=10000 off=0 | 2541/3102/4356 | 2457/10000 | 403/2541 | 377/3102 | 1190/4356 | 14.88 / 0.002 | 153/2541 | 363/3102 | 114/4356 | -12.31 / 0.002 | 0.50841 | 0.51502 | 0.42221 | -16.03 / 0.002 | +| N=20000 off=0 | 5171/6331/8497 | 4782/20000 | 694/5171 | 651/6331 | 2093/8497 | 22.31 / 0.002 | 422/5171 | 878/6331 | 281/8497 | -18.75 / 0.002 | 0.50324 | 0.51151 | 0.41571 | -23.13 / 0.002 | +| N=5000 off=3000 | 1313/1525/2161 | 1219/5000 | 184/1313 | 162/1525 | 522/2161 | 9.84 / 0.002 | 86/1313 | 187/1525 | 71/2161 | -8.13 / 0.002 | 0.50993 | 0.50560 | 0.42213 | -10.87 / 0.002 | +| N=10000 off=7000 | 2675/3178/4146 | 2318/10000 | 315/2675 | 298/3178 | 946/4146 | 16.40 / 0.002 | 182/2675 | 351/3178 | 98/4146 | -13.27 / 0.002 | 0.50225 | 0.50729 | 0.40695 | -17.18 / 0.002 | +| N=20000 off=11000 | 5407/6413/8179 | 4586/20000 | 553/5407 | 567/6413 | 1740/8179 | 20.63 / 0.002 | 295/5407 | 667/6413 | 178/8179 | -16.22 / 0.002 | 0.49723 | 0.50997 | 0.41131 | -22.87 / 0.002 | + +### Pairwise aligned/misaligned checks +| condition | low a-m diff z/p | high a-m diff z/p | SR a-m diff z/p | +|---|---:|---:|---:| +| N=5000 off=0 | +0.04422 2.47 / 0.015 | -0.09373 -7.96 / 0.002 | -0.01053 -1.12 / 0.277 | +| N=10000 off=0 | +0.03706 3.44 / 0.002 | -0.05681 -8.90 / 0.002 | -0.00661 -0.90 / 0.357 | +| N=20000 off=0 | +0.03138 4.56 / 0.002 | -0.05707 -10.48 / 0.002 | -0.00827 -1.78 / 0.097 | +| N=5000 off=3000 | +0.03391 2.37 / 0.022 | -0.05712 -5.66 / 0.002 | +0.00433 0.48 / 0.671 | +| N=10000 off=7000 | +0.02399 2.68 / 0.010 | -0.04241 -6.58 / 0.002 | -0.00504 -0.71 / 0.501 | +| N=20000 off=11000 | +0.01386 1.97 / 0.040 | -0.04945 -10.96 / 0.002 | -0.01274 -2.50 / 0.015 | + +### det(M) direct control +`det(M)=-1` e' costante. Il controllo ha una sola classe su ogni condizione, quindi non separa aligned/misaligned/zero. Baseline globali: low_low `1148/4999`, `1970/9999`, `3438/19999`, `868/4999`, `1559/9999`, `2860/19999`; high_high `514/4999`, `630/9999`, `1581/19999`, `344/4999`, `631/9999`, `1140/19999`; SR globale `0.48167`, `0.47291`, `0.46867`, `0.47066`, `0.46434`, `0.46618`. + +## Key Findings +1. **Verificato: lo zero non e' rumore sotto il null usato.** La classe zero supera il null in 6/6 condizioni su `low_low_zero_minus_nonzero`, `high_high_zero_minus_nonzero` e `sr_zero_minus_nonzero`, sempre con `p=0.002` e `|z|` da `8.13` a `23.13`. + +2. **Verificato: lo zero e' una terza classe, non un mediatore tra aligned e misaligned.** Su low_low lo zero e' sopra entrambe le classi non-zero (`0.21274..0.31747` contro aligned `0.10227..0.18417` e misaligned `0.08841..0.13995`). Su high_high lo zero e' sotto entrambe (`0.02176..0.04535` contro aligned `0.05456..0.09583` e misaligned `0.10401..0.18957`). Su SR lo zero e' sotto entrambe (`0.40695..0.43203` contro non-zero circa `0.49723..0.52611`). Il punto-zero non sta tra i poli: genera una classe propria. + +3. **Verificato: il contrasto aligned/misaligned sopravvive soprattutto su high_high.** `high_high_aligned_minus_misaligned` passa 6/6 con z da `-5.66` a `-10.96`. `low_low_aligned_minus_misaligned` passa 5/6 se la soglia richiede anche `|z|>=2`; l'ultima condizione ha `z=1.97`, `p=0.040`, quindi resta borderline e non autorizza hard wording. SR passa 1/6 e resta osservabile secondario. + +4. **Verificato: il controllo det(M) diretto risolve il flag L3 del source cycle.** `det(M)` costante non produce partizione del denominatore; il report non conclude che la dualita "non si legge" da det diretto come fatto empirico generale. Qui dichiara solo che, in questo controllo, det(M) diretto non e' un discriminatore di classe. + +## Verdict +**CONSTRAINT on DUALITA_DIPOLARE_VS_ILLUSORIA / Prime Mobius interval-charge gate**: nel perimetro primi x Mobius fino a `p<=1e6`, `S=0` deve restare nel denominatore come terza classe. Lo zero non e' rumore sotto il null di permutazione che preserva frequenza degli zeri: arricchisce low_low, sopprime high_high e abbassa SR in 6/6 condizioni. Il source cycle sopravvive come vincolo parziale: il gate non-zero aligned/misaligned resta solido per high_high, resta parziale per low_low, e non porta SR globalmente. Il nuovo portatore e' triadico: aligned / misaligned / zero. + +## Bicono della scoperta +- **Due radici**: carica non-zero alternata/concorde . carica zero dell'intervallo prime-free. +- **Singolare**: il vuoto tra primi prima della scelta binaria; `S=0` non e' assenza di segnale ma classe del bordo. +- **Invariante di passaggio**: il null conserva gap, multiset delle cariche e frequenza degli zeri; cio' che sopravvive e' l'accoppiamento ordine-carica, non la sola presenza dello zero. +- **Campo di possibilita**: qui diventa possibile testare un gate triadico del boundary aritmetico. Qui diventa non-possibile escludere `S=0` dal denominatore quando si parla di terzo incluso nel perimetro Mobius-primi. + +## Consecutio +Il prossimo passo deve separare terza classe autentica da effetto scala dell'intervallo: ripetere il gate con controllo che preserva anche la lunghezza del gap o stratifica per bucket di gap length. Se lo zero resta significativo dentro ogni bucket, il boundary e' aritmetico; se cade, il segnale e' dipendenza da lunghezza. + +## Auto-audit: source flags e 5 lenti +- **Source L3 resolved**: il report non usa un elemento `not_tested` come conclusione. Il controllo det(M) diretto e' misurato e dichiarato non partizionante nel perimetro. +- **Source denominator repair resolved**: `S=0` e' incluso come classe esplicita, con count grezzi e denominatore. +- **Aperto**: non e' ancora separata la dipendenza dalla lunghezza del gap; serve controllo stratificato. +- **L1 hard constraint vs bias**: nessun "sempre/mai"; perimetro dichiarato `p<=1e6`, sei condizioni, 400 permutazioni. +- **L2 quantita vs ratio**: count grezzi e denominatori riportati; SR separato dai rate. +- **L3 no silent patching**: claim corretto prima del test; il source cycle non viene promosso. +- **L4 edge cases**: `low_low` non-zero e' borderline in una condizione (`z=1.97`), quindi resta parziale. +- **L5 re-discovery vs discovery**: verdict `CONSTRAINT`, non `NEW`; il pattern resta da confrontare con dipendenze note tra Mobius, lunghezza intervallare e gap primes. + +## Files +- Script: `tools/exp_prime_mobius_zero_mediator_gate.py` +- Data: `tools/data/prime_mobius_zero_mediator_gate_20260508_2108.json` +- Report: `tools/data/reports/agent_20260508_2108.md` diff --git a/tools/exp_prime_mobius_zero_mediator_gate.py b/tools/exp_prime_mobius_zero_mediator_gate.py new file mode 100644 index 0000000000000000000000000000000000000000..95ecd6e07c1863f3ffd3a3a5297a8628a00fd8be --- /dev/null +++ b/tools/exp_prime_mobius_zero_mediator_gate.py @@ -0,0 +1,314 @@ +#!/usr/bin/env python3 +"""Prime x Mobius zero-mediator gate. + +Repairs the 20260508_2102 interval-charge gate by keeping transitions with +S=0 in the denominator as an explicit third class. +""" +from __future__ import annotations + +import argparse +import json +from pathlib import Path + +import numpy as np + +from exp_prime_mobius_interval_charge_gate import ( + interval_charges, + mobius_sieve, + sieve_primes, +) + + +METRIC_KEYS = [ + "low_low_aligned_rate", + "low_low_misaligned_rate", + "low_low_zero_rate", + "high_high_aligned_rate", + "high_high_misaligned_rate", + "high_high_zero_rate", + "sr_aligned_mean", + "sr_misaligned_mean", + "sr_zero_mean", + "low_low_aligned_minus_misaligned", + "low_low_zero_minus_nonzero", + "high_high_aligned_minus_misaligned", + "high_high_zero_minus_nonzero", + "sr_aligned_minus_misaligned", + "sr_zero_minus_nonzero", +] + + +def _rate(mask: np.ndarray, event: np.ndarray) -> tuple[int, int, float]: + denom = int(np.sum(mask)) + hits = int(np.sum(mask & event)) + rate = float(hits / denom) if denom else float("nan") + return hits, denom, rate + + +def _mean(mask: np.ndarray, values: np.ndarray) -> tuple[int, float]: + denom = int(np.sum(mask)) + mean = float(np.mean(values[mask])) if denom else float("nan") + return denom, mean + + +def transition_metrics_three_class(gaps: np.ndarray, charges: np.ndarray) -> dict[str, float | int]: + left = charges[:-1] + right = charges[1:] + product = left * right + aligned = product < 0 + misaligned = product > 0 + zero = product == 0 + nonzero = ~zero + + g0 = gaps[:-1].astype(float) + g1 = gaps[1:].astype(float) + ratio = np.minimum(g0, g1) / np.maximum(g0, g1) + low_low = (g0 <= 6) & (g1 <= 6) + q75 = float(np.quantile(gaps, 0.75)) + high_high = (g0 >= q75) & (g1 >= q75) + + metrics: dict[str, float | int] = { + "q75_gap": q75, + "aligned_count": int(np.sum(aligned)), + "misaligned_count": int(np.sum(misaligned)), + "zero_count": int(np.sum(zero)), + "nonzero_count": int(np.sum(nonzero)), + } + + for name, event in (("low_low", low_low), ("high_high", high_high)): + for cls_name, mask in ( + ("aligned", aligned), + ("misaligned", misaligned), + ("zero", zero), + ("nonzero", nonzero), + ): + hits, denom, rate = _rate(mask, event) + metrics[f"{name}_{cls_name}_hits"] = hits + metrics[f"{name}_{cls_name}_denom"] = denom + metrics[f"{name}_{cls_name}_rate"] = rate + + for cls_name, mask in ( + ("aligned", aligned), + ("misaligned", misaligned), + ("zero", zero), + ("nonzero", nonzero), + ): + denom, mean = _mean(mask, ratio) + metrics[f"sr_{cls_name}_denom"] = denom + metrics[f"sr_{cls_name}_mean"] = mean + + metrics["low_low_aligned_minus_misaligned"] = ( + float(metrics["low_low_aligned_rate"]) - float(metrics["low_low_misaligned_rate"]) + ) + metrics["high_high_aligned_minus_misaligned"] = ( + float(metrics["high_high_aligned_rate"]) - float(metrics["high_high_misaligned_rate"]) + ) + metrics["sr_aligned_minus_misaligned"] = ( + float(metrics["sr_aligned_mean"]) - float(metrics["sr_misaligned_mean"]) + ) + metrics["low_low_zero_minus_nonzero"] = ( + float(metrics["low_low_zero_rate"]) - float(metrics["low_low_nonzero_rate"]) + ) + metrics["high_high_zero_minus_nonzero"] = ( + float(metrics["high_high_zero_rate"]) - float(metrics["high_high_nonzero_rate"]) + ) + metrics["sr_zero_minus_nonzero"] = ( + float(metrics["sr_zero_mean"]) - float(metrics["sr_nonzero_mean"]) + ) + return metrics + + +def permutation_test( + gaps: np.ndarray, + charges: np.ndarray, + observed: dict[str, float | int], + rng: np.random.Generator, + permutations: int, +) -> dict[str, dict[str, float]]: + nulls = {key: [] for key in METRIC_KEYS} + for _ in range(permutations): + shuffled = np.array(charges, copy=True) + rng.shuffle(shuffled) + metrics = transition_metrics_three_class(gaps, shuffled) + for key in METRIC_KEYS: + nulls[key].append(float(metrics[key])) + + out: dict[str, dict[str, float]] = {} + for key, values in nulls.items(): + arr = np.array(values, dtype=float) + obs = float(observed[key]) + finite = np.isfinite(arr) + arr = arr[finite] + if arr.size == 0 or not np.isfinite(obs): + out[key] = {"observed": obs, "null_mean": float("nan"), "null_std": float("nan"), "z": float("nan"), "p_two_sided": float("nan")} + continue + std = float(np.std(arr, ddof=1)) + z = (obs - float(np.mean(arr))) / std if std > 0 else 0.0 + p = float((np.sum(np.abs(arr) >= abs(obs)) + 1) / (len(arr) + 1)) + out[key] = { + "observed": obs, + "null_mean": float(np.mean(arr)), + "null_std": std, + "z": float(z), + "p_two_sided": p, + } + return out + + +def det_m_direct_control(gaps: np.ndarray) -> dict[str, float | int | str]: + g0 = gaps[:-1].astype(float) + g1 = gaps[1:].astype(float) + ratio = np.minimum(g0, g1) / np.maximum(g0, g1) + low_low = (g0 <= 6) & (g1 <= 6) + q75 = float(np.quantile(gaps, 0.75)) + high_high = (g0 >= q75) & (g1 >= q75) + denom = int(g0.size) + return { + "det_M": -1, + "class_count": 1, + "reason": "M=[[1,1],[1,0]] has constant determinant -1 on every transition, so direct det(M) does not partition the denominator.", + "denominator": denom, + "low_low_hits": int(np.sum(low_low)), + "low_low_rate": float(np.sum(low_low) / denom), + "high_high_hits": int(np.sum(high_high)), + "high_high_rate": float(np.sum(high_high) / denom), + "sr_mean": float(np.mean(ratio)), + } + + +def classify_zero_role(observed: dict[str, float | int], tests: dict[str, dict[str, float]]) -> str: + low_z = tests["low_low_zero_minus_nonzero"]["z"] + high_z = tests["high_high_zero_minus_nonzero"]["z"] + sr_z = tests["sr_zero_minus_nonzero"]["z"] + passes = [ + abs(low_z) >= 2 and tests["low_low_zero_minus_nonzero"]["p_two_sided"] <= 0.05, + abs(high_z) >= 2 and tests["high_high_zero_minus_nonzero"]["p_two_sided"] <= 0.05, + abs(sr_z) >= 2 and tests["sr_zero_minus_nonzero"]["p_two_sided"] <= 0.05, + ] + low = float(observed["low_low_zero_rate"]) + high = float(observed["high_high_zero_rate"]) + sr = float(observed["sr_zero_mean"]) + low_a = float(observed["low_low_aligned_rate"]) + low_m = float(observed["low_low_misaligned_rate"]) + high_a = float(observed["high_high_aligned_rate"]) + high_m = float(observed["high_high_misaligned_rate"]) + sr_a = float(observed["sr_aligned_mean"]) + sr_m = float(observed["sr_misaligned_mean"]) + + between_low = min(low_a, low_m) <= low <= max(low_a, low_m) + between_high = min(high_a, high_m) <= high <= max(high_a, high_m) + between_sr = min(sr_a, sr_m) <= sr <= max(sr_a, sr_m) + + if any(passes) and (between_low or between_high or between_sr): + return "boundary" + if any(passes): + return "third_class" + return "noise_under_this_null" + + +def run_condition( + primes: np.ndarray, + mu: np.ndarray, + n_primes: int, + offset: int, + rng: np.random.Generator, + permutations: int, +) -> dict[str, object]: + segment = primes[offset : offset + n_primes + 1] + gaps = np.diff(segment) + charges = interval_charges(segment, mu) + observed = transition_metrics_three_class(gaps, charges) + tests = permutation_test(gaps, charges, observed, rng, permutations) + return { + "n_primes": n_primes, + "offset": offset, + "prime_start": int(segment[0]), + "prime_stop": int(segment[-1]), + "zero_charge_count": int(np.sum(charges == 0)), + "charge_count": int(charges.size), + "observed": observed, + "permutation_tests": tests, + "zero_role": classify_zero_role(observed, tests), + "det_m_direct_control": det_m_direct_control(gaps), + } + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--limit", type=int, default=1_000_000) + parser.add_argument("--permutations", type=int, default=400) + parser.add_argument("--seed", type=int, default=2108) + parser.add_argument("--out", default="tools/data/prime_mobius_zero_mediator_gate_20260508_2108.json") + args = parser.parse_args() + + primes = sieve_primes(args.limit) + mu = mobius_sieve(args.limit) + rng = np.random.default_rng(args.seed) + + conditions = [ + {"n_primes": 5_000, "offset": 0}, + {"n_primes": 10_000, "offset": 0}, + {"n_primes": 20_000, "offset": 0}, + {"n_primes": 5_000, "offset": 3_000}, + {"n_primes": 10_000, "offset": 7_000}, + {"n_primes": 20_000, "offset": 11_000}, + ] + max_needed = max(c["offset"] + c["n_primes"] + 1 for c in conditions) + if len(primes) <= max_needed: + raise SystemExit(f"limit={args.limit} yields only {len(primes)} primes, need {max_needed}") + + results = [ + run_condition(primes, mu, c["n_primes"], c["offset"], rng, args.permutations) + for c in conditions + ] + summary = [] + for result in results: + tests = result["permutation_tests"] + summary.append( + { + "n_primes": result["n_primes"], + "offset": result["offset"], + "low_low_aligned_minus_misaligned_pass": abs(tests["low_low_aligned_minus_misaligned"]["z"]) >= 2.0 + and tests["low_low_aligned_minus_misaligned"]["p_two_sided"] <= 0.05, + "high_high_aligned_minus_misaligned_pass": abs(tests["high_high_aligned_minus_misaligned"]["z"]) >= 2.0 + and tests["high_high_aligned_minus_misaligned"]["p_two_sided"] <= 0.05, + "sr_aligned_minus_misaligned_pass": abs(tests["sr_aligned_minus_misaligned"]["z"]) >= 2.0 + and tests["sr_aligned_minus_misaligned"]["p_two_sided"] <= 0.05, + "zero_role": result["zero_role"], + } + ) + + payload = { + "experiment": "prime_mobius_zero_mediator_gate", + "question": "Does S=0 behave as noise, boundary, or mediator in the Mobius interval-charge gate?", + "threshold_ex_ante": "|z|>=2 and permutation p<=0.05 across main and offset conditions", + "null": "Permutation of the interval-charge sequence preserves the full charge multiset and therefore preserves zero frequency.", + "limit": args.limit, + "permutations": args.permutations, + "seed": args.seed, + "conditions": results, + "significance_summary": summary, + } + + out = Path(args.out) + out.parent.mkdir(parents=True, exist_ok=True) + out.write_text(json.dumps(payload, indent=2), encoding="utf-8") + + for result in results: + obs = result["observed"] + tests = result["permutation_tests"] + print( + f"N={result['n_primes']} offset={result['offset']} " + f"a/m/z={obs['aligned_count']}/{obs['misaligned_count']}/{obs['zero_count']} " + f"low_am={obs['low_low_aligned_minus_misaligned']:.5f} z={tests['low_low_aligned_minus_misaligned']['z']:.2f} p={tests['low_low_aligned_minus_misaligned']['p_two_sided']:.3f} " + f"low_z0={obs['low_low_zero_minus_nonzero']:.5f} z={tests['low_low_zero_minus_nonzero']['z']:.2f} p={tests['low_low_zero_minus_nonzero']['p_two_sided']:.3f} " + f"high_am={obs['high_high_aligned_minus_misaligned']:.5f} z={tests['high_high_aligned_minus_misaligned']['z']:.2f} p={tests['high_high_aligned_minus_misaligned']['p_two_sided']:.3f} " + f"high_z0={obs['high_high_zero_minus_nonzero']:.5f} z={tests['high_high_zero_minus_nonzero']['z']:.2f} p={tests['high_high_zero_minus_nonzero']['p_two_sided']:.3f} " + f"sr_am={obs['sr_aligned_minus_misaligned']:.5f} z={tests['sr_aligned_minus_misaligned']['z']:.2f} p={tests['sr_aligned_minus_misaligned']['p_two_sided']:.3f} " + f"role={result['zero_role']}" + ) + print(f"wrote {out}") + + +if __name__ == "__main__": + main() exec /bin/bash -lc 'python tools/structural_check.py tools/exp_prime_mobius_zero_mediator_gate.py tools/data/reports/agent_20260508_2108.md' in /opt/MM_D-ND succeeded in 0ms: Scansione 2 file... Nessun anti-pattern trovato. diff --git a/tools/data/reports/agent_20260508_2108.md b/tools/data/reports/agent_20260508_2108.md new file mode 100644 index 0000000000000000000000000000000000000000..d3b8fa5889b9587b0e01270608220848eb4d5ed7 --- /dev/null +++ b/tools/data/reports/agent_20260508_2108.md @@ -0,0 +1,103 @@ +# Agent Report - Prime Mobius Zero-Mediator Gate +**Date**: 2026-05-08 21:08 +**Piano**: 93 +**Tension explored**: DUALITA_DIPOLARE_VS_ILLUSORIA (0.9) +**verdict**: CONSTRAINT +observables_registry: 1.0.0-2026-05-06 +observables_used: [low_low_rate, high_high_rate, SR, det_M_direct_control] +**observable_contract**: claim=lo zero della carica Mobius intervallare e' testato come terzo incluso del gate aligned/misaligned; observable=rate low_low, rate high_high, SR mean per classi aligned/misaligned/zero; operator=classificazione di S_n*S_{n+1}: aligned<0, misaligned>0, zero=0; generator=prime gaps up to p<=1e6 with Mobius sieve; denominator=main N={5000,10000,20000} offset=0 plus seedcheck offsets {3000,7000,11000}; not_tested=gap_ratio Sturmian, high-core phi survival, universal GUE/Poisson classification. + +## Respiro fuori-tempo +- **Combo**: A2 confine det=-1 + A9 terzo incluso + A11 combo + QxG continuo/discreto vuoto + DUALITA_DIPOLARE_VS_ILLUSORIA + piano primi x Mobius. Il repair non cerca un lettore nuovo: riporta nel denominatore il punto escluso dal source cycle, `S=0`. +- **Dipolo / punto-zero**: carica Mobius alternata / carica Mobius concorde; punto-zero = transizione con almeno un intervallo a carica nulla (`S_n*S_{n+1}=0`). +- **Piano superiore**: boundary operator su grafo aritmetico. Il gap e' bordo tra primi; la carica Mobius del vuoto tra primi decide se il bordo e' solo rumore di lunghezza o classe informativa. +- **Operatori laterali scelti**: boundary operator, random walk, entropia. Boundary operator definisce il bordo prime-free; random walk fornisce il null di permutazione della carica; entropia entra come dispersione del vuoto senza primi. +- **Contaminazione cognitiva**: + - **CE-0117**: usato per non promuovere il source cycle e far passare il risultato da potenziale a vincolo misurato. + - **CE-0038**: usato per riportare la forma nel Nulla-Tutto al vuoto aritmetico, qui lo zero `S=0`. + - **CE-0001 / KSAR**: usato come kernel reiterativo del ciclo 2102, con riparazione regressiva sul denominatore. + - **PVI attack**: il segnale puo' essere effetto di lunghezza del gap; per questo il null permuta l'intera sequenza delle cariche preservando multiset e frequenza degli zeri. +- **Proto-ipotesi**: se `S=0` e' terzo incluso operativo, non cade come rumore sotto il null che preserva la frequenza degli zeri. Deve produrre una classe distinguibile su low_low/high_high/SR. Se resta dentro il null, il source cycle sopravvive solo come gate binario non-zero. +- **Proiezione**: confronto aligned, misaligned e zero su `low_low`, `high_high` e `SR`; null = 400 permutazioni della sequenza `S_n`, gap invariati, multiset delle cariche invariata. + +## Claim Under Test +> Nel perimetro primi x Mobius fino a `p<=1e6`, le transizioni con `S=0` non vanno escluse: formano una terza classe del gate intervallare e vanno confrontate contro aligned/misaligned con null che preserva la frequenza degli zeri. + +## Question +Lo zero della carica Mobius intervallare e' rumore, boundary o mediatore del segnale low-low/high-high/SR? + +## Experiment Design +- Script: `tools/exp_prime_mobius_zero_mediator_gate.py`. +- Dati: primi fino a `1_000_000`; Mobius sieve sullo stesso perimetro. +- Carica intervallare: `S_n = sum(mu(k))` per `p_n < k < p_{n+1}`. +- Classi: + - `aligned`: `S_n*S_{n+1}<0`. + - `misaligned`: `S_n*S_{n+1}>0`. + - `zero`: `S_n*S_{n+1}=0`. +- Osservabili: + - `low_low_rate`: count di due gap consecutivi `<=6` sul denominatore della classe. + - `high_high_rate`: count di due gap consecutivi `>=q75` sul denominatore della classe. + - `SR`: mean min/max ratio dei gap consecutivi. +- Null test: 400 permutazioni della sequenza `S_n`; il null preserva la multiset completa delle cariche e quindi la frequenza degli zeri. +- Controllo det(M) diretto: `M=[[1,1],[1,0]]` ha `det(M)=-1` costante su ogni transizione; il controllo non partiziona il denominatore e restituisce solo le baseline globali low/high/SR. +- Soglia ex ante: `|z|>=2` e `p_two_sided<=0.05`. +- Contratto osservabile-operatore: `gap_ratio` Sturmian non testato; il source cycle 2102 non viene promosso; il claim su det diretto viene sostituito da controllo esplicito, non da conclusione non misurata. + +## Results +| condition | a/m/z denom | zero charges | low a | low m | low z | low z0 vs nonzero z/p | high a | high m | high z | high z0 vs nonzero z/p | SR a | SR m | SR z | SR z0 vs nonzero z/p | +|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:| +| N=5000 off=0 | 1200/1572/2227 | 1258/5000 | 221/1200 | 220/1572 | 707/2227 | 11.77 / 0.002 | 115/1200 | 298/1572 | 101/2227 | -10.80 / 0.002 | 0.51559 | 0.52611 | 0.43203 | -11.15 / 0.002 | +| N=10000 off=0 | 2541/3102/4356 | 2457/10000 | 403/2541 | 377/3102 | 1190/4356 | 14.88 / 0.002 | 153/2541 | 363/3102 | 114/4356 | -12.31 / 0.002 | 0.50841 | 0.51502 | 0.42221 | -16.03 / 0.002 | +| N=20000 off=0 | 5171/6331/8497 | 4782/20000 | 694/5171 | 651/6331 | 2093/8497 | 22.31 / 0.002 | 422/5171 | 878/6331 | 281/8497 | -18.75 / 0.002 | 0.50324 | 0.51151 | 0.41571 | -23.13 / 0.002 | +| N=5000 off=3000 | 1313/1525/2161 | 1219/5000 | 184/1313 | 162/1525 | 522/2161 | 9.84 / 0.002 | 86/1313 | 187/1525 | 71/2161 | -8.13 / 0.002 | 0.50993 | 0.50560 | 0.42213 | -10.87 / 0.002 | +| N=10000 off=7000 | 2675/3178/4146 | 2318/10000 | 315/2675 | 298/3178 | 946/4146 | 16.40 / 0.002 | 182/2675 | 351/3178 | 98/4146 | -13.27 / 0.002 | 0.50225 | 0.50729 | 0.40695 | -17.18 / 0.002 | +| N=20000 off=11000 | 5407/6413/8179 | 4586/20000 | 553/5407 | 567/6413 | 1740/8179 | 20.63 / 0.002 | 295/5407 | 667/6413 | 178/8179 | -16.22 / 0.002 | 0.49723 | 0.50997 | 0.41131 | -22.87 / 0.002 | + +### Pairwise aligned/misaligned checks +| condition | low a-m diff z/p | high a-m diff z/p | SR a-m diff z/p | +|---|---:|---:|---:| +| N=5000 off=0 | +0.04422 2.47 / 0.015 | -0.09373 -7.96 / 0.002 | -0.01053 -1.12 / 0.277 | +| N=10000 off=0 | +0.03706 3.44 / 0.002 | -0.05681 -8.90 / 0.002 | -0.00661 -0.90 / 0.357 | +| N=20000 off=0 | +0.03138 4.56 / 0.002 | -0.05707 -10.48 / 0.002 | -0.00827 -1.78 / 0.097 | +| N=5000 off=3000 | +0.03391 2.37 / 0.022 | -0.05712 -5.66 / 0.002 | +0.00433 0.48 / 0.671 | +| N=10000 off=7000 | +0.02399 2.68 / 0.010 | -0.04241 -6.58 / 0.002 | -0.00504 -0.71 / 0.501 | +| N=20000 off=11000 | +0.01386 1.97 / 0.040 | -0.04945 -10.96 / 0.002 | -0.01274 -2.50 / 0.015 | + +### det(M) direct control +`det(M)=-1` e' costante. Il controllo ha una sola classe su ogni condizione, quindi non separa aligned/misaligned/zero. Baseline globali: low_low `1148/4999`, `1970/9999`, `3438/19999`, `868/4999`, `1559/9999`, `2860/19999`; high_high `514/4999`, `630/9999`, `1581/19999`, `344/4999`, `631/9999`, `1140/19999`; SR globale `0.48167`, `0.47291`, `0.46867`, `0.47066`, `0.46434`, `0.46618`. + +## Key Findings +1. **Verificato: lo zero non e' rumore sotto il null usato.** La classe zero supera il null in 6/6 condizioni su `low_low_zero_minus_nonzero`, `high_high_zero_minus_nonzero` e `sr_zero_minus_nonzero`, sempre con `p=0.002` e `|z|` da `8.13` a `23.13`. + +2. **Verificato: lo zero e' una terza classe, non un mediatore tra aligned e misaligned.** Su low_low lo zero e' sopra entrambe le classi non-zero (`0.21274..0.31747` contro aligned `0.10227..0.18417` e misaligned `0.08841..0.13995`). Su high_high lo zero e' sotto entrambe (`0.02176..0.04535` contro aligned `0.05456..0.09583` e misaligned `0.10401..0.18957`). Su SR lo zero e' sotto entrambe (`0.40695..0.43203` contro non-zero circa `0.49723..0.52611`). Il punto-zero non sta tra i poli: genera una classe propria. + +3. **Verificato: il contrasto aligned/misaligned sopravvive soprattutto su high_high.** `high_high_aligned_minus_misaligned` passa 6/6 con z da `-5.66` a `-10.96`. `low_low_aligned_minus_misaligned` passa 5/6 se la soglia richiede anche `|z|>=2`; l'ultima condizione ha `z=1.97`, `p=0.040`, quindi resta borderline e non autorizza hard wording. SR passa 1/6 e resta osservabile secondario. + +4. **Verificato: il controllo det(M) diretto risolve il flag L3 del source cycle.** `det(M)` costante non produce partizione del denominatore; il report non conclude che la dualita "non si legge" da det diretto come fatto empirico generale. Qui dichiara solo che, in questo controllo, det(M) diretto non e' un discriminatore di classe. + +## Verdict +**CONSTRAINT on DUALITA_DIPOLARE_VS_ILLUSORIA / Prime Mobius interval-charge gate**: nel perimetro primi x Mobius fino a `p<=1e6`, `S=0` deve restare nel denominatore come terza classe. Lo zero non e' rumore sotto il null di permutazione che preserva frequenza degli zeri: arricchisce low_low, sopprime high_high e abbassa SR in 6/6 condizioni. Il source cycle sopravvive come vincolo parziale: il gate non-zero aligned/misaligned resta solido per high_high, resta parziale per low_low, e non porta SR globalmente. Il nuovo portatore e' triadico: aligned / misaligned / zero. + +## Bicono della scoperta +- **Due radici**: carica non-zero alternata/concorde . carica zero dell'intervallo prime-free. +- **Singolare**: il vuoto tra primi prima della scelta binaria; `S=0` non e' assenza di segnale ma classe del bordo. +- **Invariante di passaggio**: il null conserva gap, multiset delle cariche e frequenza degli zeri; cio' che sopravvive e' l'accoppiamento ordine-carica, non la sola presenza dello zero. +- **Campo di possibilita**: qui diventa possibile testare un gate triadico del boundary aritmetico. Qui diventa non-possibile escludere `S=0` dal denominatore quando si parla di terzo incluso nel perimetro Mobius-primi. + +## Consecutio +Il prossimo passo deve separare terza classe autentica da effetto scala dell'intervallo: ripetere il gate con controllo che preserva anche la lunghezza del gap o stratifica per bucket di gap length. Se lo zero resta significativo dentro ogni bucket, il boundary e' aritmetico; se cade, il segnale e' dipendenza da lunghezza. + +## Auto-audit: source flags e 5 lenti +- **Source L3 resolved**: il report non usa un elemento `not_tested` come conclusione. Il controllo det(M) diretto e' misurato e dichiarato non partizionante nel perimetro. +- **Source denominator repair resolved**: `S=0` e' incluso come classe esplicita, con count grezzi e denominatore. +- **Aperto**: non e' ancora separata la dipendenza dalla lunghezza del gap; serve controllo stratificato. +- **L1 hard constraint vs bias**: nessun "sempre/mai"; perimetro dichiarato `p<=1e6`, sei condizioni, 400 permutazioni. +- **L2 quantita vs ratio**: count grezzi e denominatori riportati; SR separato dai rate. +- **L3 no silent patching**: claim corretto prima del test; il source cycle non viene promosso. +- **L4 edge cases**: `low_low` non-zero e' borderline in una condizione (`z=1.97`), quindi resta parziale. +- **L5 re-discovery vs discovery**: verdict `CONSTRAINT`, non `NEW`; il pattern resta da confrontare con dipendenze note tra Mobius, lunghezza intervallare e gap primes. + +## Files +- Script: `tools/exp_prime_mobius_zero_mediator_gate.py` +- Data: `tools/data/prime_mobius_zero_mediator_gate_20260508_2108.json` +- Report: `tools/data/reports/agent_20260508_2108.md` diff --git a/tools/exp_prime_mobius_zero_mediator_gate.py b/tools/exp_prime_mobius_zero_mediator_gate.py new file mode 100644 index 0000000000000000000000000000000000000000..95ecd6e07c1863f3ffd3a3a5297a8628a00fd8be --- /dev/null +++ b/tools/exp_prime_mobius_zero_mediator_gate.py @@ -0,0 +1,314 @@ +#!/usr/bin/env python3 +"""Prime x Mobius zero-mediator gate. + +Repairs the 20260508_2102 interval-charge gate by keeping transitions with +S=0 in the denominator as an explicit third class. +""" +from __future__ import annotations + +import argparse +import json +from pathlib import Path + +import numpy as np + +from exp_prime_mobius_interval_charge_gate import ( + interval_charges, + mobius_sieve, + sieve_primes, +) + + +METRIC_KEYS = [ + "low_low_aligned_rate", + "low_low_misaligned_rate", + "low_low_zero_rate", + "high_high_aligned_rate", + "high_high_misaligned_rate", + "high_high_zero_rate", + "sr_aligned_mean", + "sr_misaligned_mean", + "sr_zero_mean", + "low_low_aligned_minus_misaligned", + "low_low_zero_minus_nonzero", + "high_high_aligned_minus_misaligned", + "high_high_zero_minus_nonzero", + "sr_aligned_minus_misaligned", + "sr_zero_minus_nonzero", +] + + +def _rate(mask: np.ndarray, event: np.ndarray) -> tuple[int, int, float]: + denom = int(np.sum(mask)) + hits = int(np.sum(mask & event)) + rate = float(hits / denom) if denom else float("nan") + return hits, denom, rate + + +def _mean(mask: np.ndarray, values: np.ndarray) -> tuple[int, float]: + denom = int(np.sum(mask)) + mean = float(np.mean(values[mask])) if denom else float("nan") + return denom, mean + + +def transition_metrics_three_class(gaps: np.ndarray, charges: np.ndarray) -> dict[str, float | int]: + left = charges[:-1] + right = charges[1:] + product = left * right + aligned = product < 0 + misaligned = product > 0 + zero = product == 0 + nonzero = ~zero + + g0 = gaps[:-1].astype(float) + g1 = gaps[1:].astype(float) + ratio = np.minimum(g0, g1) / np.maximum(g0, g1) + low_low = (g0 <= 6) & (g1 <= 6) + q75 = float(np.quantile(gaps, 0.75)) + high_high = (g0 >= q75) & (g1 >= q75) + + metrics: dict[str, float | int] = { + "q75_gap": q75, + "aligned_count": int(np.sum(aligned)), + "misaligned_count": int(np.sum(misaligned)), + "zero_count": int(np.sum(zero)), + "nonzero_count": int(np.sum(nonzero)), + } + + for name, event in (("low_low", low_low), ("high_high", high_high)): + for cls_name, mask in ( + ("aligned", aligned), + ("misaligned", misaligned), + ("zero", zero), + ("nonzero", nonzero), + ): + hits, denom, rate = _rate(mask, event) + metrics[f"{name}_{cls_name}_hits"] = hits + metrics[f"{name}_{cls_name}_denom"] = denom + metrics[f"{name}_{cls_name}_rate"] = rate + + for cls_name, mask in ( + ("aligned", aligned), + ("misaligned", misaligned), + ("zero", zero), + ("nonzero", nonzero), + ): + denom, mean = _mean(mask, ratio) + metrics[f"sr_{cls_name}_denom"] = denom + metrics[f"sr_{cls_name}_mean"] = mean + + metrics["low_low_aligned_minus_misaligned"] = ( + float(metrics["low_low_aligned_rate"]) - float(metrics["low_low_misaligned_rate"]) + ) + metrics["high_high_aligned_minus_misaligned"] = ( + float(metrics["high_high_aligned_rate"]) - float(metrics["high_high_misaligned_rate"]) + ) + metrics["sr_aligned_minus_misaligned"] = ( + float(metrics["sr_aligned_mean"]) - float(metrics["sr_misaligned_mean"]) + ) + metrics["low_low_zero_minus_nonzero"] = ( + float(metrics["low_low_zero_rate"]) - float(metrics["low_low_nonzero_rate"]) + ) + metrics["high_high_zero_minus_nonzero"] = ( + float(metrics["high_high_zero_rate"]) - float(metrics["high_high_nonzero_rate"]) + ) + metrics["sr_zero_minus_nonzero"] = ( + float(metrics["sr_zero_mean"]) - float(metrics["sr_nonzero_mean"]) + ) + return metrics + + +def permutation_test( + gaps: np.ndarray, + charges: np.ndarray, + observed: dict[str, float | int], + rng: np.random.Generator, + permutations: int, +) -> dict[str, dict[str, float]]: + nulls = {key: [] for key in METRIC_KEYS} + for _ in range(permutations): + shuffled = np.array(charges, copy=True) + rng.shuffle(shuffled) + metrics = transition_metrics_three_class(gaps, shuffled) + for key in METRIC_KEYS: + nulls[key].append(float(metrics[key])) + + out: dict[str, dict[str, float]] = {} + for key, values in nulls.items(): + arr = np.array(values, dtype=float) + obs = float(observed[key]) + finite = np.isfinite(arr) + arr = arr[finite] + if arr.size == 0 or not np.isfinite(obs): + out[key] = {"observed": obs, "null_mean": float("nan"), "null_std": float("nan"), "z": float("nan"), "p_two_sided": float("nan")} + continue + std = float(np.std(arr, ddof=1)) + z = (obs - float(np.mean(arr))) / std if std > 0 else 0.0 + p = float((np.sum(np.abs(arr) >= abs(obs)) + 1) / (len(arr) + 1)) + out[key] = { + "observed": obs, + "null_mean": float(np.mean(arr)), + "null_std": std, + "z": float(z), + "p_two_sided": p, + } + return out + + +def det_m_direct_control(gaps: np.ndarray) -> dict[str, float | int | str]: + g0 = gaps[:-1].astype(float) + g1 = gaps[1:].astype(float) + ratio = np.minimum(g0, g1) / np.maximum(g0, g1) + low_low = (g0 <= 6) & (g1 <= 6) + q75 = float(np.quantile(gaps, 0.75)) + high_high = (g0 >= q75) & (g1 >= q75) + denom = int(g0.size) + return { + "det_M": -1, + "class_count": 1, + "reason": "M=[[1,1],[1,0]] has constant determinant -1 on every transition, so direct det(M) does not partition the denominator.", + "denominator": denom, + "low_low_hits": int(np.sum(low_low)), + "low_low_rate": float(np.sum(low_low) / denom), + "high_high_hits": int(np.sum(high_high)), + "high_high_rate": float(np.sum(high_high) / denom), + "sr_mean": float(np.mean(ratio)), + } + + +def classify_zero_role(observed: dict[str, float | int], tests: dict[str, dict[str, float]]) -> str: + low_z = tests["low_low_zero_minus_nonzero"]["z"] + high_z = tests["high_high_zero_minus_nonzero"]["z"] + sr_z = tests["sr_zero_minus_nonzero"]["z"] + passes = [ + abs(low_z) >= 2 and tests["low_low_zero_minus_nonzero"]["p_two_sided"] <= 0.05, + abs(high_z) >= 2 and tests["high_high_zero_minus_nonzero"]["p_two_sided"] <= 0.05, + abs(sr_z) >= 2 and tests["sr_zero_minus_nonzero"]["p_two_sided"] <= 0.05, + ] + low = float(observed["low_low_zero_rate"]) + high = float(observed["high_high_zero_rate"]) + sr = float(observed["sr_zero_mean"]) + low_a = float(observed["low_low_aligned_rate"]) + low_m = float(observed["low_low_misaligned_rate"]) + high_a = float(observed["high_high_aligned_rate"]) + high_m = float(observed["high_high_misaligned_rate"]) + sr_a = float(observed["sr_aligned_mean"]) + sr_m = float(observed["sr_misaligned_mean"]) + + between_low = min(low_a, low_m) <= low <= max(low_a, low_m) + between_high = min(high_a, high_m) <= high <= max(high_a, high_m) + between_sr = min(sr_a, sr_m) <= sr <= max(sr_a, sr_m) + + if any(passes) and (between_low or between_high or between_sr): + return "boundary" + if any(passes): + return "third_class" + return "noise_under_this_null" + + +def run_condition( + primes: np.ndarray, + mu: np.ndarray, + n_primes: int, + offset: int, + rng: np.random.Generator, + permutations: int, +) -> dict[str, object]: + segment = primes[offset : offset + n_primes + 1] + gaps = np.diff(segment) + charges = interval_charges(segment, mu) + observed = transition_metrics_three_class(gaps, charges) + tests = permutation_test(gaps, charges, observed, rng, permutations) + return { + "n_primes": n_primes, + "offset": offset, + "prime_start": int(segment[0]), + "prime_stop": int(segment[-1]), + "zero_charge_count": int(np.sum(charges == 0)), + "charge_count": int(charges.size), + "observed": observed, + "permutation_tests": tests, + "zero_role": classify_zero_role(observed, tests), + "det_m_direct_control": det_m_direct_control(gaps), + } + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--limit", type=int, default=1_000_000) + parser.add_argument("--permutations", type=int, default=400) + parser.add_argument("--seed", type=int, default=2108) + parser.add_argument("--out", default="tools/data/prime_mobius_zero_mediator_gate_20260508_2108.json") + args = parser.parse_args() + + primes = sieve_primes(args.limit) + mu = mobius_sieve(args.limit) + rng = np.random.default_rng(args.seed) + + conditions = [ + {"n_primes": 5_000, "offset": 0}, + {"n_primes": 10_000, "offset": 0}, + {"n_primes": 20_000, "offset": 0}, + {"n_primes": 5_000, "offset": 3_000}, + {"n_primes": 10_000, "offset": 7_000}, + {"n_primes": 20_000, "offset": 11_000}, + ] + max_needed = max(c["offset"] + c["n_primes"] + 1 for c in conditions) + if len(primes) <= max_needed: + raise SystemExit(f"limit={args.limit} yields only {len(primes)} primes, need {max_needed}") + + results = [ + run_condition(primes, mu, c["n_primes"], c["offset"], rng, args.permutations) + for c in conditions + ] + summary = [] + for result in results: + tests = result["permutation_tests"] + summary.append( + { + "n_primes": result["n_primes"], + "offset": result["offset"], + "low_low_aligned_minus_misaligned_pass": abs(tests["low_low_aligned_minus_misaligned"]["z"]) >= 2.0 + and tests["low_low_aligned_minus_misaligned"]["p_two_sided"] <= 0.05, + "high_high_aligned_minus_misaligned_pass": abs(tests["high_high_aligned_minus_misaligned"]["z"]) >= 2.0 + and tests["high_high_aligned_minus_misaligned"]["p_two_sided"] <= 0.05, + "sr_aligned_minus_misaligned_pass": abs(tests["sr_aligned_minus_misaligned"]["z"]) >= 2.0 + and tests["sr_aligned_minus_misaligned"]["p_two_sided"] <= 0.05, + "zero_role": result["zero_role"], + } + ) + + payload = { + "experiment": "prime_mobius_zero_mediator_gate", + "question": "Does S=0 behave as noise, boundary, or mediator in the Mobius interval-charge gate?", + "threshold_ex_ante": "|z|>=2 and permutation p<=0.05 across main and offset conditions", + "null": "Permutation of the interval-charge sequence preserves the full charge multiset and therefore preserves zero frequency.", + "limit": args.limit, + "permutations": args.permutations, + "seed": args.seed, + "conditions": results, + "significance_summary": summary, + } + + out = Path(args.out) + out.parent.mkdir(parents=True, exist_ok=True) + out.write_text(json.dumps(payload, indent=2), encoding="utf-8") + + for result in results: + obs = result["observed"] + tests = result["permutation_tests"] + print( + f"N={result['n_primes']} offset={result['offset']} " + f"a/m/z={obs['aligned_count']}/{obs['misaligned_count']}/{obs['zero_count']} " + f"low_am={obs['low_low_aligned_minus_misaligned']:.5f} z={tests['low_low_aligned_minus_misaligned']['z']:.2f} p={tests['low_low_aligned_minus_misaligned']['p_two_sided']:.3f} " + f"low_z0={obs['low_low_zero_minus_nonzero']:.5f} z={tests['low_low_zero_minus_nonzero']['z']:.2f} p={tests['low_low_zero_minus_nonzero']['p_two_sided']:.3f} " + f"high_am={obs['high_high_aligned_minus_misaligned']:.5f} z={tests['high_high_aligned_minus_misaligned']['z']:.2f} p={tests['high_high_aligned_minus_misaligned']['p_two_sided']:.3f} " + f"high_z0={obs['high_high_zero_minus_nonzero']:.5f} z={tests['high_high_zero_minus_nonzero']['z']:.2f} p={tests['high_high_zero_minus_nonzero']['p_two_sided']:.3f} " + f"sr_am={obs['sr_aligned_minus_misaligned']:.5f} z={tests['sr_aligned_minus_misaligned']['z']:.2f} p={tests['sr_aligned_minus_misaligned']['p_two_sided']:.3f} " + f"role={result['zero_role']}" + ) + print(f"wrote {out}") + + +if __name__ == "__main__": + main() codex Lo structural check sui due file toccati non trova anti-pattern. Provo anche il falsifier del lab sul report nuovo; se la catena LLM non risponde, lo dichiaro come verifica non completata. exec /bin/bash -lc 'python tools/lab_falsifier.py --report tools/data/reports/agent_20260508_2108.md --output tools/data/reports/falsifier_20260508_2108.json --timeout 120' in /opt/MM_D-ND diff --git a/tools/data/reports/agent_20260508_2108.md b/tools/data/reports/agent_20260508_2108.md new file mode 100644 index 0000000000000000000000000000000000000000..d3b8fa5889b9587b0e01270608220848eb4d5ed7 --- /dev/null +++ b/tools/data/reports/agent_20260508_2108.md @@ -0,0 +1,103 @@ +# Agent Report - Prime Mobius Zero-Mediator Gate +**Date**: 2026-05-08 21:08 +**Piano**: 93 +**Tension explored**: DUALITA_DIPOLARE_VS_ILLUSORIA (0.9) +**verdict**: CONSTRAINT +observables_registry: 1.0.0-2026-05-06 +observables_used: [low_low_rate, high_high_rate, SR, det_M_direct_control] +**observable_contract**: claim=lo zero della carica Mobius intervallare e' testato come terzo incluso del gate aligned/misaligned; observable=rate low_low, rate high_high, SR mean per classi aligned/misaligned/zero; operator=classificazione di S_n*S_{n+1}: aligned<0, misaligned>0, zero=0; generator=prime gaps up to p<=1e6 with Mobius sieve; denominator=main N={5000,10000,20000} offset=0 plus seedcheck offsets {3000,7000,11000}; not_tested=gap_ratio Sturmian, high-core phi survival, universal GUE/Poisson classification. + +## Respiro fuori-tempo +- **Combo**: A2 confine det=-1 + A9 terzo incluso + A11 combo + QxG continuo/discreto vuoto + DUALITA_DIPOLARE_VS_ILLUSORIA + piano primi x Mobius. Il repair non cerca un lettore nuovo: riporta nel denominatore il punto escluso dal source cycle, `S=0`. +- **Dipolo / punto-zero**: carica Mobius alternata / carica Mobius concorde; punto-zero = transizione con almeno un intervallo a carica nulla (`S_n*S_{n+1}=0`). +- **Piano superiore**: boundary operator su grafo aritmetico. Il gap e' bordo tra primi; la carica Mobius del vuoto tra primi decide se il bordo e' solo rumore di lunghezza o classe informativa. +- **Operatori laterali scelti**: boundary operator, random walk, entropia. Boundary operator definisce il bordo prime-free; random walk fornisce il null di permutazione della carica; entropia entra come dispersione del vuoto senza primi. +- **Contaminazione cognitiva**: + - **CE-0117**: usato per non promuovere il source cycle e far passare il risultato da potenziale a vincolo misurato. + - **CE-0038**: usato per riportare la forma nel Nulla-Tutto al vuoto aritmetico, qui lo zero `S=0`. + - **CE-0001 / KSAR**: usato come kernel reiterativo del ciclo 2102, con riparazione regressiva sul denominatore. + - **PVI attack**: il segnale puo' essere effetto di lunghezza del gap; per questo il null permuta l'intera sequenza delle cariche preservando multiset e frequenza degli zeri. +- **Proto-ipotesi**: se `S=0` e' terzo incluso operativo, non cade come rumore sotto il null che preserva la frequenza degli zeri. Deve produrre una classe distinguibile su low_low/high_high/SR. Se resta dentro il null, il source cycle sopravvive solo come gate binario non-zero. +- **Proiezione**: confronto aligned, misaligned e zero su `low_low`, `high_high` e `SR`; null = 400 permutazioni della sequenza `S_n`, gap invariati, multiset delle cariche invariata. + +## Claim Under Test +> Nel perimetro primi x Mobius fino a `p<=1e6`, le transizioni con `S=0` non vanno escluse: formano una terza classe del gate intervallare e vanno confrontate contro aligned/misaligned con null che preserva la frequenza degli zeri. + +## Question +Lo zero della carica Mobius intervallare e' rumore, boundary o mediatore del segnale low-low/high-high/SR? + +## Experiment Design +- Script: `tools/exp_prime_mobius_zero_mediator_gate.py`. +- Dati: primi fino a `1_000_000`; Mobius sieve sullo stesso perimetro. +- Carica intervallare: `S_n = sum(mu(k))` per `p_n < k < p_{n+1}`. +- Classi: + - `aligned`: `S_n*S_{n+1}<0`. + - `misaligned`: `S_n*S_{n+1}>0`. + - `zero`: `S_n*S_{n+1}=0`. +- Osservabili: + - `low_low_rate`: count di due gap consecutivi `<=6` sul denominatore della classe. + - `high_high_rate`: count di due gap consecutivi `>=q75` sul denominatore della classe. + - `SR`: mean min/max ratio dei gap consecutivi. +- Null test: 400 permutazioni della sequenza `S_n`; il null preserva la multiset completa delle cariche e quindi la frequenza degli zeri. +- Controllo det(M) diretto: `M=[[1,1],[1,0]]` ha `det(M)=-1` costante su ogni transizione; il controllo non partiziona il denominatore e restituisce solo le baseline globali low/high/SR. +- Soglia ex ante: `|z|>=2` e `p_two_sided<=0.05`. +- Contratto osservabile-operatore: `gap_ratio` Sturmian non testato; il source cycle 2102 non viene promosso; il claim su det diretto viene sostituito da controllo esplicito, non da conclusione non misurata. + +## Results +| condition | a/m/z denom | zero charges | low a | low m | low z | low z0 vs nonzero z/p | high a | high m | high z | high z0 vs nonzero z/p | SR a | SR m | SR z | SR z0 vs nonzero z/p | +|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:| +| N=5000 off=0 | 1200/1572/2227 | 1258/5000 | 221/1200 | 220/1572 | 707/2227 | 11.77 / 0.002 | 115/1200 | 298/1572 | 101/2227 | -10.80 / 0.002 | 0.51559 | 0.52611 | 0.43203 | -11.15 / 0.002 | +| N=10000 off=0 | 2541/3102/4356 | 2457/10000 | 403/2541 | 377/3102 | 1190/4356 | 14.88 / 0.002 | 153/2541 | 363/3102 | 114/4356 | -12.31 / 0.002 | 0.50841 | 0.51502 | 0.42221 | -16.03 / 0.002 | +| N=20000 off=0 | 5171/6331/8497 | 4782/20000 | 694/5171 | 651/6331 | 2093/8497 | 22.31 / 0.002 | 422/5171 | 878/6331 | 281/8497 | -18.75 / 0.002 | 0.50324 | 0.51151 | 0.41571 | -23.13 / 0.002 | +| N=5000 off=3000 | 1313/1525/2161 | 1219/5000 | 184/1313 | 162/1525 | 522/2161 | 9.84 / 0.002 | 86/1313 | 187/1525 | 71/2161 | -8.13 / 0.002 | 0.50993 | 0.50560 | 0.42213 | -10.87 / 0.002 | +| N=10000 off=7000 | 2675/3178/4146 | 2318/10000 | 315/2675 | 298/3178 | 946/4146 | 16.40 / 0.002 | 182/2675 | 351/3178 | 98/4146 | -13.27 / 0.002 | 0.50225 | 0.50729 | 0.40695 | -17.18 / 0.002 | +| N=20000 off=11000 | 5407/6413/8179 | 4586/20000 | 553/5407 | 567/6413 | 1740/8179 | 20.63 / 0.002 | 295/5407 | 667/6413 | 178/8179 | -16.22 / 0.002 | 0.49723 | 0.50997 | 0.41131 | -22.87 / 0.002 | + +### Pairwise aligned/misaligned checks +| condition | low a-m diff z/p | high a-m diff z/p | SR a-m diff z/p | +|---|---:|---:|---:| +| N=5000 off=0 | +0.04422 2.47 / 0.015 | -0.09373 -7.96 / 0.002 | -0.01053 -1.12 / 0.277 | +| N=10000 off=0 | +0.03706 3.44 / 0.002 | -0.05681 -8.90 / 0.002 | -0.00661 -0.90 / 0.357 | +| N=20000 off=0 | +0.03138 4.56 / 0.002 | -0.05707 -10.48 / 0.002 | -0.00827 -1.78 / 0.097 | +| N=5000 off=3000 | +0.03391 2.37 / 0.022 | -0.05712 -5.66 / 0.002 | +0.00433 0.48 / 0.671 | +| N=10000 off=7000 | +0.02399 2.68 / 0.010 | -0.04241 -6.58 / 0.002 | -0.00504 -0.71 / 0.501 | +| N=20000 off=11000 | +0.01386 1.97 / 0.040 | -0.04945 -10.96 / 0.002 | -0.01274 -2.50 / 0.015 | + +### det(M) direct control +`det(M)=-1` e' costante. Il controllo ha una sola classe su ogni condizione, quindi non separa aligned/misaligned/zero. Baseline globali: low_low `1148/4999`, `1970/9999`, `3438/19999`, `868/4999`, `1559/9999`, `2860/19999`; high_high `514/4999`, `630/9999`, `1581/19999`, `344/4999`, `631/9999`, `1140/19999`; SR globale `0.48167`, `0.47291`, `0.46867`, `0.47066`, `0.46434`, `0.46618`. + +## Key Findings +1. **Verificato: lo zero non e' rumore sotto il null usato.** La classe zero supera il null in 6/6 condizioni su `low_low_zero_minus_nonzero`, `high_high_zero_minus_nonzero` e `sr_zero_minus_nonzero`, sempre con `p=0.002` e `|z|` da `8.13` a `23.13`. + +2. **Verificato: lo zero e' una terza classe, non un mediatore tra aligned e misaligned.** Su low_low lo zero e' sopra entrambe le classi non-zero (`0.21274..0.31747` contro aligned `0.10227..0.18417` e misaligned `0.08841..0.13995`). Su high_high lo zero e' sotto entrambe (`0.02176..0.04535` contro aligned `0.05456..0.09583` e misaligned `0.10401..0.18957`). Su SR lo zero e' sotto entrambe (`0.40695..0.43203` contro non-zero circa `0.49723..0.52611`). Il punto-zero non sta tra i poli: genera una classe propria. + +3. **Verificato: il contrasto aligned/misaligned sopravvive soprattutto su high_high.** `high_high_aligned_minus_misaligned` passa 6/6 con z da `-5.66` a `-10.96`. `low_low_aligned_minus_misaligned` passa 5/6 se la soglia richiede anche `|z|>=2`; l'ultima condizione ha `z=1.97`, `p=0.040`, quindi resta borderline e non autorizza hard wording. SR passa 1/6 e resta osservabile secondario. + +4. **Verificato: il controllo det(M) diretto risolve il flag L3 del source cycle.** `det(M)` costante non produce partizione del denominatore; il report non conclude che la dualita "non si legge" da det diretto come fatto empirico generale. Qui dichiara solo che, in questo controllo, det(M) diretto non e' un discriminatore di classe. + +## Verdict +**CONSTRAINT on DUALITA_DIPOLARE_VS_ILLUSORIA / Prime Mobius interval-charge gate**: nel perimetro primi x Mobius fino a `p<=1e6`, `S=0` deve restare nel denominatore come terza classe. Lo zero non e' rumore sotto il null di permutazione che preserva frequenza degli zeri: arricchisce low_low, sopprime high_high e abbassa SR in 6/6 condizioni. Il source cycle sopravvive come vincolo parziale: il gate non-zero aligned/misaligned resta solido per high_high, resta parziale per low_low, e non porta SR globalmente. Il nuovo portatore e' triadico: aligned / misaligned / zero. + +## Bicono della scoperta +- **Due radici**: carica non-zero alternata/concorde . carica zero dell'intervallo prime-free. +- **Singolare**: il vuoto tra primi prima della scelta binaria; `S=0` non e' assenza di segnale ma classe del bordo. +- **Invariante di passaggio**: il null conserva gap, multiset delle cariche e frequenza degli zeri; cio' che sopravvive e' l'accoppiamento ordine-carica, non la sola presenza dello zero. +- **Campo di possibilita**: qui diventa possibile testare un gate triadico del boundary aritmetico. Qui diventa non-possibile escludere `S=0` dal denominatore quando si parla di terzo incluso nel perimetro Mobius-primi. + +## Consecutio +Il prossimo passo deve separare terza classe autentica da effetto scala dell'intervallo: ripetere il gate con controllo che preserva anche la lunghezza del gap o stratifica per bucket di gap length. Se lo zero resta significativo dentro ogni bucket, il boundary e' aritmetico; se cade, il segnale e' dipendenza da lunghezza. + +## Auto-audit: source flags e 5 lenti +- **Source L3 resolved**: il report non usa un elemento `not_tested` come conclusione. Il controllo det(M) diretto e' misurato e dichiarato non partizionante nel perimetro. +- **Source denominator repair resolved**: `S=0` e' incluso come classe esplicita, con count grezzi e denominatore. +- **Aperto**: non e' ancora separata la dipendenza dalla lunghezza del gap; serve controllo stratificato. +- **L1 hard constraint vs bias**: nessun "sempre/mai"; perimetro dichiarato `p<=1e6`, sei condizioni, 400 permutazioni. +- **L2 quantita vs ratio**: count grezzi e denominatori riportati; SR separato dai rate. +- **L3 no silent patching**: claim corretto prima del test; il source cycle non viene promosso. +- **L4 edge cases**: `low_low` non-zero e' borderline in una condizione (`z=1.97`), quindi resta parziale. +- **L5 re-discovery vs discovery**: verdict `CONSTRAINT`, non `NEW`; il pattern resta da confrontare con dipendenze note tra Mobius, lunghezza intervallare e gap primes. + +## Files +- Script: `tools/exp_prime_mobius_zero_mediator_gate.py` +- Data: `tools/data/prime_mobius_zero_mediator_gate_20260508_2108.json` +- Report: `tools/data/reports/agent_20260508_2108.md` diff --git a/tools/exp_prime_mobius_zero_mediator_gate.py b/tools/exp_prime_mobius_zero_mediator_gate.py new file mode 100644 index 0000000000000000000000000000000000000000..95ecd6e07c1863f3ffd3a3a5297a8628a00fd8be --- /dev/null +++ b/tools/exp_prime_mobius_zero_mediator_gate.py @@ -0,0 +1,314 @@ +#!/usr/bin/env python3 +"""Prime x Mobius zero-mediator gate. + +Repairs the 20260508_2102 interval-charge gate by keeping transitions with +S=0 in the denominator as an explicit third class. +""" +from __future__ import annotations + +import argparse +import json +from pathlib import Path + +import numpy as np + +from exp_prime_mobius_interval_charge_gate import ( + interval_charges, + mobius_sieve, + sieve_primes, +) + + +METRIC_KEYS = [ + "low_low_aligned_rate", + "low_low_misaligned_rate", + "low_low_zero_rate", + "high_high_aligned_rate", + "high_high_misaligned_rate", + "high_high_zero_rate", + "sr_aligned_mean", + "sr_misaligned_mean", + "sr_zero_mean", + "low_low_aligned_minus_misaligned", + "low_low_zero_minus_nonzero", + "high_high_aligned_minus_misaligned", + "high_high_zero_minus_nonzero", + "sr_aligned_minus_misaligned", + "sr_zero_minus_nonzero", +] + + +def _rate(mask: np.ndarray, event: np.ndarray) -> tuple[int, int, float]: + denom = int(np.sum(mask)) + hits = int(np.sum(mask & event)) + rate = float(hits / denom) if denom else float("nan") + return hits, denom, rate + + +def _mean(mask: np.ndarray, values: np.ndarray) -> tuple[int, float]: + denom = int(np.sum(mask)) + mean = float(np.mean(values[mask])) if denom else float("nan") + return denom, mean + + +def transition_metrics_three_class(gaps: np.ndarray, charges: np.ndarray) -> dict[str, float | int]: + left = charges[:-1] + right = charges[1:] + product = left * right + aligned = product < 0 + misaligned = product > 0 + zero = product == 0 + nonzero = ~zero + + g0 = gaps[:-1].astype(float) + g1 = gaps[1:].astype(float) + ratio = np.minimum(g0, g1) / np.maximum(g0, g1) + low_low = (g0 <= 6) & (g1 <= 6) + q75 = float(np.quantile(gaps, 0.75)) + high_high = (g0 >= q75) & (g1 >= q75) + + metrics: dict[str, float | int] = { + "q75_gap": q75, + "aligned_count": int(np.sum(aligned)), + "misaligned_count": int(np.sum(misaligned)), + "zero_count": int(np.sum(zero)), + "nonzero_count": int(np.sum(nonzero)), + } + + for name, event in (("low_low", low_low), ("high_high", high_high)): + for cls_name, mask in ( + ("aligned", aligned), + ("misaligned", misaligned), + ("zero", zero), + ("nonzero", nonzero), + ): + hits, denom, rate = _rate(mask, event) + metrics[f"{name}_{cls_name}_hits"] = hits + metrics[f"{name}_{cls_name}_denom"] = denom + metrics[f"{name}_{cls_name}_rate"] = rate + + for cls_name, mask in ( + ("aligned", aligned), + ("misaligned", misaligned), + ("zero", zero), + ("nonzero", nonzero), + ): + denom, mean = _mean(mask, ratio) + metrics[f"sr_{cls_name}_denom"] = denom + metrics[f"sr_{cls_name}_mean"] = mean + + metrics["low_low_aligned_minus_misaligned"] = ( + float(metrics["low_low_aligned_rate"]) - float(metrics["low_low_misaligned_rate"]) + ) + metrics["high_high_aligned_minus_misaligned"] = ( + float(metrics["high_high_aligned_rate"]) - float(metrics["high_high_misaligned_rate"]) + ) + metrics["sr_aligned_minus_misaligned"] = ( + float(metrics["sr_aligned_mean"]) - float(metrics["sr_misaligned_mean"]) + ) + metrics["low_low_zero_minus_nonzero"] = ( + float(metrics["low_low_zero_rate"]) - float(metrics["low_low_nonzero_rate"]) + ) + metrics["high_high_zero_minus_nonzero"] = ( + float(metrics["high_high_zero_rate"]) - float(metrics["high_high_nonzero_rate"]) + ) + metrics["sr_zero_minus_nonzero"] = ( + float(metrics["sr_zero_mean"]) - float(metrics["sr_nonzero_mean"]) + ) + return metrics + + +def permutation_test( + gaps: np.ndarray, + charges: np.ndarray, + observed: dict[str, float | int], + rng: np.random.Generator, + permutations: int, +) -> dict[str, dict[str, float]]: + nulls = {key: [] for key in METRIC_KEYS} + for _ in range(permutations): + shuffled = np.array(charges, copy=True) + rng.shuffle(shuffled) + metrics = transition_metrics_three_class(gaps, shuffled) + for key in METRIC_KEYS: + nulls[key].append(float(metrics[key])) + + out: dict[str, dict[str, float]] = {} + for key, values in nulls.items(): + arr = np.array(values, dtype=float) + obs = float(observed[key]) + finite = np.isfinite(arr) + arr = arr[finite] + if arr.size == 0 or not np.isfinite(obs): + out[key] = {"observed": obs, "null_mean": float("nan"), "null_std": float("nan"), "z": float("nan"), "p_two_sided": float("nan")} + continue + std = float(np.std(arr, ddof=1)) + z = (obs - float(np.mean(arr))) / std if std > 0 else 0.0 + p = float((np.sum(np.abs(arr) >= abs(obs)) + 1) / (len(arr) + 1)) + out[key] = { + "observed": obs, + "null_mean": float(np.mean(arr)), + "null_std": std, + "z": float(z), + "p_two_sided": p, + } + return out + + +def det_m_direct_control(gaps: np.ndarray) -> dict[str, float | int | str]: + g0 = gaps[:-1].astype(float) + g1 = gaps[1:].astype(float) + ratio = np.minimum(g0, g1) / np.maximum(g0, g1) + low_low = (g0 <= 6) & (g1 <= 6) + q75 = float(np.quantile(gaps, 0.75)) + high_high = (g0 >= q75) & (g1 >= q75) + denom = int(g0.size) + return { + "det_M": -1, + "class_count": 1, + "reason": "M=[[1,1],[1,0]] has constant determinant -1 on every transition, so direct det(M) does not partition the denominator.", + "denominator": denom, + "low_low_hits": int(np.sum(low_low)), + "low_low_rate": float(np.sum(low_low) / denom), + "high_high_hits": int(np.sum(high_high)), + "high_high_rate": float(np.sum(high_high) / denom), + "sr_mean": float(np.mean(ratio)), + } + + +def classify_zero_role(observed: dict[str, float | int], tests: dict[str, dict[str, float]]) -> str: + low_z = tests["low_low_zero_minus_nonzero"]["z"] + high_z = tests["high_high_zero_minus_nonzero"]["z"] + sr_z = tests["sr_zero_minus_nonzero"]["z"] + passes = [ + abs(low_z) >= 2 and tests["low_low_zero_minus_nonzero"]["p_two_sided"] <= 0.05, + abs(high_z) >= 2 and tests["high_high_zero_minus_nonzero"]["p_two_sided"] <= 0.05, + abs(sr_z) >= 2 and tests["sr_zero_minus_nonzero"]["p_two_sided"] <= 0.05, + ] + low = float(observed["low_low_zero_rate"]) + high = float(observed["high_high_zero_rate"]) + sr = float(observed["sr_zero_mean"]) + low_a = float(observed["low_low_aligned_rate"]) + low_m = float(observed["low_low_misaligned_rate"]) + high_a = float(observed["high_high_aligned_rate"]) + high_m = float(observed["high_high_misaligned_rate"]) + sr_a = float(observed["sr_aligned_mean"]) + sr_m = float(observed["sr_misaligned_mean"]) + + between_low = min(low_a, low_m) <= low <= max(low_a, low_m) + between_high = min(high_a, high_m) <= high <= max(high_a, high_m) + between_sr = min(sr_a, sr_m) <= sr <= max(sr_a, sr_m) + + if any(passes) and (between_low or between_high or between_sr): + return "boundary" + if any(passes): + return "third_class" + return "noise_under_this_null" + + +def run_condition( + primes: np.ndarray, + mu: np.ndarray, + n_primes: int, + offset: int, + rng: np.random.Generator, + permutations: int, +) -> dict[str, object]: + segment = primes[offset : offset + n_primes + 1] + gaps = np.diff(segment) + charges = interval_charges(segment, mu) + observed = transition_metrics_three_class(gaps, charges) + tests = permutation_test(gaps, charges, observed, rng, permutations) + return { + "n_primes": n_primes, + "offset": offset, + "prime_start": int(segment[0]), + "prime_stop": int(segment[-1]), + "zero_charge_count": int(np.sum(charges == 0)), + "charge_count": int(charges.size), + "observed": observed, + "permutation_tests": tests, + "zero_role": classify_zero_role(observed, tests), + "det_m_direct_control": det_m_direct_control(gaps), + } + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--limit", type=int, default=1_000_000) + parser.add_argument("--permutations", type=int, default=400) + parser.add_argument("--seed", type=int, default=2108) + parser.add_argument("--out", default="tools/data/prime_mobius_zero_mediator_gate_20260508_2108.json") + args = parser.parse_args() + + primes = sieve_primes(args.limit) + mu = mobius_sieve(args.limit) + rng = np.random.default_rng(args.seed) + + conditions = [ + {"n_primes": 5_000, "offset": 0}, + {"n_primes": 10_000, "offset": 0}, + {"n_primes": 20_000, "offset": 0}, + {"n_primes": 5_000, "offset": 3_000}, + {"n_primes": 10_000, "offset": 7_000}, + {"n_primes": 20_000, "offset": 11_000}, + ] + max_needed = max(c["offset"] + c["n_primes"] + 1 for c in conditions) + if len(primes) <= max_needed: + raise SystemExit(f"limit={args.limit} yields only {len(primes)} primes, need {max_needed}") + + results = [ + run_condition(primes, mu, c["n_primes"], c["offset"], rng, args.permutations) + for c in conditions + ] + summary = [] + for result in results: + tests = result["permutation_tests"] + summary.append( + { + "n_primes": result["n_primes"], + "offset": result["offset"], + "low_low_aligned_minus_misaligned_pass": abs(tests["low_low_aligned_minus_misaligned"]["z"]) >= 2.0 + and tests["low_low_aligned_minus_misaligned"]["p_two_sided"] <= 0.05, + "high_high_aligned_minus_misaligned_pass": abs(tests["high_high_aligned_minus_misaligned"]["z"]) >= 2.0 + and tests["high_high_aligned_minus_misaligned"]["p_two_sided"] <= 0.05, + "sr_aligned_minus_misaligned_pass": abs(tests["sr_aligned_minus_misaligned"]["z"]) >= 2.0 + and tests["sr_aligned_minus_misaligned"]["p_two_sided"] <= 0.05, + "zero_role": result["zero_role"], + } + ) + + payload = { + "experiment": "prime_mobius_zero_mediator_gate", + "question": "Does S=0 behave as noise, boundary, or mediator in the Mobius interval-charge gate?", + "threshold_ex_ante": "|z|>=2 and permutation p<=0.05 across main and offset conditions", + "null": "Permutation of the interval-charge sequence preserves the full charge multiset and therefore preserves zero frequency.", + "limit": args.limit, + "permutations": args.permutations, + "seed": args.seed, + "conditions": results, + "significance_summary": summary, + } + + out = Path(args.out) + out.parent.mkdir(parents=True, exist_ok=True) + out.write_text(json.dumps(payload, indent=2), encoding="utf-8") + + for result in results: + obs = result["observed"] + tests = result["permutation_tests"] + print( + f"N={result['n_primes']} offset={result['offset']} " + f"a/m/z={obs['aligned_count']}/{obs['misaligned_count']}/{obs['zero_count']} " + f"low_am={obs['low_low_aligned_minus_misaligned']:.5f} z={tests['low_low_aligned_minus_misaligned']['z']:.2f} p={tests['low_low_aligned_minus_misaligned']['p_two_sided']:.3f} " + f"low_z0={obs['low_low_zero_minus_nonzero']:.5f} z={tests['low_low_zero_minus_nonzero']['z']:.2f} p={tests['low_low_zero_minus_nonzero']['p_two_sided']:.3f} " + f"high_am={obs['high_high_aligned_minus_misaligned']:.5f} z={tests['high_high_aligned_minus_misaligned']['z']:.2f} p={tests['high_high_aligned_minus_misaligned']['p_two_sided']:.3f} " + f"high_z0={obs['high_high_zero_minus_nonzero']:.5f} z={tests['high_high_zero_minus_nonzero']['z']:.2f} p={tests['high_high_zero_minus_nonzero']['p_two_sided']:.3f} " + f"sr_am={obs['sr_aligned_minus_misaligned']:.5f} z={tests['sr_aligned_minus_misaligned']['z']:.2f} p={tests['sr_aligned_minus_misaligned']['p_two_sided']:.3f} " + f"role={result['zero_role']}" + ) + print(f"wrote {out}") + + +if __name__ == "__main__": + main() diff --git a/tools/data/reports/agent_20260508_2108.md b/tools/data/reports/agent_20260508_2108.md new file mode 100644 index 0000000000000000000000000000000000000000..d3b8fa5889b9587b0e01270608220848eb4d5ed7 --- /dev/null +++ b/tools/data/reports/agent_20260508_2108.md @@ -0,0 +1,103 @@ +# Agent Report - Prime Mobius Zero-Mediator Gate +**Date**: 2026-05-08 21:08 +**Piano**: 93 +**Tension explored**: DUALITA_DIPOLARE_VS_ILLUSORIA (0.9) +**verdict**: CONSTRAINT +observables_registry: 1.0.0-2026-05-06 +observables_used: [low_low_rate, high_high_rate, SR, det_M_direct_control] +**observable_contract**: claim=lo zero della carica Mobius intervallare e' testato come terzo incluso del gate aligned/misaligned; observable=rate low_low, rate high_high, SR mean per classi aligned/misaligned/zero; operator=classificazione di S_n*S_{n+1}: aligned<0, misaligned>0, zero=0; generator=prime gaps up to p<=1e6 with Mobius sieve; denominator=main N={5000,10000,20000} offset=0 plus seedcheck offsets {3000,7000,11000}; not_tested=gap_ratio Sturmian, high-core phi survival, universal GUE/Poisson classification. + +## Respiro fuori-tempo +- **Combo**: A2 confine det=-1 + A9 terzo incluso + A11 combo + QxG continuo/discreto vuoto + DUALITA_DIPOLARE_VS_ILLUSORIA + piano primi x Mobius. Il repair non cerca un lettore nuovo: riporta nel denominatore il punto escluso dal source cycle, `S=0`. +- **Dipolo / punto-zero**: carica Mobius alternata / carica Mobius concorde; punto-zero = transizione con almeno un intervallo a carica nulla (`S_n*S_{n+1}=0`). +- **Piano superiore**: boundary operator su grafo aritmetico. Il gap e' bordo tra primi; la carica Mobius del vuoto tra primi decide se il bordo e' solo rumore di lunghezza o classe informativa. +- **Operatori laterali scelti**: boundary operator, random walk, entropia. Boundary operator definisce il bordo prime-free; random walk fornisce il null di permutazione della carica; entropia entra come dispersione del vuoto senza primi. +- **Contaminazione cognitiva**: + - **CE-0117**: usato per non promuovere il source cycle e far passare il risultato da potenziale a vincolo misurato. + - **CE-0038**: usato per riportare la forma nel Nulla-Tutto al vuoto aritmetico, qui lo zero `S=0`. + - **CE-0001 / KSAR**: usato come kernel reiterativo del ciclo 2102, con riparazione regressiva sul denominatore. + - **PVI attack**: il segnale puo' essere effetto di lunghezza del gap; per questo il null permuta l'intera sequenza delle cariche preservando multiset e frequenza degli zeri. +- **Proto-ipotesi**: se `S=0` e' terzo incluso operativo, non cade come rumore sotto il null che preserva la frequenza degli zeri. Deve produrre una classe distinguibile su low_low/high_high/SR. Se resta dentro il null, il source cycle sopravvive solo come gate binario non-zero. +- **Proiezione**: confronto aligned, misaligned e zero su `low_low`, `high_high` e `SR`; null = 400 permutazioni della sequenza `S_n`, gap invariati, multiset delle cariche invariata. + +## Claim Under Test +> Nel perimetro primi x Mobius fino a `p<=1e6`, le transizioni con `S=0` non vanno escluse: formano una terza classe del gate intervallare e vanno confrontate contro aligned/misaligned con null che preserva la frequenza degli zeri. + +## Question +Lo zero della carica Mobius intervallare e' rumore, boundary o mediatore del segnale low-low/high-high/SR? + +## Experiment Design +- Script: `tools/exp_prime_mobius_zero_mediator_gate.py`. +- Dati: primi fino a `1_000_000`; Mobius sieve sullo stesso perimetro. +- Carica intervallare: `S_n = sum(mu(k))` per `p_n < k < p_{n+1}`. +- Classi: + - `aligned`: `S_n*S_{n+1}<0`. + - `misaligned`: `S_n*S_{n+1}>0`. + - `zero`: `S_n*S_{n+1}=0`. +- Osservabili: + - `low_low_rate`: count di due gap consecutivi `<=6` sul denominatore della classe. + - `high_high_rate`: count di due gap consecutivi `>=q75` sul denominatore della classe. + - `SR`: mean min/max ratio dei gap consecutivi. +- Null test: 400 permutazioni della sequenza `S_n`; il null preserva la multiset completa delle cariche e quindi la frequenza degli zeri. +- Controllo det(M) diretto: `M=[[1,1],[1,0]]` ha `det(M)=-1` costante su ogni transizione; il controllo non partiziona il denominatore e restituisce solo le baseline globali low/high/SR. +- Soglia ex ante: `|z|>=2` e `p_two_sided<=0.05`. +- Contratto osservabile-operatore: `gap_ratio` Sturmian non testato; il source cycle 2102 non viene promosso; il claim su det diretto viene sostituito da controllo esplicito, non da conclusione non misurata. + +## Results +| condition | a/m/z denom | zero charges | low a | low m | low z | low z0 vs nonzero z/p | high a | high m | high z | high z0 vs nonzero z/p | SR a | SR m | SR z | SR z0 vs nonzero z/p | +|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:| +| N=5000 off=0 | 1200/1572/2227 | 1258/5000 | 221/1200 | 220/1572 | 707/2227 | 11.77 / 0.002 | 115/1200 | 298/1572 | 101/2227 | -10.80 / 0.002 | 0.51559 | 0.52611 | 0.43203 | -11.15 / 0.002 | +| N=10000 off=0 | 2541/3102/4356 | 2457/10000 | 403/2541 | 377/3102 | 1190/4356 | 14.88 / 0.002 | 153/2541 | 363/3102 | 114/4356 | -12.31 / 0.002 | 0.50841 | 0.51502 | 0.42221 | -16.03 / 0.002 | +| N=20000 off=0 | 5171/6331/8497 | 4782/20000 | 694/5171 | 651/6331 | 2093/8497 | 22.31 / 0.002 | 422/5171 | 878/6331 | 281/8497 | -18.75 / 0.002 | 0.50324 | 0.51151 | 0.41571 | -23.13 / 0.002 | +| N=5000 off=3000 | 1313/1525/2161 | 1219/5000 | 184/1313 | 162/1525 | 522/2161 | 9.84 / 0.002 | 86/1313 | 187/1525 | 71/2161 | -8.13 / 0.002 | 0.50993 | 0.50560 | 0.42213 | -10.87 / 0.002 | +| N=10000 off=7000 | 2675/3178/4146 | 2318/10000 | 315/2675 | 298/3178 | 946/4146 | 16.40 / 0.002 | 182/2675 | 351/3178 | 98/4146 | -13.27 / 0.002 | 0.50225 | 0.50729 | 0.40695 | -17.18 / 0.002 | +| N=20000 off=11000 | 5407/6413/8179 | 4586/20000 | 553/5407 | 567/6413 | 1740/8179 | 20.63 / 0.002 | 295/5407 | 667/6413 | 178/8179 | -16.22 / 0.002 | 0.49723 | 0.50997 | 0.41131 | -22.87 / 0.002 | + +### Pairwise aligned/misaligned checks +| condition | low a-m diff z/p | high a-m diff z/p | SR a-m diff z/p | +|---|---:|---:|---:| +| N=5000 off=0 | +0.04422 2.47 / 0.015 | -0.09373 -7.96 / 0.002 | -0.01053 -1.12 / 0.277 | +| N=10000 off=0 | +0.03706 3.44 / 0.002 | -0.05681 -8.90 / 0.002 | -0.00661 -0.90 / 0.357 | +| N=20000 off=0 | +0.03138 4.56 / 0.002 | -0.05707 -10.48 / 0.002 | -0.00827 -1.78 / 0.097 | +| N=5000 off=3000 | +0.03391 2.37 / 0.022 | -0.05712 -5.66 / 0.002 | +0.00433 0.48 / 0.671 | +| N=10000 off=7000 | +0.02399 2.68 / 0.010 | -0.04241 -6.58 / 0.002 | -0.00504 -0.71 / 0.501 | +| N=20000 off=11000 | +0.01386 1.97 / 0.040 | -0.04945 -10.96 / 0.002 | -0.01274 -2.50 / 0.015 | + +### det(M) direct control +`det(M)=-1` e' costante. Il controllo ha una sola classe su ogni condizione, quindi non separa aligned/misaligned/zero. Baseline globali: low_low `1148/4999`, `1970/9999`, `3438/19999`, `868/4999`, `1559/9999`, `2860/19999`; high_high `514/4999`, `630/9999`, `1581/19999`, `344/4999`, `631/9999`, `1140/19999`; SR globale `0.48167`, `0.47291`, `0.46867`, `0.47066`, `0.46434`, `0.46618`. + +## Key Findings +1. **Verificato: lo zero non e' rumore sotto il null usato.** La classe zero supera il null in 6/6 condizioni su `low_low_zero_minus_nonzero`, `high_high_zero_minus_nonzero` e `sr_zero_minus_nonzero`, sempre con `p=0.002` e `|z|` da `8.13` a `23.13`. + +2. **Verificato: lo zero e' una terza classe, non un mediatore tra aligned e misaligned.** Su low_low lo zero e' sopra entrambe le classi non-zero (`0.21274..0.31747` contro aligned `0.10227..0.18417` e misaligned `0.08841..0.13995`). Su high_high lo zero e' sotto entrambe (`0.02176..0.04535` contro aligned `0.05456..0.09583` e misaligned `0.10401..0.18957`). Su SR lo zero e' sotto entrambe (`0.40695..0.43203` contro non-zero circa `0.49723..0.52611`). Il punto-zero non sta tra i poli: genera una classe propria. + +3. **Verificato: il contrasto aligned/misaligned sopravvive soprattutto su high_high.** `high_high_aligned_minus_misaligned` passa 6/6 con z da `-5.66` a `-10.96`. `low_low_aligned_minus_misaligned` passa 5/6 se la soglia richiede anche `|z|>=2`; l'ultima condizione ha `z=1.97`, `p=0.040`, quindi resta borderline e non autorizza hard wording. SR passa 1/6 e resta osservabile secondario. + +4. **Verificato: il controllo det(M) diretto risolve il flag L3 del source cycle.** `det(M)` costante non produce partizione del denominatore; il report non conclude che la dualita "non si legge" da det diretto come fatto empirico generale. Qui dichiara solo che, in questo controllo, det(M) diretto non e' un discriminatore di classe. + +## Verdict +**CONSTRAINT on DUALITA_DIPOLARE_VS_ILLUSORIA / Prime Mobius interval-charge gate**: nel perimetro primi x Mobius fino a `p<=1e6`, `S=0` deve restare nel denominatore come terza classe. Lo zero non e' rumore sotto il null di permutazione che preserva frequenza degli zeri: arricchisce low_low, sopprime high_high e abbassa SR in 6/6 condizioni. Il source cycle sopravvive come vincolo parziale: il gate non-zero aligned/misaligned resta solido per high_high, resta parziale per low_low, e non porta SR globalmente. Il nuovo portatore e' triadico: aligned / misaligned / zero. + +## Bicono della scoperta +- **Due radici**: carica non-zero alternata/concorde . carica zero dell'intervallo prime-free. +- **Singolare**: il vuoto tra primi prima della scelta binaria; `S=0` non e' assenza di segnale ma classe del bordo. +- **Invariante di passaggio**: il null conserva gap, multiset delle cariche e frequenza degli zeri; cio' che sopravvive e' l'accoppiamento ordine-carica, non la sola presenza dello zero. +- **Campo di possibilita**: qui diventa possibile testare un gate triadico del boundary aritmetico. Qui diventa non-possibile escludere `S=0` dal denominatore quando si parla di terzo incluso nel perimetro Mobius-primi. + +## Consecutio +Il prossimo passo deve separare terza classe autentica da effetto scala dell'intervallo: ripetere il gate con controllo che preserva anche la lunghezza del gap o stratifica per bucket di gap length. Se lo zero resta significativo dentro ogni bucket, il boundary e' aritmetico; se cade, il segnale e' dipendenza da lunghezza. + +## Auto-audit: source flags e 5 lenti +- **Source L3 resolved**: il report non usa un elemento `not_tested` come conclusione. Il controllo det(M) diretto e' misurato e dichiarato non partizionante nel perimetro. +- **Source denominator repair resolved**: `S=0` e' incluso come classe esplicita, con count grezzi e denominatore. +- **Aperto**: non e' ancora separata la dipendenza dalla lunghezza del gap; serve controllo stratificato. +- **L1 hard constraint vs bias**: nessun "sempre/mai"; perimetro dichiarato `p<=1e6`, sei condizioni, 400 permutazioni. +- **L2 quantita vs ratio**: count grezzi e denominatori riportati; SR separato dai rate. +- **L3 no silent patching**: claim corretto prima del test; il source cycle non viene promosso. +- **L4 edge cases**: `low_low` non-zero e' borderline in una condizione (`z=1.97`), quindi resta parziale. +- **L5 re-discovery vs discovery**: verdict `CONSTRAINT`, non `NEW`; il pattern resta da confrontare con dipendenze note tra Mobius, lunghezza intervallare e gap primes. + +## Files +- Script: `tools/exp_prime_mobius_zero_mediator_gate.py` +- Data: `tools/data/prime_mobius_zero_mediator_gate_20260508_2108.json` +- Report: `tools/data/reports/agent_20260508_2108.md` diff --git a/tools/exp_prime_mobius_zero_mediator_gate.py b/tools/exp_prime_mobius_zero_mediator_gate.py new file mode 100644 index 0000000000000000000000000000000000000000..95ecd6e07c1863f3ffd3a3a5297a8628a00fd8be --- /dev/null +++ b/tools/exp_prime_mobius_zero_mediator_gate.py @@ -0,0 +1,314 @@ +#!/usr/bin/env python3 +"""Prime x Mobius zero-mediator gate. + +Repairs the 20260508_2102 interval-charge gate by keeping transitions with +S=0 in the denominator as an explicit third class. +""" +from __future__ import annotations + +import argparse +import json +from pathlib import Path + +import numpy as np + +from exp_prime_mobius_interval_charge_gate import ( + interval_charges, + mobius_sieve, + sieve_primes, +) + + +METRIC_KEYS = [ + "low_low_aligned_rate", + "low_low_misaligned_rate", + "low_low_zero_rate", + "high_high_aligned_rate", + "high_high_misaligned_rate", + "high_high_zero_rate", + "sr_aligned_mean", + "sr_misaligned_mean", + "sr_zero_mean", + "low_low_aligned_minus_misaligned", + "low_low_zero_minus_nonzero", + "high_high_aligned_minus_misaligned", + "high_high_zero_minus_nonzero", + "sr_aligned_minus_misaligned", + "sr_zero_minus_nonzero", +] + + +def _rate(mask: np.ndarray, event: np.ndarray) -> tuple[int, int, float]: + denom = int(np.sum(mask)) + hits = int(np.sum(mask & event)) + rate = float(hits / denom) if denom else float("nan") + return hits, denom, rate + + +def _mean(mask: np.ndarray, values: np.ndarray) -> tuple[int, float]: + denom = int(np.sum(mask)) + mean = float(np.mean(values[mask])) if denom else float("nan") + return denom, mean + + +def transition_metrics_three_class(gaps: np.ndarray, charges: np.ndarray) -> dict[str, float | int]: + left = charges[:-1] + right = charges[1:] + product = left * right + aligned = product < 0 + misaligned = product > 0 + zero = product == 0 + nonzero = ~zero + + g0 = gaps[:-1].astype(float) + g1 = gaps[1:].astype(float) + ratio = np.minimum(g0, g1) / np.maximum(g0, g1) + low_low = (g0 <= 6) & (g1 <= 6) + q75 = float(np.quantile(gaps, 0.75)) + high_high = (g0 >= q75) & (g1 >= q75) + + metrics: dict[str, float | int] = { + "q75_gap": q75, + "aligned_count": int(np.sum(aligned)), + "misaligned_count": int(np.sum(misaligned)), + "zero_count": int(np.sum(zero)), + "nonzero_count": int(np.sum(nonzero)), + } + + for name, event in (("low_low", low_low), ("high_high", high_high)): + for cls_name, mask in ( + ("aligned", aligned), + ("misaligned", misaligned), + ("zero", zero), + ("nonzero", nonzero), + ): + hits, denom, rate = _rate(mask, event) + metrics[f"{name}_{cls_name}_hits"] = hits + metrics[f"{name}_{cls_name}_denom"] = denom + metrics[f"{name}_{cls_name}_rate"] = rate + + for cls_name, mask in ( + ("aligned", aligned), + ("misaligned", misaligned), + ("zero", zero), + ("nonzero", nonzero), + ): + denom, mean = _mean(mask, ratio) + metrics[f"sr_{cls_name}_denom"] = denom + metrics[f"sr_{cls_name}_mean"] = mean + + metrics["low_low_aligned_minus_misaligned"] = ( + float(metrics["low_low_aligned_rate"]) - float(metrics["low_low_misaligned_rate"]) + ) + metrics["high_high_aligned_minus_misaligned"] = ( + float(metrics["high_high_aligned_rate"]) - float(metrics["high_high_misaligned_rate"]) + ) + metrics["sr_aligned_minus_misaligned"] = ( + float(metrics["sr_aligned_mean"]) - float(metrics["sr_misaligned_mean"]) + ) + metrics["low_low_zero_minus_nonzero"] = ( + float(metrics["low_low_zero_rate"]) - float(metrics["low_low_nonzero_rate"]) + ) + metrics["high_high_zero_minus_nonzero"] = ( + float(metrics["high_high_zero_rate"]) - float(metrics["high_high_nonzero_rate"]) + ) + metrics["sr_zero_minus_nonzero"] = ( + float(metrics["sr_zero_mean"]) - float(metrics["sr_nonzero_mean"]) + ) + return metrics + + +def permutation_test( + gaps: np.ndarray, + charges: np.ndarray, + observed: dict[str, float | int], + rng: np.random.Generator, + permutations: int, +) -> dict[str, dict[str, float]]: + nulls = {key: [] for key in METRIC_KEYS} + for _ in range(permutations): + shuffled = np.array(charges, copy=True) + rng.shuffle(shuffled) + metrics = transition_metrics_three_class(gaps, shuffled) + for key in METRIC_KEYS: + nulls[key].append(float(metrics[key])) + + out: dict[str, dict[str, float]] = {} + for key, values in nulls.items(): + arr = np.array(values, dtype=float) + obs = float(observed[key]) + finite = np.isfinite(arr) + arr = arr[finite] + if arr.size == 0 or not np.isfinite(obs): + out[key] = {"observed": obs, "null_mean": float("nan"), "null_std": float("nan"), "z": float("nan"), "p_two_sided": float("nan")} + continue + std = float(np.std(arr, ddof=1)) + z = (obs - float(np.mean(arr))) / std if std > 0 else 0.0 + p = float((np.sum(np.abs(arr) >= abs(obs)) + 1) / (len(arr) + 1)) + out[key] = { + "observed": obs, + "null_mean": float(np.mean(arr)), + "null_std": std, + "z": float(z), + "p_two_sided": p, + } + return out + + +def det_m_direct_control(gaps: np.ndarray) -> dict[str, float | int | str]: + g0 = gaps[:-1].astype(float) + g1 = gaps[1:].astype(float) + ratio = np.minimum(g0, g1) / np.maximum(g0, g1) + low_low = (g0 <= 6) & (g1 <= 6) + q75 = float(np.quantile(gaps, 0.75)) + high_high = (g0 >= q75) & (g1 >= q75) + denom = int(g0.size) + return { + "det_M": -1, + "class_count": 1, + "reason": "M=[[1,1],[1,0]] has constant determinant -1 on every transition, so direct det(M) does not partition the denominator.", + "denominator": denom, + "low_low_hits": int(np.sum(low_low)), + "low_low_rate": float(np.sum(low_low) / denom), + "high_high_hits": int(np.sum(high_high)), + "high_high_rate": float(np.sum(high_high) / denom), + "sr_mean": float(np.mean(ratio)), + } + + +def classify_zero_role(observed: dict[str, float | int], tests: dict[str, dict[str, float]]) -> str: + low_z = tests["low_low_zero_minus_nonzero"]["z"] + high_z = tests["high_high_zero_minus_nonzero"]["z"] + sr_z = tests["sr_zero_minus_nonzero"]["z"] + passes = [ + abs(low_z) >= 2 and tests["low_low_zero_minus_nonzero"]["p_two_sided"] <= 0.05, + abs(high_z) >= 2 and tests["high_high_zero_minus_nonzero"]["p_two_sided"] <= 0.05, + abs(sr_z) >= 2 and tests["sr_zero_minus_nonzero"]["p_two_sided"] <= 0.05, + ] + low = float(observed["low_low_zero_rate"]) + high = float(observed["high_high_zero_rate"]) + sr = float(observed["sr_zero_mean"]) + low_a = float(observed["low_low_aligned_rate"]) + low_m = float(observed["low_low_misaligned_rate"]) + high_a = float(observed["high_high_aligned_rate"]) + high_m = float(observed["high_high_misaligned_rate"]) + sr_a = float(observed["sr_aligned_mean"]) + sr_m = float(observed["sr_misaligned_mean"]) + + between_low = min(low_a, low_m) <= low <= max(low_a, low_m) + between_high = min(high_a, high_m) <= high <= max(high_a, high_m) + between_sr = min(sr_a, sr_m) <= sr <= max(sr_a, sr_m) + + if any(passes) and (between_low or between_high or between_sr): + return "boundary" + if any(passes): + return "third_class" + return "noise_under_this_null" + + +def run_condition( + primes: np.ndarray, + mu: np.ndarray, + n_primes: int, + offset: int, + rng: np.random.Generator, + permutations: int, +) -> dict[str, object]: + segment = primes[offset : offset + n_primes + 1] + gaps = np.diff(segment) + charges = interval_charges(segment, mu) + observed = transition_metrics_three_class(gaps, charges) + tests = permutation_test(gaps, charges, observed, rng, permutations) + return { + "n_primes": n_primes, + "offset": offset, + "prime_start": int(segment[0]), + "prime_stop": int(segment[-1]), + "zero_charge_count": int(np.sum(charges == 0)), + "charge_count": int(charges.size), + "observed": observed, + "permutation_tests": tests, + "zero_role": classify_zero_role(observed, tests), + "det_m_direct_control": det_m_direct_control(gaps), + } + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--limit", type=int, default=1_000_000) + parser.add_argument("--permutations", type=int, default=400) + parser.add_argument("--seed", type=int, default=2108) + parser.add_argument("--out", default="tools/data/prime_mobius_zero_mediator_gate_20260508_2108.json") + args = parser.parse_args() + + primes = sieve_primes(args.limit) + mu = mobius_sieve(args.limit) + rng = np.random.default_rng(args.seed) + + conditions = [ + {"n_primes": 5_000, "offset": 0}, + {"n_primes": 10_000, "offset": 0}, + {"n_primes": 20_000, "offset": 0}, + {"n_primes": 5_000, "offset": 3_000}, + {"n_primes": 10_000, "offset": 7_000}, + {"n_primes": 20_000, "offset": 11_000}, + ] + max_needed = max(c["offset"] + c["n_primes"] + 1 for c in conditions) + if len(primes) <= max_needed: + raise SystemExit(f"limit={args.limit} yields only {len(primes)} primes, need {max_needed}") + + results = [ + run_condition(primes, mu, c["n_primes"], c["offset"], rng, args.permutations) + for c in conditions + ] + summary = [] + for result in results: + tests = result["permutation_tests"] + summary.append( + { + "n_primes": result["n_primes"], + "offset": result["offset"], + "low_low_aligned_minus_misaligned_pass": abs(tests["low_low_aligned_minus_misaligned"]["z"]) >= 2.0 + and tests["low_low_aligned_minus_misaligned"]["p_two_sided"] <= 0.05, + "high_high_aligned_minus_misaligned_pass": abs(tests["high_high_aligned_minus_misaligned"]["z"]) >= 2.0 + and tests["high_high_aligned_minus_misaligned"]["p_two_sided"] <= 0.05, + "sr_aligned_minus_misaligned_pass": abs(tests["sr_aligned_minus_misaligned"]["z"]) >= 2.0 + and tests["sr_aligned_minus_misaligned"]["p_two_sided"] <= 0.05, + "zero_role": result["zero_role"], + } + ) + + payload = { + "experiment": "prime_mobius_zero_mediator_gate", + "question": "Does S=0 behave as noise, boundary, or mediator in the Mobius interval-charge gate?", + "threshold_ex_ante": "|z|>=2 and permutation p<=0.05 across main and offset conditions", + "null": "Permutation of the interval-charge sequence preserves the full charge multiset and therefore preserves zero frequency.", + "limit": args.limit, + "permutations": args.permutations, + "seed": args.seed, + "conditions": results, + "significance_summary": summary, + } + + out = Path(args.out) + out.parent.mkdir(parents=True, exist_ok=True) + out.write_text(json.dumps(payload, indent=2), encoding="utf-8") + + for result in results: + obs = result["observed"] + tests = result["permutation_tests"] + print( + f"N={result['n_primes']} offset={result['offset']} " + f"a/m/z={obs['aligned_count']}/{obs['misaligned_count']}/{obs['zero_count']} " + f"low_am={obs['low_low_aligned_minus_misaligned']:.5f} z={tests['low_low_aligned_minus_misaligned']['z']:.2f} p={tests['low_low_aligned_minus_misaligned']['p_two_sided']:.3f} " + f"low_z0={obs['low_low_zero_minus_nonzero']:.5f} z={tests['low_low_zero_minus_nonzero']['z']:.2f} p={tests['low_low_zero_minus_nonzero']['p_two_sided']:.3f} " + f"high_am={obs['high_high_aligned_minus_misaligned']:.5f} z={tests['high_high_aligned_minus_misaligned']['z']:.2f} p={tests['high_high_aligned_minus_misaligned']['p_two_sided']:.3f} " + f"high_z0={obs['high_high_zero_minus_nonzero']:.5f} z={tests['high_high_zero_minus_nonzero']['z']:.2f} p={tests['high_high_zero_minus_nonzero']['p_two_sided']:.3f} " + f"sr_am={obs['sr_aligned_minus_misaligned']:.5f} z={tests['sr_aligned_minus_misaligned']['z']:.2f} p={tests['sr_aligned_minus_misaligned']['p_two_sided']:.3f} " + f"role={result['zero_role']}" + ) + print(f"wrote {out}") + + +if __name__ == "__main__": + main() diff --git a/tools/data/reports/agent_20260508_2108.md b/tools/data/reports/agent_20260508_2108.md new file mode 100644 index 0000000000000000000000000000000000000000..d3b8fa5889b9587b0e01270608220848eb4d5ed7 --- /dev/null +++ b/tools/data/reports/agent_20260508_2108.md @@ -0,0 +1,103 @@ +# Agent Report - Prime Mobius Zero-Mediator Gate +**Date**: 2026-05-08 21:08 +**Piano**: 93 +**Tension explored**: DUALITA_DIPOLARE_VS_ILLUSORIA (0.9) +**verdict**: CONSTRAINT +observables_registry: 1.0.0-2026-05-06 +observables_used: [low_low_rate, high_high_rate, SR, det_M_direct_control] +**observable_contract**: claim=lo zero della carica Mobius intervallare e' testato come terzo incluso del gate aligned/misaligned; observable=rate low_low, rate high_high, SR mean per classi aligned/misaligned/zero; operator=classificazione di S_n*S_{n+1}: aligned<0, misaligned>0, zero=0; generator=prime gaps up to p<=1e6 with Mobius sieve; denominator=main N={5000,10000,20000} offset=0 plus seedcheck offsets {3000,7000,11000}; not_tested=gap_ratio Sturmian, high-core phi survival, universal GUE/Poisson classification. + +## Respiro fuori-tempo +- **Combo**: A2 confine det=-1 + A9 terzo incluso + A11 combo + QxG continuo/discreto vuoto + DUALITA_DIPOLARE_VS_ILLUSORIA + piano primi x Mobius. Il repair non cerca un lettore nuovo: riporta nel denominatore il punto escluso dal source cycle, `S=0`. +- **Dipolo / punto-zero**: carica Mobius alternata / carica Mobius concorde; punto-zero = transizione con almeno un intervallo a carica nulla (`S_n*S_{n+1}=0`). +- **Piano superiore**: boundary operator su grafo aritmetico. Il gap e' bordo tra primi; la carica Mobius del vuoto tra primi decide se il bordo e' solo rumore di lunghezza o classe informativa. +- **Operatori laterali scelti**: boundary operator, random walk, entropia. Boundary operator definisce il bordo prime-free; random walk fornisce il null di permutazione della carica; entropia entra come dispersione del vuoto senza primi. +- **Contaminazione cognitiva**: + - **CE-0117**: usato per non promuovere il source cycle e far passare il risultato da potenziale a vincolo misurato. + - **CE-0038**: usato per riportare la forma nel Nulla-Tutto al vuoto aritmetico, qui lo zero `S=0`. + - **CE-0001 / KSAR**: usato come kernel reiterativo del ciclo 2102, con riparazione regressiva sul denominatore. + - **PVI attack**: il segnale puo' essere effetto di lunghezza del gap; per questo il null permuta l'intera sequenza delle cariche preservando multiset e frequenza degli zeri. +- **Proto-ipotesi**: se `S=0` e' terzo incluso operativo, non cade come rumore sotto il null che preserva la frequenza degli zeri. Deve produrre una classe distinguibile su low_low/high_high/SR. Se resta dentro il null, il source cycle sopravvive solo come gate binario non-zero. +- **Proiezione**: confronto aligned, misaligned e zero su `low_low`, `high_high` e `SR`; null = 400 permutazioni della sequenza `S_n`, gap invariati, multiset delle cariche invariata. + +## Claim Under Test +> Nel perimetro primi x Mobius fino a `p<=1e6`, le transizioni con `S=0` non vanno escluse: formano una terza classe del gate intervallare e vanno confrontate contro aligned/misaligned con null che preserva la frequenza degli zeri. + +## Question +Lo zero della carica Mobius intervallare e' rumore, boundary o mediatore del segnale low-low/high-high/SR? + +## Experiment Design +- Script: `tools/exp_prime_mobius_zero_mediator_gate.py`. +- Dati: primi fino a `1_000_000`; Mobius sieve sullo stesso perimetro. +- Carica intervallare: `S_n = sum(mu(k))` per `p_n < k < p_{n+1}`. +- Classi: + - `aligned`: `S_n*S_{n+1}<0`. + - `misaligned`: `S_n*S_{n+1}>0`. + - `zero`: `S_n*S_{n+1}=0`. +- Osservabili: + - `low_low_rate`: count di due gap consecutivi `<=6` sul denominatore della classe. + - `high_high_rate`: count di due gap consecutivi `>=q75` sul denominatore della classe. + - `SR`: mean min/max ratio dei gap consecutivi. +- Null test: 400 permutazioni della sequenza `S_n`; il null preserva la multiset completa delle cariche e quindi la frequenza degli zeri. +- Controllo det(M) diretto: `M=[[1,1],[1,0]]` ha `det(M)=-1` costante su ogni transizione; il controllo non partiziona il denominatore e restituisce solo le baseline globali low/high/SR. +- Soglia ex ante: `|z|>=2` e `p_two_sided<=0.05`. +- Contratto osservabile-operatore: `gap_ratio` Sturmian non testato; il source cycle 2102 non viene promosso; il claim su det diretto viene sostituito da controllo esplicito, non da conclusione non misurata. + +## Results +| condition | a/m/z denom | zero charges | low a | low m | low z | low z0 vs nonzero z/p | high a | high m | high z | high z0 vs nonzero z/p | SR a | SR m | SR z | SR z0 vs nonzero z/p | +|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:| +| N=5000 off=0 | 1200/1572/2227 | 1258/5000 | 221/1200 | 220/1572 | 707/2227 | 11.77 / 0.002 | 115/1200 | 298/1572 | 101/2227 | -10.80 / 0.002 | 0.51559 | 0.52611 | 0.43203 | -11.15 / 0.002 | +| N=10000 off=0 | 2541/3102/4356 | 2457/10000 | 403/2541 | 377/3102 | 1190/4356 | 14.88 / 0.002 | 153/2541 | 363/3102 | 114/4356 | -12.31 / 0.002 | 0.50841 | 0.51502 | 0.42221 | -16.03 / 0.002 | +| N=20000 off=0 | 5171/6331/8497 | 4782/20000 | 694/5171 | 651/6331 | 2093/8497 | 22.31 / 0.002 | 422/5171 | 878/6331 | 281/8497 | -18.75 / 0.002 | 0.50324 | 0.51151 | 0.41571 | -23.13 / 0.002 | +| N=5000 off=3000 | 1313/1525/2161 | 1219/5000 | 184/1313 | 162/1525 | 522/2161 | 9.84 / 0.002 | 86/1313 | 187/1525 | 71/2161 | -8.13 / 0.002 | 0.50993 | 0.50560 | 0.42213 | -10.87 / 0.002 | +| N=10000 off=7000 | 2675/3178/4146 | 2318/10000 | 315/2675 | 298/3178 | 946/4146 | 16.40 / 0.002 | 182/2675 | 351/3178 | 98/4146 | -13.27 / 0.002 | 0.50225 | 0.50729 | 0.40695 | -17.18 / 0.002 | +| N=20000 off=11000 | 5407/6413/8179 | 4586/20000 | 553/5407 | 567/6413 | 1740/8179 | 20.63 / 0.002 | 295/5407 | 667/6413 | 178/8179 | -16.22 / 0.002 | 0.49723 | 0.50997 | 0.41131 | -22.87 / 0.002 | + +### Pairwise aligned/misaligned checks +| condition | low a-m diff z/p | high a-m diff z/p | SR a-m diff z/p | +|---|---:|---:|---:| +| N=5000 off=0 | +0.04422 2.47 / 0.015 | -0.09373 -7.96 / 0.002 | -0.01053 -1.12 / 0.277 | +| N=10000 off=0 | +0.03706 3.44 / 0.002 | -0.05681 -8.90 / 0.002 | -0.00661 -0.90 / 0.357 | +| N=20000 off=0 | +0.03138 4.56 / 0.002 | -0.05707 -10.48 / 0.002 | -0.00827 -1.78 / 0.097 | +| N=5000 off=3000 | +0.03391 2.37 / 0.022 | -0.05712 -5.66 / 0.002 | +0.00433 0.48 / 0.671 | +| N=10000 off=7000 | +0.02399 2.68 / 0.010 | -0.04241 -6.58 / 0.002 | -0.00504 -0.71 / 0.501 | +| N=20000 off=11000 | +0.01386 1.97 / 0.040 | -0.04945 -10.96 / 0.002 | -0.01274 -2.50 / 0.015 | + +### det(M) direct control +`det(M)=-1` e' costante. Il controllo ha una sola classe su ogni condizione, quindi non separa aligned/misaligned/zero. Baseline globali: low_low `1148/4999`, `1970/9999`, `3438/19999`, `868/4999`, `1559/9999`, `2860/19999`; high_high `514/4999`, `630/9999`, `1581/19999`, `344/4999`, `631/9999`, `1140/19999`; SR globale `0.48167`, `0.47291`, `0.46867`, `0.47066`, `0.46434`, `0.46618`. + +## Key Findings +1. **Verificato: lo zero non e' rumore sotto il null usato.** La classe zero supera il null in 6/6 condizioni su `low_low_zero_minus_nonzero`, `high_high_zero_minus_nonzero` e `sr_zero_minus_nonzero`, sempre con `p=0.002` e `|z|` da `8.13` a `23.13`. + +2. **Verificato: lo zero e' una terza classe, non un mediatore tra aligned e misaligned.** Su low_low lo zero e' sopra entrambe le classi non-zero (`0.21274..0.31747` contro aligned `0.10227..0.18417` e misaligned `0.08841..0.13995`). Su high_high lo zero e' sotto entrambe (`0.02176..0.04535` contro aligned `0.05456..0.09583` e misaligned `0.10401..0.18957`). Su SR lo zero e' sotto entrambe (`0.40695..0.43203` contro non-zero circa `0.49723..0.52611`). Il punto-zero non sta tra i poli: genera una classe propria. + +3. **Verificato: il contrasto aligned/misaligned sopravvive soprattutto su high_high.** `high_high_aligned_minus_misaligned` passa 6/6 con z da `-5.66` a `-10.96`. `low_low_aligned_minus_misaligned` passa 5/6 se la soglia richiede anche `|z|>=2`; l'ultima condizione ha `z=1.97`, `p=0.040`, quindi resta borderline e non autorizza hard wording. SR passa 1/6 e resta osservabile secondario. + +4. **Verificato: il controllo det(M) diretto risolve il flag L3 del source cycle.** `det(M)` costante non produce partizione del denominatore; il report non conclude che la dualita "non si legge" da det diretto come fatto empirico generale. Qui dichiara solo che, in questo controllo, det(M) diretto non e' un discriminatore di classe. + +## Verdict +**CONSTRAINT on DUALITA_DIPOLARE_VS_ILLUSORIA / Prime Mobius interval-charge gate**: nel perimetro primi x Mobius fino a `p<=1e6`, `S=0` deve restare nel denominatore come terza classe. Lo zero non e' rumore sotto il null di permutazione che preserva frequenza degli zeri: arricchisce low_low, sopprime high_high e abbassa SR in 6/6 condizioni. Il source cycle sopravvive come vincolo parziale: il gate non-zero aligned/misaligned resta solido per high_high, resta parziale per low_low, e non porta SR globalmente. Il nuovo portatore e' triadico: aligned / misaligned / zero. + +## Bicono della scoperta +- **Due radici**: carica non-zero alternata/concorde . carica zero dell'intervallo prime-free. +- **Singolare**: il vuoto tra primi prima della scelta binaria; `S=0` non e' assenza di segnale ma classe del bordo. +- **Invariante di passaggio**: il null conserva gap, multiset delle cariche e frequenza degli zeri; cio' che sopravvive e' l'accoppiamento ordine-carica, non la sola presenza dello zero. +- **Campo di possibilita**: qui diventa possibile testare un gate triadico del boundary aritmetico. Qui diventa non-possibile escludere `S=0` dal denominatore quando si parla di terzo incluso nel perimetro Mobius-primi. + +## Consecutio +Il prossimo passo deve separare terza classe autentica da effetto scala dell'intervallo: ripetere il gate con controllo che preserva anche la lunghezza del gap o stratifica per bucket di gap length. Se lo zero resta significativo dentro ogni bucket, il boundary e' aritmetico; se cade, il segnale e' dipendenza da lunghezza. + +## Auto-audit: source flags e 5 lenti +- **Source L3 resolved**: il report non usa un elemento `not_tested` come conclusione. Il controllo det(M) diretto e' misurato e dichiarato non partizionante nel perimetro. +- **Source denominator repair resolved**: `S=0` e' incluso come classe esplicita, con count grezzi e denominatore. +- **Aperto**: non e' ancora separata la dipendenza dalla lunghezza del gap; serve controllo stratificato. +- **L1 hard constraint vs bias**: nessun "sempre/mai"; perimetro dichiarato `p<=1e6`, sei condizioni, 400 permutazioni. +- **L2 quantita vs ratio**: count grezzi e denominatori riportati; SR separato dai rate. +- **L3 no silent patching**: claim corretto prima del test; il source cycle non viene promosso. +- **L4 edge cases**: `low_low` non-zero e' borderline in una condizione (`z=1.97`), quindi resta parziale. +- **L5 re-discovery vs discovery**: verdict `CONSTRAINT`, non `NEW`; il pattern resta da confrontare con dipendenze note tra Mobius, lunghezza intervallare e gap primes. + +## Files +- Script: `tools/exp_prime_mobius_zero_mediator_gate.py` +- Data: `tools/data/prime_mobius_zero_mediator_gate_20260508_2108.json` +- Report: `tools/data/reports/agent_20260508_2108.md` diff --git a/tools/exp_prime_mobius_zero_mediator_gate.py b/tools/exp_prime_mobius_zero_mediator_gate.py new file mode 100644 index 0000000000000000000000000000000000000000..95ecd6e07c1863f3ffd3a3a5297a8628a00fd8be --- /dev/null +++ b/tools/exp_prime_mobius_zero_mediator_gate.py @@ -0,0 +1,314 @@ +#!/usr/bin/env python3 +"""Prime x Mobius zero-mediator gate. + +Repairs the 20260508_2102 interval-charge gate by keeping transitions with +S=0 in the denominator as an explicit third class. +""" +from __future__ import annotations + +import argparse +import json +from pathlib import Path + +import numpy as np + +from exp_prime_mobius_interval_charge_gate import ( + interval_charges, + mobius_sieve, + sieve_primes, +) + + +METRIC_KEYS = [ + "low_low_aligned_rate", + "low_low_misaligned_rate", + "low_low_zero_rate", + "high_high_aligned_rate", + "high_high_misaligned_rate", + "high_high_zero_rate", + "sr_aligned_mean", + "sr_misaligned_mean", + "sr_zero_mean", + "low_low_aligned_minus_misaligned", + "low_low_zero_minus_nonzero", + "high_high_aligned_minus_misaligned", + "high_high_zero_minus_nonzero", + "sr_aligned_minus_misaligned", + "sr_zero_minus_nonzero", +] + + +def _rate(mask: np.ndarray, event: np.ndarray) -> tuple[int, int, float]: + denom = int(np.sum(mask)) + hits = int(np.sum(mask & event)) + rate = float(hits / denom) if denom else float("nan") + return hits, denom, rate + + +def _mean(mask: np.ndarray, values: np.ndarray) -> tuple[int, float]: + denom = int(np.sum(mask)) + mean = float(np.mean(values[mask])) if denom else float("nan") + return denom, mean + + +def transition_metrics_three_class(gaps: np.ndarray, charges: np.ndarray) -> dict[str, float | int]: + left = charges[:-1] + right = charges[1:] + product = left * right + aligned = product < 0 + misaligned = product > 0 + zero = product == 0 + nonzero = ~zero + + g0 = gaps[:-1].astype(float) + g1 = gaps[1:].astype(float) + ratio = np.minimum(g0, g1) / np.maximum(g0, g1) + low_low = (g0 <= 6) & (g1 <= 6) + q75 = float(np.quantile(gaps, 0.75)) + high_high = (g0 >= q75) & (g1 >= q75) + + metrics: dict[str, float | int] = { + "q75_gap": q75, + "aligned_count": int(np.sum(aligned)), + "misaligned_count": int(np.sum(misaligned)), + "zero_count": int(np.sum(zero)), + "nonzero_count": int(np.sum(nonzero)), + } + + for name, event in (("low_low", low_low), ("high_high", high_high)): + for cls_name, mask in ( + ("aligned", aligned), + ("misaligned", misaligned), + ("zero", zero), + ("nonzero", nonzero), + ): + hits, denom, rate = _rate(mask, event) + metrics[f"{name}_{cls_name}_hits"] = hits + metrics[f"{name}_{cls_name}_denom"] = denom + metrics[f"{name}_{cls_name}_rate"] = rate + + for cls_name, mask in ( + ("aligned", aligned), + ("misaligned", misaligned), + ("zero", zero), + ("nonzero", nonzero), + ): + denom, mean = _mean(mask, ratio) + metrics[f"sr_{cls_name}_denom"] = denom + metrics[f"sr_{cls_name}_mean"] = mean + + metrics["low_low_aligned_minus_misaligned"] = ( + float(metrics["low_low_aligned_rate"]) - float(metrics["low_low_misaligned_rate"]) + ) + metrics["high_high_aligned_minus_misaligned"] = ( + float(metrics["high_high_aligned_rate"]) - float(metrics["high_high_misaligned_rate"]) + ) + metrics["sr_aligned_minus_misaligned"] = ( + float(metrics["sr_aligned_mean"]) - float(metrics["sr_misaligned_mean"]) + ) + metrics["low_low_zero_minus_nonzero"] = ( + float(metrics["low_low_zero_rate"]) - float(metrics["low_low_nonzero_rate"]) + ) + metrics["high_high_zero_minus_nonzero"] = ( + float(metrics["high_high_zero_rate"]) - float(metrics["high_high_nonzero_rate"]) + ) + metrics["sr_zero_minus_nonzero"] = ( + float(metrics["sr_zero_mean"]) - float(metrics["sr_nonzero_mean"]) + ) + return metrics + + +def permutation_test( + gaps: np.ndarray, + charges: np.ndarray, + observed: dict[str, float | int], + rng: np.random.Generator, + permutations: int, +) -> dict[str, dict[str, float]]: + nulls = {key: [] for key in METRIC_KEYS} + for _ in range(permutations): + shuffled = np.array(charges, copy=True) + rng.shuffle(shuffled) + metrics = transition_metrics_three_class(gaps, shuffled) + for key in METRIC_KEYS: + nulls[key].append(float(metrics[key])) + + out: dict[str, dict[str, float]] = {} + for key, values in nulls.items(): + arr = np.array(values, dtype=float) + obs = float(observed[key]) + finite = np.isfinite(arr) + arr = arr[finite] + if arr.size == 0 or not np.isfinite(obs): + out[key] = {"observed": obs, "null_mean": float("nan"), "null_std": float("nan"), "z": float("nan"), "p_two_sided": float("nan")} + continue + std = float(np.std(arr, ddof=1)) + z = (obs - float(np.mean(arr))) / std if std > 0 else 0.0 + p = float((np.sum(np.abs(arr) >= abs(obs)) + 1) / (len(arr) + 1)) + out[key] = { + "observed": obs, + "null_mean": float(np.mean(arr)), + "null_std": std, + "z": float(z), + "p_two_sided": p, + } + return out + + +def det_m_direct_control(gaps: np.ndarray) -> dict[str, float | int | str]: + g0 = gaps[:-1].astype(float) + g1 = gaps[1:].astype(float) + ratio = np.minimum(g0, g1) / np.maximum(g0, g1) + low_low = (g0 <= 6) & (g1 <= 6) + q75 = float(np.quantile(gaps, 0.75)) + high_high = (g0 >= q75) & (g1 >= q75) + denom = int(g0.size) + return { + "det_M": -1, + "class_count": 1, + "reason": "M=[[1,1],[1,0]] has constant determinant -1 on every transition, so direct det(M) does not partition the denominator.", + "denominator": denom, + "low_low_hits": int(np.sum(low_low)), + "low_low_rate": float(np.sum(low_low) / denom), + "high_high_hits": int(np.sum(high_high)), + "high_high_rate": float(np.sum(high_high) / denom), + "sr_mean": float(np.mean(ratio)), + } + + +def classify_zero_role(observed: dict[str, float | int], tests: dict[str, dict[str, float]]) -> str: + low_z = tests["low_low_zero_minus_nonzero"]["z"] + high_z = tests["high_high_zero_minus_nonzero"]["z"] + sr_z = tests["sr_zero_minus_nonzero"]["z"] + passes = [ + abs(low_z) >= 2 and tests["low_low_zero_minus_nonzero"]["p_two_sided"] <= 0.05, + abs(high_z) >= 2 and tests["high_high_zero_minus_nonzero"]["p_two_sided"] <= 0.05, + abs(sr_z) >= 2 and tests["sr_zero_minus_nonzero"]["p_two_sided"] <= 0.05, + ] + low = float(observed["low_low_zero_rate"]) + high = float(observed["high_high_zero_rate"]) + sr = float(observed["sr_zero_mean"]) + low_a = float(observed["low_low_aligned_rate"]) + low_m = float(observed["low_low_misaligned_rate"]) + high_a = float(observed["high_high_aligned_rate"]) + high_m = float(observed["high_high_misaligned_rate"]) + sr_a = float(observed["sr_aligned_mean"]) + sr_m = float(observed["sr_misaligned_mean"]) + + between_low = min(low_a, low_m) <= low <= max(low_a, low_m) + between_high = min(high_a, high_m) <= high <= max(high_a, high_m) + between_sr = min(sr_a, sr_m) <= sr <= max(sr_a, sr_m) + + if any(passes) and (between_low or between_high or between_sr): + return "boundary" + if any(passes): + return "third_class" + return "noise_under_this_null" + + +def run_condition( + primes: np.ndarray, + mu: np.ndarray, + n_primes: int, + offset: int, + rng: np.random.Generator, + permutations: int, +) -> dict[str, object]: + segment = primes[offset : offset + n_primes + 1] + gaps = np.diff(segment) + charges = interval_charges(segment, mu) + observed = transition_metrics_three_class(gaps, charges) + tests = permutation_test(gaps, charges, observed, rng, permutations) + return { + "n_primes": n_primes, + "offset": offset, + "prime_start": int(segment[0]), + "prime_stop": int(segment[-1]), + "zero_charge_count": int(np.sum(charges == 0)), + "charge_count": int(charges.size), + "observed": observed, + "permutation_tests": tests, + "zero_role": classify_zero_role(observed, tests), + "det_m_direct_control": det_m_direct_control(gaps), + } + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--limit", type=int, default=1_000_000) + parser.add_argument("--permutations", type=int, default=400) + parser.add_argument("--seed", type=int, default=2108) + parser.add_argument("--out", default="tools/data/prime_mobius_zero_mediator_gate_20260508_2108.json") + args = parser.parse_args() + + primes = sieve_primes(args.limit) + mu = mobius_sieve(args.limit) + rng = np.random.default_rng(args.seed) + + conditions = [ + {"n_primes": 5_000, "offset": 0}, + {"n_primes": 10_000, "offset": 0}, + {"n_primes": 20_000, "offset": 0}, + {"n_primes": 5_000, "offset": 3_000}, + {"n_primes": 10_000, "offset": 7_000}, + {"n_primes": 20_000, "offset": 11_000}, + ] + max_needed = max(c["offset"] + c["n_primes"] + 1 for c in conditions) + if len(primes) <= max_needed: + raise SystemExit(f"limit={args.limit} yields only {len(primes)} primes, need {max_needed}") + + results = [ + run_condition(primes, mu, c["n_primes"], c["offset"], rng, args.permutations) + for c in conditions + ] + summary = [] + for result in results: + tests = result["permutation_tests"] + summary.append( + { + "n_primes": result["n_primes"], + "offset": result["offset"], + "low_low_aligned_minus_misaligned_pass": abs(tests["low_low_aligned_minus_misaligned"]["z"]) >= 2.0 + and tests["low_low_aligned_minus_misaligned"]["p_two_sided"] <= 0.05, + "high_high_aligned_minus_misaligned_pass": abs(tests["high_high_aligned_minus_misaligned"]["z"]) >= 2.0 + and tests["high_high_aligned_minus_misaligned"]["p_two_sided"] <= 0.05, + "sr_aligned_minus_misaligned_pass": abs(tests["sr_aligned_minus_misaligned"]["z"]) >= 2.0 + and tests["sr_aligned_minus_misaligned"]["p_two_sided"] <= 0.05, + "zero_role": result["zero_role"], + } + ) + + payload = { + "experiment": "prime_mobius_zero_mediator_gate", + "question": "Does S=0 behave as noise, boundary, or mediator in the Mobius interval-charge gate?", + "threshold_ex_ante": "|z|>=2 and permutation p<=0.05 across main and offset conditions", + "null": "Permutation of the interval-charge sequence preserves the full charge multiset and therefore preserves zero frequency.", + "limit": args.limit, + "permutations": args.permutations, + "seed": args.seed, + "conditions": results, + "significance_summary": summary, + } + + out = Path(args.out) + out.parent.mkdir(parents=True, exist_ok=True) + out.write_text(json.dumps(payload, indent=2), encoding="utf-8") + + for result in results: + obs = result["observed"] + tests = result["permutation_tests"] + print( + f"N={result['n_primes']} offset={result['offset']} " + f"a/m/z={obs['aligned_count']}/{obs['misaligned_count']}/{obs['zero_count']} " + f"low_am={obs['low_low_aligned_minus_misaligned']:.5f} z={tests['low_low_aligned_minus_misaligned']['z']:.2f} p={tests['low_low_aligned_minus_misaligned']['p_two_sided']:.3f} " + f"low_z0={obs['low_low_zero_minus_nonzero']:.5f} z={tests['low_low_zero_minus_nonzero']['z']:.2f} p={tests['low_low_zero_minus_nonzero']['p_two_sided']:.3f} " + f"high_am={obs['high_high_aligned_minus_misaligned']:.5f} z={tests['high_high_aligned_minus_misaligned']['z']:.2f} p={tests['high_high_aligned_minus_misaligned']['p_two_sided']:.3f} " + f"high_z0={obs['high_high_zero_minus_nonzero']:.5f} z={tests['high_high_zero_minus_nonzero']['z']:.2f} p={tests['high_high_zero_minus_nonzero']['p_two_sided']:.3f} " + f"sr_am={obs['sr_aligned_minus_misaligned']:.5f} z={tests['sr_aligned_minus_misaligned']['z']:.2f} p={tests['sr_aligned_minus_misaligned']['p_two_sided']:.3f} " + f"role={result['zero_role']}" + ) + print(f"wrote {out}") + + +if __name__ == "__main__": + main() exited 2 in 30618ms: [provider: codex-cli unavailable, next] [provider: claude-cli unavailable, next] [provider: openrouter unavailable, next] [falsifier] chain failed: all providers in chain ['codex-cli', 'claude-cli', 'openrouter'] failed (check codex auth, claude auth, OPENROUTER_API_KEY env) [falsifier] LLM call failed (exit=1). Conservative: BLOCK. codex Il falsifier non ha prodotto una valutazione: tutti i provider locali risultano non disponibili, quindi il tool ha scritto solo un blocco conservativo. Faccio ancora una verifica tecnica dello script e poi chiudo il cycle con i file prodotti. exec /bin/bash -lc 'ls -l tools/data/reports/agent_20260508_2108.md tools/data/prime_mobius_zero_mediator_gate_20260508_2108.json tools/exp_prime_mobius_zero_mediator_gate.py tools/data/reports/falsifier_20260508_2108.raw.txt 2>/dev/null' in /opt/MM_D-ND succeeded in 0ms: -rw-r--r-- 1 root root 40788 May 8 21:10 tools/data/prime_mobius_zero_mediator_gate_20260508_2108.json -rw-r--r-- 1 root root 11059 May 8 21:12 tools/data/reports/agent_20260508_2108.md -rw-r--r-- 1 root root 15 May 8 21:13 tools/data/reports/falsifier_20260508_2108.raw.txt -rw-r--r-- 1 root root 12166 May 8 21:10 tools/exp_prime_mobius_zero_mediator_gate.py exec /bin/bash -lc 'git diff -- tools/exp_prime_mobius_zero_mediator_gate.py tools/data/reports/agent_20260508_2108.md --stat' in /opt/MM_D-ND succeeded in 0ms: exec /bin/bash -lc 'python -m py_compile tools/exp_prime_mobius_zero_mediator_gate.py' in /opt/MM_D-ND succeeded in 0ms: diff --git a/tools/data/reports/agent_20260508_2108.md b/tools/data/reports/agent_20260508_2108.md new file mode 100644 index 0000000000000000000000000000000000000000..d3b8fa5889b9587b0e01270608220848eb4d5ed7 --- /dev/null +++ b/tools/data/reports/agent_20260508_2108.md @@ -0,0 +1,103 @@ +# Agent Report - Prime Mobius Zero-Mediator Gate +**Date**: 2026-05-08 21:08 +**Piano**: 93 +**Tension explored**: DUALITA_DIPOLARE_VS_ILLUSORIA (0.9) +**verdict**: CONSTRAINT +observables_registry: 1.0.0-2026-05-06 +observables_used: [low_low_rate, high_high_rate, SR, det_M_direct_control] +**observable_contract**: claim=lo zero della carica Mobius intervallare e' testato come terzo incluso del gate aligned/misaligned; observable=rate low_low, rate high_high, SR mean per classi aligned/misaligned/zero; operator=classificazione di S_n*S_{n+1}: aligned<0, misaligned>0, zero=0; generator=prime gaps up to p<=1e6 with Mobius sieve; denominator=main N={5000,10000,20000} offset=0 plus seedcheck offsets {3000,7000,11000}; not_tested=gap_ratio Sturmian, high-core phi survival, universal GUE/Poisson classification. + +## Respiro fuori-tempo +- **Combo**: A2 confine det=-1 + A9 terzo incluso + A11 combo + QxG continuo/discreto vuoto + DUALITA_DIPOLARE_VS_ILLUSORIA + piano primi x Mobius. Il repair non cerca un lettore nuovo: riporta nel denominatore il punto escluso dal source cycle, `S=0`. +- **Dipolo / punto-zero**: carica Mobius alternata / carica Mobius concorde; punto-zero = transizione con almeno un intervallo a carica nulla (`S_n*S_{n+1}=0`). +- **Piano superiore**: boundary operator su grafo aritmetico. Il gap e' bordo tra primi; la carica Mobius del vuoto tra primi decide se il bordo e' solo rumore di lunghezza o classe informativa. +- **Operatori laterali scelti**: boundary operator, random walk, entropia. Boundary operator definisce il bordo prime-free; random walk fornisce il null di permutazione della carica; entropia entra come dispersione del vuoto senza primi. +- **Contaminazione cognitiva**: + - **CE-0117**: usato per non promuovere il source cycle e far passare il risultato da potenziale a vincolo misurato. + - **CE-0038**: usato per riportare la forma nel Nulla-Tutto al vuoto aritmetico, qui lo zero `S=0`. + - **CE-0001 / KSAR**: usato come kernel reiterativo del ciclo 2102, con riparazione regressiva sul denominatore. + - **PVI attack**: il segnale puo' essere effetto di lunghezza del gap; per questo il null permuta l'intera sequenza delle cariche preservando multiset e frequenza degli zeri. +- **Proto-ipotesi**: se `S=0` e' terzo incluso operativo, non cade come rumore sotto il null che preserva la frequenza degli zeri. Deve produrre una classe distinguibile su low_low/high_high/SR. Se resta dentro il null, il source cycle sopravvive solo come gate binario non-zero. +- **Proiezione**: confronto aligned, misaligned e zero su `low_low`, `high_high` e `SR`; null = 400 permutazioni della sequenza `S_n`, gap invariati, multiset delle cariche invariata. + +## Claim Under Test +> Nel perimetro primi x Mobius fino a `p<=1e6`, le transizioni con `S=0` non vanno escluse: formano una terza classe del gate intervallare e vanno confrontate contro aligned/misaligned con null che preserva la frequenza degli zeri. + +## Question +Lo zero della carica Mobius intervallare e' rumore, boundary o mediatore del segnale low-low/high-high/SR? + +## Experiment Design +- Script: `tools/exp_prime_mobius_zero_mediator_gate.py`. +- Dati: primi fino a `1_000_000`; Mobius sieve sullo stesso perimetro. +- Carica intervallare: `S_n = sum(mu(k))` per `p_n < k < p_{n+1}`. +- Classi: + - `aligned`: `S_n*S_{n+1}<0`. + - `misaligned`: `S_n*S_{n+1}>0`. + - `zero`: `S_n*S_{n+1}=0`. +- Osservabili: + - `low_low_rate`: count di due gap consecutivi `<=6` sul denominatore della classe. + - `high_high_rate`: count di due gap consecutivi `>=q75` sul denominatore della classe. + - `SR`: mean min/max ratio dei gap consecutivi. +- Null test: 400 permutazioni della sequenza `S_n`; il null preserva la multiset completa delle cariche e quindi la frequenza degli zeri. +- Controllo det(M) diretto: `M=[[1,1],[1,0]]` ha `det(M)=-1` costante su ogni transizione; il controllo non partiziona il denominatore e restituisce solo le baseline globali low/high/SR. +- Soglia ex ante: `|z|>=2` e `p_two_sided<=0.05`. +- Contratto osservabile-operatore: `gap_ratio` Sturmian non testato; il source cycle 2102 non viene promosso; il claim su det diretto viene sostituito da controllo esplicito, non da conclusione non misurata. + +## Results +| condition | a/m/z denom | zero charges | low a | low m | low z | low z0 vs nonzero z/p | high a | high m | high z | high z0 vs nonzero z/p | SR a | SR m | SR z | SR z0 vs nonzero z/p | +|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:| +| N=5000 off=0 | 1200/1572/2227 | 1258/5000 | 221/1200 | 220/1572 | 707/2227 | 11.77 / 0.002 | 115/1200 | 298/1572 | 101/2227 | -10.80 / 0.002 | 0.51559 | 0.52611 | 0.43203 | -11.15 / 0.002 | +| N=10000 off=0 | 2541/3102/4356 | 2457/10000 | 403/2541 | 377/3102 | 1190/4356 | 14.88 / 0.002 | 153/2541 | 363/3102 | 114/4356 | -12.31 / 0.002 | 0.50841 | 0.51502 | 0.42221 | -16.03 / 0.002 | +| N=20000 off=0 | 5171/6331/8497 | 4782/20000 | 694/5171 | 651/6331 | 2093/8497 | 22.31 / 0.002 | 422/5171 | 878/6331 | 281/8497 | -18.75 / 0.002 | 0.50324 | 0.51151 | 0.41571 | -23.13 / 0.002 | +| N=5000 off=3000 | 1313/1525/2161 | 1219/5000 | 184/1313 | 162/1525 | 522/2161 | 9.84 / 0.002 | 86/1313 | 187/1525 | 71/2161 | -8.13 / 0.002 | 0.50993 | 0.50560 | 0.42213 | -10.87 / 0.002 | +| N=10000 off=7000 | 2675/3178/4146 | 2318/10000 | 315/2675 | 298/3178 | 946/4146 | 16.40 / 0.002 | 182/2675 | 351/3178 | 98/4146 | -13.27 / 0.002 | 0.50225 | 0.50729 | 0.40695 | -17.18 / 0.002 | +| N=20000 off=11000 | 5407/6413/8179 | 4586/20000 | 553/5407 | 567/6413 | 1740/8179 | 20.63 / 0.002 | 295/5407 | 667/6413 | 178/8179 | -16.22 / 0.002 | 0.49723 | 0.50997 | 0.41131 | -22.87 / 0.002 | + +### Pairwise aligned/misaligned checks +| condition | low a-m diff z/p | high a-m diff z/p | SR a-m diff z/p | +|---|---:|---:|---:| +| N=5000 off=0 | +0.04422 2.47 / 0.015 | -0.09373 -7.96 / 0.002 | -0.01053 -1.12 / 0.277 | +| N=10000 off=0 | +0.03706 3.44 / 0.002 | -0.05681 -8.90 / 0.002 | -0.00661 -0.90 / 0.357 | +| N=20000 off=0 | +0.03138 4.56 / 0.002 | -0.05707 -10.48 / 0.002 | -0.00827 -1.78 / 0.097 | +| N=5000 off=3000 | +0.03391 2.37 / 0.022 | -0.05712 -5.66 / 0.002 | +0.00433 0.48 / 0.671 | +| N=10000 off=7000 | +0.02399 2.68 / 0.010 | -0.04241 -6.58 / 0.002 | -0.00504 -0.71 / 0.501 | +| N=20000 off=11000 | +0.01386 1.97 / 0.040 | -0.04945 -10.96 / 0.002 | -0.01274 -2.50 / 0.015 | + +### det(M) direct control +`det(M)=-1` e' costante. Il controllo ha una sola classe su ogni condizione, quindi non separa aligned/misaligned/zero. Baseline globali: low_low `1148/4999`, `1970/9999`, `3438/19999`, `868/4999`, `1559/9999`, `2860/19999`; high_high `514/4999`, `630/9999`, `1581/19999`, `344/4999`, `631/9999`, `1140/19999`; SR globale `0.48167`, `0.47291`, `0.46867`, `0.47066`, `0.46434`, `0.46618`. + +## Key Findings +1. **Verificato: lo zero non e' rumore sotto il null usato.** La classe zero supera il null in 6/6 condizioni su `low_low_zero_minus_nonzero`, `high_high_zero_minus_nonzero` e `sr_zero_minus_nonzero`, sempre con `p=0.002` e `|z|` da `8.13` a `23.13`. + +2. **Verificato: lo zero e' una terza classe, non un mediatore tra aligned e misaligned.** Su low_low lo zero e' sopra entrambe le classi non-zero (`0.21274..0.31747` contro aligned `0.10227..0.18417` e misaligned `0.08841..0.13995`). Su high_high lo zero e' sotto entrambe (`0.02176..0.04535` contro aligned `0.05456..0.09583` e misaligned `0.10401..0.18957`). Su SR lo zero e' sotto entrambe (`0.40695..0.43203` contro non-zero circa `0.49723..0.52611`). Il punto-zero non sta tra i poli: genera una classe propria. + +3. **Verificato: il contrasto aligned/misaligned sopravvive soprattutto su high_high.** `high_high_aligned_minus_misaligned` passa 6/6 con z da `-5.66` a `-10.96`. `low_low_aligned_minus_misaligned` passa 5/6 se la soglia richiede anche `|z|>=2`; l'ultima condizione ha `z=1.97`, `p=0.040`, quindi resta borderline e non autorizza hard wording. SR passa 1/6 e resta osservabile secondario. + +4. **Verificato: il controllo det(M) diretto risolve il flag L3 del source cycle.** `det(M)` costante non produce partizione del denominatore; il report non conclude che la dualita "non si legge" da det diretto come fatto empirico generale. Qui dichiara solo che, in questo controllo, det(M) diretto non e' un discriminatore di classe. + +## Verdict +**CONSTRAINT on DUALITA_DIPOLARE_VS_ILLUSORIA / Prime Mobius interval-charge gate**: nel perimetro primi x Mobius fino a `p<=1e6`, `S=0` deve restare nel denominatore come terza classe. Lo zero non e' rumore sotto il null di permutazione che preserva frequenza degli zeri: arricchisce low_low, sopprime high_high e abbassa SR in 6/6 condizioni. Il source cycle sopravvive come vincolo parziale: il gate non-zero aligned/misaligned resta solido per high_high, resta parziale per low_low, e non porta SR globalmente. Il nuovo portatore e' triadico: aligned / misaligned / zero. + +## Bicono della scoperta +- **Due radici**: carica non-zero alternata/concorde . carica zero dell'intervallo prime-free. +- **Singolare**: il vuoto tra primi prima della scelta binaria; `S=0` non e' assenza di segnale ma classe del bordo. +- **Invariante di passaggio**: il null conserva gap, multiset delle cariche e frequenza degli zeri; cio' che sopravvive e' l'accoppiamento ordine-carica, non la sola presenza dello zero. +- **Campo di possibilita**: qui diventa possibile testare un gate triadico del boundary aritmetico. Qui diventa non-possibile escludere `S=0` dal denominatore quando si parla di terzo incluso nel perimetro Mobius-primi. + +## Consecutio +Il prossimo passo deve separare terza classe autentica da effetto scala dell'intervallo: ripetere il gate con controllo che preserva anche la lunghezza del gap o stratifica per bucket di gap length. Se lo zero resta significativo dentro ogni bucket, il boundary e' aritmetico; se cade, il segnale e' dipendenza da lunghezza. + +## Auto-audit: source flags e 5 lenti +- **Source L3 resolved**: il report non usa un elemento `not_tested` come conclusione. Il controllo det(M) diretto e' misurato e dichiarato non partizionante nel perimetro. +- **Source denominator repair resolved**: `S=0` e' incluso come classe esplicita, con count grezzi e denominatore. +- **Aperto**: non e' ancora separata la dipendenza dalla lunghezza del gap; serve controllo stratificato. +- **L1 hard constraint vs bias**: nessun "sempre/mai"; perimetro dichiarato `p<=1e6`, sei condizioni, 400 permutazioni. +- **L2 quantita vs ratio**: count grezzi e denominatori riportati; SR separato dai rate. +- **L3 no silent patching**: claim corretto prima del test; il source cycle non viene promosso. +- **L4 edge cases**: `low_low` non-zero e' borderline in una condizione (`z=1.97`), quindi resta parziale. +- **L5 re-discovery vs discovery**: verdict `CONSTRAINT`, non `NEW`; il pattern resta da confrontare con dipendenze note tra Mobius, lunghezza intervallare e gap primes. + +## Files +- Script: `tools/exp_prime_mobius_zero_mediator_gate.py` +- Data: `tools/data/prime_mobius_zero_mediator_gate_20260508_2108.json` +- Report: `tools/data/reports/agent_20260508_2108.md` diff --git a/tools/exp_prime_mobius_zero_mediator_gate.py b/tools/exp_prime_mobius_zero_mediator_gate.py new file mode 100644 index 0000000000000000000000000000000000000000..95ecd6e07c1863f3ffd3a3a5297a8628a00fd8be --- /dev/null +++ b/tools/exp_prime_mobius_zero_mediator_gate.py @@ -0,0 +1,314 @@ +#!/usr/bin/env python3 +"""Prime x Mobius zero-mediator gate. + +Repairs the 20260508_2102 interval-charge gate by keeping transitions with +S=0 in the denominator as an explicit third class. +""" +from __future__ import annotations + +import argparse +import json +from pathlib import Path + +import numpy as np + +from exp_prime_mobius_interval_charge_gate import ( + interval_charges, + mobius_sieve, + sieve_primes, +) + + +METRIC_KEYS = [ + "low_low_aligned_rate", + "low_low_misaligned_rate", + "low_low_zero_rate", + "high_high_aligned_rate", + "high_high_misaligned_rate", + "high_high_zero_rate", + "sr_aligned_mean", + "sr_misaligned_mean", + "sr_zero_mean", + "low_low_aligned_minus_misaligned", + "low_low_zero_minus_nonzero", + "high_high_aligned_minus_misaligned", + "high_high_zero_minus_nonzero", + "sr_aligned_minus_misaligned", + "sr_zero_minus_nonzero", +] + + +def _rate(mask: np.ndarray, event: np.ndarray) -> tuple[int, int, float]: + denom = int(np.sum(mask)) + hits = int(np.sum(mask & event)) + rate = float(hits / denom) if denom else float("nan") + return hits, denom, rate + + +def _mean(mask: np.ndarray, values: np.ndarray) -> tuple[int, float]: + denom = int(np.sum(mask)) + mean = float(np.mean(values[mask])) if denom else float("nan") + return denom, mean + + +def transition_metrics_three_class(gaps: np.ndarray, charges: np.ndarray) -> dict[str, float | int]: + left = charges[:-1] + right = charges[1:] + product = left * right + aligned = product < 0 + misaligned = product > 0 + zero = product == 0 + nonzero = ~zero + + g0 = gaps[:-1].astype(float) + g1 = gaps[1:].astype(float) + ratio = np.minimum(g0, g1) / np.maximum(g0, g1) + low_low = (g0 <= 6) & (g1 <= 6) + q75 = float(np.quantile(gaps, 0.75)) + high_high = (g0 >= q75) & (g1 >= q75) + + metrics: dict[str, float | int] = { + "q75_gap": q75, + "aligned_count": int(np.sum(aligned)), + "misaligned_count": int(np.sum(misaligned)), + "zero_count": int(np.sum(zero)), + "nonzero_count": int(np.sum(nonzero)), + } + + for name, event in (("low_low", low_low), ("high_high", high_high)): + for cls_name, mask in ( + ("aligned", aligned), + ("misaligned", misaligned), + ("zero", zero), + ("nonzero", nonzero), + ): + hits, denom, rate = _rate(mask, event) + metrics[f"{name}_{cls_name}_hits"] = hits + metrics[f"{name}_{cls_name}_denom"] = denom + metrics[f"{name}_{cls_name}_rate"] = rate + + for cls_name, mask in ( + ("aligned", aligned), + ("misaligned", misaligned), + ("zero", zero), + ("nonzero", nonzero), + ): + denom, mean = _mean(mask, ratio) + metrics[f"sr_{cls_name}_denom"] = denom + metrics[f"sr_{cls_name}_mean"] = mean + + metrics["low_low_aligned_minus_misaligned"] = ( + float(metrics["low_low_aligned_rate"]) - float(metrics["low_low_misaligned_rate"]) + ) + metrics["high_high_aligned_minus_misaligned"] = ( + float(metrics["high_high_aligned_rate"]) - float(metrics["high_high_misaligned_rate"]) + ) + metrics["sr_aligned_minus_misaligned"] = ( + float(metrics["sr_aligned_mean"]) - float(metrics["sr_misaligned_mean"]) + ) + metrics["low_low_zero_minus_nonzero"] = ( + float(metrics["low_low_zero_rate"]) - float(metrics["low_low_nonzero_rate"]) + ) + metrics["high_high_zero_minus_nonzero"] = ( + float(metrics["high_high_zero_rate"]) - float(metrics["high_high_nonzero_rate"]) + ) + metrics["sr_zero_minus_nonzero"] = ( + float(metrics["sr_zero_mean"]) - float(metrics["sr_nonzero_mean"]) + ) + return metrics + + +def permutation_test( + gaps: np.ndarray, + charges: np.ndarray, + observed: dict[str, float | int], + rng: np.random.Generator, + permutations: int, +) -> dict[str, dict[str, float]]: + nulls = {key: [] for key in METRIC_KEYS} + for _ in range(permutations): + shuffled = np.array(charges, copy=True) + rng.shuffle(shuffled) + metrics = transition_metrics_three_class(gaps, shuffled) + for key in METRIC_KEYS: + nulls[key].append(float(metrics[key])) + + out: dict[str, dict[str, float]] = {} + for key, values in nulls.items(): + arr = np.array(values, dtype=float) + obs = float(observed[key]) + finite = np.isfinite(arr) + arr = arr[finite] + if arr.size == 0 or not np.isfinite(obs): + out[key] = {"observed": obs, "null_mean": float("nan"), "null_std": float("nan"), "z": float("nan"), "p_two_sided": float("nan")} + continue + std = float(np.std(arr, ddof=1)) + z = (obs - float(np.mean(arr))) / std if std > 0 else 0.0 + p = float((np.sum(np.abs(arr) >= abs(obs)) + 1) / (len(arr) + 1)) + out[key] = { + "observed": obs, + "null_mean": float(np.mean(arr)), + "null_std": std, + "z": float(z), + "p_two_sided": p, + } + return out + + +def det_m_direct_control(gaps: np.ndarray) -> dict[str, float | int | str]: + g0 = gaps[:-1].astype(float) + g1 = gaps[1:].astype(float) + ratio = np.minimum(g0, g1) / np.maximum(g0, g1) + low_low = (g0 <= 6) & (g1 <= 6) + q75 = float(np.quantile(gaps, 0.75)) + high_high = (g0 >= q75) & (g1 >= q75) + denom = int(g0.size) + return { + "det_M": -1, + "class_count": 1, + "reason": "M=[[1,1],[1,0]] has constant determinant -1 on every transition, so direct det(M) does not partition the denominator.", + "denominator": denom, + "low_low_hits": int(np.sum(low_low)), + "low_low_rate": float(np.sum(low_low) / denom), + "high_high_hits": int(np.sum(high_high)), + "high_high_rate": float(np.sum(high_high) / denom), + "sr_mean": float(np.mean(ratio)), + } + + +def classify_zero_role(observed: dict[str, float | int], tests: dict[str, dict[str, float]]) -> str: + low_z = tests["low_low_zero_minus_nonzero"]["z"] + high_z = tests["high_high_zero_minus_nonzero"]["z"] + sr_z = tests["sr_zero_minus_nonzero"]["z"] + passes = [ + abs(low_z) >= 2 and tests["low_low_zero_minus_nonzero"]["p_two_sided"] <= 0.05, + abs(high_z) >= 2 and tests["high_high_zero_minus_nonzero"]["p_two_sided"] <= 0.05, + abs(sr_z) >= 2 and tests["sr_zero_minus_nonzero"]["p_two_sided"] <= 0.05, + ] + low = float(observed["low_low_zero_rate"]) + high = float(observed["high_high_zero_rate"]) + sr = float(observed["sr_zero_mean"]) + low_a = float(observed["low_low_aligned_rate"]) + low_m = float(observed["low_low_misaligned_rate"]) + high_a = float(observed["high_high_aligned_rate"]) + high_m = float(observed["high_high_misaligned_rate"]) + sr_a = float(observed["sr_aligned_mean"]) + sr_m = float(observed["sr_misaligned_mean"]) + + between_low = min(low_a, low_m) <= low <= max(low_a, low_m) + between_high = min(high_a, high_m) <= high <= max(high_a, high_m) + between_sr = min(sr_a, sr_m) <= sr <= max(sr_a, sr_m) + + if any(passes) and (between_low or between_high or between_sr): + return "boundary" + if any(passes): + return "third_class" + return "noise_under_this_null" + + +def run_condition( + primes: np.ndarray, + mu: np.ndarray, + n_primes: int, + offset: int, + rng: np.random.Generator, + permutations: int, +) -> dict[str, object]: + segment = primes[offset : offset + n_primes + 1] + gaps = np.diff(segment) + charges = interval_charges(segment, mu) + observed = transition_metrics_three_class(gaps, charges) + tests = permutation_test(gaps, charges, observed, rng, permutations) + return { + "n_primes": n_primes, + "offset": offset, + "prime_start": int(segment[0]), + "prime_stop": int(segment[-1]), + "zero_charge_count": int(np.sum(charges == 0)), + "charge_count": int(charges.size), + "observed": observed, + "permutation_tests": tests, + "zero_role": classify_zero_role(observed, tests), + "det_m_direct_control": det_m_direct_control(gaps), + } + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--limit", type=int, default=1_000_000) + parser.add_argument("--permutations", type=int, default=400) + parser.add_argument("--seed", type=int, default=2108) + parser.add_argument("--out", default="tools/data/prime_mobius_zero_mediator_gate_20260508_2108.json") + args = parser.parse_args() + + primes = sieve_primes(args.limit) + mu = mobius_sieve(args.limit) + rng = np.random.default_rng(args.seed) + + conditions = [ + {"n_primes": 5_000, "offset": 0}, + {"n_primes": 10_000, "offset": 0}, + {"n_primes": 20_000, "offset": 0}, + {"n_primes": 5_000, "offset": 3_000}, + {"n_primes": 10_000, "offset": 7_000}, + {"n_primes": 20_000, "offset": 11_000}, + ] + max_needed = max(c["offset"] + c["n_primes"] + 1 for c in conditions) + if len(primes) <= max_needed: + raise SystemExit(f"limit={args.limit} yields only {len(primes)} primes, need {max_needed}") + + results = [ + run_condition(primes, mu, c["n_primes"], c["offset"], rng, args.permutations) + for c in conditions + ] + summary = [] + for result in results: + tests = result["permutation_tests"] + summary.append( + { + "n_primes": result["n_primes"], + "offset": result["offset"], + "low_low_aligned_minus_misaligned_pass": abs(tests["low_low_aligned_minus_misaligned"]["z"]) >= 2.0 + and tests["low_low_aligned_minus_misaligned"]["p_two_sided"] <= 0.05, + "high_high_aligned_minus_misaligned_pass": abs(tests["high_high_aligned_minus_misaligned"]["z"]) >= 2.0 + and tests["high_high_aligned_minus_misaligned"]["p_two_sided"] <= 0.05, + "sr_aligned_minus_misaligned_pass": abs(tests["sr_aligned_minus_misaligned"]["z"]) >= 2.0 + and tests["sr_aligned_minus_misaligned"]["p_two_sided"] <= 0.05, + "zero_role": result["zero_role"], + } + ) + + payload = { + "experiment": "prime_mobius_zero_mediator_gate", + "question": "Does S=0 behave as noise, boundary, or mediator in the Mobius interval-charge gate?", + "threshold_ex_ante": "|z|>=2 and permutation p<=0.05 across main and offset conditions", + "null": "Permutation of the interval-charge sequence preserves the full charge multiset and therefore preserves zero frequency.", + "limit": args.limit, + "permutations": args.permutations, + "seed": args.seed, + "conditions": results, + "significance_summary": summary, + } + + out = Path(args.out) + out.parent.mkdir(parents=True, exist_ok=True) + out.write_text(json.dumps(payload, indent=2), encoding="utf-8") + + for result in results: + obs = result["observed"] + tests = result["permutation_tests"] + print( + f"N={result['n_primes']} offset={result['offset']} " + f"a/m/z={obs['aligned_count']}/{obs['misaligned_count']}/{obs['zero_count']} " + f"low_am={obs['low_low_aligned_minus_misaligned']:.5f} z={tests['low_low_aligned_minus_misaligned']['z']:.2f} p={tests['low_low_aligned_minus_misaligned']['p_two_sided']:.3f} " + f"low_z0={obs['low_low_zero_minus_nonzero']:.5f} z={tests['low_low_zero_minus_nonzero']['z']:.2f} p={tests['low_low_zero_minus_nonzero']['p_two_sided']:.3f} " + f"high_am={obs['high_high_aligned_minus_misaligned']:.5f} z={tests['high_high_aligned_minus_misaligned']['z']:.2f} p={tests['high_high_aligned_minus_misaligned']['p_two_sided']:.3f} " + f"high_z0={obs['high_high_zero_minus_nonzero']:.5f} z={tests['high_high_zero_minus_nonzero']['z']:.2f} p={tests['high_high_zero_minus_nonzero']['p_two_sided']:.3f} " + f"sr_am={obs['sr_aligned_minus_misaligned']:.5f} z={tests['sr_aligned_minus_misaligned']['z']:.2f} p={tests['sr_aligned_minus_misaligned']['p_two_sided']:.3f} " + f"role={result['zero_role']}" + ) + print(f"wrote {out}") + + +if __name__ == "__main__": + main() exec /bin/bash -lc "find tools -path '*/__pycache__/*exp_prime_mobius_zero_mediator_gate*' -print" in /opt/MM_D-ND succeeded in 0ms: tools/__pycache__/exp_prime_mobius_zero_mediator_gate.cpython-312.pyc diff --git a/tools/data/reports/agent_20260508_2108.md b/tools/data/reports/agent_20260508_2108.md new file mode 100644 index 0000000000000000000000000000000000000000..d3b8fa5889b9587b0e01270608220848eb4d5ed7 --- /dev/null +++ b/tools/data/reports/agent_20260508_2108.md @@ -0,0 +1,103 @@ +# Agent Report - Prime Mobius Zero-Mediator Gate +**Date**: 2026-05-08 21:08 +**Piano**: 93 +**Tension explored**: DUALITA_DIPOLARE_VS_ILLUSORIA (0.9) +**verdict**: CONSTRAINT +observables_registry: 1.0.0-2026-05-06 +observables_used: [low_low_rate, high_high_rate, SR, det_M_direct_control] +**observable_contract**: claim=lo zero della carica Mobius intervallare e' testato come terzo incluso del gate aligned/misaligned; observable=rate low_low, rate high_high, SR mean per classi aligned/misaligned/zero; operator=classificazione di S_n*S_{n+1}: aligned<0, misaligned>0, zero=0; generator=prime gaps up to p<=1e6 with Mobius sieve; denominator=main N={5000,10000,20000} offset=0 plus seedcheck offsets {3000,7000,11000}; not_tested=gap_ratio Sturmian, high-core phi survival, universal GUE/Poisson classification. + +## Respiro fuori-tempo +- **Combo**: A2 confine det=-1 + A9 terzo incluso + A11 combo + QxG continuo/discreto vuoto + DUALITA_DIPOLARE_VS_ILLUSORIA + piano primi x Mobius. Il repair non cerca un lettore nuovo: riporta nel denominatore il punto escluso dal source cycle, `S=0`. +- **Dipolo / punto-zero**: carica Mobius alternata / carica Mobius concorde; punto-zero = transizione con almeno un intervallo a carica nulla (`S_n*S_{n+1}=0`). +- **Piano superiore**: boundary operator su grafo aritmetico. Il gap e' bordo tra primi; la carica Mobius del vuoto tra primi decide se il bordo e' solo rumore di lunghezza o classe informativa. +- **Operatori laterali scelti**: boundary operator, random walk, entropia. Boundary operator definisce il bordo prime-free; random walk fornisce il null di permutazione della carica; entropia entra come dispersione del vuoto senza primi. +- **Contaminazione cognitiva**: + - **CE-0117**: usato per non promuovere il source cycle e far passare il risultato da potenziale a vincolo misurato. + - **CE-0038**: usato per riportare la forma nel Nulla-Tutto al vuoto aritmetico, qui lo zero `S=0`. + - **CE-0001 / KSAR**: usato come kernel reiterativo del ciclo 2102, con riparazione regressiva sul denominatore. + - **PVI attack**: il segnale puo' essere effetto di lunghezza del gap; per questo il null permuta l'intera sequenza delle cariche preservando multiset e frequenza degli zeri. +- **Proto-ipotesi**: se `S=0` e' terzo incluso operativo, non cade come rumore sotto il null che preserva la frequenza degli zeri. Deve produrre una classe distinguibile su low_low/high_high/SR. Se resta dentro il null, il source cycle sopravvive solo come gate binario non-zero. +- **Proiezione**: confronto aligned, misaligned e zero su `low_low`, `high_high` e `SR`; null = 400 permutazioni della sequenza `S_n`, gap invariati, multiset delle cariche invariata. + +## Claim Under Test +> Nel perimetro primi x Mobius fino a `p<=1e6`, le transizioni con `S=0` non vanno escluse: formano una terza classe del gate intervallare e vanno confrontate contro aligned/misaligned con null che preserva la frequenza degli zeri. + +## Question +Lo zero della carica Mobius intervallare e' rumore, boundary o mediatore del segnale low-low/high-high/SR? + +## Experiment Design +- Script: `tools/exp_prime_mobius_zero_mediator_gate.py`. +- Dati: primi fino a `1_000_000`; Mobius sieve sullo stesso perimetro. +- Carica intervallare: `S_n = sum(mu(k))` per `p_n < k < p_{n+1}`. +- Classi: + - `aligned`: `S_n*S_{n+1}<0`. + - `misaligned`: `S_n*S_{n+1}>0`. + - `zero`: `S_n*S_{n+1}=0`. +- Osservabili: + - `low_low_rate`: count di due gap consecutivi `<=6` sul denominatore della classe. + - `high_high_rate`: count di due gap consecutivi `>=q75` sul denominatore della classe. + - `SR`: mean min/max ratio dei gap consecutivi. +- Null test: 400 permutazioni della sequenza `S_n`; il null preserva la multiset completa delle cariche e quindi la frequenza degli zeri. +- Controllo det(M) diretto: `M=[[1,1],[1,0]]` ha `det(M)=-1` costante su ogni transizione; il controllo non partiziona il denominatore e restituisce solo le baseline globali low/high/SR. +- Soglia ex ante: `|z|>=2` e `p_two_sided<=0.05`. +- Contratto osservabile-operatore: `gap_ratio` Sturmian non testato; il source cycle 2102 non viene promosso; il claim su det diretto viene sostituito da controllo esplicito, non da conclusione non misurata. + +## Results +| condition | a/m/z denom | zero charges | low a | low m | low z | low z0 vs nonzero z/p | high a | high m | high z | high z0 vs nonzero z/p | SR a | SR m | SR z | SR z0 vs nonzero z/p | +|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:| +| N=5000 off=0 | 1200/1572/2227 | 1258/5000 | 221/1200 | 220/1572 | 707/2227 | 11.77 / 0.002 | 115/1200 | 298/1572 | 101/2227 | -10.80 / 0.002 | 0.51559 | 0.52611 | 0.43203 | -11.15 / 0.002 | +| N=10000 off=0 | 2541/3102/4356 | 2457/10000 | 403/2541 | 377/3102 | 1190/4356 | 14.88 / 0.002 | 153/2541 | 363/3102 | 114/4356 | -12.31 / 0.002 | 0.50841 | 0.51502 | 0.42221 | -16.03 / 0.002 | +| N=20000 off=0 | 5171/6331/8497 | 4782/20000 | 694/5171 | 651/6331 | 2093/8497 | 22.31 / 0.002 | 422/5171 | 878/6331 | 281/8497 | -18.75 / 0.002 | 0.50324 | 0.51151 | 0.41571 | -23.13 / 0.002 | +| N=5000 off=3000 | 1313/1525/2161 | 1219/5000 | 184/1313 | 162/1525 | 522/2161 | 9.84 / 0.002 | 86/1313 | 187/1525 | 71/2161 | -8.13 / 0.002 | 0.50993 | 0.50560 | 0.42213 | -10.87 / 0.002 | +| N=10000 off=7000 | 2675/3178/4146 | 2318/10000 | 315/2675 | 298/3178 | 946/4146 | 16.40 / 0.002 | 182/2675 | 351/3178 | 98/4146 | -13.27 / 0.002 | 0.50225 | 0.50729 | 0.40695 | -17.18 / 0.002 | +| N=20000 off=11000 | 5407/6413/8179 | 4586/20000 | 553/5407 | 567/6413 | 1740/8179 | 20.63 / 0.002 | 295/5407 | 667/6413 | 178/8179 | -16.22 / 0.002 | 0.49723 | 0.50997 | 0.41131 | -22.87 / 0.002 | + +### Pairwise aligned/misaligned checks +| condition | low a-m diff z/p | high a-m diff z/p | SR a-m diff z/p | +|---|---:|---:|---:| +| N=5000 off=0 | +0.04422 2.47 / 0.015 | -0.09373 -7.96 / 0.002 | -0.01053 -1.12 / 0.277 | +| N=10000 off=0 | +0.03706 3.44 / 0.002 | -0.05681 -8.90 / 0.002 | -0.00661 -0.90 / 0.357 | +| N=20000 off=0 | +0.03138 4.56 / 0.002 | -0.05707 -10.48 / 0.002 | -0.00827 -1.78 / 0.097 | +| N=5000 off=3000 | +0.03391 2.37 / 0.022 | -0.05712 -5.66 / 0.002 | +0.00433 0.48 / 0.671 | +| N=10000 off=7000 | +0.02399 2.68 / 0.010 | -0.04241 -6.58 / 0.002 | -0.00504 -0.71 / 0.501 | +| N=20000 off=11000 | +0.01386 1.97 / 0.040 | -0.04945 -10.96 / 0.002 | -0.01274 -2.50 / 0.015 | + +### det(M) direct control +`det(M)=-1` e' costante. Il controllo ha una sola classe su ogni condizione, quindi non separa aligned/misaligned/zero. Baseline globali: low_low `1148/4999`, `1970/9999`, `3438/19999`, `868/4999`, `1559/9999`, `2860/19999`; high_high `514/4999`, `630/9999`, `1581/19999`, `344/4999`, `631/9999`, `1140/19999`; SR globale `0.48167`, `0.47291`, `0.46867`, `0.47066`, `0.46434`, `0.46618`. + +## Key Findings +1. **Verificato: lo zero non e' rumore sotto il null usato.** La classe zero supera il null in 6/6 condizioni su `low_low_zero_minus_nonzero`, `high_high_zero_minus_nonzero` e `sr_zero_minus_nonzero`, sempre con `p=0.002` e `|z|` da `8.13` a `23.13`. + +2. **Verificato: lo zero e' una terza classe, non un mediatore tra aligned e misaligned.** Su low_low lo zero e' sopra entrambe le classi non-zero (`0.21274..0.31747` contro aligned `0.10227..0.18417` e misaligned `0.08841..0.13995`). Su high_high lo zero e' sotto entrambe (`0.02176..0.04535` contro aligned `0.05456..0.09583` e misaligned `0.10401..0.18957`). Su SR lo zero e' sotto entrambe (`0.40695..0.43203` contro non-zero circa `0.49723..0.52611`). Il punto-zero non sta tra i poli: genera una classe propria. + +3. **Verificato: il contrasto aligned/misaligned sopravvive soprattutto su high_high.** `high_high_aligned_minus_misaligned` passa 6/6 con z da `-5.66` a `-10.96`. `low_low_aligned_minus_misaligned` passa 5/6 se la soglia richiede anche `|z|>=2`; l'ultima condizione ha `z=1.97`, `p=0.040`, quindi resta borderline e non autorizza hard wording. SR passa 1/6 e resta osservabile secondario. + +4. **Verificato: il controllo det(M) diretto risolve il flag L3 del source cycle.** `det(M)` costante non produce partizione del denominatore; il report non conclude che la dualita "non si legge" da det diretto come fatto empirico generale. Qui dichiara solo che, in questo controllo, det(M) diretto non e' un discriminatore di classe. + +## Verdict +**CONSTRAINT on DUALITA_DIPOLARE_VS_ILLUSORIA / Prime Mobius interval-charge gate**: nel perimetro primi x Mobius fino a `p<=1e6`, `S=0` deve restare nel denominatore come terza classe. Lo zero non e' rumore sotto il null di permutazione che preserva frequenza degli zeri: arricchisce low_low, sopprime high_high e abbassa SR in 6/6 condizioni. Il source cycle sopravvive come vincolo parziale: il gate non-zero aligned/misaligned resta solido per high_high, resta parziale per low_low, e non porta SR globalmente. Il nuovo portatore e' triadico: aligned / misaligned / zero. + +## Bicono della scoperta +- **Due radici**: carica non-zero alternata/concorde . carica zero dell'intervallo prime-free. +- **Singolare**: il vuoto tra primi prima della scelta binaria; `S=0` non e' assenza di segnale ma classe del bordo. +- **Invariante di passaggio**: il null conserva gap, multiset delle cariche e frequenza degli zeri; cio' che sopravvive e' l'accoppiamento ordine-carica, non la sola presenza dello zero. +- **Campo di possibilita**: qui diventa possibile testare un gate triadico del boundary aritmetico. Qui diventa non-possibile escludere `S=0` dal denominatore quando si parla di terzo incluso nel perimetro Mobius-primi. + +## Consecutio +Il prossimo passo deve separare terza classe autentica da effetto scala dell'intervallo: ripetere il gate con controllo che preserva anche la lunghezza del gap o stratifica per bucket di gap length. Se lo zero resta significativo dentro ogni bucket, il boundary e' aritmetico; se cade, il segnale e' dipendenza da lunghezza. + +## Auto-audit: source flags e 5 lenti +- **Source L3 resolved**: il report non usa un elemento `not_tested` come conclusione. Il controllo det(M) diretto e' misurato e dichiarato non partizionante nel perimetro. +- **Source denominator repair resolved**: `S=0` e' incluso come classe esplicita, con count grezzi e denominatore. +- **Aperto**: non e' ancora separata la dipendenza dalla lunghezza del gap; serve controllo stratificato. +- **L1 hard constraint vs bias**: nessun "sempre/mai"; perimetro dichiarato `p<=1e6`, sei condizioni, 400 permutazioni. +- **L2 quantita vs ratio**: count grezzi e denominatori riportati; SR separato dai rate. +- **L3 no silent patching**: claim corretto prima del test; il source cycle non viene promosso. +- **L4 edge cases**: `low_low` non-zero e' borderline in una condizione (`z=1.97`), quindi resta parziale. +- **L5 re-discovery vs discovery**: verdict `CONSTRAINT`, non `NEW`; il pattern resta da confrontare con dipendenze note tra Mobius, lunghezza intervallare e gap primes. + +## Files +- Script: `tools/exp_prime_mobius_zero_mediator_gate.py` +- Data: `tools/data/prime_mobius_zero_mediator_gate_20260508_2108.json` +- Report: `tools/data/reports/agent_20260508_2108.md` diff --git a/tools/exp_prime_mobius_zero_mediator_gate.py b/tools/exp_prime_mobius_zero_mediator_gate.py new file mode 100644 index 0000000000000000000000000000000000000000..95ecd6e07c1863f3ffd3a3a5297a8628a00fd8be --- /dev/null +++ b/tools/exp_prime_mobius_zero_mediator_gate.py @@ -0,0 +1,314 @@ +#!/usr/bin/env python3 +"""Prime x Mobius zero-mediator gate. + +Repairs the 20260508_2102 interval-charge gate by keeping transitions with +S=0 in the denominator as an explicit third class. +""" +from __future__ import annotations + +import argparse +import json +from pathlib import Path + +import numpy as np + +from exp_prime_mobius_interval_charge_gate import ( + interval_charges, + mobius_sieve, + sieve_primes, +) + + +METRIC_KEYS = [ + "low_low_aligned_rate", + "low_low_misaligned_rate", + "low_low_zero_rate", + "high_high_aligned_rate", + "high_high_misaligned_rate", + "high_high_zero_rate", + "sr_aligned_mean", + "sr_misaligned_mean", + "sr_zero_mean", + "low_low_aligned_minus_misaligned", + "low_low_zero_minus_nonzero", + "high_high_aligned_minus_misaligned", + "high_high_zero_minus_nonzero", + "sr_aligned_minus_misaligned", + "sr_zero_minus_nonzero", +] + + +def _rate(mask: np.ndarray, event: np.ndarray) -> tuple[int, int, float]: + denom = int(np.sum(mask)) + hits = int(np.sum(mask & event)) + rate = float(hits / denom) if denom else float("nan") + return hits, denom, rate + + +def _mean(mask: np.ndarray, values: np.ndarray) -> tuple[int, float]: + denom = int(np.sum(mask)) + mean = float(np.mean(values[mask])) if denom else float("nan") + return denom, mean + + +def transition_metrics_three_class(gaps: np.ndarray, charges: np.ndarray) -> dict[str, float | int]: + left = charges[:-1] + right = charges[1:] + product = left * right + aligned = product < 0 + misaligned = product > 0 + zero = product == 0 + nonzero = ~zero + + g0 = gaps[:-1].astype(float) + g1 = gaps[1:].astype(float) + ratio = np.minimum(g0, g1) / np.maximum(g0, g1) + low_low = (g0 <= 6) & (g1 <= 6) + q75 = float(np.quantile(gaps, 0.75)) + high_high = (g0 >= q75) & (g1 >= q75) + + metrics: dict[str, float | int] = { + "q75_gap": q75, + "aligned_count": int(np.sum(aligned)), + "misaligned_count": int(np.sum(misaligned)), + "zero_count": int(np.sum(zero)), + "nonzero_count": int(np.sum(nonzero)), + } + + for name, event in (("low_low", low_low), ("high_high", high_high)): + for cls_name, mask in ( + ("aligned", aligned), + ("misaligned", misaligned), + ("zero", zero), + ("nonzero", nonzero), + ): + hits, denom, rate = _rate(mask, event) + metrics[f"{name}_{cls_name}_hits"] = hits + metrics[f"{name}_{cls_name}_denom"] = denom + metrics[f"{name}_{cls_name}_rate"] = rate + + for cls_name, mask in ( + ("aligned", aligned), + ("misaligned", misaligned), + ("zero", zero), + ("nonzero", nonzero), + ): + denom, mean = _mean(mask, ratio) + metrics[f"sr_{cls_name}_denom"] = denom + metrics[f"sr_{cls_name}_mean"] = mean + + metrics["low_low_aligned_minus_misaligned"] = ( + float(metrics["low_low_aligned_rate"]) - float(metrics["low_low_misaligned_rate"]) + ) + metrics["high_high_aligned_minus_misaligned"] = ( + float(metrics["high_high_aligned_rate"]) - float(metrics["high_high_misaligned_rate"]) + ) + metrics["sr_aligned_minus_misaligned"] = ( + float(metrics["sr_aligned_mean"]) - float(metrics["sr_misaligned_mean"]) + ) + metrics["low_low_zero_minus_nonzero"] = ( + float(metrics["low_low_zero_rate"]) - float(metrics["low_low_nonzero_rate"]) + ) + metrics["high_high_zero_minus_nonzero"] = ( + float(metrics["high_high_zero_rate"]) - float(metrics["high_high_nonzero_rate"]) + ) + metrics["sr_zero_minus_nonzero"] = ( + float(metrics["sr_zero_mean"]) - float(metrics["sr_nonzero_mean"]) + ) + return metrics + + +def permutation_test( + gaps: np.ndarray, + charges: np.ndarray, + observed: dict[str, float | int], + rng: np.random.Generator, + permutations: int, +) -> dict[str, dict[str, float]]: + nulls = {key: [] for key in METRIC_KEYS} + for _ in range(permutations): + shuffled = np.array(charges, copy=True) + rng.shuffle(shuffled) + metrics = transition_metrics_three_class(gaps, shuffled) + for key in METRIC_KEYS: + nulls[key].append(float(metrics[key])) + + out: dict[str, dict[str, float]] = {} + for key, values in nulls.items(): + arr = np.array(values, dtype=float) + obs = float(observed[key]) + finite = np.isfinite(arr) + arr = arr[finite] + if arr.size == 0 or not np.isfinite(obs): + out[key] = {"observed": obs, "null_mean": float("nan"), "null_std": float("nan"), "z": float("nan"), "p_two_sided": float("nan")} + continue + std = float(np.std(arr, ddof=1)) + z = (obs - float(np.mean(arr))) / std if std > 0 else 0.0 + p = float((np.sum(np.abs(arr) >= abs(obs)) + 1) / (len(arr) + 1)) + out[key] = { + "observed": obs, + "null_mean": float(np.mean(arr)), + "null_std": std, + "z": float(z), + "p_two_sided": p, + } + return out + + +def det_m_direct_control(gaps: np.ndarray) -> dict[str, float | int | str]: + g0 = gaps[:-1].astype(float) + g1 = gaps[1:].astype(float) + ratio = np.minimum(g0, g1) / np.maximum(g0, g1) + low_low = (g0 <= 6) & (g1 <= 6) + q75 = float(np.quantile(gaps, 0.75)) + high_high = (g0 >= q75) & (g1 >= q75) + denom = int(g0.size) + return { + "det_M": -1, + "class_count": 1, + "reason": "M=[[1,1],[1,0]] has constant determinant -1 on every transition, so direct det(M) does not partition the denominator.", + "denominator": denom, + "low_low_hits": int(np.sum(low_low)), + "low_low_rate": float(np.sum(low_low) / denom), + "high_high_hits": int(np.sum(high_high)), + "high_high_rate": float(np.sum(high_high) / denom), + "sr_mean": float(np.mean(ratio)), + } + + +def classify_zero_role(observed: dict[str, float | int], tests: dict[str, dict[str, float]]) -> str: + low_z = tests["low_low_zero_minus_nonzero"]["z"] + high_z = tests["high_high_zero_minus_nonzero"]["z"] + sr_z = tests["sr_zero_minus_nonzero"]["z"] + passes = [ + abs(low_z) >= 2 and tests["low_low_zero_minus_nonzero"]["p_two_sided"] <= 0.05, + abs(high_z) >= 2 and tests["high_high_zero_minus_nonzero"]["p_two_sided"] <= 0.05, + abs(sr_z) >= 2 and tests["sr_zero_minus_nonzero"]["p_two_sided"] <= 0.05, + ] + low = float(observed["low_low_zero_rate"]) + high = float(observed["high_high_zero_rate"]) + sr = float(observed["sr_zero_mean"]) + low_a = float(observed["low_low_aligned_rate"]) + low_m = float(observed["low_low_misaligned_rate"]) + high_a = float(observed["high_high_aligned_rate"]) + high_m = float(observed["high_high_misaligned_rate"]) + sr_a = float(observed["sr_aligned_mean"]) + sr_m = float(observed["sr_misaligned_mean"]) + + between_low = min(low_a, low_m) <= low <= max(low_a, low_m) + between_high = min(high_a, high_m) <= high <= max(high_a, high_m) + between_sr = min(sr_a, sr_m) <= sr <= max(sr_a, sr_m) + + if any(passes) and (between_low or between_high or between_sr): + return "boundary" + if any(passes): + return "third_class" + return "noise_under_this_null" + + +def run_condition( + primes: np.ndarray, + mu: np.ndarray, + n_primes: int, + offset: int, + rng: np.random.Generator, + permutations: int, +) -> dict[str, object]: + segment = primes[offset : offset + n_primes + 1] + gaps = np.diff(segment) + charges = interval_charges(segment, mu) + observed = transition_metrics_three_class(gaps, charges) + tests = permutation_test(gaps, charges, observed, rng, permutations) + return { + "n_primes": n_primes, + "offset": offset, + "prime_start": int(segment[0]), + "prime_stop": int(segment[-1]), + "zero_charge_count": int(np.sum(charges == 0)), + "charge_count": int(charges.size), + "observed": observed, + "permutation_tests": tests, + "zero_role": classify_zero_role(observed, tests), + "det_m_direct_control": det_m_direct_control(gaps), + } + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--limit", type=int, default=1_000_000) + parser.add_argument("--permutations", type=int, default=400) + parser.add_argument("--seed", type=int, default=2108) + parser.add_argument("--out", default="tools/data/prime_mobius_zero_mediator_gate_20260508_2108.json") + args = parser.parse_args() + + primes = sieve_primes(args.limit) + mu = mobius_sieve(args.limit) + rng = np.random.default_rng(args.seed) + + conditions = [ + {"n_primes": 5_000, "offset": 0}, + {"n_primes": 10_000, "offset": 0}, + {"n_primes": 20_000, "offset": 0}, + {"n_primes": 5_000, "offset": 3_000}, + {"n_primes": 10_000, "offset": 7_000}, + {"n_primes": 20_000, "offset": 11_000}, + ] + max_needed = max(c["offset"] + c["n_primes"] + 1 for c in conditions) + if len(primes) <= max_needed: + raise SystemExit(f"limit={args.limit} yields only {len(primes)} primes, need {max_needed}") + + results = [ + run_condition(primes, mu, c["n_primes"], c["offset"], rng, args.permutations) + for c in conditions + ] + summary = [] + for result in results: + tests = result["permutation_tests"] + summary.append( + { + "n_primes": result["n_primes"], + "offset": result["offset"], + "low_low_aligned_minus_misaligned_pass": abs(tests["low_low_aligned_minus_misaligned"]["z"]) >= 2.0 + and tests["low_low_aligned_minus_misaligned"]["p_two_sided"] <= 0.05, + "high_high_aligned_minus_misaligned_pass": abs(tests["high_high_aligned_minus_misaligned"]["z"]) >= 2.0 + and tests["high_high_aligned_minus_misaligned"]["p_two_sided"] <= 0.05, + "sr_aligned_minus_misaligned_pass": abs(tests["sr_aligned_minus_misaligned"]["z"]) >= 2.0 + and tests["sr_aligned_minus_misaligned"]["p_two_sided"] <= 0.05, + "zero_role": result["zero_role"], + } + ) + + payload = { + "experiment": "prime_mobius_zero_mediator_gate", + "question": "Does S=0 behave as noise, boundary, or mediator in the Mobius interval-charge gate?", + "threshold_ex_ante": "|z|>=2 and permutation p<=0.05 across main and offset conditions", + "null": "Permutation of the interval-charge sequence preserves the full charge multiset and therefore preserves zero frequency.", + "limit": args.limit, + "permutations": args.permutations, + "seed": args.seed, + "conditions": results, + "significance_summary": summary, + } + + out = Path(args.out) + out.parent.mkdir(parents=True, exist_ok=True) + out.write_text(json.dumps(payload, indent=2), encoding="utf-8") + + for result in results: + obs = result["observed"] + tests = result["permutation_tests"] + print( + f"N={result['n_primes']} offset={result['offset']} " + f"a/m/z={obs['aligned_count']}/{obs['misaligned_count']}/{obs['zero_count']} " + f"low_am={obs['low_low_aligned_minus_misaligned']:.5f} z={tests['low_low_aligned_minus_misaligned']['z']:.2f} p={tests['low_low_aligned_minus_misaligned']['p_two_sided']:.3f} " + f"low_z0={obs['low_low_zero_minus_nonzero']:.5f} z={tests['low_low_zero_minus_nonzero']['z']:.2f} p={tests['low_low_zero_minus_nonzero']['p_two_sided']:.3f} " + f"high_am={obs['high_high_aligned_minus_misaligned']:.5f} z={tests['high_high_aligned_minus_misaligned']['z']:.2f} p={tests['high_high_aligned_minus_misaligned']['p_two_sided']:.3f} " + f"high_z0={obs['high_high_zero_minus_nonzero']:.5f} z={tests['high_high_zero_minus_nonzero']['z']:.2f} p={tests['high_high_zero_minus_nonzero']['p_two_sided']:.3f} " + f"sr_am={obs['sr_aligned_minus_misaligned']:.5f} z={tests['sr_aligned_minus_misaligned']['z']:.2f} p={tests['sr_aligned_minus_misaligned']['p_two_sided']:.3f} " + f"role={result['zero_role']}" + ) + print(f"wrote {out}") + + +if __name__ == "__main__": + main() exec /bin/bash -lc 'rm tools/__pycache__/exp_prime_mobius_zero_mediator_gate.cpython-312.pyc' in /opt/MM_D-ND succeeded in 0ms: diff --git a/tools/data/reports/agent_20260508_2108.md b/tools/data/reports/agent_20260508_2108.md new file mode 100644 index 0000000000000000000000000000000000000000..d3b8fa5889b9587b0e01270608220848eb4d5ed7 --- /dev/null +++ b/tools/data/reports/agent_20260508_2108.md @@ -0,0 +1,103 @@ +# Agent Report - Prime Mobius Zero-Mediator Gate +**Date**: 2026-05-08 21:08 +**Piano**: 93 +**Tension explored**: DUALITA_DIPOLARE_VS_ILLUSORIA (0.9) +**verdict**: CONSTRAINT +observables_registry: 1.0.0-2026-05-06 +observables_used: [low_low_rate, high_high_rate, SR, det_M_direct_control] +**observable_contract**: claim=lo zero della carica Mobius intervallare e' testato come terzo incluso del gate aligned/misaligned; observable=rate low_low, rate high_high, SR mean per classi aligned/misaligned/zero; operator=classificazione di S_n*S_{n+1}: aligned<0, misaligned>0, zero=0; generator=prime gaps up to p<=1e6 with Mobius sieve; denominator=main N={5000,10000,20000} offset=0 plus seedcheck offsets {3000,7000,11000}; not_tested=gap_ratio Sturmian, high-core phi survival, universal GUE/Poisson classification. + +## Respiro fuori-tempo +- **Combo**: A2 confine det=-1 + A9 terzo incluso + A11 combo + QxG continuo/discreto vuoto + DUALITA_DIPOLARE_VS_ILLUSORIA + piano primi x Mobius. Il repair non cerca un lettore nuovo: riporta nel denominatore il punto escluso dal source cycle, `S=0`. +- **Dipolo / punto-zero**: carica Mobius alternata / carica Mobius concorde; punto-zero = transizione con almeno un intervallo a carica nulla (`S_n*S_{n+1}=0`). +- **Piano superiore**: boundary operator su grafo aritmetico. Il gap e' bordo tra primi; la carica Mobius del vuoto tra primi decide se il bordo e' solo rumore di lunghezza o classe informativa. +- **Operatori laterali scelti**: boundary operator, random walk, entropia. Boundary operator definisce il bordo prime-free; random walk fornisce il null di permutazione della carica; entropia entra come dispersione del vuoto senza primi. +- **Contaminazione cognitiva**: + - **CE-0117**: usato per non promuovere il source cycle e far passare il risultato da potenziale a vincolo misurato. + - **CE-0038**: usato per riportare la forma nel Nulla-Tutto al vuoto aritmetico, qui lo zero `S=0`. + - **CE-0001 / KSAR**: usato come kernel reiterativo del ciclo 2102, con riparazione regressiva sul denominatore. + - **PVI attack**: il segnale puo' essere effetto di lunghezza del gap; per questo il null permuta l'intera sequenza delle cariche preservando multiset e frequenza degli zeri. +- **Proto-ipotesi**: se `S=0` e' terzo incluso operativo, non cade come rumore sotto il null che preserva la frequenza degli zeri. Deve produrre una classe distinguibile su low_low/high_high/SR. Se resta dentro il null, il source cycle sopravvive solo come gate binario non-zero. +- **Proiezione**: confronto aligned, misaligned e zero su `low_low`, `high_high` e `SR`; null = 400 permutazioni della sequenza `S_n`, gap invariati, multiset delle cariche invariata. + +## Claim Under Test +> Nel perimetro primi x Mobius fino a `p<=1e6`, le transizioni con `S=0` non vanno escluse: formano una terza classe del gate intervallare e vanno confrontate contro aligned/misaligned con null che preserva la frequenza degli zeri. + +## Question +Lo zero della carica Mobius intervallare e' rumore, boundary o mediatore del segnale low-low/high-high/SR? + +## Experiment Design +- Script: `tools/exp_prime_mobius_zero_mediator_gate.py`. +- Dati: primi fino a `1_000_000`; Mobius sieve sullo stesso perimetro. +- Carica intervallare: `S_n = sum(mu(k))` per `p_n < k < p_{n+1}`. +- Classi: + - `aligned`: `S_n*S_{n+1}<0`. + - `misaligned`: `S_n*S_{n+1}>0`. + - `zero`: `S_n*S_{n+1}=0`. +- Osservabili: + - `low_low_rate`: count di due gap consecutivi `<=6` sul denominatore della classe. + - `high_high_rate`: count di due gap consecutivi `>=q75` sul denominatore della classe. + - `SR`: mean min/max ratio dei gap consecutivi. +- Null test: 400 permutazioni della sequenza `S_n`; il null preserva la multiset completa delle cariche e quindi la frequenza degli zeri. +- Controllo det(M) diretto: `M=[[1,1],[1,0]]` ha `det(M)=-1` costante su ogni transizione; il controllo non partiziona il denominatore e restituisce solo le baseline globali low/high/SR. +- Soglia ex ante: `|z|>=2` e `p_two_sided<=0.05`. +- Contratto osservabile-operatore: `gap_ratio` Sturmian non testato; il source cycle 2102 non viene promosso; il claim su det diretto viene sostituito da controllo esplicito, non da conclusione non misurata. + +## Results +| condition | a/m/z denom | zero charges | low a | low m | low z | low z0 vs nonzero z/p | high a | high m | high z | high z0 vs nonzero z/p | SR a | SR m | SR z | SR z0 vs nonzero z/p | +|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:| +| N=5000 off=0 | 1200/1572/2227 | 1258/5000 | 221/1200 | 220/1572 | 707/2227 | 11.77 / 0.002 | 115/1200 | 298/1572 | 101/2227 | -10.80 / 0.002 | 0.51559 | 0.52611 | 0.43203 | -11.15 / 0.002 | +| N=10000 off=0 | 2541/3102/4356 | 2457/10000 | 403/2541 | 377/3102 | 1190/4356 | 14.88 / 0.002 | 153/2541 | 363/3102 | 114/4356 | -12.31 / 0.002 | 0.50841 | 0.51502 | 0.42221 | -16.03 / 0.002 | +| N=20000 off=0 | 5171/6331/8497 | 4782/20000 | 694/5171 | 651/6331 | 2093/8497 | 22.31 / 0.002 | 422/5171 | 878/6331 | 281/8497 | -18.75 / 0.002 | 0.50324 | 0.51151 | 0.41571 | -23.13 / 0.002 | +| N=5000 off=3000 | 1313/1525/2161 | 1219/5000 | 184/1313 | 162/1525 | 522/2161 | 9.84 / 0.002 | 86/1313 | 187/1525 | 71/2161 | -8.13 / 0.002 | 0.50993 | 0.50560 | 0.42213 | -10.87 / 0.002 | +| N=10000 off=7000 | 2675/3178/4146 | 2318/10000 | 315/2675 | 298/3178 | 946/4146 | 16.40 / 0.002 | 182/2675 | 351/3178 | 98/4146 | -13.27 / 0.002 | 0.50225 | 0.50729 | 0.40695 | -17.18 / 0.002 | +| N=20000 off=11000 | 5407/6413/8179 | 4586/20000 | 553/5407 | 567/6413 | 1740/8179 | 20.63 / 0.002 | 295/5407 | 667/6413 | 178/8179 | -16.22 / 0.002 | 0.49723 | 0.50997 | 0.41131 | -22.87 / 0.002 | + +### Pairwise aligned/misaligned checks +| condition | low a-m diff z/p | high a-m diff z/p | SR a-m diff z/p | +|---|---:|---:|---:| +| N=5000 off=0 | +0.04422 2.47 / 0.015 | -0.09373 -7.96 / 0.002 | -0.01053 -1.12 / 0.277 | +| N=10000 off=0 | +0.03706 3.44 / 0.002 | -0.05681 -8.90 / 0.002 | -0.00661 -0.90 / 0.357 | +| N=20000 off=0 | +0.03138 4.56 / 0.002 | -0.05707 -10.48 / 0.002 | -0.00827 -1.78 / 0.097 | +| N=5000 off=3000 | +0.03391 2.37 / 0.022 | -0.05712 -5.66 / 0.002 | +0.00433 0.48 / 0.671 | +| N=10000 off=7000 | +0.02399 2.68 / 0.010 | -0.04241 -6.58 / 0.002 | -0.00504 -0.71 / 0.501 | +| N=20000 off=11000 | +0.01386 1.97 / 0.040 | -0.04945 -10.96 / 0.002 | -0.01274 -2.50 / 0.015 | + +### det(M) direct control +`det(M)=-1` e' costante. Il controllo ha una sola classe su ogni condizione, quindi non separa aligned/misaligned/zero. Baseline globali: low_low `1148/4999`, `1970/9999`, `3438/19999`, `868/4999`, `1559/9999`, `2860/19999`; high_high `514/4999`, `630/9999`, `1581/19999`, `344/4999`, `631/9999`, `1140/19999`; SR globale `0.48167`, `0.47291`, `0.46867`, `0.47066`, `0.46434`, `0.46618`. + +## Key Findings +1. **Verificato: lo zero non e' rumore sotto il null usato.** La classe zero supera il null in 6/6 condizioni su `low_low_zero_minus_nonzero`, `high_high_zero_minus_nonzero` e `sr_zero_minus_nonzero`, sempre con `p=0.002` e `|z|` da `8.13` a `23.13`. + +2. **Verificato: lo zero e' una terza classe, non un mediatore tra aligned e misaligned.** Su low_low lo zero e' sopra entrambe le classi non-zero (`0.21274..0.31747` contro aligned `0.10227..0.18417` e misaligned `0.08841..0.13995`). Su high_high lo zero e' sotto entrambe (`0.02176..0.04535` contro aligned `0.05456..0.09583` e misaligned `0.10401..0.18957`). Su SR lo zero e' sotto entrambe (`0.40695..0.43203` contro non-zero circa `0.49723..0.52611`). Il punto-zero non sta tra i poli: genera una classe propria. + +3. **Verificato: il contrasto aligned/misaligned sopravvive soprattutto su high_high.** `high_high_aligned_minus_misaligned` passa 6/6 con z da `-5.66` a `-10.96`. `low_low_aligned_minus_misaligned` passa 5/6 se la soglia richiede anche `|z|>=2`; l'ultima condizione ha `z=1.97`, `p=0.040`, quindi resta borderline e non autorizza hard wording. SR passa 1/6 e resta osservabile secondario. + +4. **Verificato: il controllo det(M) diretto risolve il flag L3 del source cycle.** `det(M)` costante non produce partizione del denominatore; il report non conclude che la dualita "non si legge" da det diretto come fatto empirico generale. Qui dichiara solo che, in questo controllo, det(M) diretto non e' un discriminatore di classe. + +## Verdict +**CONSTRAINT on DUALITA_DIPOLARE_VS_ILLUSORIA / Prime Mobius interval-charge gate**: nel perimetro primi x Mobius fino a `p<=1e6`, `S=0` deve restare nel denominatore come terza classe. Lo zero non e' rumore sotto il null di permutazione che preserva frequenza degli zeri: arricchisce low_low, sopprime high_high e abbassa SR in 6/6 condizioni. Il source cycle sopravvive come vincolo parziale: il gate non-zero aligned/misaligned resta solido per high_high, resta parziale per low_low, e non porta SR globalmente. Il nuovo portatore e' triadico: aligned / misaligned / zero. + +## Bicono della scoperta +- **Due radici**: carica non-zero alternata/concorde . carica zero dell'intervallo prime-free. +- **Singolare**: il vuoto tra primi prima della scelta binaria; `S=0` non e' assenza di segnale ma classe del bordo. +- **Invariante di passaggio**: il null conserva gap, multiset delle cariche e frequenza degli zeri; cio' che sopravvive e' l'accoppiamento ordine-carica, non la sola presenza dello zero. +- **Campo di possibilita**: qui diventa possibile testare un gate triadico del boundary aritmetico. Qui diventa non-possibile escludere `S=0` dal denominatore quando si parla di terzo incluso nel perimetro Mobius-primi. + +## Consecutio +Il prossimo passo deve separare terza classe autentica da effetto scala dell'intervallo: ripetere il gate con controllo che preserva anche la lunghezza del gap o stratifica per bucket di gap length. Se lo zero resta significativo dentro ogni bucket, il boundary e' aritmetico; se cade, il segnale e' dipendenza da lunghezza. + +## Auto-audit: source flags e 5 lenti +- **Source L3 resolved**: il report non usa un elemento `not_tested` come conclusione. Il controllo det(M) diretto e' misurato e dichiarato non partizionante nel perimetro. +- **Source denominator repair resolved**: `S=0` e' incluso come classe esplicita, con count grezzi e denominatore. +- **Aperto**: non e' ancora separata la dipendenza dalla lunghezza del gap; serve controllo stratificato. +- **L1 hard constraint vs bias**: nessun "sempre/mai"; perimetro dichiarato `p<=1e6`, sei condizioni, 400 permutazioni. +- **L2 quantita vs ratio**: count grezzi e denominatori riportati; SR separato dai rate. +- **L3 no silent patching**: claim corretto prima del test; il source cycle non viene promosso. +- **L4 edge cases**: `low_low` non-zero e' borderline in una condizione (`z=1.97`), quindi resta parziale. +- **L5 re-discovery vs discovery**: verdict `CONSTRAINT`, non `NEW`; il pattern resta da confrontare con dipendenze note tra Mobius, lunghezza intervallare e gap primes. + +## Files +- Script: `tools/exp_prime_mobius_zero_mediator_gate.py` +- Data: `tools/data/prime_mobius_zero_mediator_gate_20260508_2108.json` +- Report: `tools/data/reports/agent_20260508_2108.md` diff --git a/tools/exp_prime_mobius_zero_mediator_gate.py b/tools/exp_prime_mobius_zero_mediator_gate.py new file mode 100644 index 0000000000000000000000000000000000000000..95ecd6e07c1863f3ffd3a3a5297a8628a00fd8be --- /dev/null +++ b/tools/exp_prime_mobius_zero_mediator_gate.py @@ -0,0 +1,314 @@ +#!/usr/bin/env python3 +"""Prime x Mobius zero-mediator gate. + +Repairs the 20260508_2102 interval-charge gate by keeping transitions with +S=0 in the denominator as an explicit third class. +""" +from __future__ import annotations + +import argparse +import json +from pathlib import Path + +import numpy as np + +from exp_prime_mobius_interval_charge_gate import ( + interval_charges, + mobius_sieve, + sieve_primes, +) + + +METRIC_KEYS = [ + "low_low_aligned_rate", + "low_low_misaligned_rate", + "low_low_zero_rate", + "high_high_aligned_rate", + "high_high_misaligned_rate", + "high_high_zero_rate", + "sr_aligned_mean", + "sr_misaligned_mean", + "sr_zero_mean", + "low_low_aligned_minus_misaligned", + "low_low_zero_minus_nonzero", + "high_high_aligned_minus_misaligned", + "high_high_zero_minus_nonzero", + "sr_aligned_minus_misaligned", + "sr_zero_minus_nonzero", +] + + +def _rate(mask: np.ndarray, event: np.ndarray) -> tuple[int, int, float]: + denom = int(np.sum(mask)) + hits = int(np.sum(mask & event)) + rate = float(hits / denom) if denom else float("nan") + return hits, denom, rate + + +def _mean(mask: np.ndarray, values: np.ndarray) -> tuple[int, float]: + denom = int(np.sum(mask)) + mean = float(np.mean(values[mask])) if denom else float("nan") + return denom, mean + + +def transition_metrics_three_class(gaps: np.ndarray, charges: np.ndarray) -> dict[str, float | int]: + left = charges[:-1] + right = charges[1:] + product = left * right + aligned = product < 0 + misaligned = product > 0 + zero = product == 0 + nonzero = ~zero + + g0 = gaps[:-1].astype(float) + g1 = gaps[1:].astype(float) + ratio = np.minimum(g0, g1) / np.maximum(g0, g1) + low_low = (g0 <= 6) & (g1 <= 6) + q75 = float(np.quantile(gaps, 0.75)) + high_high = (g0 >= q75) & (g1 >= q75) + + metrics: dict[str, float | int] = { + "q75_gap": q75, + "aligned_count": int(np.sum(aligned)), + "misaligned_count": int(np.sum(misaligned)), + "zero_count": int(np.sum(zero)), + "nonzero_count": int(np.sum(nonzero)), + } + + for name, event in (("low_low", low_low), ("high_high", high_high)): + for cls_name, mask in ( + ("aligned", aligned), + ("misaligned", misaligned), + ("zero", zero), + ("nonzero", nonzero), + ): + hits, denom, rate = _rate(mask, event) + metrics[f"{name}_{cls_name}_hits"] = hits + metrics[f"{name}_{cls_name}_denom"] = denom + metrics[f"{name}_{cls_name}_rate"] = rate + + for cls_name, mask in ( + ("aligned", aligned), + ("misaligned", misaligned), + ("zero", zero), + ("nonzero", nonzero), + ): + denom, mean = _mean(mask, ratio) + metrics[f"sr_{cls_name}_denom"] = denom + metrics[f"sr_{cls_name}_mean"] = mean + + metrics["low_low_aligned_minus_misaligned"] = ( + float(metrics["low_low_aligned_rate"]) - float(metrics["low_low_misaligned_rate"]) + ) + metrics["high_high_aligned_minus_misaligned"] = ( + float(metrics["high_high_aligned_rate"]) - float(metrics["high_high_misaligned_rate"]) + ) + metrics["sr_aligned_minus_misaligned"] = ( + float(metrics["sr_aligned_mean"]) - float(metrics["sr_misaligned_mean"]) + ) + metrics["low_low_zero_minus_nonzero"] = ( + float(metrics["low_low_zero_rate"]) - float(metrics["low_low_nonzero_rate"]) + ) + metrics["high_high_zero_minus_nonzero"] = ( + float(metrics["high_high_zero_rate"]) - float(metrics["high_high_nonzero_rate"]) + ) + metrics["sr_zero_minus_nonzero"] = ( + float(metrics["sr_zero_mean"]) - float(metrics["sr_nonzero_mean"]) + ) + return metrics + + +def permutation_test( + gaps: np.ndarray, + charges: np.ndarray, + observed: dict[str, float | int], + rng: np.random.Generator, + permutations: int, +) -> dict[str, dict[str, float]]: + nulls = {key: [] for key in METRIC_KEYS} + for _ in range(permutations): + shuffled = np.array(charges, copy=True) + rng.shuffle(shuffled) + metrics = transition_metrics_three_class(gaps, shuffled) + for key in METRIC_KEYS: + nulls[key].append(float(metrics[key])) + + out: dict[str, dict[str, float]] = {} + for key, values in nulls.items(): + arr = np.array(values, dtype=float) + obs = float(observed[key]) + finite = np.isfinite(arr) + arr = arr[finite] + if arr.size == 0 or not np.isfinite(obs): + out[key] = {"observed": obs, "null_mean": float("nan"), "null_std": float("nan"), "z": float("nan"), "p_two_sided": float("nan")} + continue + std = float(np.std(arr, ddof=1)) + z = (obs - float(np.mean(arr))) / std if std > 0 else 0.0 + p = float((np.sum(np.abs(arr) >= abs(obs)) + 1) / (len(arr) + 1)) + out[key] = { + "observed": obs, + "null_mean": float(np.mean(arr)), + "null_std": std, + "z": float(z), + "p_two_sided": p, + } + return out + + +def det_m_direct_control(gaps: np.ndarray) -> dict[str, float | int | str]: + g0 = gaps[:-1].astype(float) + g1 = gaps[1:].astype(float) + ratio = np.minimum(g0, g1) / np.maximum(g0, g1) + low_low = (g0 <= 6) & (g1 <= 6) + q75 = float(np.quantile(gaps, 0.75)) + high_high = (g0 >= q75) & (g1 >= q75) + denom = int(g0.size) + return { + "det_M": -1, + "class_count": 1, + "reason": "M=[[1,1],[1,0]] has constant determinant -1 on every transition, so direct det(M) does not partition the denominator.", + "denominator": denom, + "low_low_hits": int(np.sum(low_low)), + "low_low_rate": float(np.sum(low_low) / denom), + "high_high_hits": int(np.sum(high_high)), + "high_high_rate": float(np.sum(high_high) / denom), + "sr_mean": float(np.mean(ratio)), + } + + +def classify_zero_role(observed: dict[str, float | int], tests: dict[str, dict[str, float]]) -> str: + low_z = tests["low_low_zero_minus_nonzero"]["z"] + high_z = tests["high_high_zero_minus_nonzero"]["z"] + sr_z = tests["sr_zero_minus_nonzero"]["z"] + passes = [ + abs(low_z) >= 2 and tests["low_low_zero_minus_nonzero"]["p_two_sided"] <= 0.05, + abs(high_z) >= 2 and tests["high_high_zero_minus_nonzero"]["p_two_sided"] <= 0.05, + abs(sr_z) >= 2 and tests["sr_zero_minus_nonzero"]["p_two_sided"] <= 0.05, + ] + low = float(observed["low_low_zero_rate"]) + high = float(observed["high_high_zero_rate"]) + sr = float(observed["sr_zero_mean"]) + low_a = float(observed["low_low_aligned_rate"]) + low_m = float(observed["low_low_misaligned_rate"]) + high_a = float(observed["high_high_aligned_rate"]) + high_m = float(observed["high_high_misaligned_rate"]) + sr_a = float(observed["sr_aligned_mean"]) + sr_m = float(observed["sr_misaligned_mean"]) + + between_low = min(low_a, low_m) <= low <= max(low_a, low_m) + between_high = min(high_a, high_m) <= high <= max(high_a, high_m) + between_sr = min(sr_a, sr_m) <= sr <= max(sr_a, sr_m) + + if any(passes) and (between_low or between_high or between_sr): + return "boundary" + if any(passes): + return "third_class" + return "noise_under_this_null" + + +def run_condition( + primes: np.ndarray, + mu: np.ndarray, + n_primes: int, + offset: int, + rng: np.random.Generator, + permutations: int, +) -> dict[str, object]: + segment = primes[offset : offset + n_primes + 1] + gaps = np.diff(segment) + charges = interval_charges(segment, mu) + observed = transition_metrics_three_class(gaps, charges) + tests = permutation_test(gaps, charges, observed, rng, permutations) + return { + "n_primes": n_primes, + "offset": offset, + "prime_start": int(segment[0]), + "prime_stop": int(segment[-1]), + "zero_charge_count": int(np.sum(charges == 0)), + "charge_count": int(charges.size), + "observed": observed, + "permutation_tests": tests, + "zero_role": classify_zero_role(observed, tests), + "det_m_direct_control": det_m_direct_control(gaps), + } + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--limit", type=int, default=1_000_000) + parser.add_argument("--permutations", type=int, default=400) + parser.add_argument("--seed", type=int, default=2108) + parser.add_argument("--out", default="tools/data/prime_mobius_zero_mediator_gate_20260508_2108.json") + args = parser.parse_args() + + primes = sieve_primes(args.limit) + mu = mobius_sieve(args.limit) + rng = np.random.default_rng(args.seed) + + conditions = [ + {"n_primes": 5_000, "offset": 0}, + {"n_primes": 10_000, "offset": 0}, + {"n_primes": 20_000, "offset": 0}, + {"n_primes": 5_000, "offset": 3_000}, + {"n_primes": 10_000, "offset": 7_000}, + {"n_primes": 20_000, "offset": 11_000}, + ] + max_needed = max(c["offset"] + c["n_primes"] + 1 for c in conditions) + if len(primes) <= max_needed: + raise SystemExit(f"limit={args.limit} yields only {len(primes)} primes, need {max_needed}") + + results = [ + run_condition(primes, mu, c["n_primes"], c["offset"], rng, args.permutations) + for c in conditions + ] + summary = [] + for result in results: + tests = result["permutation_tests"] + summary.append( + { + "n_primes": result["n_primes"], + "offset": result["offset"], + "low_low_aligned_minus_misaligned_pass": abs(tests["low_low_aligned_minus_misaligned"]["z"]) >= 2.0 + and tests["low_low_aligned_minus_misaligned"]["p_two_sided"] <= 0.05, + "high_high_aligned_minus_misaligned_pass": abs(tests["high_high_aligned_minus_misaligned"]["z"]) >= 2.0 + and tests["high_high_aligned_minus_misaligned"]["p_two_sided"] <= 0.05, + "sr_aligned_minus_misaligned_pass": abs(tests["sr_aligned_minus_misaligned"]["z"]) >= 2.0 + and tests["sr_aligned_minus_misaligned"]["p_two_sided"] <= 0.05, + "zero_role": result["zero_role"], + } + ) + + payload = { + "experiment": "prime_mobius_zero_mediator_gate", + "question": "Does S=0 behave as noise, boundary, or mediator in the Mobius interval-charge gate?", + "threshold_ex_ante": "|z|>=2 and permutation p<=0.05 across main and offset conditions", + "null": "Permutation of the interval-charge sequence preserves the full charge multiset and therefore preserves zero frequency.", + "limit": args.limit, + "permutations": args.permutations, + "seed": args.seed, + "conditions": results, + "significance_summary": summary, + } + + out = Path(args.out) + out.parent.mkdir(parents=True, exist_ok=True) + out.write_text(json.dumps(payload, indent=2), encoding="utf-8") + + for result in results: + obs = result["observed"] + tests = result["permutation_tests"] + print( + f"N={result['n_primes']} offset={result['offset']} " + f"a/m/z={obs['aligned_count']}/{obs['misaligned_count']}/{obs['zero_count']} " + f"low_am={obs['low_low_aligned_minus_misaligned']:.5f} z={tests['low_low_aligned_minus_misaligned']['z']:.2f} p={tests['low_low_aligned_minus_misaligned']['p_two_sided']:.3f} " + f"low_z0={obs['low_low_zero_minus_nonzero']:.5f} z={tests['low_low_zero_minus_nonzero']['z']:.2f} p={tests['low_low_zero_minus_nonzero']['p_two_sided']:.3f} " + f"high_am={obs['high_high_aligned_minus_misaligned']:.5f} z={tests['high_high_aligned_minus_misaligned']['z']:.2f} p={tests['high_high_aligned_minus_misaligned']['p_two_sided']:.3f} " + f"high_z0={obs['high_high_zero_minus_nonzero']:.5f} z={tests['high_high_zero_minus_nonzero']['z']:.2f} p={tests['high_high_zero_minus_nonzero']['p_two_sided']:.3f} " + f"sr_am={obs['sr_aligned_minus_misaligned']:.5f} z={tests['sr_aligned_minus_misaligned']['z']:.2f} p={tests['sr_aligned_minus_misaligned']['p_two_sided']:.3f} " + f"role={result['zero_role']}" + ) + print(f"wrote {out}") + + +if __name__ == "__main__": + main() codex Completato il cycle repair. Ho creato: - [tools/exp_prime_mobius_zero_mediator_gate.py](/opt/MM_D-ND/tools/exp_prime_mobius_zero_mediator_gate.py) - [tools/data/prime_mobius_zero_mediator_gate_20260508_2108.json](/opt/MM_D-ND/tools/data/prime_mobius_zero_mediator_gate_20260508_2108.json) - [tools/data/reports/agent_20260508_2108.md](/opt/MM_D-ND/tools/data/reports/agent_20260508_2108.md) Risultato centrale: `S=0` non cade come rumore sotto il null che preserva la frequenza degli zeri. Forma una terza classe: arricchisce `low_low`, sopprime `high_high`, abbassa `SR` in 6/6 condizioni. Il gate non-zero aligned/misaligned resta forte su `high_high`, parziale su `low_low`, non stabile su `SR`. Verifiche: - Esperimento eseguito con `p<=1e6`, 6 condizioni, 400 permutazioni. - `python tools/structural_check.py ...` passato: nessun anti-pattern trovato. - `python -m py_compile` passato. - `lab_falsifier.py` non ha potuto valutare: provider `codex-cli`, `claude-cli`, `openrouter` non disponibili; ha prodotto blocco conservativo raw come telemetria. diff --git a/tools/data/reports/agent_20260508_2108.md b/tools/data/reports/agent_20260508_2108.md new file mode 100644 index 0000000000000000000000000000000000000000..d3b8fa5889b9587b0e01270608220848eb4d5ed7 --- /dev/null +++ b/tools/data/reports/agent_20260508_2108.md @@ -0,0 +1,103 @@ +# Agent Report - Prime Mobius Zero-Mediator Gate +**Date**: 2026-05-08 21:08 +**Piano**: 93 +**Tension explored**: DUALITA_DIPOLARE_VS_ILLUSORIA (0.9) +**verdict**: CONSTRAINT +observables_registry: 1.0.0-2026-05-06 +observables_used: [low_low_rate, high_high_rate, SR, det_M_direct_control] +**observable_contract**: claim=lo zero della carica Mobius intervallare e' testato come terzo incluso del gate aligned/misaligned; observable=rate low_low, rate high_high, SR mean per classi aligned/misaligned/zero; operator=classificazione di S_n*S_{n+1}: aligned<0, misaligned>0, zero=0; generator=prime gaps up to p<=1e6 with Mobius sieve; denominator=main N={5000,10000,20000} offset=0 plus seedcheck offsets {3000,7000,11000}; not_tested=gap_ratio Sturmian, high-core phi survival, universal GUE/Poisson classification. + +## Respiro fuori-tempo +- **Combo**: A2 confine det=-1 + A9 terzo incluso + A11 combo + QxG continuo/discreto vuoto + DUALITA_DIPOLARE_VS_ILLUSORIA + piano primi x Mobius. Il repair non cerca un lettore nuovo: riporta nel denominatore il punto escluso dal source cycle, `S=0`. +- **Dipolo / punto-zero**: carica Mobius alternata / carica Mobius concorde; punto-zero = transizione con almeno un intervallo a carica nulla (`S_n*S_{n+1}=0`). +- **Piano superiore**: boundary operator su grafo aritmetico. Il gap e' bordo tra primi; la carica Mobius del vuoto tra primi decide se il bordo e' solo rumore di lunghezza o classe informativa. +- **Operatori laterali scelti**: boundary operator, random walk, entropia. Boundary operator definisce il bordo prime-free; random walk fornisce il null di permutazione della carica; entropia entra come dispersione del vuoto senza primi. +- **Contaminazione cognitiva**: + - **CE-0117**: usato per non promuovere il source cycle e far passare il risultato da potenziale a vincolo misurato. + - **CE-0038**: usato per riportare la forma nel Nulla-Tutto al vuoto aritmetico, qui lo zero `S=0`. + - **CE-0001 / KSAR**: usato come kernel reiterativo del ciclo 2102, con riparazione regressiva sul denominatore. + - **PVI attack**: il segnale puo' essere effetto di lunghezza del gap; per questo il null permuta l'intera sequenza delle cariche preservando multiset e frequenza degli zeri. +- **Proto-ipotesi**: se `S=0` e' terzo incluso operativo, non cade come rumore sotto il null che preserva la frequenza degli zeri. Deve produrre una classe distinguibile su low_low/high_high/SR. Se resta dentro il null, il source cycle sopravvive solo come gate binario non-zero. +- **Proiezione**: confronto aligned, misaligned e zero su `low_low`, `high_high` e `SR`; null = 400 permutazioni della sequenza `S_n`, gap invariati, multiset delle cariche invariata. + +## Claim Under Test +> Nel perimetro primi x Mobius fino a `p<=1e6`, le transizioni con `S=0` non vanno escluse: formano una terza classe del gate intervallare e vanno confrontate contro aligned/misaligned con null che preserva la frequenza degli zeri. + +## Question +Lo zero della carica Mobius intervallare e' rumore, boundary o mediatore del segnale low-low/high-high/SR? + +## Experiment Design +- Script: `tools/exp_prime_mobius_zero_mediator_gate.py`. +- Dati: primi fino a `1_000_000`; Mobius sieve sullo stesso perimetro. +- Carica intervallare: `S_n = sum(mu(k))` per `p_n < k < p_{n+1}`. +- Classi: + - `aligned`: `S_n*S_{n+1}<0`. + - `misaligned`: `S_n*S_{n+1}>0`. + - `zero`: `S_n*S_{n+1}=0`. +- Osservabili: + - `low_low_rate`: count di due gap consecutivi `<=6` sul denominatore della classe. + - `high_high_rate`: count di due gap consecutivi `>=q75` sul denominatore della classe. + - `SR`: mean min/max ratio dei gap consecutivi. +- Null test: 400 permutazioni della sequenza `S_n`; il null preserva la multiset completa delle cariche e quindi la frequenza degli zeri. +- Controllo det(M) diretto: `M=[[1,1],[1,0]]` ha `det(M)=-1` costante su ogni transizione; il controllo non partiziona il denominatore e restituisce solo le baseline globali low/high/SR. +- Soglia ex ante: `|z|>=2` e `p_two_sided<=0.05`. +- Contratto osservabile-operatore: `gap_ratio` Sturmian non testato; il source cycle 2102 non viene promosso; il claim su det diretto viene sostituito da controllo esplicito, non da conclusione non misurata. + +## Results +| condition | a/m/z denom | zero charges | low a | low m | low z | low z0 vs nonzero z/p | high a | high m | high z | high z0 vs nonzero z/p | SR a | SR m | SR z | SR z0 vs nonzero z/p | +|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:| +| N=5000 off=0 | 1200/1572/2227 | 1258/5000 | 221/1200 | 220/1572 | 707/2227 | 11.77 / 0.002 | 115/1200 | 298/1572 | 101/2227 | -10.80 / 0.002 | 0.51559 | 0.52611 | 0.43203 | -11.15 / 0.002 | +| N=10000 off=0 | 2541/3102/4356 | 2457/10000 | 403/2541 | 377/3102 | 1190/4356 | 14.88 / 0.002 | 153/2541 | 363/3102 | 114/4356 | -12.31 / 0.002 | 0.50841 | 0.51502 | 0.42221 | -16.03 / 0.002 | +| N=20000 off=0 | 5171/6331/8497 | 4782/20000 | 694/5171 | 651/6331 | 2093/8497 | 22.31 / 0.002 | 422/5171 | 878/6331 | 281/8497 | -18.75 / 0.002 | 0.50324 | 0.51151 | 0.41571 | -23.13 / 0.002 | +| N=5000 off=3000 | 1313/1525/2161 | 1219/5000 | 184/1313 | 162/1525 | 522/2161 | 9.84 / 0.002 | 86/1313 | 187/1525 | 71/2161 | -8.13 / 0.002 | 0.50993 | 0.50560 | 0.42213 | -10.87 / 0.002 | +| N=10000 off=7000 | 2675/3178/4146 | 2318/10000 | 315/2675 | 298/3178 | 946/4146 | 16.40 / 0.002 | 182/2675 | 351/3178 | 98/4146 | -13.27 / 0.002 | 0.50225 | 0.50729 | 0.40695 | -17.18 / 0.002 | +| N=20000 off=11000 | 5407/6413/8179 | 4586/20000 | 553/5407 | 567/6413 | 1740/8179 | 20.63 / 0.002 | 295/5407 | 667/6413 | 178/8179 | -16.22 / 0.002 | 0.49723 | 0.50997 | 0.41131 | -22.87 / 0.002 | + +### Pairwise aligned/misaligned checks +| condition | low a-m diff z/p | high a-m diff z/p | SR a-m diff z/p | +|---|---:|---:|---:| +| N=5000 off=0 | +0.04422 2.47 / 0.015 | -0.09373 -7.96 / 0.002 | -0.01053 -1.12 / 0.277 | +| N=10000 off=0 | +0.03706 3.44 / 0.002 | -0.05681 -8.90 / 0.002 | -0.00661 -0.90 / 0.357 | +| N=20000 off=0 | +0.03138 4.56 / 0.002 | -0.05707 -10.48 / 0.002 | -0.00827 -1.78 / 0.097 | +| N=5000 off=3000 | +0.03391 2.37 / 0.022 | -0.05712 -5.66 / 0.002 | +0.00433 0.48 / 0.671 | +| N=10000 off=7000 | +0.02399 2.68 / 0.010 | -0.04241 -6.58 / 0.002 | -0.00504 -0.71 / 0.501 | +| N=20000 off=11000 | +0.01386 1.97 / 0.040 | -0.04945 -10.96 / 0.002 | -0.01274 -2.50 / 0.015 | + +### det(M) direct control +`det(M)=-1` e' costante. Il controllo ha una sola classe su ogni condizione, quindi non separa aligned/misaligned/zero. Baseline globali: low_low `1148/4999`, `1970/9999`, `3438/19999`, `868/4999`, `1559/9999`, `2860/19999`; high_high `514/4999`, `630/9999`, `1581/19999`, `344/4999`, `631/9999`, `1140/19999`; SR globale `0.48167`, `0.47291`, `0.46867`, `0.47066`, `0.46434`, `0.46618`. + +## Key Findings +1. **Verificato: lo zero non e' rumore sotto il null usato.** La classe zero supera il null in 6/6 condizioni su `low_low_zero_minus_nonzero`, `high_high_zero_minus_nonzero` e `sr_zero_minus_nonzero`, sempre con `p=0.002` e `|z|` da `8.13` a `23.13`. + +2. **Verificato: lo zero e' una terza classe, non un mediatore tra aligned e misaligned.** Su low_low lo zero e' sopra entrambe le classi non-zero (`0.21274..0.31747` contro aligned `0.10227..0.18417` e misaligned `0.08841..0.13995`). Su high_high lo zero e' sotto entrambe (`0.02176..0.04535` contro aligned `0.05456..0.09583` e misaligned `0.10401..0.18957`). Su SR lo zero e' sotto entrambe (`0.40695..0.43203` contro non-zero circa `0.49723..0.52611`). Il punto-zero non sta tra i poli: genera una classe propria. + +3. **Verificato: il contrasto aligned/misaligned sopravvive soprattutto su high_high.** `high_high_aligned_minus_misaligned` passa 6/6 con z da `-5.66` a `-10.96`. `low_low_aligned_minus_misaligned` passa 5/6 se la soglia richiede anche `|z|>=2`; l'ultima condizione ha `z=1.97`, `p=0.040`, quindi resta borderline e non autorizza hard wording. SR passa 1/6 e resta osservabile secondario. + +4. **Verificato: il controllo det(M) diretto risolve il flag L3 del source cycle.** `det(M)` costante non produce partizione del denominatore; il report non conclude che la dualita "non si legge" da det diretto come fatto empirico generale. Qui dichiara solo che, in questo controllo, det(M) diretto non e' un discriminatore di classe. + +## Verdict +**CONSTRAINT on DUALITA_DIPOLARE_VS_ILLUSORIA / Prime Mobius interval-charge gate**: nel perimetro primi x Mobius fino a `p<=1e6`, `S=0` deve restare nel denominatore come terza classe. Lo zero non e' rumore sotto il null di permutazione che preserva frequenza degli zeri: arricchisce low_low, sopprime high_high e abbassa SR in 6/6 condizioni. Il source cycle sopravvive come vincolo parziale: il gate non-zero aligned/misaligned resta solido per high_high, resta parziale per low_low, e non porta SR globalmente. Il nuovo portatore e' triadico: aligned / misaligned / zero. + +## Bicono della scoperta +- **Due radici**: carica non-zero alternata/concorde . carica zero dell'intervallo prime-free. +- **Singolare**: il vuoto tra primi prima della scelta binaria; `S=0` non e' assenza di segnale ma classe del bordo. +- **Invariante di passaggio**: il null conserva gap, multiset delle cariche e frequenza degli zeri; cio' che sopravvive e' l'accoppiamento ordine-carica, non la sola presenza dello zero. +- **Campo di possibilita**: qui diventa possibile testare un gate triadico del boundary aritmetico. Qui diventa non-possibile escludere `S=0` dal denominatore quando si parla di terzo incluso nel perimetro Mobius-primi. + +## Consecutio +Il prossimo passo deve separare terza classe autentica da effetto scala dell'intervallo: ripetere il gate con controllo che preserva anche la lunghezza del gap o stratifica per bucket di gap length. Se lo zero resta significativo dentro ogni bucket, il boundary e' aritmetico; se cade, il segnale e' dipendenza da lunghezza. + +## Auto-audit: source flags e 5 lenti +- **Source L3 resolved**: il report non usa un elemento `not_tested` come conclusione. Il controllo det(M) diretto e' misurato e dichiarato non partizionante nel perimetro. +- **Source denominator repair resolved**: `S=0` e' incluso come classe esplicita, con count grezzi e denominatore. +- **Aperto**: non e' ancora separata la dipendenza dalla lunghezza del gap; serve controllo stratificato. +- **L1 hard constraint vs bias**: nessun "sempre/mai"; perimetro dichiarato `p<=1e6`, sei condizioni, 400 permutazioni. +- **L2 quantita vs ratio**: count grezzi e denominatori riportati; SR separato dai rate. +- **L3 no silent patching**: claim corretto prima del test; il source cycle non viene promosso. +- **L4 edge cases**: `low_low` non-zero e' borderline in una condizione (`z=1.97`), quindi resta parziale. +- **L5 re-discovery vs discovery**: verdict `CONSTRAINT`, non `NEW`; il pattern resta da confrontare con dipendenze note tra Mobius, lunghezza intervallare e gap primes. + +## Files +- Script: `tools/exp_prime_mobius_zero_mediator_gate.py` +- Data: `tools/data/prime_mobius_zero_mediator_gate_20260508_2108.json` +- Report: `tools/data/reports/agent_20260508_2108.md` diff --git a/tools/exp_prime_mobius_zero_mediator_gate.py b/tools/exp_prime_mobius_zero_mediator_gate.py new file mode 100644 index 0000000000000000000000000000000000000000..95ecd6e07c1863f3ffd3a3a5297a8628a00fd8be --- /dev/null +++ b/tools/exp_prime_mobius_zero_mediator_gate.py @@ -0,0 +1,314 @@ +#!/usr/bin/env python3 +"""Prime x Mobius zero-mediator gate. + +Repairs the 20260508_2102 interval-charge gate by keeping transitions with +S=0 in the denominator as an explicit third class. +""" +from __future__ import annotations + +import argparse +import json +from pathlib import Path + +import numpy as np + +from exp_prime_mobius_interval_charge_gate import ( + interval_charges, + mobius_sieve, + sieve_primes, +) + + +METRIC_KEYS = [ + "low_low_aligned_rate", + "low_low_misaligned_rate", + "low_low_zero_rate", + "high_high_aligned_rate", + "high_high_misaligned_rate", + "high_high_zero_rate", + "sr_aligned_mean", + "sr_misaligned_mean", + "sr_zero_mean", + "low_low_aligned_minus_misaligned", + "low_low_zero_minus_nonzero", + "high_high_aligned_minus_misaligned", + "high_high_zero_minus_nonzero", + "sr_aligned_minus_misaligned", + "sr_zero_minus_nonzero", +] + + +def _rate(mask: np.ndarray, event: np.ndarray) -> tuple[int, int, float]: + denom = int(np.sum(mask)) + hits = int(np.sum(mask & event)) + rate = float(hits / denom) if denom else float("nan") + return hits, denom, rate + + +def _mean(mask: np.ndarray, values: np.ndarray) -> tuple[int, float]: + denom = int(np.sum(mask)) + mean = float(np.mean(values[mask])) if denom else float("nan") + return denom, mean + + +def transition_metrics_three_class(gaps: np.ndarray, charges: np.ndarray) -> dict[str, float | int]: + left = charges[:-1] + right = charges[1:] + product = left * right + aligned = product < 0 + misaligned = product > 0 + zero = product == 0 + nonzero = ~zero + + g0 = gaps[:-1].astype(float) + g1 = gaps[1:].astype(float) + ratio = np.minimum(g0, g1) / np.maximum(g0, g1) + low_low = (g0 <= 6) & (g1 <= 6) + q75 = float(np.quantile(gaps, 0.75)) + high_high = (g0 >= q75) & (g1 >= q75) + + metrics: dict[str, float | int] = { + "q75_gap": q75, + "aligned_count": int(np.sum(aligned)), + "misaligned_count": int(np.sum(misaligned)), + "zero_count": int(np.sum(zero)), + "nonzero_count": int(np.sum(nonzero)), + } + + for name, event in (("low_low", low_low), ("high_high", high_high)): + for cls_name, mask in ( + ("aligned", aligned), + ("misaligned", misaligned), + ("zero", zero), + ("nonzero", nonzero), + ): + hits, denom, rate = _rate(mask, event) + metrics[f"{name}_{cls_name}_hits"] = hits + metrics[f"{name}_{cls_name}_denom"] = denom + metrics[f"{name}_{cls_name}_rate"] = rate + + for cls_name, mask in ( + ("aligned", aligned), + ("misaligned", misaligned), + ("zero", zero), + ("nonzero", nonzero), + ): + denom, mean = _mean(mask, ratio) + metrics[f"sr_{cls_name}_denom"] = denom + metrics[f"sr_{cls_name}_mean"] = mean + + metrics["low_low_aligned_minus_misaligned"] = ( + float(metrics["low_low_aligned_rate"]) - float(metrics["low_low_misaligned_rate"]) + ) + metrics["high_high_aligned_minus_misaligned"] = ( + float(metrics["high_high_aligned_rate"]) - float(metrics["high_high_misaligned_rate"]) + ) + metrics["sr_aligned_minus_misaligned"] = ( + float(metrics["sr_aligned_mean"]) - float(metrics["sr_misaligned_mean"]) + ) + metrics["low_low_zero_minus_nonzero"] = ( + float(metrics["low_low_zero_rate"]) - float(metrics["low_low_nonzero_rate"]) + ) + metrics["high_high_zero_minus_nonzero"] = ( + float(metrics["high_high_zero_rate"]) - float(metrics["high_high_nonzero_rate"]) + ) + metrics["sr_zero_minus_nonzero"] = ( + float(metrics["sr_zero_mean"]) - float(metrics["sr_nonzero_mean"]) + ) + return metrics + + +def permutation_test( + gaps: np.ndarray, + charges: np.ndarray, + observed: dict[str, float | int], + rng: np.random.Generator, + permutations: int, +) -> dict[str, dict[str, float]]: + nulls = {key: [] for key in METRIC_KEYS} + for _ in range(permutations): + shuffled = np.array(charges, copy=True) + rng.shuffle(shuffled) + metrics = transition_metrics_three_class(gaps, shuffled) + for key in METRIC_KEYS: + nulls[key].append(float(metrics[key])) + + out: dict[str, dict[str, float]] = {} + for key, values in nulls.items(): + arr = np.array(values, dtype=float) + obs = float(observed[key]) + finite = np.isfinite(arr) + arr = arr[finite] + if arr.size == 0 or not np.isfinite(obs): + out[key] = {"observed": obs, "null_mean": float("nan"), "null_std": float("nan"), "z": float("nan"), "p_two_sided": float("nan")} + continue + std = float(np.std(arr, ddof=1)) + z = (obs - float(np.mean(arr))) / std if std > 0 else 0.0 + p = float((np.sum(np.abs(arr) >= abs(obs)) + 1) / (len(arr) + 1)) + out[key] = { + "observed": obs, + "null_mean": float(np.mean(arr)), + "null_std": std, + "z": float(z), + "p_two_sided": p, + } + return out + + +def det_m_direct_control(gaps: np.ndarray) -> dict[str, float | int | str]: + g0 = gaps[:-1].astype(float) + g1 = gaps[1:].astype(float) + ratio = np.minimum(g0, g1) / np.maximum(g0, g1) + low_low = (g0 <= 6) & (g1 <= 6) + q75 = float(np.quantile(gaps, 0.75)) + high_high = (g0 >= q75) & (g1 >= q75) + denom = int(g0.size) + return { + "det_M": -1, + "class_count": 1, + "reason": "M=[[1,1],[1,0]] has constant determinant -1 on every transition, so direct det(M) does not partition the denominator.", + "denominator": denom, + "low_low_hits": int(np.sum(low_low)), + "low_low_rate": float(np.sum(low_low) / denom), + "high_high_hits": int(np.sum(high_high)), + "high_high_rate": float(np.sum(high_high) / denom), + "sr_mean": float(np.mean(ratio)), + } + + +def classify_zero_role(observed: dict[str, float | int], tests: dict[str, dict[str, float]]) -> str: + low_z = tests["low_low_zero_minus_nonzero"]["z"] + high_z = tests["high_high_zero_minus_nonzero"]["z"] + sr_z = tests["sr_zero_minus_nonzero"]["z"] + passes = [ + abs(low_z) >= 2 and tests["low_low_zero_minus_nonzero"]["p_two_sided"] <= 0.05, + abs(high_z) >= 2 and tests["high_high_zero_minus_nonzero"]["p_two_sided"] <= 0.05, + abs(sr_z) >= 2 and tests["sr_zero_minus_nonzero"]["p_two_sided"] <= 0.05, + ] + low = float(observed["low_low_zero_rate"]) + high = float(observed["high_high_zero_rate"]) + sr = float(observed["sr_zero_mean"]) + low_a = float(observed["low_low_aligned_rate"]) + low_m = float(observed["low_low_misaligned_rate"]) + high_a = float(observed["high_high_aligned_rate"]) + high_m = float(observed["high_high_misaligned_rate"]) + sr_a = float(observed["sr_aligned_mean"]) + sr_m = float(observed["sr_misaligned_mean"]) + + between_low = min(low_a, low_m) <= low <= max(low_a, low_m) + between_high = min(high_a, high_m) <= high <= max(high_a, high_m) + between_sr = min(sr_a, sr_m) <= sr <= max(sr_a, sr_m) + + if any(passes) and (between_low or between_high or between_sr): + return "boundary" + if any(passes): + return "third_class" + return "noise_under_this_null" + + +def run_condition( + primes: np.ndarray, + mu: np.ndarray, + n_primes: int, + offset: int, + rng: np.random.Generator, + permutations: int, +) -> dict[str, object]: + segment = primes[offset : offset + n_primes + 1] + gaps = np.diff(segment) + charges = interval_charges(segment, mu) + observed = transition_metrics_three_class(gaps, charges) + tests = permutation_test(gaps, charges, observed, rng, permutations) + return { + "n_primes": n_primes, + "offset": offset, + "prime_start": int(segment[0]), + "prime_stop": int(segment[-1]), + "zero_charge_count": int(np.sum(charges == 0)), + "charge_count": int(charges.size), + "observed": observed, + "permutation_tests": tests, + "zero_role": classify_zero_role(observed, tests), + "det_m_direct_control": det_m_direct_control(gaps), + } + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--limit", type=int, default=1_000_000) + parser.add_argument("--permutations", type=int, default=400) + parser.add_argument("--seed", type=int, default=2108) + parser.add_argument("--out", default="tools/data/prime_mobius_zero_mediator_gate_20260508_2108.json") + args = parser.parse_args() + + primes = sieve_primes(args.limit) + mu = mobius_sieve(args.limit) + rng = np.random.default_rng(args.seed) + + conditions = [ + {"n_primes": 5_000, "offset": 0}, + {"n_primes": 10_000, "offset": 0}, + {"n_primes": 20_000, "offset": 0}, + {"n_primes": 5_000, "offset": 3_000}, + {"n_primes": 10_000, "offset": 7_000}, + {"n_primes": 20_000, "offset": 11_000}, + ] + max_needed = max(c["offset"] + c["n_primes"] + 1 for c in conditions) + if len(primes) <= max_needed: + raise SystemExit(f"limit={args.limit} yields only {len(primes)} primes, need {max_needed}") + + results = [ + run_condition(primes, mu, c["n_primes"], c["offset"], rng, args.permutations) + for c in conditions + ] + summary = [] + for result in results: + tests = result["permutation_tests"] + summary.append( + { + "n_primes": result["n_primes"], + "offset": result["offset"], + "low_low_aligned_minus_misaligned_pass": abs(tests["low_low_aligned_minus_misaligned"]["z"]) >= 2.0 + and tests["low_low_aligned_minus_misaligned"]["p_two_sided"] <= 0.05, + "high_high_aligned_minus_misaligned_pass": abs(tests["high_high_aligned_minus_misaligned"]["z"]) >= 2.0 + and tests["high_high_aligned_minus_misaligned"]["p_two_sided"] <= 0.05, + "sr_aligned_minus_misaligned_pass": abs(tests["sr_aligned_minus_misaligned"]["z"]) >= 2.0 + and tests["sr_aligned_minus_misaligned"]["p_two_sided"] <= 0.05, + "zero_role": result["zero_role"], + } + ) + + payload = { + "experiment": "prime_mobius_zero_mediator_gate", + "question": "Does S=0 behave as noise, boundary, or mediator in the Mobius interval-charge gate?", + "threshold_ex_ante": "|z|>=2 and permutation p<=0.05 across main and offset conditions", + "null": "Permutation of the interval-charge sequence preserves the full charge multiset and therefore preserves zero frequency.", + "limit": args.limit, + "permutations": args.permutations, + "seed": args.seed, + "conditions": results, + "significance_summary": summary, + } + + out = Path(args.out) + out.parent.mkdir(parents=True, exist_ok=True) + out.write_text(json.dumps(payload, indent=2), encoding="utf-8") + + for result in results: + obs = result["observed"] + tests = result["permutation_tests"] + print( + f"N={result['n_primes']} offset={result['offset']} " + f"a/m/z={obs['aligned_count']}/{obs['misaligned_count']}/{obs['zero_count']} " + f"low_am={obs['low_low_aligned_minus_misaligned']:.5f} z={tests['low_low_aligned_minus_misaligned']['z']:.2f} p={tests['low_low_aligned_minus_misaligned']['p_two_sided']:.3f} " + f"low_z0={obs['low_low_zero_minus_nonzero']:.5f} z={tests['low_low_zero_minus_nonzero']['z']:.2f} p={tests['low_low_zero_minus_nonzero']['p_two_sided']:.3f} " + f"high_am={obs['high_high_aligned_minus_misaligned']:.5f} z={tests['high_high_aligned_minus_misaligned']['z']:.2f} p={tests['high_high_aligned_minus_misaligned']['p_two_sided']:.3f} " + f"high_z0={obs['high_high_zero_minus_nonzero']:.5f} z={tests['high_high_zero_minus_nonzero']['z']:.2f} p={tests['high_high_zero_minus_nonzero']['p_two_sided']:.3f} " + f"sr_am={obs['sr_aligned_minus_misaligned']:.5f} z={tests['sr_aligned_minus_misaligned']['z']:.2f} p={tests['sr_aligned_minus_misaligned']['p_two_sided']:.3f} " + f"role={result['zero_role']}" + ) + print(f"wrote {out}") + + +if __name__ == "__main__": + main() tokens used 100,251 Completato il cycle repair. Ho creato: - [tools/exp_prime_mobius_zero_mediator_gate.py](/opt/MM_D-ND/tools/exp_prime_mobius_zero_mediator_gate.py) - [tools/data/prime_mobius_zero_mediator_gate_20260508_2108.json](/opt/MM_D-ND/tools/data/prime_mobius_zero_mediator_gate_20260508_2108.json) - [tools/data/reports/agent_20260508_2108.md](/opt/MM_D-ND/tools/data/reports/agent_20260508_2108.md) Risultato centrale: `S=0` non cade come rumore sotto il null che preserva la frequenza degli zeri. Forma una terza classe: arricchisce `low_low`, sopprime `high_high`, abbassa `SR` in 6/6 condizioni. Il gate non-zero aligned/misaligned resta forte su `high_high`, parziale su `low_low`, non stabile su `SR`. Verifiche: - Esperimento eseguito con `p<=1e6`, 6 condizioni, 400 permutazioni. - `python tools/structural_check.py ...` passato: nessun anti-pattern trovato. - `python -m py_compile` passato. - `lab_falsifier.py` non ha potuto valutare: provider `codex-cli`, `claude-cli`, `openrouter` non disponibili; ha prodotto blocco conservativo raw come telemetria.